get_token(self, user_id: bytes) -> Dict[str, bytes]

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

{
    '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'
}

{
    'token_padded_ok': False, 
    'verify_success': False
}

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]

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])

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"])

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

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

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)

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)

"""
    模拟创建带有漏洞的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)))