Padding Oracle Attack学习笔记#

前言#

周末的比赛出了这题，最近一直对数学性强的加密研究较多，对于此类算法性强的加密方法没有过多关注，结果比赛就是被socket的通信坑了大半天v_v

这篇文章主要是简单记录一下，具体原理和攻击方法有很多师傅讲的要比我好很多。

而且写完我感觉也挺乱的，似乎只有脚本可以供各位参考

AEC-CBC加密#

加解密基本原理图：

CBC加密时按AES.block_size字节分块将明文分块，每块异或分别使用key加密，加密后输出同时自身参与下一块的异或操作。解密时每一块密文通过key作用再与前一块密文进行异或得到明文。

注意无论是加密还是解密，都与且仅与上一块通过单次异或作用。

PKCS7 Padding#

注意到上述CBC加解密过程中将明文密文按AES.block_size字节分块，如果明文长度不是AES.block_size字节的整数倍呢？需要使用PKCS7 Padding的数据填充规则，以AES.block_size = 16为例，下面演示padding的过程。

无论明文多长，最后一块的长度一定是 $\{1,2,3,\cdots,14,15,16\}$ ，对每种情况的最后一块数据进行填充(包括最后一节为16字节的情况)，补充的字节数是到下一个16字节倍数所需字节数，每个填充字节的值也是到下一个16字节倍数所需字节数。

听起来很拗口，下面看具体情况：

最后一节为 $15$ 个字节，需要补充 $1$ 个字节达到 $16$ 的倍数，则填充 $1$ 个0x01

最后一节为 $10$ 个字节，需要补充 $6$ 个字节达到 $16$ 的倍数，则填充 $6$ 个0x06

最后一节为 $2$ 个字节，需要补充 $14$ 个字节达到 $16$ 的倍数，则填充 $14$ 个0x0e

最后一节为 $16$ 个字节，需要补充 $16$ 个字节达到 $16$ 的倍数，则填充 $16$ 个0x10

因此，补充后最后一节的可能性有如下16种情况：

1
... | XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX 01
2
... | XX XX XX XX XX XX XX XX XX XX XX XX XX XX 02 02
3
... | XX XX XX XX XX XX XX XX XX XX XX XX XX 03 03 03
4
... | XX XX XX XX XX XX XX XX XX XX XX XX 04 04 04 04
5
... | XX XX XX XX XX XX XX XX XX XX XX 05 05 05 05 05
6
... | XX XX XX XX XX XX XX XX XX XX 06 06 06 06 06 06
7
... | XX XX XX XX XX XX XX XX XX 07 07 07 07 07 07 07
8
... | XX XX XX XX XX XX XX XX 08 08 08 08 08 08 08 08
9
... | XX XX XX XX XX XX XX 09 09 09 09 09 09 09 09 09
10
... | XX XX XX XX XX XX 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a
11
... | XX XX XX XX XX 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b
12
... | XX XX XX XX 0c 0c 0c 0c 0c 0c 0c 0c 0c 0c 0c 0c
13
... | XX XX XX 0d 0d 0d 0d 0d 0d 0d 0d 0d 0d 0d 0d 0d
14
... | XX XX 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e
15
... | XX 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f
16
... | 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10

下面这种具体情况是正确的：

1
35 70 f2 45 09 d3 a3 6b 90 3e 3a 58 03 03 03 03

下面这种具体情况是错误的：

1
35 70 f2 45 09 d3 a3 6b 90 3e 3a 58 07 02 03 03

正确的情况在Unpadding中可以正确还原出明文

错误的情况在Unpadding中会出错

如果恰巧，当服务端把是否Unpadding成功的信息泄露出来，就可以针对其进行破解

例题#

1
from base64 import *
2
from Crypto.Random import get_random_bytes
3
from Crypto.Cipher import AES
4
from Crypto.Util.number import *
5
import os
6
import string
7
from hashlib import sha256
8
import socketserver
9
import signal
10
import random
11
# flag = os.getenv('FLAG').encode()
12

