added comments

Author: fxxce

AES/AES.py

@@ -1,38 +1,38 @@
 # https://engineering.purdue.edu/kak/compsec/NewLectures/Lecture8.pdf
 # http://www.moserware.com/2009/09/stick-figure-guide-to-advanced.html
 
-def h2b(msg):
+def h2b(val):
     hex_val = {"0": "0000", "1": "0001", "2": "0010", "3": "0011",
                "4": "0100", "5": "0101", "6": "0110", "7": "0111",
                "8": "1000", "9": "1001", "a": "1010", "b": "1011",
                "c": "1100", "d": "1101", "e": "1110", "f": "1111"}
-    m_len = len(msg)
+    m_len = len(val)
     final = ""
     for i in range(0, m_len):
-        final = final + hex_val[msg[i]]
+        final = final + hex_val[val[i]]
     return final
 
 
-def b2h(msg):
+def b2h(val):
     bin_val = {"0000": "0", "0001": "1", "0010": "2", "0011": "3",
                "0100": "4", "0101": "5", "0110": "6", "0111": "7",
                "1000": "8", "1001": "9", "1010": "a", "1011": "b",
                "1100": "c", "1101": "d", "1110": "e", "1111": "f"}
-    m_len = len(msg)
+    m_len = len(val)
     lst = []
     final = ""
     count = 0
     i = 0
     while count != m_len:
-        lst = lst + [msg[count:count + 4]]
+        lst = lst + [val[count:count + 4]]
         final = final + bin_val[lst[i]]
         i = i + 1
         count = count + 4
 
     return final
 
 
-def substitution_box(x):
+def substitution_box(rc):
     hex_val = {"0": "0", "1": "1", "2": "2", "3": "3",
                "4": "4", "5": "5", "6": "6", "7": "7",
                "8": "8", "9": "9", "a": "10", "b": "11",
@@ -55,7 +55,7 @@ def substitution_box(x):
                       ["e1", "f8", "98", "11", "69", "d9", "8e", "94", "9b", "1e", "87", "e9", "ce", "55", "28", "df"],
                       ["8c", "a1", "89", "0d", "bf", "e6", "42", "68", "41", "99", "2d", "0f", "b0", "54", "bb", "16"]]
 
-    substitution = rijndael_s_box[int(hex_val[x[0]])][int(hex_val[x[1]])]
+    substitution = rijndael_s_box[int(hex_val[rc[0]])][int(hex_val[rc[1]])]
     return substitution
 
 
@@ -70,88 +70,34 @@ def xor(left, right):
     return final
 
 
-def key(s_key, rnd):
-    keys = []
-
-    # Rcon = 128 -> 10, 192 -> 8, 256 -> 7
-    # Rcon =  [01, 02, 04, 08, 10, 20, 40, 80, 1b, 36]
-    # Rcon(i) = [rc(i), 00(0x), 00(0x), 00(0x)] --> (0x) = hex
-    # Rcon = [["01", "00", "00", "00"], ["02", "00", "00", "00"], ["04", "00", "00", "00"], ["08", "00", "00", "00"],
-    #         ["10", "00", "00", "00"], ["20", "00", "00", "00"], ["40", "00", "00", "00"], ["80", "00", "00", "00"],
-    #         ["1b", "00", "00", "00"], ["36""00", "00", "00"]]
-
-    for pos in range(0, 4):
-        if pos == 0:
-            first_col = []
-            tmp = s_key[3]
-            t_len = len(tmp)
-
-            for i in range(1, t_len):
-                first_col = first_col + [tmp[i]]
-            first_col = first_col + [tmp[0]]
-            col = []
-
-            f_len = len(first_col)
-            for i in range(0, f_len):
-                col = col + [substitution_box(first_col[i])]
-
-            tmp_key = []
-            for i in range(0, 4):
-                sub_key = xor(h2b(s_key[0][i]), h2b(rnd[i]))
-                sub_key1 = xor(sub_key, h2b(col[i]))
-                tmp_key = tmp_key + [str(b2h(sub_key1))]
-
-            keys = keys + [tmp_key]
-
-        elif pos > 0:
-            first_col = []
-
-            for i in range(0, 4):
-                sub_key = xor(h2b(s_key[pos][i]), h2b(keys[pos - 1][i]))
-                first_col = first_col + [str(b2h(sub_key))]
-
-            keys = keys + [first_col]
-    return keys
-
-
-def col_to_row(keys):
+def col_to_row(val):
     row = []
     for i in range(0, 4):
         col = []
         for j in range(0, 4):
