python--AES加密

AES加密，用的是第三方模块 pycryptodome

安装：pip install pycryptodome -i https://pypi.douban.com/simple

win环境：pip install pycryptodome

linux环境：pip install pycrypto

ECB模式加密

from Crypto.Cipher import AES
import base64

password = '1234567890123456'.encode() #秘钥
#秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据）

text = 'wo is liming' #需要加密的内容

while len(text.encode('utf-8')) % 16 != 0:  # 如果text不足16位的倍数就用空格补足为16位
        text += '\0'
text=text.encode()

model = AES.MODE_ECB #定义模式
#模式：
#电码本模式（Electronic Codebook Book (ECB)）
#密码分组链接模式（Cipher Block Chaining (CBC)）
#计算器模式（Counter (CTR)）
#密码反馈模式（Cipher FeedBack (CFB)）
#输出反馈模式（Output FeedBack (OFB)）

aes = AES.new(password,model) #创建一个aes对象

en_text = aes.encrypt(text) #加密明文
#b'\x0b\x0f.\x1fc\x83-/\xac\x04#\x89Qs\x8c\xec'

en_text = base64.encodebytes(en_text) #将返回的字节型数据转进行base64编码
#b'Cw8uH2ODLS+sBCOJUXOM7A==\n'
en_text = en_text.decode('utf8') #转换成python中的字符串类型
#Cw8uH2ODLS+sBCOJUXOM7A==

print(en_text)

ECB模式解密

from Crypto.Cipher import AES
import base64

password = '1234567890123456'.encode() #秘钥
#秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据）
model = AES.MODE_ECB #定义模式
aes = AES.new(password,model) #创建一个aes对象

text='Cw8uH2ODLS+sBCOJUXOM7A=='.encode(encoding='utf-8')  # 需要解密的文本
#b'Cw8uH2ODLS+sBCOJUXOM7A=='
ecrypted_base64 = base64.decodebytes(text)  #base64解码成字节流
#b'\x0b\x0f.\x1fc\x83-/\xac\x04#\x89Qs\x8c\xec'
str=aes.decrypt(ecrypted_base64)  #解密
#b'wo is liming\x00\x00\x00\x00'
str=str.decode()
#wo is liming

print(str)

CBC模式加密

CBC模式是其中公认的安全性最好的模式

from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex


text = 'wo is liming' #需要加密的内容
while len(text.encode('utf-8')) % 16 != 0:  # 如果text不足16位的倍数就用空格补足为16位
        text += '\0'
text=text.encode()

mode = AES.MODE_CBC #定义模式

key = '1234567890123456'.encode('utf-8') #秘钥
##秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据）
iv = b'abcdabcdabcdabcd'   #偏移量--必须16字节

cryptos = AES.new(key, mode, iv)   #创建一个aes对象
cipher_text = cryptos.encrypt(text)  #利用aes对象进行加密
#b'\xf7t\xa0\x18 \x84-\xcco-\x91\xf5\xdb\x89\xe3\x88'

x=b2a_hex(cipher_text)  # 因为AES加密后的字符串不一定是ascii字符集的，输出保存可能存在问题，所以这里转为16进制字符串
#b'f774a01820842dcc6f2d91f5db89e388'
en_text = x.decode('utf-8') #转换成python中的字符串类型
#<class 'str'> f774a01820842dcc6f2d91f5db89e388

print(type(en_text),en_text)

CBC模式解密

from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex

mode = AES.MODE_CBC #定义模式
key = '1234567890123456'.encode('utf-8') #秘钥
##秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据）
iv = b'abcdabcdabcdabcd'   #偏移量--必须16字节
cryptos = AES.new(key, mode, iv)   #创建一个aes对象

text = 'f774a01820842dcc6f2d91f5db89e388' #需要解密的内容
x=a2b_hex(text)  # 16进制转换成二进制
b'\xf7t\xa0\x18 \x84-\xcco-\x91\xf5\xdb\x89\xe3\x88'
x=cryptos.decrypt(x)  #解密
# b'wo is liming\x00\x00\x00\x00'
x=bytes.decode(x).rstrip('\0')  #转换成字符串
#<class 'str'> wo is liming

print(type(x),x)

CFB模式加密

from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex

mode = AES.MODE_CFB #定义模式
key = '1234567890123456'.encode('utf-8') #秘钥
##秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据）
iv = b'abcdabcdabcdabcd'   #偏移量--必须16字节
aes = AES.new(key, mode, iv)   #创建一个aes对象

