• python实现AES加密解密

    1. 前言
    AES是一种对称加密，所谓对称加密就是加密与解密使用的秘钥是一个。

    之前写过一片关于python AES加密解密的文章，但是这里面细节实在很多，这次我从 参数类型、加密模式、编码模式、补全模式、等等方面 系统的说明如何使用AES加密解密。

    看文章不能急功近利，为了解决一个问题临时查到一个代码套用进去，或许可以迅速解决问题，但是遇到新的问题还需要再次查询，这种我认为还是比较浪费时间的。我相信看完认真看完这篇文章的你会大有收获。

    2. 环境安装
    1. pip uninstall crypto
    2. pip uninstall pycryptodome
    3. pip install pycryptodome

    前面两个卸载命令是为了防止一些安装环境问题，具体请看文章

    3.加密模式

     AES 加密最常用的模式就是 ECB模式 和 CBC 模式，当然还有很多其它模式，他们都属于AES加密。ECB模式和CBC 模式俩者区别就是 ECB 不需要 iv偏移量，而CBC需要。

    4.AES加密使用参数

    以下参数都是在python中使用的。

    参数作用及数据类型
    秘钥加密的时候用秘钥，解密的时候需要同样的秘钥才能解出来; 数据类型为bytes
    明文需要加密的参数; 数据类型为bytes
    模式aes 加密常用的有 ECB 和 CBC 模式（我只用了这两个模式，还有其他模式）;数据类型为aes类内部的枚举量
    iv 偏移量这个参数在 ECB 模式下不需要，在 CBC 模式下需要；数据类型为byte

    下面简单的一个例子ECB模式加密解密 :

    1. from Crypto.Cipher import AES
    2.  
    3. password = b'1234567812345678' #秘钥，b就是表示为bytes类型
    4. text = b'abcdefghijklmnhi' #需要加密的内容，bytes类型
    5. aes = AES.new(password,AES.MODE_ECB) #创建一个aes对象
    6. # AES.MODE_ECB 表示模式是ECB模式
    7. en_text = aes.encrypt(text) #加密明文
    8. print("密文：",en_text) #加密明文，bytes类型
    9. den_text = aes.decrypt(en_text) # 解密密文
    10. print("明文：",den_text)

    输出:

    1. 密文： b'WU\xe0\x0e\xa3\x87\x12\x95\\]O\xd7\xe3\xd4 )'
    2. 明文： b'abcdefghijklmnhi'

    以上是针对ECB模式的加密解密，从这个例子中可以看出参数中有几个限制。

    1. 秘钥必须为16字节或者16字节的倍数的字节型数据。
    2. 明文必须为16字节或者16字节的倍数的字节型数据，如果不够16字节需要进行补全，关于补全规则，后面会在补全模式中具体介绍。

    通过CBC模式例子：

    1. from Crypto.Cipher import AES
    2. password = b'1234567812345678' #秘钥，b就是表示为bytes类型
    3. iv = b'1234567812345678' # iv偏移量，bytes类型
    4. text = b'abcdefghijklmnhi' #需要加密的内容，bytes类型
    5. aes = AES.new(password,AES.MODE_CBC,iv) #创建一个aes对象
    6. # AES.MODE_CBC 表示模式是CBC模式
    7. en_text = aes.encrypt(text) 
    8. print("密文：",en_text) #加密明文，bytes类型
    9. aes = AES.new(password,AES.MODE_CBC,iv) #CBC模式下解密需要重新创建一个aes对象
    10. den_text = aes.decrypt(en_text)
    11. print("明文：",den_text)

    输出:

    1. 密文： b'\x93\x8bN!\xe7~>\xb0M\xba\x91\xab74;0'
    2. 明文： b'abcdefghijklmnhi'

    通过上面CBC模式的例子，可以简单看出CBC模式与ECB模式的区别：AES.new() 解密和加密重新生成了aes对象，加密和解密不能调用同一个aes对象，否则会报错TypeError: decrypt() cannot be called after encrypt()。

    总结：

    1. 在Python中进行AES加密解密时，所传入的密文、明文、秘钥、iv偏移量、都需要是bytes（字节型）数据。python 在构建aes对象时也只能接受bytes类型数据。

    2.当秘钥，iv偏移量，待加密的明文，字节长度不够16字节或者16字节倍数的时候需要进行补全。

    3. CBC模式需要重新生成AES对象，为了防止这类错误，我写代码无论是什么模式都重新生成AES对象。


    5.编码模式

    前面说了，python中的 AES 加密解密，只能接受字节型(bytes)数据。而我们常见的 待加密的明文可能是中文，或者待解密的密文经过base64编码的，这种都需要先进行编码或者解码，然后才能用AES进行加密或解密。反正无论是什么情况，在python使用AES进行加密或者解密时，都需要先转换成bytes型数据。

    我们以ECB模式针对中文明文进行加密解密举例：

    1. from Crypto.Cipher import AES
    2.  
    3. password = b'1234567812345678' #秘钥，b就是表示为bytes类型
    4. text = "好好学习天天向上".encode('gbk') #gbk编码，是1个中文字符对应2个字节，8个中文正好16字节
    5. aes = AES.new(password,AES.MODE_ECB) #创建一个aes对象
    6. # AES.MODE_ECB 表示模式是ECB模式
    7. print(len(text))
    8. en_text = aes.encrypt(text) #加密明文
    9. print("密文：",en_text) #加密明文，bytes类型
    10. den_text = aes.decrypt(en_text) # 解密密文
    11. print("明文：",den_text.decode("gbk")) # 解密后同样需要进行解码

    输出:

    1. 16
    2. 密文： b'=\xdd8k\x86\xed\xec\x17\x1f\xf7\xb2\x84~\x02\xc6C'
    3. 明文： 好好学习天天向上

    对于中文明文，我们可以使用encode()函数进行编码，将字符串转换成bytes类型数据，而这里我选择gbk编码，是为了正好能满足16字节，utf8编码是一个中文字符对应3个字节。这里为了举例所以才选择使用gbk编码。

    在解密后，同样是需要decode()函数进行解码的，将字节型数据转换回中文字符（字符串类型）。

    现在我们来看另外一种情况，密文是经过base64编码的(这种也是非常常见的，很多网站也是这样使用的)，我们用 http://tool.chacuo.net/cryptaes/ 这个网站举例子：

    模式：ECB

    密码: 1234567812345678

    字符集：gbk编码

    输出: base64

    我们来写一个python 进行aes解密：

    1. from Crypto.Cipher import AES
    2. import base64
    3.  
    4. password = b'1234567812345678' 
    5. aes = AES.new(password,AES.MODE_ECB) 
    6. en_text = b"Pd04a4bt7Bcf97KEfgLGQw=="
    7. en_text = base64.decodebytes(en_text) #将进行base64解码，返回值依然是bytes
    8. den_text = aes.decrypt(en_text)
    9. print("明文：",den_text.decode("gbk"))

    输出:

    明文： 好好学习天天向上

    这里的 b"Pd04a4bt7Bcf97KEfgLGQw==" 是一个bytes数据， 如果你传递的是一个字符串，你可以直接使用 encode()函数 将其转换为 bytes类型数据。

    1. from Crypto.Cipher import AES
    2. import base64
    3.  
    4. password = b'1234567812345678' 
    5. aes = AES.new(password,AES.MODE_ECB) 
    6. en_text = "Pd04a4bt7Bcf97KEfgLGQw==".encode() #将字符串转换成bytes数据
    7. en_text = base64.decodebytes(en_text) #将进行base64解码，参数为bytes数据,返回值依然是bytes
    8. den_text = aes.decrypt(en_text) 
    9. print("明文：",den_text.decode("gbk"))

    因为无论是 utf8 和 gbk 编码，针对英文字符编码都是一个字符对应一个字节，所以这里**encode()**函数主要作用就是转换成bytes数据，然后使用base64进行解码。

    hexstr，base64编码解码例子：

    1. import base64
    2. import binascii
    3. data = "hello".encode()
    4. data = base64.b64encode(data)
    5. print("base64编码:",data)
    6. data = base64.b64decode(data)
    7. print("base64解码:",data)
    8. data = binascii.b2a_hex(data)
    9. print("hexstr编码:",data)
    10. data = binascii.a2b_hex(data)
    11. print("hexstr解码:",data)

    输出:

    1. base64编码: b'aGVsbG8='
    2. base64解码: b'hello'
    3. hexstr编码: b'68656c6c6f'
    4. hexstr解码: b'hello'

    这里要说明一下，有一些AES加密，所用的秘钥，或者IV向量是通过 base64编码或者 hexstr编码后的。针对这种，首先要进行的就是进行解码，都转换回 bytes数据，再次强调，python实现 AES加密解密传递的参数都是 bytes(字节型) 数据。

    另外，我记得之前的 pycryptodome库，传递IV向量时，和明文时可以直接使用字符串类型数据，不过现在新的版本都必须为 字节型数据了，可能是为了统一好记。

    6.填充模式

    前面我使用秘钥，还有明文，包括IV向量，都是固定16字节，也就是数据块对齐了。而填充模式就是为了解决数据块不对齐的问题，使用什么字符进行填充就对应着不同的填充模式

    AES补全模式常见有以下几种：

    模式意义
    ZeroPadding用b’\x00’进行填充，这里的0可不是字符串0，而是字节型数据的b’\x00’
    PKCS7Padding当需要N个数据才能对齐时，填充字节型数据为N、并且填充N个
    PKCS5Padding与PKCS7Padding相同，在AES加密解密填充方面我没感到什么区别
    no padding当为16字节数据时候，可以不进行填充，而不够16字节数据时同ZeroPadding一样

    这里有一个细节问题，我发现很多文章说的也是不对的。

    ZeroPadding填充模式的意义：很多文章解释是当为16字节倍数时就不填充，然后当不够16字节倍数时再用字节数据0填充，这个解释是不对的，这解释应该是no padding的，而ZeroPadding是不管数据是否对其，都进行填充，直到填充到下一次对齐为止，也就是说即使你够了16字节数据，它会继续填充16字节的0，然后一共数据就是32字节。

    这里可能会有一个疑问，为什么是16字节 ，其实这个是 数据块的大小，网站上也有对应设置，网站上对应的叫128位，也就是16字节对齐，当然也有192位(24字节)，256位(32字节)。

    本文在这个解释之后，后面就说数据块对齐问题了，而不会再说16字节倍数了。

    除了no padding 填充模式，剩下的填充模式都会填充到下一次数据块对齐为止，而不会出现不填充的问题。

    PKCS7Padding和 PKCS5Padding需要填充字节对应表：

    明文长度值（mod 16）添加的填充字节数每个填充字节的值
    0160x10
    1150x0F
    2140x0E
    3130X0D
    4120x0C
    5110x0B
    6100x0A
    790x09
    880x08
    970x08
    1060x07
    1150x06
    1240x05
    1330x04
    1420x03
    1510x01

    这里可以看到，当明文长度值已经对齐时（mod 16 = 0），还是需要进行填充，并且填充16个字节值为0x10。ZeroPadding填充逻辑也是类似的，只不过填充的字节值都为0x00，在python表示成 b'\x00'。

    填充完毕后，就可以使用 AES进行加密解密了，当然解密后，也需要剔除填充的数据，无奈Python这些步骤需要自己实现（如果有这样的库还请评论指出）。

    7.Python的完整实现:
    1. from Crypto.Cipher import AES
    2. import base64
    3. import binascii
    4.  
    5. # 数据类
    6. class MData():
    7.     def __init__(self, data = b"",characterSet='utf-8'):
    8.         # data肯定为bytes
    9.         self.data = data
    10.         self.characterSet = characterSet
    11.   
    12.     def saveData(self,FileName):
    13.         with open(FileName,'wb') as f:
    14.             f.write(self.data)
    15.  
    16.     def fromString(self,data):
    17.         self.data = data.encode(self.characterSet)
    18.         return self.data
    19.  
    20.     def fromBase64(self,data):
    21.         self.data = base64.b64decode(data.encode(self.characterSet))
    22.         return self.data
    23.  
    24.     def fromHexStr(self,data):
    25.         self.data = binascii.a2b_hex(data)
    26.         return self.data
    27.  
    28.     def toString(self):
    29.         return self.data.decode(self.characterSet)
    30.  
    31.     def toBase64(self):
    32.         return base64.b64encode(self.data).decode()
    33.  
    34.     def toHexStr(self):
    35.         return binascii.b2a_hex(self.data).decode()
    36.  
    37.     def toBytes(self):
    38.         return self.data
    39.  
    40.     def __str__(self):
    41.         try:
    42.             return self.toString()
    43.         except Exception:
    44.             return self.toBase64()
    45.  
    46.  
    47. ### 封装类
    48. class AEScryptor():
    49.     def __init__(self,key,mode,iv = '',paddingMode= "NoPadding",characterSet ="utf-8"):
    50.         '''
    51.         构建一个AES对象
    52.         key: 秘钥，字节型数据
    53.         mode: 使用模式，只提供两种，AES.MODE_CBC, AES.MODE_ECB
    54.         iv： iv偏移量，字节型数据
    55.         paddingMode: 填充模式，默认为NoPadding, 可选NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding
    56.         characterSet: 字符集编码
    57.         '''
    58.         self.key = key
    59.         self.mode = mode
    60.         self.iv = iv
    61.         self.characterSet = characterSet
    62.         self.paddingMode = paddingMode
    63.         self.data = ""
    64.  
    65.     def __ZeroPadding(self,data):
    66.         data += b'\x00'
    67.         while len(data) % 16 != 0:
    68.             data += b'\x00'
    69.         return data
    70.  
    71.     def __StripZeroPadding(self,data):
    72.         data = data[:-1]
    73.         while len(data) % 16 != 0:
    74.             data = data.rstrip(b'\x00')
    75.             if data[-1] != b"\x00":
    76.                 break
    77.         return data
    78.  
    79.     def __PKCS5_7Padding(self,data):
    80.         needSize = 16-len(data) % 16
    81.         if needSize == 0:
    82.             needSize = 16
    83.         return data + needSize.to_bytes(1,'little')*needSize
    84.  
    85.     def __StripPKCS5_7Padding(self,data):
    86.         paddingSize = data[-1]
    87.         return data.rstrip(paddingSize.to_bytes(1,'little'))
    88.  
    89.     def __paddingData(self,data):
    90.         if self.paddingMode == "NoPadding":
    91.             if len(data) % 16 == 0:
    92.                 return data
    93.             else:
    94.                 return self.__ZeroPadding(data)
    95.         elif self.paddingMode == "ZeroPadding":
    96.             return self.__ZeroPadding(data)
    97.         elif self.paddingMode == "PKCS5Padding" or self.paddingMode == "PKCS7Padding":
    98.             return self.__PKCS5_7Padding(data)
    99.         else:
    100.             print("不支持Padding")
    101.  
    102.     def __stripPaddingData(self,data):
    103.         if self.paddingMode == "NoPadding":
    104.             return self.__StripZeroPadding(data)
    105.         elif self.paddingMode == "ZeroPadding":
    106.             return self.__StripZeroPadding(data)
    107.  
    108.         elif self.paddingMode == "PKCS5Padding" or self.paddingMode == "PKCS7Padding":
    109.             return self.__StripPKCS5_7Padding(data)
    110.         else:
    111.             print("不支持Padding")
    112.  
    113.     def setCharacterSet(self,characterSet):
    114.         '''
    115.         设置字符集编码
    116.         characterSet: 字符集编码
    117.         '''
    118.         self.characterSet = characterSet
    119.  
    120.     def setPaddingMode(self,mode):
    121.         '''
    122.         设置填充模式
    123.         mode: 可选NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding
    124.         '''
    125.         self.paddingMode = mode
    126.  
    127.     def decryptFromBase64(self,entext):
    128.         '''
    129.         从base64编码字符串编码进行AES解密
    130.         entext: 数据类型str
    131.         '''
    132.         mData = MData(characterSet=self.characterSet)
    133.         self.data = mData.fromBase64(entext)
    134.         return self.__decrypt()
    135.  
    136.     def decryptFromHexStr(self,entext):
    137.         '''
    138.         从hexstr编码字符串编码进行AES解密
    139.         entext: 数据类型str
    140.         '''
    141.         mData = MData(characterSet=self.characterSet)
    142.         self.data = mData.fromHexStr(entext)
    143.         return self.__decrypt()
    144.  
    145.     def decryptFromString(self,entext):
    146.         '''
    147.         从字符串进行AES解密
    148.         entext: 数据类型str
    149.         '''
    150.         mData = MData(characterSet=self.characterSet)
    151.         self.data = mData.fromString(entext)
    152.         return self.__decrypt()
    153.  
    154.     def decryptFromBytes(self,entext):
    155.         '''
    156.         从二进制进行AES解密
    157.         entext: 数据类型bytes
    158.         '''
    159.         self.data = entext
    160.         return self.__decrypt()
    161.  
    162.     def encryptFromString(self,data):
    163.         '''
    164.         对字符串进行AES加密
    165.         data: 待加密字符串，数据类型为str
    166.         '''
    167.         self.data = data.encode(self.characterSet)
    168.         return self.__encrypt()
    169.  
    170.     def __encrypt(self):
    171.         if self.mode == AES.MODE_CBC:
    172.             aes = AES.new(self.key,self.mode,self.iv) 
    173.         elif self.mode == AES.MODE_ECB:
    174.             aes = AES.new(self.key,self.mode) 
    175.         else:
    176.             print("不支持这种模式")  
    177.             return           
    178.  
    179.         data = self.__paddingData(self.data)
    180.         enData = aes.encrypt(data)
    181.         return MData(enData)
    182.  
    183.     def __decrypt(self):
    184.         if self.mode == AES.MODE_CBC:
    185.             aes = AES.new(self.key,self.mode,self.iv) 
    186.         elif self.mode == AES.MODE_ECB:
    187.             aes = AES.new(self.key,self.mode) 
    188.         else:
    189.             print("不支持这种模式")  
    190.             return           
    191.         data = aes.decrypt(self.data)
    192.         mData = MData(self.__stripPaddingData(data),characterSet=self.characterSet)
    193.         return mData
    194.  
    195.  
    196. if __name__ == '__main__':
    197.     key = b"1234567812345678"
    198.     iv =  b"0000000000000000"
    199.     aes = AEScryptor(key,AES.MODE_CBC,iv,paddingMode= "ZeroPadding",characterSet='utf-8')
    200.     
    201.     data = "好好学习"
    202.     rData = aes.encryptFromString(data)
    203.     print("密文：",rData.toBase64())
    204.     rData = aes.decryptFromBase64(rData.toBase64())
    205.     print("明文：",rData)
    206.

    我简单的对其进行了封装，加密和解密返回的数据类型可以使用toBase64(),toHexStr() 进行编码。另外我没有对key和iv进行补全，可以使用MData类自己实现，更多详细使用可以通过源码中注释了解。

    原文来自一位大佬，原链接：https://blog.csdn.net/chouzhou9701/article/details/122019967

    8.python实现 RSA加密

    -------RES加密来自于一个全球领先的视频为基础的安防大厂 DAHUA------

    1. from Crypto.Cipher import PKCS1_v1_5
    2. from Crypto.PublicKey import RSA
    3.  
    4.  
    5. def get_encrypt_password(pubkey, password):
    6.     if isinstance(password, str):  # isinstance函数来判断一个对象是否是一个已知的类型
    7.  
    8.         password = password.encode()  # 把字符串password 编码成字节类型(byte)
    9.  
    10.         # 秘钥生成 --XXX接口返回一个publickey,然后再拼接后作为秘钥
    11.         pub_key = """-----BEGIN PUBLIC KEY-----     
    12.         """ + pubkey.strip('"') + """
    13.         -----END PUBLIC KEY-----"""
    14.     # 实例化一个rsa 对象
    15.     key_obj = RSA.importKey(pub_key)  
    16.  
    17.     # 新建一个cipher对象
    18.     cipher = PKCS1_v1_5.new(key_obj) 
    19.  
    20.     # 调用cipher加密方法后再进行一次base64编码
    21.     web_safe_pwd = base64.b64encode(cipher.encrypt(password))  
    22.  
    23.     # 返回RSA 加密后的密文
    24.     return web_safe_pwd.decode()

    ==================================================

    在使用requests库中的POST方法时传参数据体数据类型错误的坑

    post 传json时，这里的是传python中的dict 而不是dict做dumps后的数据,这里是坑，测试了几次记录一下

    1. import requests
    2.  
    3. # 请求HTTPS 跳过ssl校验 并不打印警告信息 ,这里飘红不影响
    4. from requests.packages import urllib3
    5. urllib3.disable_warnings()
    6.  
    7. # 获取token
    8. def getToken():
    9.     url = f"{IP}:{PORT}/xxxxx
    11.     # 获取 access_token
    12.     access_Token = getToken()["data"]["access_token"]
    13.     Authorization = f"bearer {access_Token}"
    14.     
    15.     # 增加头部
    16.     headers = {
    17.     'Content-type': 'application/json',
    18.     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64;'
    19.                   ' x64) AppleWebKit/537.36 (KHTML, like'
    20.                   ' Gecko) Chrome/89.0.4389.90 Safari/537.36',
    21.     'Cookie': 'JSESSIONID=123456789;name=value'   ## 这里也可以设置cookie,
    22.     'Authorization': Authorization 
    23.     
    24.     }
    26.     # 请求体--数据部分
    27.     data = {
    28.         "grant_type": "password",
    29.         "username": USERNAME,
    30.         "password": rsaPassword,
    31.         "client_id": CLIENT_ID,
    32.         "client_secret": CLIENT_SECRET,
    33.         "public_key": pubkey
    34.     }
    35.     # jdata = json.dumps(data)
    36.     
    37.     # post 传json时，这里的是传python中的dict 而不是dict做dumps后的数据,这里是坑，测试了几次
    38.     # 一个respones对象
    39.     res = requests.post(url=url, headers=headers,json=data, verify=False,)
    41.     return res.json()  #返回的直接是python中的字符串格式

  • 相关阅读:
    拒绝服务 DDoS 攻击
    ZooKeeper之Java API的基本使用以及应用场景的实现
    STL-stack
    HXAPIGate系列——HXAPIGate快速入门
    SpringBoot+Vue+token实现（表单+图片）上传、图片地址保存到数据库。上传图片保存位置自己定义、图片可以在前端回显（一））
    数据库设计之E-R图和关系表
    TinyShell（CSAPP实验）
    【深度学习】详解 ViLT
    从0到1 express 安装swagger
    NestJs和Vite使用monorepo管理项目中,需要使用共享的文件夹步骤
  • 原文地址：https://blog.csdn.net/weixin_42419429/article/details/136405371