-            col = col + [keys[j][i]]
+            col = col + [val[j][i]]
         row = row + [col]
     return row
 
 
-def row_to_col(keys):
+def row_to_col(val):
     col = []
     for i in range(0, 4):
         row = []
         for j in range(0, 4):
-            row = row + [keys[j][i]]
+            row = row + [val[j][i]]
         col = col + [row]
     return col
 
 
-def add_round(plaintext, keys):
-    row = []
-    for i in range(0, 4):
-        col = []
-        for j in range(0, 4):
-            tmp = xor(h2b(keys[i][j]), h2b(plaintext[i][j]))
-            col = col + [b2h(tmp)]
-        row = row + [col]
-
-    return col_to_row(row)
-
-
-def substitute_byte(keys):
+# it replaces every state element from its respective position in s-box
+# row = first four bits or first value, and col = next four bits or next value
+def substitute_byte(state):
     row = []
     for i in range(0, 4):
         col = []
         for j in range(0, 4):
-            col = col + [substitution_box(keys[i][j])]
+            col = col + [substitution_box(state[i][j])]
         row = row + [col]
     return row
 
@@ -164,7 +110,7 @@ def shift_row(sub_bytes):
     first = sub_bytes[0]
     state_array = state_array + [first]
 
-    # row [1 , 2, 3, 4] --> [2, 3, 4, 1]
+    # row [1, 2, 3, 4] --> [2, 3, 4, 1]
     second = [sub_bytes[1][1]] + [sub_bytes[1][2]] + [sub_bytes[1][3]] + [sub_bytes[1][0]]
     state_array = state_array + [second]
 
@@ -179,20 +125,26 @@ def shift_row(sub_bytes):
     return state_array
 
 
-def mix_byte(inp):
+# implementation of multiplication by 2 in galois field (0x02)
+def multiply_by_02(inp):
     bin_val = h2b(inp[0]) + h2b(inp[1])
     final = ""
     if bin_val[0] == '1':
+        # zero fill left shift
         bin_val = bin_val[1:len(bin_val)] + '0'
+        # XORing the result with 0x1b
         final = xor(bin_val, h2b('1b'))
     elif bin_val[0] == '0':
         final = bin_val[1:len(bin_val)] + '0'
 
     return final
 
 
-def mix_byte2(inp):
-    mix = mix_byte(inp)
+# implementation of multiplication by 3 in galois field (0x03)
+# example: 0x03 * num = (0x02 + 0x01) * num = num * 0x02 + 0x01 * num
+def multiply_by_03(inp):
+    mix = multiply_by_02(inp)
+    # addition in galois field is xor
     final = xor(mix, h2b(inp))
 
     return final
@@ -210,7 +162,7 @@ def mix_byte2(inp):
 
 # s′0,j = (0x02 × s0,j) ⊗ (0x03 × s1,j ) ⊗ s2,j ⊗ s3,j
 def row0(row):
-    xor01 = xor(mix_byte(row[0]), mix_byte2(row[1]))
+    xor01 = xor(multiply_by_02(row[0]), multiply_by_03(row[1]))
     xor23 = xor(h2b(row[2]), h2b(row[3]))
     final_xor = xor(xor01, xor23)
 
@@ -219,8 +171,8 @@ def row0(row):
 
 # s′1,j = s0,j ⊗ (0x02 × s1,j) ⊗ (0x03 × s2,j) ⊗ s3,j
 def row1(row):
