30分钟搞定AES系列（上）：基础特性

1. ECB模式（The Electronic Codebook Mode）
2. CBC模式（The Cipher Block Chaining Mode）
3. CTR模式（The Counter Mode）
4. GCM模式（The Galois/Counter Mode）
5. CFB模式（The Cipher Feedback Mode）
6. OFB模式（The Output Feedback Mode）

    def padding_check(self, origin: str, block_size: int):
        """ 
            假设BlockSize为128即16个字节，则：
            对于原文长度不足16个字节的，按照16字节(128比特)的BlockSize进行填充 
        """
        padder = padding.PKCS7(block_size).padder()
        ret = padder.update(origin.encode('utf-8'))
        ret += padder.finalize()
        print("origin=", list(origin),
              "after padding=", list(ret))
        
        """ 验证填充完成后的字节数是否符合预期 """
        self.assertEqual(len(ret) % get_bytes_len(block_size), 0)
        
        """ 填充值同时也是填充的字节长度 """
        padding_value = get_padding_value(
            get_bytes_len(block_size), len(origin))
        
        """ 填充长度为 padding_value 个字节，每个字节的值应该都是 padding_value """
        for i in range(1, padding_value + 1):
            self.assertEqual(int(ret[0 - i]), int(padding_value))

    def test_ecb_cipher(self):
        origin_1 = "aaaaaaaaaaaaaaaa"
        origin_2 = "bbbbbbbbbbbbbbbb"
        origin_3 = (origin_1 + origin_2)
        key = "1234567890123456".encode('utf-8')
        aes_obj = aes_encryption.aes_encryption("ecb", key)
        print("Current AES Mode:", aes_obj.current_mode)
        cipher_1, cipher_1_len = aes_obj.encrypt(origin_1.encode('utf-8'))
        cipher_2, cipher_2_len = aes_obj.encrypt(origin_2.encode('utf-8'))
        cipher_3, cipher_3_len = aes_obj.encrypt(origin_3.encode('utf-8'))
        print("cipher_1:{}".format(list(cipher_1)))
        print("cipher_2:{}".format(list(cipher_2)))
        print("cipher_3:{}".format(list(cipher_3)))
        """ ECB模式下的密文与明文一一对应，不安全 """
        self.assertEqual(cipher_1_len % 16, 0)
        self.assertEqual(cipher_2_len % 16, 0)
        self.assertEqual(cipher_3_len % 16, 0)
        self.assertEqual(
            cipher_1[:cipher_1_len - 16] + cipher_2[:cipher_2_len - 16], cipher_3[:cipher_3_len - 16])
        self.assertEqual(len(aes_obj.key_value) % 16, 0)
        self.assertLessEqual(len(aes_obj.key_value), 32)

    def test_aes_cbc_encryption(self):
        origin = os.urandom(random.randint(17, 256))
        key = os.urandom(32)
        iv = os.urandom(16)
        aes_obj = aes_encryption.aes_encryption("cbc", key, iv)
        print("Current AES Mode:", aes_obj.current_mode)
        cipher, cipher_len = aes_obj.encrypt(origin)
        plain, plain_len = aes_obj.decrypt(cipher)
        self.assertEqual(plain, origin)
        self.assertEqual(len(origin), plain_len)
        self.assertGreaterEqual(cipher_len, len(origin))
        print("cipher_len:", cipher_len)
        print("origin_len:", len(origin))
        print("len(origin) % 16 = ", len(origin) % 16)
        """
            假如原始数据长度等于 BlockSize * n，
            则使用 NoPadding 时加密后数据长度等于 BlockSize * n，其它情况下加密数据长度等于 BlockSize * (n+1)。
            假如原始数据长度等于 BlockSize*n+m [其中 m 小于BlockSize]，
            除了 NoPadding 填充之外的任何方式，加密数据长度都等于 BlockSize*(n+1)；
        """
        if len(origin) % 16 == 0:
            self.assertEqual(cipher_len, len(origin))
        else:
            self.assertEqual(cipher_len, (len(origin) // 16 + 1) * 16)

    def test_aes_cbc_decrypt_by_wrong_iv(self):
        """
            CBC模式的链式反应一般指的是加密的过程，因为当IV改变，加密过程中的所有密文block都会改变
            而解密的时候IV只会对第一个明文block有影响
        """
        # 64字节长度的明文
        origin_plain = os.urandom(64)
        print("origin_plain[0:16]:{}".format(list(origin_plain[0:16])))
        print("origin_plain[16:32]:{}".format(list(origin_plain[16:32])))
        print("origin_plain[32:48]:{}".format(list(origin_plain[32:48])))
        print("origin_plain[48:64]:{}".format(list(origin_plain[48:64])))
        # 32字节长度的key
        key = os.urandom(32)
        # print("key:{}".format(list(key)))
        # 16字节长度的iv
        iv = os.urandom(16)
        print("correct iv:{}".format(list(iv)))
        aes_obj = aes_encryption.aes_encryption("cbc", key, iv)
        cipher, cipher_len = aes_obj.encrypt(origin_plain)
        # 使用正确的key 和 iv进行解密
        plain, plain_len = aes_obj.decrypt(cipher)
        self.assertEqual(plain, origin_plain)
        self.assertEqual(len(origin_plain), plain_len)
        self.assertGreaterEqual(cipher_len, len(origin_plain))
        # 将iv设置为错误的值
        aes_obj.iv_value = os.urandom(16)
        self.assertNotEqual(iv, aes_obj.iv_value)
        print("wrong iv:{}".format(list(aes_obj.iv_value)))
        wrong_plain, wrong_plain_len = aes_obj.decrypt(cipher)
        print("wrong_plain[0:16]:{}".format(list(wrong_plain[0:16])))
        print("wrong_plain[16:32]:{}".format(list(wrong_plain[16:32])))
        print("wrong_plain[32:48]:{}".format(list(wrong_plain[32:48])))
        print("wrong_plain[48:64]:{}".format(list(wrong_plain[48:64])))
        # 即使使用错误的iv进行解密，但是得到的长度还是正确的，只是解密出来的内容会有不同
        self.assertNotEqual(wrong_plain, origin_plain)
        self.assertNotEqual(wrong_plain, plain)
        self.assertEqual(len(origin_plain), wrong_plain_len)
        # 解密的时候，错误的iv只影响明文块的第一个16字节block
        self.assertNotEqual(wrong_plain[0:16], origin_plain[0:16])
        self.assertEqual(wrong_plain[16:], origin_plain[16:])

无法保证消息的完整性：
    缺乏消息身份验证，攻击者很容易对截获的加密消息进行比特翻转，再重放，且无需对其进行解密。
    而因为CTR模式的延展性，一个比特的反转就会带来毁灭性的结果。
计数器块重用导致明文泄露：
    如果计数器块(nonce)被重用，它可能会导致泄漏明文；
    特别是CTR模式加密需要唯一的随机数输入，绝对不能将其重复用于使用同一密钥加密的两条不同的消息，所以随机数生成方法尤为重要。
密文长度已知(可以通过padding对原文的长度进行隐藏)：
    因为CTR模式不需要padding，所以其加密后的密文长度是可以知道的。
    尽管在许多加密方法中，消息长度并不被视作秘密（secert），但由于对称加密的特性，所以可以获得对应的明文长度，
    从而出现明文高位泄露的风险。

AES-128-GCM
AES-192-GCM
AES-256-GCM
ChaCha20-IETF-Poly1305
ChaCha20-IETF-Poly1305