CBC Padding Oracle

2022-05-19

攻击场景：对称密码采用PKCS5或PKCS7 padding，存在接口可以为攻击者提供多次解密。

攻击原理：由于PKCS5和PKCS7的填充规则，每次解密以后通过检验填充部分的内容来确定解密是否正确，即key是否正确。遍历可能的key进行解密和验证，确定正确的key。

危害程度：出现过相关的CVE，高危。

例1.Xman 夏令营的一道题，给了AESCipher.py,lockfile.py和flag.encrypted三个文件

AESCipher.py

from Crypto import Random
from Crypto.Cipher import AES


class AESCipher(object):

    def __init__(self, key):
        self.bs = 32
        self.key = key

    @staticmethod
    def str_to_bytes(data):
        u_type = type(b''.decode('utf8'))
        if isinstance(data, u_type):
            return data.encode('utf8')
        return data

    def _pad(self, s):
        return s + (self.bs - len(s) % self.bs
                   ) * AESCipher.str_to_bytes(chr(self.bs - len(s) % self.bs))

    @staticmethod
    def _unpad(s):
        return s[:-ord(s[len(s) - 1:])]

    def encrypt(self, raw):
        raw = self._pad(AESCipher.str_to_bytes(raw))
        iv = Random.new().read(AES.block_size)
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return iv + cipher.encrypt(raw)

    def decrypt(self, enc):
        iv = enc[:AES.block_size]
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return cipher.decrypt(enc[AES.block_size:])

lockfile.py

#!/usr/bin/env python3
import sys
import hashlib
from AESCipher import *


class FileLocker(object):

    def __init__(self, keys):
        assert len(keys) == 4
        self.keys = keys
        self.ciphers = []
        for i in range(4):
            self.ciphers.append(AESCipher(keys[i]))

    def enc(self, plaintext):
        stage1 = self.ciphers[0].encrypt(plaintext)
        stage2 = self.ciphers[1].encrypt(stage1)
        stage3 = self.ciphers[2].encrypt(stage2)
        ciphertext = self.ciphers[3].encrypt(stage3)
        return ciphertext

    def dec(self, ciphertext):
        stage3 = AESCipher._unpad(self.ciphers[3].decrypt(ciphertext))
        stage2 = AESCipher._unpad(self.ciphers[2].decrypt(stage3))
        stage1 = AESCipher._unpad(self.ciphers[1].decrypt(stage2))
        plaintext = AESCipher._unpad(self.ciphers[0].decrypt(stage1))
        return plaintext


if __name__ == "__main__":
    if len(sys.argv) != 3:
        # PASSWORD SHOULD BE Visible character
        print("Usage: ./lockfile.py plainfile password")
        exit()

    filename = sys.argv[1]
    plaintext = open(filename, "rb").read()

    password = sys.argv[2].encode('utf-8')
    assert len(password) == 8
    i = len(password) / 4
    keys = [
        hashlib.sha256(password[0:i]).digest(),
        hashlib.sha256(password[i:2 * i]).digest(),
        hashlib.sha256(password[2 * i:3 * i]).digest(),
        hashlib.sha256(password[3 * i:4 * i]).digest(),
    ]
    s = FileLocker(keys)

    ciphertext = s.enc(plaintext)

    open(filename + ".encrypted", "w").write(ciphertext)

可以看到加密程序对于 key 的处理很特别，八字符的 key 被分成了四组，每组两个字符哈希后作为 AES 密钥，把明文加密了四次。采用的是下一轮加密上一轮的密文这种形式。

padding是PKCS5：

1 2	def _pad(self, s): return s + (self.bs - len(s) % self.bs) * AESCipher.str_to_bytes(chr(self.bs - len(s) % self.bs))

直接爆破八个字符显然不可能，数量级是len(dict)^8,我们考虑把每步分解，如果四轮加密中，每一轮都能知道当前的两个字符是否正确，那么数量级就变成了4*(len(dict)^2),就能减少运算复杂度。而由于padding是PKCS5，是可以验证每轮解密是否正确的。check代码：

def checkPadding(raw):
    s=raw[-1]
    if s==chr(0) or s==chr(1):
        return False
    if raw[len(raw)-ord(s):]==ord(s)*s:
        return True
    else:
        return False

解密得到的明文最后字节是0的时候，key一定错误，因为没有填充0的用法；最后一位字符是1是有可能的，正好缺了一个字节，但只会发生在填充最原始的明文的时候，因为第二轮开始加密的都是上一轮的密文，都是 AES 分组大小的倍数，不可能差一个字节，而且爆破的过程中如果解密出来最后一个字节正好是 chr(1),就会认为填充正确，判断错误的几率还是很大的，所以代码里直接返回 False 更容易找到正确的明文。

完整exp：

# -*- coding:utf-8 -*-
import hashlib
import string
import libnum
from AESCipher import *

def checkPadding(raw):
    s=raw[-1]
    if s==chr(0) or s==chr(1):
        return False
    if raw[len(raw)-ord(s):]==ord(s)*s:
        return True
    else:
        return False
flag_enc=open("flag.encrypted").read()

dict=[]
for x in string.printable:
    for y in string.printable:
        dict.append(hashlib.sha256(x+y).digest())

cipher=flag_enc
for i in range(4):
    for key in dict:
        raw=AESCipher(key).decrypt(cipher)
        if checkPadding(raw):
            cipher=AESCipher._unpad(raw)
            break
flag=""
i=0
while i<len(cipher)-1:
    if cipher[i]=='1':
        flag+=chr(int(cipher[i:i+3]))
        i=i+3
    else:
        flag+=chr(int(cipher[i:i+2]))
        i=i+2
print flag

上述题目是最简单的padding类型，解更复杂的题目则需要利用CBC模式特征，如例2

还有其他攻击场景，比如在不知道密钥的情况下，完成数据的加密，绕过服务端的校验（解密成功+明文有效），达到攻击的目的。

还有类似于例3这样的变式题；这是tjctf的一道题，padding方式虽然略有不同，但核心思想一致。