122 lines
4.5 KiB
Python
Executable file
122 lines
4.5 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
import aes
|
|
|
|
D = 6000 # Number of power traces (Number of Samples)
|
|
T = 87 # Number of data points per power trace (Points in time)
|
|
KEY_GUESSES = np.arange(256, dtype=np.uint8)
|
|
|
|
|
|
def calculate_models(
|
|
ciphertexts: np.ndarray[np.ndarray[np.uint8]],
|
|
) -> np.ndarray[np.ndarray[np.ndarray[np.uint8]]]:
|
|
"""
|
|
Calculates for each sample ciphertext c the state just before the last
|
|
SubBytes operation of the AddKey step in the last round of AES.
|
|
|
|
In order to do this we calculate: sbox^-1 (c ⊕ k_hyp)
|
|
and return an numpy array with this form
|
|
[
|
|
[ # first ciphertext sample c1
|
|
[c_1_0 ⊕ 0, c_1_0 ⊕ 1, ..., c_1_0 ⊕ 255], # first byte of c1
|
|
[c_1_1 ⊕ 0, c_1_1 ⊕ 1, ..., c_1_1 ⊕ 255], # second byte of c1
|
|
...,
|
|
[c_1_15 ⊕ 0, c_1_15 ⊕ 1, ..., c_1_15 ⊕ 255], # 16'th byte of c1
|
|
],
|
|
[ # second ciphertext sample c2
|
|
[c_2_0 ⊕ 0, c_2_0 ⊕ 1, ..., c_2_0 ⊕ 255],
|
|
[c_2_1 ⊕ 0, c_2_1 ⊕ 1, ..., c_2_1 ⊕ 255],
|
|
...,
|
|
[c_2_15 ⊕ 0, c_2_15 ⊕ 1, ..., c_2_15 ⊕ 255],
|
|
],
|
|
...,
|
|
[ # last ciphertext sample cD
|
|
[c_D_0 ⊕ 0, c_D_0 ⊕ 1, ..., c_D_0 ⊕ 255],
|
|
[c_D_1 ⊕ 0, c_D_1 ⊕ 1, ..., c_D_1 ⊕ 255],
|
|
...,
|
|
[c_D_15 ⊕ 0, c_D_15 ⊕ 1, ..., c_D_15 ⊕ 255],
|
|
],
|
|
]
|
|
|
|
Args:
|
|
ciphertexts:
|
|
An array of all samples (ciphertexts) as an np.ndarray of np.ndarrays
|
|
for each byte as np.uint8.
|
|
|
|
Returns:
|
|
models:
|
|
An np.ndarray with each model of the state before the SubBytes
|
|
operation of the AddKey step in the last round of AES.
|
|
- axis 0: Samples/Ciphertexts
|
|
- axis 1: Bytes per sample
|
|
- axis 2: Byte xor k_hyp
|
|
"""
|
|
|
|
# duplicate each ciphertext 256 times to xor with all possible keys.
|
|
models = np.repeat(ciphertexts, 256, axis=0).reshape((D, 256, 16))
|
|
|
|
# create a view of models with the inner axis swaped, so when we xor with
|
|
# KEY_GUESSES numpy can use broadcast.
|
|
models_view = np.swapaxes(models, 1, 2)
|
|
|
|
# c ⊕ k_hyp
|
|
np.bitwise_xor(models_view, KEY_GUESSES, out=models_view)
|
|
|
|
# apply reverse rbox to all bytes. (rsbox(c ⊕ k_hyp))
|
|
models = np.vectorize(lambda x: aes.core.rsbox(x))(models)
|
|
return models
|
|
|
|
|
|
def read_msgs(file_name: str) -> np.ndarray[np.ndarray[np.ndarray[np.uint8]]]:
|
|
msgs = np.empty((D, 3, 16), dtype=np.uint8)
|
|
|
|
with open(file_name, 'r') as fd:
|
|
for idx, (key, plain_text) in enumerate(
|
|
(line.strip().split(',') for line in fd)
|
|
):
|
|
msgs[idx][0] = np.frombuffer(bytes.fromhex(key), dtype=np.uint8) # key
|
|
msgs[idx][1] = np.frombuffer(bytes.fromhex(plain_text), dtype=np.uint8) # plain text
|
|
msgs[idx][2] = np.array( # ciphertext
|
|
aes.aes(int(key, 16), 128).enc_once(int(plain_text, 16)), dtype=np.uint8
|
|
)
|
|
|
|
return msgs
|
|
|
|
def read_traces(file_name: str) -> np.ndarray[np.ndarray[np.uint8]]:
|
|
return np.loadtxt(file_name, delimiter=",", dtype=np.uint8)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
msgs = read_msgs("Task-3-example_traces/test_msgs.csv")
|
|
traces = read_traces("Task-3-example_traces/test_traces.csv")
|
|
models = calculate_models(msgs[:, 2])
|
|
|
|
np.set_printoptions(formatter={"int": hex})
|
|
last_round_key = aes.core.key_expansion(msgs[0][0].tolist())[-16:]
|
|
|
|
|
|
for bit in range(128):
|
|
# i'th row, and j'th col is the correlation coefficient of key_hyp = i and time sample j
|
|
r = np.corrcoef(
|
|
np.bitwise_and(models[:, :, bit//8], np.array([2**(bit % 8)], dtype=np.uint8)),
|
|
traces,
|
|
rowvar=False
|
|
)[:256, -87:]
|
|
|
|
guess = np.argmax(np.max(np.abs(r), axis=1))
|
|
# print(guess)
|
|
|
|
exit(0)
|
|
# tmp = np.sort(r.flatten())
|
|
# confidence = max(abs(tmp[0] - tmp[1]), abs(tmp[-2] - tmp[-1]))
|
|
# if confidence > 0.005:
|
|
# fig, axs = plt.subplots(1, 1, layout='constrained')
|
|
# axs.set_title(f"Bit {bit%8 + 1} of Byte {bit//8 + 1} (Confidence: {confidence:.6f})")
|
|
# axs.plot(r.transpose(), alpha=0.3, color='grey')
|
|
# axs.plot(r[last_round_key[bit//8]], color="blue")
|
|
# axs.plot(r[guess], color="red")
|
|
# axs.set_xlabel("Time Samples")
|
|
# axs.set_ylabel("Correlation")
|
|
# axs.grid(True)
|
|
# plt.show()
|