Crypto模块使用

AES简介

• 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。

• AES加密有AES-128、AES-192、AES-256三种，分别对应三种密钥长度128bits（16字节）、192bits（24字节）、256bits（32字节）。当然，密钥越长，安全性越高，加解密花费时间也越长。默认的是AES-128，其安全性完全够用。

• AES算法为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图：
  

AES只是个基本算法，实现AES有几种模式，主要有ECB、CBC、CFB和OFB这几种（其实还有个CTR）：

1. ECB模式（电子密码本模式：Electronic codebook）
   ECB是最简单的块密码加密模式，加密前根据加密块大小（如AES为128位）分成若干块，之后将每块使用相同的密钥单独加密，解密同理。

2. CBC模式（密码分组链接：Cipher-block chaining）
   CBC模式对于每个待加密的密码块在加密前会先与前一个密码块的密文异或然后再用加密器加密。第一个明文块与一个叫初始化向量的数据块异或。

3. CFB模式（密文反馈：Cipher feedback）
   与ECB和CBC模式只能够加密块数据不同，CFB能够将块密文（Block Cipher）转换为流密文（Stream Cipher）。

4. OFB模式（输出反馈：Output feedback）
   OFB是先用块加密器生成密钥流（Keystream），然后再将密钥流与明文流异或得到密文流，解密是先用块加密器生成密钥流，再将密钥流与密文流异或得到明文，由于异或操作的对称性所以加密和解密的流程是完全一样的。

代码实现与解析

1. ECB模式

from Crypto.Cipher import AES
import base64


class AEScoder():
    def __init__(self):
        self.__encryptKey = "iEpSxImA0vpMUAabsjJWug=="
        self.__key = base64.b64decode(self.__encryptKey)

    # AES加密
    def encrypt(self, data):
        BS = 16
        pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
        cipher = AES.new(self.__key, AES.MODE_ECB)
        encrData = cipher.encrypt(pad(data).encode('utf-8'))
        # encrData = base64.b64encode(encrData)
        return encrData

    # AES解密
    def decrypt(self, encrData):
        # encrData = base64.b64decode(encrData)
        # unpad = lambda s: s[0:-s[len(s)-1]]
        unpad = lambda s: s[0:-s[-1]]
        cipher = AES.new(self.__key, AES.MODE_ECB)
        decrData = unpad(cipher.decrypt(encrData))
        return decrData.decode('utf-8')


if __name__ == '__main__':
    aescoder = AEScoder()
    data = 'hello world'
    a = aescoder.encrypt(data)
    print("加密：", a)
    print("解密：", aescoder.decrypt(a))

• 简析1：这里采用了面向对象的写法，创建了一个类，同时也偷懒直接把密钥写死成了类的属性。如果有灵活修改密钥的需求，将密钥作为参数传进去即可。
• 简析2：例子里用了ECB模式，这是AES加密最简单也是很常用的模式。另外一个常用模式是CBC，会比ECB模式多一个初始偏移向量iv：cipher = AES.new(self.__key, AES.MODE_CBC, iv)。
• 简析3：pad和unpad分别是填充函数和逆填充函数。因为AES加密对加密文本有长度要求，必须是密钥字节数的倍数。这里的encryptKey在经过base64解码后的长度是16个字节。

填充算法拓展

• 这里采用的填充算法其实有个专有名词，叫pkcs7padding。
  简单解释就是缺几位就补几：填充字符串由一个字节序列组成，每个字节填充该填充字节序列的长度。
  如果要填充8个字节,那么填充的字节的值就是0x08；要填充7个字节,那么填入的值就是0x07；以此类推。
  如果文本长度正好是BlockSize长度的倍数，也会填充一个BlockSize长度的值。这样的好处是，根据最后一个Byte的填充值即可知道填充字节数。