text = 'wo is liming' #需要加密的内容
while len(text.encode('utf-8')) % 16 != 0:  # 如果text不足16位的倍数就用空格补足为16位
        text += '\0'
text=text.encode()
encrypt_aes = aes.encrypt(text)   # 进行aes加密
#b'\x0c\x9e\xcaW\x97\x06\n\x9f\xde\xc0\xdd\x91\x1eh\x11\x0c'

x=b2a_hex(encrypt_aes)  # 因为AES加密后的字符串不一定是ascii字符集的，输出保存可能存在问题，所以这里转为16进制字符串
#b'0c9eca5797060a9fdec0dd911e68110c'

en_text = x.decode('utf-8') #转换成python中的字符串类型
#0c9eca5797060a9fdec0dd911e68110c

print(en_text)

CFB模式解密

from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex

mode = AES.MODE_CFB #定义模式
key = '1234567890123456'.encode('utf-8') #秘钥
##秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据）
iv = b'abcdabcdabcdabcd'   #偏移量--必须16字节
aes = AES.new(key, mode, iv)   #创建一个aes对象

text = '0c9eca5797060a9fdec0dd911e68110c' #需要解密的内容
x=a2b_hex(text)  # 16进制转换成二进制
#b'abcdabcdabcdabcd\x0c\x9e\xcaW\x97\x06\n\x9f\xde\xc0\xdd\x91\x1eh\x11\x0c'
x=aes.decrypt(x)  #解密
#b'\x1ap\x80\x82\x1ap\x80\x82\x1ap\x80\x82\x1ap\x80\x82wo is liming\x00\x00\x00\x00'

x=bytes.decode(x).rstrip('\0')  #转换成字符串
#wo is liming
print(x)

python 实现AES CBC 与PKCS7Padding联合加密

from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import algorithms


def pkcs7_padding(data):
    """
    PKCS7Padding填充加密，假设数据长度需要填充n(n>0)个字节才对齐，那么填充n个字节，每个字节都是n;
    如果数据本身就已经对齐了，则填充一块长度为块大小的数据，每个字节都是块大小。
    :param data:
    :return:
    """
    if not isinstance(data, bytes):
        data = data.encode()
    padder = padding.PKCS7(algorithms.AES.block_size).padder()
    padded_data = padder.update(data) + padder.finalize()
    return padded_data

def pkcs7_unpadding(padded_data):
    """
    PKCS7Padding填充解密
    :param padded_data:
    :return:
    """
    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
    data = unpadder.update(padded_data)
    try:
        uppadded_data = data + unpadder.finalize()
    except ValueError:
        raise Exception('无效的加密信息!')
    else:
        return uppadded_data

def encrypt(value, key="1234123412ABCDEF", iv="ABCDEF1234123412"):
    """
    AES CBC加密
    :param value:
    :param key:
    :param iv:
    :return:
    """
    k = key.encode('utf-8')  # 密钥
    iv = iv.encode('utf-8')  # 偏移量
    mode = AES.MODE_CBC
    value = value.encode('utf-8')  # 对数据进行utf-8编码
    cryptor = AES.new(k, mode, iv)  # 创建一个新的AES实例
    ciphertext = cryptor.encrypt(pkcs7_padding(value))  # 加密字符串
    ciphertext_hex = b2a_hex(ciphertext)  # 字符串转十六进制数据
    ciphertext_hex_de = ciphertext_hex.decode()
    return ciphertext_hex_de.upper()

def decrypt(text, key="1234123412ABCDEF", iv="ABCDEF1234123412"):
    """
    AES CBC解密
    :param text:
    :param key:
    :param iv:
    :return:
    """
    #  偏移量'iv'
    key = key.encode('utf-8')  # 密钥
    iv = iv.encode('utf-8')  # 偏移量
    mode = AES.MODE_CBC
    cryptor = AES.new(key, mode, iv)
    plain_text = cryptor.decrypt(a2b_hex(text))
    # return plain_text.rstrip('\0')
    return bytes.decode(plain_text).rstrip("\x01").\
        rstrip("\x02").rstrip("\x03").rstrip("\x04").rstrip("\x05").\
        rstrip("\x06").rstrip("\x07").rstrip("\x08").rstrip("\x09").\
        rstrip("\x0a").rstrip("\x0b").rstrip("\x0c").rstrip("\x0d").\
        rstrip("\x0e").rstrip("\x0f").rstrip("\x10")