13
AES.block_size=16
14
iv = get_random_bytes(AES.block_size)
15
key = get_random_bytes(16)
16

17
class Task(socketserver.BaseRequestHandler):
18
    def proof_of_work(self):
19
        random.seed(os.urandom(8))
20
        proof = ''.join(
21
            [random.choice(string.ascii_letters+string.digits) for _ in range(20)])
22
        _hexdigest = sha256(proof.encode()).hexdigest()
23
        self.send(f"[+] sha256(XXXX+{proof[4:]}) == {_hexdigest}".encode())
24
        x = self.recv(prompt=b'[+] Plz tell me XXXX: ')
25
        if len(x) != 4 or sha256(x+proof[4:].encode()).hexdigest() != _hexdigest:
26
            return True
27
        return True
28

29
    def _recvall(self):
30
        BUFF_SIZE = 2048
31
        data = b''
32
        while True:
33
            part = self.request.recv(BUFF_SIZE)
34
            data += part
35
            if len(part) < BUFF_SIZE:
36
                break
37
        print("[+] "+ data.strip().decode())
38
        return data.strip()
39

40
    def send(self, msg, newline=True):
41
        try:
42
            if newline:
43
                msg += b'\n'
44
            self.request.sendall(msg)
45
            print('[-] '+msg.decode())
46
        except:
47
            pass
48

49
    def recv(self, prompt=b'> '):
50
        self.send(prompt, newline=False)
51
        return self._recvall()
52

53
    def timeout_handler(self, signum, frame):
54
        raise TimeoutError
55

56

57
class ThreadedServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
58
    pass
59

60

61
def pad(text):
62
    pad_num = 16 - len(text) % 16
63
    return text + pad_num*bytes([pad_num])
64

65

66
def unpad(text):
67
    pad_num = int(text[-1])
68
    if pad_num == 0:
69
        return b'Man'
70
    for i in range(1, pad_num+1):
71
        if int(text[-i]) != pad_num:
72
            return b'Man'
73
    else:
74
        tmp = text[:-pad_num]
75
        return b'Mamba out!'
76

77

78
def encrypt(plain_text, key):
79
    cipher = AES.new(key, AES.MODE_CBC, iv)
80
    cipher_text = cipher.encrypt(pad(plain_text))
81
    return iv + cipher_text
82

83

84
def decrypt(cipher_text, key):
85
    iv = cipher_text[:AES.block_size]
86
    cipher = AES.new(key, AES.MODE_CBC, iv)
87
    tmp = cipher.decrypt(cipher_text[AES.block_size:])
88
    result = unpad(tmp)
89
    return result
90

91

92
class test(Task):
93
    def handle(self):
94
        if not self.proof_of_work():
95
            self.send(b'[!] Wrong!')
96
            return
97
        enc = encrypt(flag, key)
98
        self.send(b'secret:')
99
        self.send(b64encode(enc))
100
        self.send(b'What can I say?')
101
        while True:
102
            data = self.recv()
103
            try:
104
                self.send(decrypt(b64decode(data), key))
105
            except:
106
                self.send(b'Damn!')
107

108

109
if __name__ == "__main__":
110
    HOST, PORT = '0.0.0.0', 4444
111
    server = ThreadedServer((HOST, PORT), test)
112
    server.allow_reuse_address = True
113
    print(HOST, PORT)
114
    server.serve_forever()

首先进工作量证明，通过后得到明文加密后的(base64)信息，然后用户即可发送数据让服务端进行验证。

攻击流程#

攻击流程也可以大致写出：