• 实际上，java中实现AES加密算法的默认模式是Cipher.getInstance(“AES/ECB/PKCS5Padding”)
  PKCS#5在填充方面，是PKCS#7的一个子集：PKCS#5只是对于8字节（BlockSize=8）进行填充，填充内容为0x01-0x08；但是PKCS#7不仅仅是对8字节填充，其BlockSize范围是1-255字节。
  然而因为AES并没有64位（8字节）的块, 如果采用PKCS5, 那么实质上就是采用PKCS7。

2. CBC模式

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


# 如果text不足16位的倍数就用空格补足为16位
def add_to_16(text):
    if len(text.encode('utf-8')) % 16:
        add = 16 - (len(text.encode('utf-8')) % 16)
    else:
        add = 0
    text = text + ('\0' * add)
    return text.encode('utf-8')


# 加密函数
def encrypt(text):
    key = '9999999999999999'.encode('utf-8')
    mode = AES.MODE_CBC
    iv = b'qqqqqqqqqqqqqqqq'
    text = add_to_16(text)
    cryptos = AES.new(key, mode, iv)
    cipher_text = cryptos.encrypt(text)
    # 因为AES加密后的字符串不一定是ascii字符集的，输出保存可能存在问题，所以这里转为16进制字符串
    return b2a_hex(cipher_text)


# 解密后，去掉补足的空格用strip() 去掉
def decrypt(text):
    key = '9999999999999999'.encode('utf-8')
    iv = b'qqqqqqqqqqqqqqqq'
    mode = AES.MODE_CBC
    cryptos = AES.new(key, mode, iv)
    plain_text = cryptos.decrypt(a2b_hex(text))
    return bytes.decode(plain_text).rstrip('\0')


if __name__ == '__main__':
    e = encrypt("hello world")  # 加密
    d = decrypt(e)  # 解密
    print("加密:", e)
    print("解密:", d)

补充一个RSA的

import base64

from Crypto import Random
from Crypto.Hash import SHA
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Crypto.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5

# 1.伪随机生成器
random_generator = Random.new().read
print(random_generator)

# 2. rsa实例
rsa = RSA.generate(1024, random_generator)
print(rsa)

# 3. 生成私钥 公钥
private_key = rsa.export_key()
public_key = rsa.publickey().export_key()
print(private_key)
print(public_key)

# 4. 秘钥写入文件
with open('private_key.pem', 'wb') as f:
    f.write(private_key)

with open('public_key.pem', 'wb') as f:
    f.write(public_key)

# 5. 公钥加密
with open('public_key.pem', 'rb') as f:
    public_key = f.read()
    rsa_key = RSA.import_key(public_key)
    pkcs = Cipher_pkcs1_v1_5.new(rsa_key)
    text = base64.b64encode(pkcs.encrypt('1234'.encode(encoding='utf-8')))
    print("-" * 120)
    print(text)

# 6. 私钥解密
with open('private_key.pem', 'rb') as f:
    private_key = f.read()
    rsa_key = RSA.import_key(private_key)
    pkcs = Cipher_pkcs1_v1_5.new(rsa_key)
    text = pkcs.decrypt(base64.b64decode(text), random_generator).decode()
    print("-" * 120)
    print(text)

# 7. 签名和验签
# 7.1 私钥签名
print('私钥签名')
with open('private_key.pem') as f:
    key = f.read()
    rsa_key = RSA.importKey(key)
    signer = Signature_pkcs1_v1_5.new(rsa_key)
    digest = SHA.new()
    digest.update('签名和验签'.encode("utf8"))
    sign = signer.sign(digest)
    signature = base64.b64encode(sign)

print(signature)

# 7.2 公钥验签
print('公钥验签')
with open('public_key.pem') as f:
    key = f.read()
    rsa_key = RSA.importKey(key)
    verifier = Signature_pkcs1_v1_5.new(rsa_key)
    digest = SHA.new()
    digest.update('签名和验签'.encode("utf8"))
    is_verify = verifier.verify(digest, base64.b64decode(signature))

print(is_verify)