30分钟搞定AES系列(中)：PaddingOracle填充攻击分析与启示

1
2

get_token(self, user_id: bytes) -> Dict[str, bytes]
verify_token(self, token: bytes, user_id: bytes, iv: bytes) -> Dict[str, bool]

1
2
3
4

{
    'token': b'[\xf1\xd9\x16\x8b\xb5\x8d\x17\xe2{\xc7\xfdvl=\x95\xb0\xd9g\n\x1d\x1d-\x8a;\xc5\xf1\x8eh\x15\xb5\xa0',
    'iv': b'0000000000000000'
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def oracle_sslv3_padding(input_data: bytes, block_bytes_size: int = 16) -> bytes:
    """
    假设填充默认以16个字节即128bits 为一个block
    只将填充长度放到填充完成后的最后一个字节中
    其余的填充字节中默认填充0x00
    
    也就是说:
    无论原文是否为block_bytes_size的整数倍,末尾都会添加一个block_bytes_size的填充块
    最后的那个填充块,只有最有一个字节是有意义的,代表了填充的长度
    而最有一个填充块的前block_bytes_size - 1个字节都是无意义的(因为都是0x00)
    """
    needed_bytes = block_bytes_size - len(input_data) % block_bytes_size
    # 由于这种攻击一般发生在SSLv3的网络通信链路上
    # 因此这里默认使用大端字节序
    padding_value = needed_bytes.to_bytes(needed_bytes, "big")
    return input_data + padding_value

def oracle_sslv3_unpadding(input_data: bytes) -> bytes:
    """
    使用不太安全的方式进行padding的去除:
    只关心最后一个字节的值,将其作为填充的长度
    """
    padded_len = int(input_data[-1])
    return input_data[: len(input_data) - padded_len]

1
2
3
4

def check_padding_data(input_data: bytes) -> bool:
    padded_len = input_data[-1]
    padded_data = input_data[0 - padded_len:]
    return padded_data == bytes([0x00] * (padded_len - 1)) + bytes([padded_len])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

def test_oracle_encrypt_decrypt(self):
    """ 验证在参数合法的情况下是否可以正常加解密 """
    key = bytes().zfill(32)
    iv = bytes().zfill(16)
    user_id = b"hello,world12345"
    
    oracle_server = aes_attack.dangerous_oracle_sslv3_server(key, iv)
    ret = oracle_server.get_token(user_id)
    print(ret)
    
    self.assertTrue("token" in ret)
    self.assertTrue("iv" in ret)
    
    verify_ret = oracle_server.verify_token(ret["token"], user_id, ret["iv"])
    print(verify_ret)
    
    self.assertTrue("token_padded_ok" in verify_ret)
    self.assertTrue(verify_ret["token_padded_ok"])
    self.assertTrue("verify_success" in verify_ret)
    self.assertTrue(verify_ret["verify_success"])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

CBC模式加密过程:
1. 明文经过填充后,分为不同的组block,以组的方式对数据进行处理
2. 初始化向量(IV)首先和第一组明文进行XOR(异或)操作,得到"中间值"
3. 采用密钥对中间值进行块加密,删除第一组加密的密文 (加密过程涉及复杂的变换、移位等)
4. 第一组加密的密文作为第二组的初始向量(IV),参与第二组明文的异或操作
5. 依次执行块加密,最后将每一块的密文拼接成密文

CBC模式解密过程:
1. 将密文进行分组(按照加密采用的分组大小),默认将前面的一组密文作为后面密文块的初始化向量,第一个密文块的初始化向量使用用户自定义的初始化向量,即原始的IV。
2. 使用加密密钥对密文的第一组进行解密,得到"中间值"
3. 将中间值和初始化向量进行异或,得到该组的明文
4. 前一块密文是后一块密文的IV,通过异或中间值,得到明文
5. 块全部解密完成后,拼接得到明文,密码算法校验明文的格式(填充格式是否正确)
6. 校验通过得到明文,校验失败得到密文

1

plain_block_mid_0 ^ IV == plain_block_0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

def get_mid_value(cipher_block: bytes, server: dangerous_oracle_sslv3_server) -> bytes:
    """
    输入分组的密文数据块和解密接口
    输出这个密文块被AES-CBC算子解密后的中间值
    """
    plain_block_mid = [0x00] * len(cipher_block)
    
    for byte_index in range(1, 17):
        """
        byte_index表示当前正在破解的倒数第几个字节
        当前破解倒数第一个字节,则表示 当前假设明文块填充了一个字节
        当前破解倒数第二个字节,则表示,当前假设明文块填充了两个字节
        以此类推
        """
        for v in range(0, 256):
            """
            当前破解第几个字节,则构造测试IV的第几个字节就需要被遍历赋值并测试填充是否正常
            """
            test_iv = [0x00] * 16
            test_iv[0 - byte_index] = v
            
            if byte_index > 1:
                test_iv[-1] = byte_index ^ plain_block_mid[-1]
                for x in range(2, byte_index):
                    test_iv[0 - x] = 0x00 ^ plain_block_mid[0 - x]
            
            ret = server.verify_token(cipher_block, bytes().zfill(16), bytes(test_iv))
            if ret["token_padded_ok"]:
                if byte_index == 1:
                    plain_block_mid[0 - byte_index] = byte_index ^ test_iv[0 - byte_index]
                else:
                    plain_block_mid[0 - byte_index] = 0x00 ^ test_iv[0 - byte_index]
                print("crack byte_index={} success, test_iv={}, plain_block_mid={}".format(
                    byte_index, list(test_iv), list(plain_block_mid)))
                break
                
    return bytes(plain_block_mid)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

def crack_cipher(cipher: bytes, original_iv: bytes, server: dangerous_oracle_sslv3_server) -> bytes:
    """
    输入完整的AES-CBC密文
    返回破解出的明文
    """
    cipher_len = len(cipher)
    group = int(cipher_len / 16)
    ret = [0x00] * cipher_len
    
    for i in range(group):
        mid_block = get_mid_value(cipher[i * 16:(i + 1) * 16], server)
        for j in range(0, len(mid_block)):
            if i == 0:
                ret[i * 16 + j] = list(mid_block)[j] ^ list(original_iv)[j]
            else:
                ret[i * 16 + j] = list(mid_block)[j] ^ list(cipher[(i-1) * 16: i * 16])[j]
    
    print("=" * 32)
    return bytes(ret)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

""" 模拟创建带有漏洞的oracle服务"""
key = bytes().zfill(32)
iv = bytes().zfill(16)
danger_oracle_server = dangerous_oracle_sslv3_server(key, iv)

""" 攻击者首先随便创建了一个user_id进行试探,以获取到服务端返回的iv
攻击者此时可以根据自己输入的明文计算出来明文被填充后的完整block"""
user_id = b"hello,world1234567890123456"
user_id_padded = oracle_sslv3_padding(user_id)

ret = danger_oracle_server.get_token(user_id)
token = ret["token"]
iv = ret["iv"]

print(
    "user_id:{}\nuser_id_padded:{}\ntoken:{}, length:{}\niv:{}\n{}".format(
        list(user_id), list(user_id_padded), list(token), len(token), list(iv)
        32))

ret = crack_cipher(token, iv, danger_oracle_server)
print("cracked_plain={}\norigin plain={}".format(list(ret), list(user_id)))