保存真正明文加密后的密文，其中前16字节为IV初始化向量
创建一个 $32$ 字节的数组，用于实时更新将要攻击的数据列表，前 $16$ 字节位初始化为先前得到的IV向量；创建一个 $16$ 字节的数组，用于寄存中间值。
对攻击列表的最后一位从0x00到0x01遍历，直到服务端的Unpadding成功，且当改变倒数第二位时，Unpadding过程仍然通过，证明此轮Unpadding的结果末位确实为0x01
把攻击列表的末位与0x01异或得到的结果即为此轮解密后的中间值
把攻击列表的末位修改为中间值异或 0x02以实施对倒数第二位的攻击
从第三步重复，对倒数第二位实施攻击，直到 $16$ 个字节均攻击完毕
改攻击列表前 $16$ 字节为密文第一组，从第三步重复，直到每部分密文攻击完毕

攻击参考脚本#

1
from base64 import *
2
from pwn import *
3

4
# 工作量证明
5
def crack_proof_of_work(proof4:str,_hexdigest:str) -> bytes:
6
    from hashlib import sha256
7
    print("Task get: ",proof4,_hexdigest)
8
    import string
9
    alphabet = string.ascii_letters+string.digits
10
    for a in alphabet:
11
        for b in alphabet:
12
            for c in alphabet:
13
                for d in alphabet:
14
                    if sha256((a+b+c+d+proof4).encode()).hexdigest() == _hexdigest:
15
                        print(f"proof of work cracked: {a}{b}{c}{d}")
16
                        return (a+b+c+d).encode()
17

18
# 连接远程主机
19
s = remote("127.0.0.1", 4444)
20
proof_of_work_problem = s.recvline(keepends=False).decode()
21
print(s.recv()) # b'[+] Plz tell me XXXX: '
22
proof_of_work_answer = crack_proof_of_work(proof_of_work_problem[16:32],proof_of_work_problem[37:101])
23
s.sendline(proof_of_work_answer)
24
print(s.recvline(keepends=True)) # b'secret:\n'
25
encbase64bytes = s.recvline(keepends=False)
26
print(s.recv()) # b'What can I say?\n> '
27

28
flag = ''
29

30
for N in [0,16,32]: # 原题密文去掉IV向量就只有48字节分3段，按实际情况更改
31
    middle_list = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0]
32
    attack_list = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0]
33
    attack_list.extend(list(b64decode(encbase64bytes))[16+N:32+N])
34
    s.send(b64encode(bytes(attack_list)))
35
    for index in range(15,-1,-1):
36
        for i in range(256):
37
            attack_list[index] = i
38
            s.send(b64encode(bytes(attack_list)))
39
            res = s.recvline(keepends=False)
40
            # print(res)
41
            _ = s.recv()
42
            if res != b'Man':
43
                break
44
        if index == 0:
45
            print(f"Got one bit! {index}",end=' \r')
46
            middle_list[index] = attack_list[index] ^ (16-index)
47
            break
48
        attack_list[index-1] ^= 0x0f # 反转比特 验证
49
        s.send(b64encode(bytes(attack_list)))
50
        res = s.recvline(keepends=False)
51
        # print(res)
52
        _ = s.recv()
53
        if res != b'Man':
54
            print(f"Got one bit! {index}",end='\r')
55
            middle_list[index] = attack_list[index] ^ (16-index)
56
            # 初始化下一padding
57
            for j in range(index,16):
58
                attack_list[j] = middle_list[j] ^ (16-index+1)
59
            index -= 1
60
        else:
61
            # 没想好怎么写这个分支，反正一般用不着吧（
62
            pass
63
    flag_ = bytes([middle_list[i] ^ list(b64decode(encbase64bytes))[0+N:16+N][i] for i in range(16)]).decode()
64
    flag += flag_
65
    print(f"\nflag got: {flag_} \n {flag}")

结语#

我真的感觉文章写完后超级超级乱，就留着自用吧（逃

参考学习#

非常清晰的动画讲解↓ Padding Oracle 攻击 - BiliBili

音乐

Padding Oracle Attack学习笔记