diff --git a/lab08_DPA/dpa_student_v2/dpa_student.ipynb b/lab08_DPA/dpa_student_v2/dpa_student.ipynb new file mode 100644 index 0000000..cb497fb --- /dev/null +++ b/lab08_DPA/dpa_student_v2/dpa_student.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Break AES using DPA with correlations\n", + "\n", + "You need:\n", + "* `plaintext.txt`: all PT blocks, (one block per line, in hex, bytes separated by spaces)\n", + "* `ciphertext.txt`: all CT blocks, (one block per line, in hex, bytes separated by spaces)\n", + "* `traceLength.txt`: how many samples per trace (one decimal number)\n", + "* `traces.bin`: raw measured traces, one byte per sample (uint8), all traces together continuously\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "GEwwR12Gupsi" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "8fW8nPQ5uyEO" + }, + "outputs": [], + "source": [ + "# AES SBOX\n", + "sbox = np.array([\n", + " 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n", + " 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n", + " 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n", + " 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n", + " 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n", + " 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n", + " 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n", + " 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\n", + " 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,\n", + " 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,\n", + " 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,\n", + " 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,\n", + " 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,\n", + " 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,\n", + " 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\n", + " 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16\n", + " ], dtype='uint8')\n", + "\n", + "# Hamming weight lookup table\n", + "hw_table = []\n", + "for i in range(256):\n", + " s = '{0:08b}'.format(i)\n", + " hw_table.append(s.count('1'))\n", + "hw_table = np.array(hw_table, 'uint8')\n", + "\n", + "# Correlation of two matrices\n", + "def correlate(x, y):\n", + " \"\"\"\n", + " Correlate all columns from matrix x of shape (a,b)\n", + " with all columns from matrix y of shape (a,c),\n", + " creating correlation matrix C of shape (b,c).\n", + " \n", + " Originally matlab script by Jiri Bucek in NI-HWB.\n", + " \"\"\"\n", + " x = x - np.average(x, 0) # remove vertical averages\n", + " y = y - np.average(y, 0) # remove vertical averages\n", + " C = x.T @ y # (n-1) Cov(x,y)\n", + " C = C / (np.sum(x**2, 0)**(1/2))[:,np.newaxis] # divide by (n-1) Var(x)\n", + " C = C / (np.sum(y**2, 0)**(1/2)) # divide by (n-1) Var(y)\n", + " return C\n", + "\n", + "# Load PT of CT from file\n", + "def load_text(file_name):\n", + " \"\"\"\n", + " Load any text PT/CT from file containing hex strings with bytes \n", + " separated by spaces, one block per line\n", + " Output is a matrix of bytes (np.array)\n", + " \"\"\"\n", + " txt_str = open(file_name).readlines()\n", + " del txt_str[-1] #discard last empty line\n", + " #split each line into bytes and convert from hex\n", + " txt_bytes_list = list(\n", + " map(lambda line: \n", + " list(\n", + " map(lambda s: int(s, 16),\n", + " line.rstrip().split(\" \"))\n", + " ),\n", + " txt_str)\n", + " )\n", + " return np.array(txt_bytes_list, 'uint8')" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "id": "--PH16eNuz_H" + }, + "outputs": [], + "source": [ + "# read plaintext inputs\n", + "inputs = load_text(\"plaintext.txt\")\n", + "\n", + "# read length of one complete trace (number of samples per trace)\n", + "with open(\"traceLength.txt\", \"r\") as fin:\n", + " trace_length = int(fin.readline())\n", + "\n", + "# trim each trace - select interesting part\n", + "start = 0\n", + "round_len = 22000\n", + "#round_len = trace_length # CHANGE to the length of the first round; \n", + "\n", + "# read traces from binary file\n", + "traces = np.fromfile(\"traces.bin\", dtype='uint8') # read as linear array\n", + "traces = np.reshape(traces, (traces.size // trace_length, trace_length)) # reshape into matrix\n", + "traces = traces[:, start:round_len] # select only the interesting part of each trace" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "id": "ZVJ_Tk55u1wu" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 16)\n", + "200000\n", + "(100, 22000)\n" + ] + } + ], + "source": [ + "print(inputs.shape) # dimensions of inputs\n", + "print(trace_length)\n", + "print(traces.shape) # dimensions of matrix of traces" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "id": "6hzUcHiWxyH0" + }, + "outputs": [], + "source": [ + "# If you feel brave enough -- interactive plots\n", + "#!pip install ipympl\n", + "#from google.colab import output\n", + "#output.enable_custom_widget_manager()\n", + "#%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": { + "id": "wDAUVmNOu3BP" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot one trace\n", + "fig = plt.figure()\n", + "plt.plot(traces[:5, :25].T,'^') # z 5 prubehu 25 prvnich samplu\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "w6boaqAQvF1G" + }, + "source": [ + "## **Attack the first key byte**\n", + "![Intermediate value](dpa-aes-v.png)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "id": "WaKiOUmbvbQR" + }, + "outputs": [], + "source": [ + "# Generate key hypotheses (all possible byte values)\n", + "keys = np.arange(start=0, stop=256, step=1, dtype='uint8')\n", + "# Select the first byte of each input block\n", + "inp = inputs[:, 0]\n", + "# XOR each data byte with each key\n", + "xmat = inp[:, np.newaxis] ^ keys" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "inputs\n", + "[[ 37 235 140 ... 71 237 252]\n", + " [134 25 178 ... 142 50 68]\n", + " [215 215 233 ... 61 22 57]\n", + " ...\n", + " [ 18 188 253 ... 68 197 189]\n", + " [ 87 194 19 ... 160 8 136]\n", + " [148 238 68 ... 23 94 218]]\n", + "inputs shape\n", + "(100, 16)\n", + "inp shape\n", + "(100,)\n", + "inp[:, np.newaxis].shape\n", + "(100, 1)\n", + "keys shape\n", + "(256,)\n", + "xmat shape\n", + "(100, 256)\n", + "xmat\n", + "[[ 37 36 39 ... 216 219 218]\n", + " [134 135 132 ... 123 120 121]\n", + " [215 214 213 ... 42 41 40]\n", + " ...\n", + " [ 18 19 16 ... 239 236 237]\n", + " [ 87 86 85 ... 170 169 168]\n", + " [148 149 150 ... 105 106 107]]\n" + ] + } + ], + "source": [ + "# Examine the inputs matrix. Does it contain the data from plaintext.txt?\n", + "print(\"inputs\")\n", + "print(inputs)\n", + "# What is the shape of all the operands from the previous cell?\n", + "print(\"inputs shape\")\n", + "print(inputs.shape)\n", + "\n", + "print(\"inp shape\")\n", + "print(inp.shape)\n", + "\n", + "print(\"inp[:, np.newaxis].shape\")\n", + "print(inp[:, np.newaxis].shape)\n", + "\n", + "print(\"keys shape\")\n", + "print(keys.shape)\n", + "\n", + "print(\"xmat shape\")\n", + "print(xmat.shape)\n", + "# Do you understand the values after the XOR operation? What AES operation do they represent?\n", + "\n", + "print(\"xmat\")\n", + "print(xmat)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": { + "id": "VrBZd18VwBOH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 256)\n", + "(100, 256)\n" + ] + } + ], + "source": [ + "# Substitute with SBOX all XORed values -- matrix of intermediate values\n", + "smat = sbox[xmat]\n", + "print(xmat.shape)\n", + "print(smat.shape)\n", + "#plt.imshow(xmat)\n", + "#plt.imshow(smat)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "id": "4GfR9BU-wT4G" + }, + "outputs": [], + "source": [ + "# Compute Hamming Weights -- the matrix of hypothetical power consumption\n", + "hmat = hw_table[smat]" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "id": "J8TTPk-WwjQH" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 256)\n", + "(100, 22000)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compute the correlation matrix -- correlate the hypotheses with measured traces\n", + "print(hmat.shape)\n", + "print(traces.shape)\n", + "corr = correlate(hmat, traces)\n", + "plt.imshow(corr)\n", + "# What is the shape and contents of the correlation matrix?" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": { + "id": "iOqbuNAKxCvP" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "key: 222 time: 3348\n", + "key: Þ, de\n" + ] + } + ], + "source": [ + "# Find the absolute maximum correlation\n", + "acorr = abs(corr)\n", + "max_acorr = acorr.max()\n", + "(k, j) = np.where(acorr == max_acorr) # find idices of maximum\n", + "print(\"key: %d time: %d\" % (k[0], j[0]))\n", + "print(\"key: %1c, %02x\" % (k[0], k[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the correlation traces for the right key byte guess and one wrong key byte guess\n", + "# Do you see the correlation peaks?\n", + "fig = plt.figure()\n", + "plt.plot(corr[220:224].T)\n", + "#plt.plot(?)\n", + "#plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Z62RVYJYzncZ" + }, + "source": [ + "## **Break all key bytes!**" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "id": "T7HhwO-ezpoQ" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "key: 222 time: 3348\n", + "Þ, de @ 3348\n", + "key: 173 time: 15779\n", + "­, ad @ 15779\n", + "key: 190 time: 3829\n", + "¾, be @ 3829\n", + "key: 239 time: 4045\n", + "ï, ef @ 4045\n", + "key: 32 time: 4280\n", + " , 20 @ 4280\n", + "key: 116 time: 9180\n", + "t, 74 @ 9180\n", + "key: 111 time: 4744\n", + "o, 6f @ 4744\n", + "key: 112 time: 9064\n", + "p, 70 @ 9064\n", + "key: 32 time: 5209\n", + " , 20 @ 5209\n", + "key: 115 time: 5441\n", + "s, 73 @ 5441\n", + "key: 101 time: 5678\n", + "e, 65 @ 5678\n", + "key: 99 time: 17859\n", + "c, 63 @ 17859\n", + "key: 114 time: 17175\n", + "r, 72 @ 17175\n", + "key: 101 time: 13170\n", + "e, 65 @ 13170\n", + "key: 116 time: 6605\n", + "t, 74 @ 6605\n", + "key: 33 time: 6837\n", + "!, 21 @ 6837\n", + "key: [222 173 190 239 32 116 111 112 32 115 101 99 114 101 116 33]\n" + ] + } + ], + "source": [ + "keys = np.array(range(0, 256))\n", + "kk = np.zeros(16, dtype='uint8')\n", + "for i in range(0, 16): # for each input byte\n", + " # Select the i byte of each input block\n", + " inp = inputs[:, i]\n", + "\n", + " # XOR each data byte with each key\n", + " xmat = inp[:, np.newaxis] ^ keys \n", + "\n", + " # Substitute with SBOX all XORed values -- matrix of intermediate values\n", + " smat = sbox[xmat]\n", + "\n", + " # Compute Hamming Weights -- the matrix of hypothetical power consumption\n", + " hmat = hw_table[smat]\n", + "\n", + " corr = correlate(hmat, traces)\n", + " acorr = abs(corr)\n", + " max_acorr = acorr.max()\n", + " (k, j) = np.where(acorr == max_acorr) # find idices of maximum\n", + " print(\"key: %d time: %d\" % (k[0], j[0]))\n", + " #print(\"key: %1c, %02x\" % (k[0], k[0]))\n", + "\n", + " kk[i] = k[0]\n", + " print(\"%1c, %02x @ %d\" % (k[0], k[0], j[0]))\n", + "print(\"key: \", kk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Verify the key on a PT, CT pair!**" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (3519104482.py, line 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[117], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m outputs = ?\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "key_bytes = bytes(kk)\n", + "outputs = ?" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'Crypto'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[78], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# !pip install pycryptodome\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mCrypto\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mCipher\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m AES\n\u001b[1;32m 3\u001b[0m cipher \u001b[38;5;241m=\u001b[39m AES\u001b[38;5;241m.\u001b[39mnew(key_bytes, AES\u001b[38;5;241m.\u001b[39mMODE_ECB)\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'Crypto'" + ] + } + ], + "source": [ + "# !pip install pycryptodome\n", + "from Crypto.Cipher import AES\n", + "cipher = AES.new(key_bytes, AES.MODE_ECB)\n", + "??" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "dpa_student.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}