-    xor01 = xor(h2b(row[0]), mix_byte(row[1]))
-    xor23 = xor(mix_byte2(row[2]), h2b(row[3]))
+    xor01 = xor(h2b(row[0]), multiply_by_02(row[1]))
+    xor23 = xor(multiply_by_03(row[2]), h2b(row[3]))
     final_xor = xor(xor01, xor23)
 
     return b2h(final_xor)
@@ -229,16 +181,16 @@ def row1(row):
 # s′2,j = s0,j ⊗ s1,j ⊗ (0x02 × s2,j ) ⊗ (0x03 × s3,j)
 def row2(row):
     xor01 = xor(h2b(row[0]), h2b(row[1]))
-    xor23 = xor(mix_byte(row[2]), mix_byte2(row[3]))
+    xor23 = xor(multiply_by_02(row[2]), multiply_by_03(row[3]))
     final_xor = xor(xor01, xor23)
 
     return b2h(final_xor)
 
 
 # s′3,j = (0x03 × s0,j) ⊗ s1,j ⊗ s2,j ⊗ (0x02 × s3,j)
 def row3(row):
-    xor01 = xor(mix_byte2(row[0]), h2b(row[1]))
-    xor23 = xor(mix_byte(row[3]), h2b(row[2]))
+    xor01 = xor(multiply_by_03(row[0]), h2b(row[1]))
+    xor23 = xor(multiply_by_02(row[3]), h2b(row[2]))
     final_xor = xor(xor01, xor23)
 
     return b2h(final_xor)
@@ -253,15 +205,72 @@ def mix_col(s_row):
     return final_row
 
 
-rnd_const = [["01", "00", "00", "00"], ["02", "00", "00", "00"], ["04", "00", "00", "00"], ["08", "00", "00", "00"],
-             ["10", "00", "00", "00"], ["20", "00", "00", "00"], ["40", "00", "00", "00"], ["80", "00", "00", "00"],
-             ["1b", "00", "00", "00"], ["36", "00", "00", "00"]]
+def key_expansion(s_key, rnd):
+    keys = []
+
+    # Rcon = 128 -> 10, 192 -> 8, 256 -> 7
+    # Rcon =  [01, 02, 04, 08, 10, 20, 40, 80, 1b, 36]
+    # Rcon(i) = [rc(i), 00(0x), 00(0x), 00(0x)]
+    # Rcon = [["01", "00", "00", "00"], ["02", "00", "00", "00"], ["04", "00", "00", "00"], ["08", "00", "00", "00"],
+    #         ["10", "00", "00", "00"], ["20", "00", "00", "00"], ["40", "00", "00", "00"], ["80", "00", "00", "00"],
+    #         ["1b", "00", "00", "00"], ["36""00", "00", "00"]]
 
+    for pos in range(0, 4):
+        if pos == 0:
+            first_col = []
+            tmp = s_key[3]
+            t_len = len(tmp)
+
+            for i in range(1, t_len):
+                first_col = first_col + [tmp[i]]
+            first_col = first_col + [tmp[0]]
+            col = []
+
+            f_len = len(first_col)
+            for i in range(0, f_len):
+                col = col + [substitution_box(first_col[i])]
+
+            tmp_key = []
+            for i in range(0, 4):
+                sub_key = xor(h2b(s_key[0][i]), h2b(rnd[i]))
+                sub_key1 = xor(sub_key, h2b(col[i]))
+                tmp_key = tmp_key + [str(b2h(sub_key1))]
+
+            keys = keys + [tmp_key]
 
+        elif pos > 0:
+            first_col = []
+
+            for i in range(0, 4):
+                sub_key = xor(h2b(s_key[pos][i]), h2b(keys[pos - 1][i]))
+                first_col = first_col + [str(b2h(sub_key))]
+
+            keys = keys + [first_col]
+    return keys
+
+
+def add_round(plain_text, keys):
+    row = []
+    for i in range(0, 4):
+        col = []
+        for j in range(0, 4):
+            tmp = xor(h2b(keys[i][j]), h2b(plain_text[i][j]))
+            col = col + [b2h(tmp)]
+        row = row + [col]
+
+    return col_to_row(row)
+
+
+# checking if entered text is of valid size, and adding fillers
 def valid_block_size(msg):
     m_len = len(msg)
     final = msg
