In this exercise you will perform a timing attack against CBC-MAC.
You are given access to a CBC-MAC $\mathsf{Verify}$ oracle, which tests whether the received tag matches the one computed using the secret key. Timing attacks exploit naive equality comparisons between the received and computed MACs (for example, the comparison is done byte by byte; more checks means more latency).
Your task is to produce a forged tag for the message 'Hristos a inviat' without knowing the key. Do this by iterating through all possible values for a specific byte; when the oracle's latency for a certain value seems larger than the rest, it suggests that the equality test returned True and the oracle passed to the next byte.
Try to start by finding the first byte and checking your result with the timing attack.
You can use time.clock()
before and after each oracle query to measure its runtime.
TODO1: Implement the CBC-MAC function.
TODO2: Implement the MAC time verification attack and obtain the desired MAC without knowing the key.
import sys import random import string import time import itertools import operator import base64 from Crypto.Cipher import AES from Crypto.Hash import SHA256 def slow_foo(): p = 181 k = 2 while k < p: if p % k == 0: return k += 1 def aes_enc(k, m): """ Encrypt a message m with a key k in ECB mode using AES as follows: c = AES(k, m) Args: m should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring ciphertext c """ aes = AES.new(k) c = aes.encrypt(m) return c def aes_dec(k, c): """ Decrypt a ciphertext c with a key k in ECB mode using AES as follows: m = AES(k, c) Args: c should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring message m """ aes = AES.new(k) m = aes.decrypt(c) return m def aes_enc_cbc(k, m, iv): """ Encrypt a message m with a key k in CBC mode using AES as follows: c = AES(k, m) Args: m should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. iv should be a bytestring of length exactly 16 bytes. Return: The bytestring ciphertext c """ aes = AES.new(k, AES.MODE_CBC, iv) c = aes.encrypt(m) return c def aes_dec_cbc(k, c, iv): """ Decrypt a ciphertext c with a key k in CBC mode using AES as follows: m = AES(k, c) Args: c should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. iv should be a bytestring of length exactly 16 bytes. Return: The bytestring message m """ aes = AES.new(k, AES.MODE_CBC, iv) m = aes.decrypt(c) return m def aes_cbc_mac(k, m): """ Compute a CBC-MAC of message m with a key k using AES as follows: t = AES-CBC-MAC(k=(k1,k2), m), where k1 is used for the raw-CBC operation and k2 is used for the final encryption. k1 and k2 are derived from k as follows: [k1|k2] = SHA256(k | "CBC MAC keys") Note: the IV for CBC in this case will be 0. Args: m should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring MAC t, of 16 bytes. """ #Require good size m = m.ljust(16) k = k.ljust(16) #Derive the keys for raw-CBC and for the final tag #[k1 | k2] = SHA256(k + "CBC MAC keys") #Get the MAC: #1 - Do aes-CBC with k1 and iv=0, then keep only last block (last 16 bytes) of encryption #2 - Perform another AES encryption (simple, without CBC) on the last block from #1 using k2 #t = tag t = 16*'\x00' return t def verify(message, tag): key = 'Cozonace si oua ' # Get correct tag goodtag = aes_cbc_mac(key, message) # Compare tags for i in range(16): # Artificially extend byte comparison duration slow_foo() if tag[i] != goodtag[i]: return False return True def main(): message = 'Hristos a inviat' # Step 1. Iterate through all possible first byte values, and call the # Verify oracle for each of them tag = 16*'\x00' verify(message, tag) # Step 2. Store the byte that caused the longest computation time # Step 3. Continue the operation for each byte (except the last) # Step 4. Guess the last byte, and query the oracle with the complete tag mytag = '???' result = verify(message, mytag) if result == True: print "Found tag: " + mytag if __name__ == "__main__": main()
Alice wants to share a secret with Bob, but she knows that if she explicitly tells it to Bob, Eve somehow will find out (she hears everything). So she and Bob establish a small game which helps them think about the same secret, without saying it. The game goes like this:
$\mathsf{Puzzle}_i = \mathsf{AES}(\mathsf{key} = 0^{14} \| i, \mathsf{plaintext = Puzzle} \| i \| secret_i)$ where $secret_i$ represents the $i$-th secret Alice generated (represents 8 randomly generated bytes) and which should be figured out by Bob.
In the end, both Alice and Bob share the same secret, and Eve has no clue about it.
Your job is to implement this mechanism starting from the following skeleton:
import random import string from Crypto.Cipher import AES import os def aes_enc(k, m): """ Encrypt a message m with a key k in ECB mode using AES as follows: c = AES(k, m) Args: m should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring ciphertext c """ aes = AES.new(k) c = aes.encrypt(m) return c def aes_dec(k, c): """ Decrypt a ciphertext c with a key k in ECB mode using AES as follows: m = AES(k, c) Args: c should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring message m """ aes = AES.new(k) m = aes.decrypt(c) return m alice_keys = [] bob_key = [] # TODO This is Alice. She generates 2^16 random keys and 2^16 puzzles. # A puzzle has the following formula: # puzzle[i] = aes_enc(key = 0..0 + i, plaintext ="Puzzle" + chr(i) + chr(j) + alice_keys[i]) # This function shall fill in the alice_keys list and shall return a list of 2^16 puzzles. def gen_puzzles(): # TODO # TODO This is Bob. He tries to solve one random puzzle. His purpose is to solve one random puzzle # offered by Alice. # This function shall fill in the bob_key list with the secret discovered by Bob. # The function shall return the index of the chosen puzzle. def solve_puzzle(puzzles): # TODO def main(): # Alice generates some puzzles puzzles = gen_puzzles() # Bob solves one random puzzle and discovers the secret x = solve_puzzle(puzzles) print "Bob's secret key: " + bob_key[0] # Alice receives the puzzle index from Bob and now knows the secret print "Alice's secret key: " + alice_keys[x] # The secret should be the same, even if it was not explicitly shared if bob_key[0] == alice_keys[x]: print ":)" else: print ":(" if __name__ == "__main__": main()
In this exercise you'll try to implement the CBC-padding attack of Serge Vaudenay: http://link.springer.com/content/pdf/10.1007%2F3-540-46035-7_35.pdf
See sections 3.1 to 3.3 of chapter 3 in the paper above for more details.
Another useful link: https://robertheaton.com/2013/07/29/padding-oracle-attack/
Given a message of length L bytes, we need to pad with b more bytes such that L+b is a multiple of the cipher's block size (e.g. 16 bytes in the case of AES). Each of the last b bytes will have the value b. For example, for a message that has 30 bytes, we shall add two bytes with the value 0x02 at the end, obtaining m = [b1 | b2 | .. | b30 | 0x02 | 0x02], where bi are the 30 original bytes.
The idea in short is the following: given a 1-block ciphertext c = [c1 | c2 | … | c16], you can find its last byte by crafting a 2-block ciphetext c' = [r | c], where r = [r1 | r2 | … | r16] contains random bytes. Then, by using an oracle that tells you whether the padding of the decryption of c' is correct or not, you can determine the value of c16. For this you just try all possible values of r16, until for one of them you will find that the oracle returns a successful result (it will do that for one value). In that case, due to the workings of CBC, you found out that r16 ⊕ LSB(Dec(k, c)) = 1. Hence you find that the last byte of the decryption of c is r16 ⊕ 1.
Once you found the last byte c16 of the decryption of c, you can work your way towards the following byte, c15. This time you need to target the two-byte padding [0x02 | 0x02]. For this you simply use for r16 the value LSB(Dec(k, c)) ⊕ 0x02, and try all values for r15 just as we did above for r16. In the same manner you can decrypt all the ciphertext blocks c1 … c16.
You can then repeat the above process for any ciphertext of arbitrary length. Simply apply the attack on all blocks.
You are given the following ciphertext: 553b43d4b821332868fece8149eea14a2b0a98c7bed43cc1cf75f4e778cb315dc1d92 8d0340e0aab4900ca8af9adaee761e2affa3e9996d81483e950b913492b
and a padding oracle (see the method “check_cbcpad” below), which knows the key that was used to encrypt the ciphertext and which will answer 1 if the padding of the ciphertext is correct and 0 otherwise.
Your task is to decrypt the message by using the CBC-padding attack.
Here is a starting python script, which contains your padding oracle:
import sys import random import string import time from Crypto.Cipher import AES IV = 'Hristos a inviat' def strxor(a, b): # xor two strings (trims the longer input) return "".join([chr(ord(x) ^ ord(y)) for (x, y) in zip(a, b)]) def hexxor(a, b): # xor two hex strings (trims the longer input) ha = a.decode('hex') hb = b.decode('hex') return "".join([chr(ord(x) ^ ord(y)).encode('hex') for (x, y) in zip(ha, hb)]) def bitxor(a, b): # xor two bit strings (trims the longer input) return "".join([str(int(x)^int(y)) for (x, y) in zip(a, b)]) def str2bin(ss): """ Transform a string (e.g. 'Hello') into a string of bits """ bs = '' for c in ss: bs = bs + bin(ord(c))[2:].zfill(8) return bs def str2int(ss): """ Transform a string (e.g. 'Hello') into a (long) integer by converting first to a bistream """ bs = str2bin(ss) li = int(bs, 2) return li def hex2bin(hs): """ Transform a hex string (e.g. 'a2') into a string of bits (e.g.10100010) """ bs = '' for c in hs: bs = bs + bin(int(c,16))[2:].zfill(4) return bs def bin2hex(bs): """ Transform a bit string into a hex string """ bv = int(bs,2) return int2hexstring(bv) def byte2bin(bval): """ Transform a byte (8-bit) value into a bitstring """ return bin(bval)[2:].zfill(8) def int2hexstring(bval): """ Transform an int value into a hexstring (even number of characters) """ hs = hex(bval)[2:] lh = len(hs) return hs.zfill(lh + lh%2) def check_cbcpad(c): """ Oracle for checking if a given ciphertext has correct CBC-padding. That is, it checks that the last n bytes all have the value n. Args: c is the ciphertext to be checked. Note: the key is supposed to be known just by the oracle. Return 1 if the pad is correct, 0 otherwise. """ ko = 'Sfantul Gheorghe' m = aes_dec_cbc(ko, c, IV) lm = len(m) lb = ord(m[lm-1]) if lb > lm or lb == 0: return 0 for k in range(lb): if ord(m[lm-1-k]) != lb: return 0 return 1 def aes_enc(k, m): """ Encrypt a message m with a key k in ECB mode using AES as follows: c = AES(k, m) Args: m should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring ciphertext c """ aes = AES.new(k) c = aes.encrypt(m) return c def aes_dec(k, c): """ Decrypt a ciphertext c with a key k in ECB mode using AES as follows: m = AES(k, c) Args: c should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. Return: The bytestring message m """ aes = AES.new(k) m = aes.decrypt(c) return m def aes_enc_cbc(k, m, iv): """ Encrypt a message m with a key k in CBC mode using AES as follows: c = AES(k, m) Args: m should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. iv should be a bytestring of length exactly 16 bytes. Return: The bytestring ciphertext c """ aes = AES.new(k, AES.MODE_CBC, iv) c = aes.encrypt(m) return c def aes_dec_cbc(k, c, iv): """ Decrypt a ciphertext c with a key k in CBC mode using AES as follows: m = AES(k, c) Args: c should be a bytestring multiple of 16 bytes (i.e. a sequence of characters such as 'Hello...' or '\x02\x04...') k should be a bytestring of length exactly 16 bytes. iv should be a bytestring of length exactly 16 bytes. Return: The bytestring message m """ aes = AES.new(k, AES.MODE_CBC, iv) m = aes.decrypt(c) return m def main(): # Find the message corresponding to this ciphertext by using the cbc-padding attack c = '553b43d4b821332868fece8149eea14a2b0a98c7bed43cc1cf75f4e778cb315dc1d928d0340e0aab4900ca8af9adaee761e2affa3e9996d81483e950b913492b' ct = c.decode('hex') #Check correct padding print 'Oracle check of pad = ' + str(check_cbcpad(ct)) # TODO: implement the CBC-padding attack to find the message corresponding to the above ciphertext # Note: you cannot use the key known by the oracle # You can use the known IV in order to recover the full message if __name__ == "__main__": main()