-    if m_len % 32 != 0:
+    if m_len > 32:
+        print("Not a valid size block, Exceeding Block size!")
+        final = final[0:32]
+        print("After filler:", final)
+        return final
+    elif m_len % 32 != 0:
         print("Not a valid size block")
         for i in range(abs(32 - (m_len % 32))):
             final = final + "0"
@@ -273,7 +282,7 @@ def valid_block_size(msg):
 
 
 def key_and_text_to_matrix(key_string):
-    arr = [["00" for i in range(4)] for j in range(4)]
+    arr = [["00" for _ in range(4)] for _ in range(4)]
     row = 0
     col = 0
     for i in range(0, len(key_string), 2):
@@ -289,16 +298,21 @@ def key_and_text_to_matrix(key_string):
     return arr
 
 
-def aes_encryption(plaintext, aes_key):
-    add_round_key = add_round(plaintext, aes_key)
+rnd_const = [["01", "00", "00", "00"], ["02", "00", "00", "00"], ["04", "00", "00", "00"], ["08", "00", "00", "00"],
+             ["10", "00", "00", "00"], ["20", "00", "00", "00"], ["40", "00", "00", "00"], ["80", "00", "00", "00"],
+             ["1b", "00", "00", "00"], ["36", "00", "00", "00"]]
+
+
+def aes_encryption(plain_text, aes_key):
+    add_round_key = add_round(plain_text, aes_key)
     sub_byte = substitute_byte(add_round_key)
     shift_rows = shift_row(sub_byte)
     mix_column = mix_col(row_to_col(shift_rows))
-    add_round_key = add_round(mix_column, key(aes_key, rnd_const[0]))
-    aes_key = key(aes_key, rnd_const[0])
+    add_round_key = add_round(mix_column, key_expansion(aes_key, rnd_const[0]))
+    aes_key = key_expansion(aes_key, rnd_const[0])
 
     for i in range(1, 9):
-        tmp_key = key(aes_key, rnd_const[i])
+        tmp_key = key_expansion(aes_key, rnd_const[i])
         aes_key = tmp_key
         sub_byte = substitute_byte(add_round_key)
         shift_rows = shift_row(sub_byte)
@@ -307,7 +321,7 @@ def aes_encryption(plaintext, aes_key):
 
     sub_byte = substitute_byte(add_round_key)
     shift_rows = row_to_col(shift_row(sub_byte))
-    tmp_key = key(aes_key, rnd_const[9])
+    tmp_key = key_expansion(aes_key, rnd_const[9])
     aes_key = tmp_key
     add_round_key = add_round(shift_rows, aes_key)
 
@@ -318,18 +332,18 @@ def aes_encryption(plaintext, aes_key):
     return cipher
 
 
-pt = input("Enter text: ")
-valid_pt_block = valid_block_size(pt)
-pt_matrix = key_and_text_to_matrix(pt)
-print("Plaintext Block:", pt_matrix)
+plaintext = input("Enter text: ")
+valid_pt_block = valid_block_size(plaintext)
+plaintext_matrix = key_and_text_to_matrix(plaintext)
+print("Plaintext Block:", plaintext_matrix)
 print("---------------------------------------------------------------------------------------------------------------")
 
-k = input("Enter key: ")
-valid_k_block = valid_block_size(k)
-key_mat = key_and_text_to_matrix(k)
-print("Key Block:", key_mat)
+key = input("Enter key: ")
+valid_k_block = valid_block_size(key)
+key_matrix = key_and_text_to_matrix(key)
+print("Key Block:", key_matrix)
 print("---------------------------------------------------------------------------------------------------------------")
 
-cipher_text = aes_encryption(pt_matrix, key_mat)
+cipher_text = aes_encryption(plaintext_matrix, key_matrix)
 print("Encrypted Text: ", cipher_text)
 print("---------------------------------------------------------------------------------------------------------------")