refactor key structure

src/mimick_csharp_test.py

@@ -1,5 +1,8 @@
 from src.models import ServerEphemeralKeys, ServerPersistentKeys, ClientEphemeralKeys, ClientPersistentKeys, \
-    MutualEphemeralKeys, AlphabetKey, DarcKey, OuterShuffleKey, MutualPersistentKeys
+    MutualEphemeralKeys, AlphabetKey, DarcKey, OuterShuffleKey, MutualPersistentKeys, ClientKeys, ServerKeys, \
+    MutualKeys, ServerPersistentDataKeys, ServerEphemeralDataKeys, MutualPersistentDataKeys, MutualEphemeralDataKeys, \
+    ServerPersistentMediumKeys, ServerEphemeralMediumKeys, MutualPersistentMediumKeys, MutualEphemeralMediumKeys, \
+    ClientPersistentDataKeys, ClientEphemeralDataKeys, ClientEphemeralMediumKeys, ClientPersistentMediumKeys
 import json
 
 height = 10
@@ -7,12 +10,13 @@ width = 7
 block_size = 10
 
 
-def darc_phase1(alphabet: DarcKey, server_persistent_keys: ServerPersistentKeys, server_ephemeral_keys: ServerEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def darc_phase1(alphabet: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys):
-    alphabet_phase1 = translate_data(alphabet, server_persistent_keys, server_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    alphabet_phase1 = translate_data(alphabet, server_keys.Persistent.Data, server_keys.Ephemeral.Data, mutual_keys.Persistent.Data, mutual_keys.Ephemeral.Data)
-    medium = translate_medium(server_persistent_keys, server_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    medium = translate_medium(server_keys.Persistent.Medium, server_keys.Ephemeral.Medium, mutual_keys.Persistent.Medium, mutual_keys.Ephemeral.Medium)
     return alphabet_phase1, medium
 
-def translate_data(alphabet: DarcKey, server_persistent_keys: ServerPersistentKeys, server_ephemeral_keys: ServerEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+
+def translate_data(alphabet: AlphabetKey, server_persistent_keys: ServerPersistentDataKeys, server_ephemeral_keys: ServerEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
     function_ephemeral_key_applied = mutual_persistent_keys.Inner1 << mutual_ephemeral_keys.Inner1
     outer_function_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionKey << mutual_ephemeral_keys.OuterFunctionKey
     outer_function_function_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionFunctionKey << mutual_ephemeral_keys.OuterFunctionFunctionKey
@@ -35,7 +39,8 @@ def translate_data(alphabet: DarcKey, server_persistent_keys: ServerPersistentKe
     operand = operand ^ (operand1 << inner_function_shuffled) ^ (operand2 << inner_function_shuffled)
     return operand
 
-def translate_medium(server_persistent_keys: ServerPersistentKeys, server_ephemeral_keys: ServerEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+
+def translate_medium(server_persistent_keys: ServerPersistentMediumKeys, server_ephemeral_keys: ServerEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
 
     function_ephemeral_key_applied = mutual_persistent_keys.FunctionMediumKey << mutual_ephemeral_keys.FunctionMediumKey
     outer_function_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionMediumKey << mutual_ephemeral_keys.OuterFunctionMediumEphemeralKey
@@ -56,8 +61,13 @@ def translate_medium(server_persistent_keys: ServerPersistentKeys, server_epheme
     return operand
 
 
+def darc_phase2(alphabet: AlphabetKey, medium: AlphabetKey, client_keys: ClientKeys, mutual_keys: MutualKeys):
+    alphabet_phase2 = receive_alphabet(alphabet, client_keys.Persistent.Data, client_keys.Ephemeral.Data, mutual_keys.Persistent.Data , mutual_keys.Ephemeral.Data)
+    medium = receive_medium(medium, client_keys.Persistent.Medium, client_keys.Ephemeral.Medium, mutual_keys.Persistent.Medium, mutual_keys.Ephemeral.Medium)
+    return alphabet_phase2, medium
 
-def receive_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+
+def receive_alphabet(alphabet: AlphabetKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
     function_key_applied = mutual_persistent_keys.Inner1 << mutual_ephemeral_keys.Inner1
     outer_function_key_applied = mutual_persistent_keys.OuterFunctionKey << mutual_ephemeral_keys.OuterFunctionKey
     outer_function_function_key_applied = mutual_persistent_keys.OuterFunctionFunctionKey << mutual_ephemeral_keys.OuterFunctionFunctionKey
@@ -82,7 +92,7 @@ def receive_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistent
     return result
 
 
-def receive_medium(medium: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def receive_medium(medium: AlphabetKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
     function_key_applied = mutual_persistent_keys.FunctionMediumKey << mutual_ephemeral_keys.FunctionMediumKey
     outer_function_key_applied = mutual_persistent_keys.OuterFunctionMediumKey << mutual_ephemeral_keys.OuterFunctionMediumEphemeralKey
     outer_function_function_key_applied = mutual_persistent_keys.OuterFunctionFunctionMediumKey << mutual_ephemeral_keys.OuterFunctionFunctionMediumEphemeralKey
@@ -108,13 +118,13 @@ def receive_medium(medium: DarcKey, client_persistent_keys: ClientPersistentKeys
     return result
 
 
-def darc_phase2(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def darc_phase3(alphabet: AlphabetKey, medium: AlphabetKey, client_keys: ClientKeys, mutual_keys: MutualKeys):
-    alphabet_phase2 = receive_alphabet(alphabet, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    alphabet_phase3 = transmit_alphabet(alphabet, client_keys.Persistent.Data, client_keys.Ephemeral.Data, mutual_keys.Persistent.Data, mutual_keys.Ephemeral.Data)
-    medium = receive_medium(medium, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    medium = transmit_medium(medium, client_keys.Persistent.Medium, client_keys.Ephemeral.Medium, mutual_keys.Persistent.Medium, mutual_keys.Ephemeral.Medium)
-    return alphabet_phase2, medium
+    return alphabet_phase3, medium
 
 
-def transmit_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def transmit_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
     outer_server_shuffle_function_key_applied = mutual_persistent_keys.OuterServerShuffleFunctionKey << mutual_ephemeral_keys.OuterServerShuffleFunctionKey
     outer_client_shuffle_key_applied = client_persistent_keys.OuterClientShuffleKey << client_ephemeral_keys.OuterClientShuffleEphemeralKey
     outer_client_shuffle_function_key_applied = client_persistent_keys.OuterClientShuffleFunctionKey << client_ephemeral_keys.OuterClientShuffleFunctionEphemeralKey
@@ -150,7 +160,7 @@ def transmit_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersisten
     return result
 
 
-def transmit_medium(medium: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def transmit_medium(medium: DarcKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
     client_shuffle_ephemeral_key_b = ~client_ephemeral_keys.ClientShuffleMediumEphemeralKeyA
     outer_server_shuffle_function_key_applied = mutual_persistent_keys.OuterServerShuffleFunctionMediumKey << mutual_ephemeral_keys.OuterServerShuffleFunctionMediumEphemeralKey
     outer_client_shuffle_key_applied = client_persistent_keys.OuterClientShuffleMediumKey << client_ephemeral_keys.OuterClientShuffleMediumEphemeralKey
@@ -186,14 +196,9 @@ def transmit_medium(medium: DarcKey, client_persistent_keys: ClientPersistentKey
     return result
 
 
-def darc_phase3(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def merge_message(alphabet: DarcKey, medium: DarcKey, client_keys: ClientKeys, mutual_keys: MutualKeys, input_sequence: list[int]):
-    alphabet_phase3 = transmit_alphabet(alphabet, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    outer_client_shuffle_alphabet_key_applied = client_keys.Persistent.Data.OuterClientShuffleKey << client_keys.Ephemeral.Data.OuterClientShuffleEphemeralKey
-    medium = transmit_medium(medium, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    outer_client_shuffle_function_alphabet_key_applied = client_keys.Persistent.Data.OuterClientShuffleFunctionKey << client_keys.Ephemeral.Data.OuterClientShuffleFunctionEphemeralKey
-    return alphabet_phase3, medium
-
-def merge_message(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: ClientPersistentKeys, client_ephemeral_keys: ClientEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys, input_sequence: list[int]):
-    outer_client_shuffle_alphabet_key_applied = client_persistent_keys.OuterClientShuffleKey << client_ephemeral_keys.OuterClientShuffleEphemeralKey
-    outer_client_shuffle_function_alphabet_key_applied = client_persistent_keys.OuterClientShuffleFunctionKey << client_ephemeral_keys.OuterClientShuffleFunctionEphemeralKey
     outer_client_shuffle_alphabet_key_applied = ~(outer_client_shuffle_alphabet_key_applied << outer_client_shuffle_function_alphabet_key_applied)
 
     msg_len = len(input_sequence)
@@ -207,8 +212,8 @@ def merge_message(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: Cl
 
     input_sequence_applied = outer_client_shuffle_alphabet_key_applied << padded_input_sequence
 
-    outer_client_shuffle_medium_key_applied = client_persistent_keys.OuterClientShuffleMediumKey << client_ephemeral_keys.OuterClientShuffleMediumEphemeralKey
+    outer_client_shuffle_medium_key_applied = client_keys.Persistent.Medium.OuterClientShuffleMediumKey << client_keys.Ephemeral.Medium.OuterClientShuffleMediumEphemeralKey
-    outer_client_shuffle_function_medium_key_applied = client_persistent_keys.OuterClientShuffleFunctionMediumKey << client_ephemeral_keys.OuterClientShuffleFunctionMediumEphemeralKey
+    outer_client_shuffle_function_medium_key_applied = client_keys.Persistent.Medium.OuterClientShuffleFunctionMediumKey << client_keys.Ephemeral.Medium.OuterClientShuffleFunctionMediumEphemeralKey
 
     outer_client_shuffle_medium_key_applied = outer_client_shuffle_medium_key_applied << outer_client_shuffle_function_medium_key_applied
 
@@ -220,9 +225,9 @@ def merge_message(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: Cl
     if msg_len < height:
         message.matrix[message_pad_key.matrix[0][msg_len]] = eof_arr
 
-    position_function_key_applied = mutual_persistent_keys.PositionFunctionMediumKey << mutual_ephemeral_keys.PositionFunctionMediumEphemeralKey
+    position_function_key_applied = mutual_keys.Persistent.Medium.PositionFunctionMediumKey << mutual_keys.Ephemeral.Medium.PositionFunctionMediumEphemeralKey
-    outer_position_function_key_applied = mutual_persistent_keys.OuterPositionFunctionMediumKey << mutual_ephemeral_keys.OuterPositionFunctionMediumEphemeralKey
+    outer_position_function_key_applied = mutual_keys.Persistent.Medium.OuterPositionFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterPositionFunctionMediumEphemeralKey
-    outer_position_shuffle_key_applied = mutual_persistent_keys.OuterPositionShuffleMediumKey << mutual_ephemeral_keys.OuterPositionShuffleMediumEphemeralKey
+    outer_position_shuffle_key_applied = mutual_keys.Persistent.Medium.OuterPositionShuffleMediumKey << mutual_keys.Ephemeral.Medium.OuterPositionShuffleMediumEphemeralKey
 
     outer_position_function_key_applied = outer_position_shuffle_key_applied << outer_position_function_key_applied
 
@@ -236,8 +241,8 @@ def merge_message(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: Cl
 
     message = operand ^ (operand1 << inner_function_key_applied)
 
-    outer_position_shuffle_function_key_applied = mutual_persistent_keys.OuterPositionShuffleFunctionMediumKey << mutual_ephemeral_keys.OuterPositionShuffleFunctionMediumEphemeralKey
+    outer_position_shuffle_function_key_applied = mutual_keys.Persistent.Medium.OuterPositionShuffleFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterPositionShuffleFunctionMediumEphemeralKey
-    position_shuffle_key_applied = mutual_persistent_keys.PositionShuffleMediumKey << mutual_ephemeral_keys.PositionShuffleMediumEphemeralKey
+    position_shuffle_key_applied = mutual_keys.Persistent.Medium.PositionShuffleMediumKey << mutual_keys.Ephemeral.Medium.PositionShuffleMediumEphemeralKey
 
     outer_position_shuffle_key_applied = outer_client_shuffle_medium_key_applied << outer_position_shuffle_key_applied
     outer_position_shuffle_function_key_applied = outer_position_shuffle_function_key_applied << outer_position_function_key_applied
@@ -247,67 +252,67 @@ def merge_message(alphabet: DarcKey, medium: DarcKey, client_persistent_keys: Cl
     return message
 
 
-def darc_phase_4(alphabet: DarcKey, darc_message: DarcKey, server_persistent_keys: ServerPersistentKeys, server_ephemeral_keys: ServerEphemeralKeys, mutual_persistent_keys: MutualPersistentKeys, mutual_ephemeral_keys: MutualEphemeralKeys):
+def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys):
-    outer_position_function_ephemeral_key_applied = mutual_persistent_keys.OuterPositionFunctionMediumKey << mutual_ephemeral_keys.OuterPositionFunctionMediumEphemeralKey
+    outer_position_function_ephemeral_key_applied = mutual_keys.Persistent.Medium.OuterPositionFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterPositionFunctionMediumEphemeralKey
-    outer_position_shuffle_ephemeral_key_applied = mutual_persistent_keys.OuterPositionShuffleMediumKey << mutual_ephemeral_keys.OuterPositionShuffleMediumEphemeralKey
+    outer_position_shuffle_ephemeral_key_applied = mutual_keys.Persistent.Medium.OuterPositionShuffleMediumKey << mutual_keys.Ephemeral.Medium.OuterPositionShuffleMediumEphemeralKey
 
     outer_position_function_ephemeral_key_applied = ~(outer_position_shuffle_ephemeral_key_applied << outer_position_function_ephemeral_key_applied)
     outer_position_shuffle_ephemeral_key_applied = ~outer_position_shuffle_ephemeral_key_applied
 
-    outer_position_shuffle_function_ephemeral_key_applied = mutual_persistent_keys.OuterPositionShuffleFunctionMediumKey << mutual_ephemeral_keys.OuterPositionShuffleFunctionMediumEphemeralKey
+    outer_position_shuffle_function_ephemeral_key_applied = mutual_keys.Persistent.Medium.OuterPositionShuffleFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterPositionShuffleFunctionMediumEphemeralKey
     outer_position_shuffle_function_ephemeral_key_applied = outer_position_shuffle_function_ephemeral_key_applied << outer_position_function_ephemeral_key_applied
 
-    outer_function_function_medium_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionFunctionMediumKey << mutual_ephemeral_keys.OuterFunctionFunctionMediumEphemeralKey
+    outer_function_function_medium_ephemeral_key_applied = mutual_keys.Persistent.Medium.OuterFunctionFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterFunctionFunctionMediumEphemeralKey
-    outer_server_shuffle_function_ephemeral_key_applied = mutual_persistent_keys.OuterServerShuffleFunctionKey << mutual_ephemeral_keys.OuterServerShuffleFunctionKey
+    outer_server_shuffle_function_ephemeral_key_applied = mutual_keys.Persistent.Data.OuterServerShuffleFunctionKey << mutual_keys.Ephemeral.Data.OuterServerShuffleFunctionKey
 
-    outer_server_shuffle_function_medium_ephemeral_key_applied = mutual_persistent_keys.OuterServerShuffleFunctionMediumKey << mutual_ephemeral_keys.OuterServerShuffleFunctionMediumEphemeralKey
+    outer_server_shuffle_function_medium_ephemeral_key_applied = mutual_keys.Persistent.Medium.OuterServerShuffleFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterServerShuffleFunctionMediumEphemeralKey
 
-    function_medium_ephemeral_key_applied = mutual_persistent_keys.FunctionMediumKey << mutual_ephemeral_keys.FunctionMediumKey
+    function_medium_ephemeral_key_applied = mutual_keys.Persistent.Medium.FunctionMediumKey << mutual_keys.Ephemeral.Medium.FunctionMediumKey
 
-    client_shuffle_medium_key_x = mutual_persistent_keys.ClientShuffleMediumKeyX < outer_server_shuffle_function_medium_ephemeral_key_applied
+    client_shuffle_medium_key_x = mutual_keys.Persistent.Medium.ClientShuffleMediumKeyX < outer_server_shuffle_function_medium_ephemeral_key_applied
     client_shuffle_medium_key_x = (function_medium_ephemeral_key_applied < outer_function_function_medium_ephemeral_key_applied) << client_shuffle_medium_key_x
 
-    position_shuffle_ephemeral_key_applied = mutual_persistent_keys.PositionShuffleMediumKey << mutual_ephemeral_keys.PositionShuffleMediumEphemeralKey
+    position_shuffle_ephemeral_key_applied = mutual_keys.Persistent.Medium.PositionShuffleMediumKey << mutual_keys.Ephemeral.Medium.PositionShuffleMediumEphemeralKey
 
     position_shuffle_ephemeral_key_applied = position_shuffle_ephemeral_key_applied < outer_position_shuffle_function_ephemeral_key_applied
     client_shuffle_medium_key_x = client_shuffle_medium_key_x << position_shuffle_ephemeral_key_applied
 
 
-    outer_function_medium_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionMediumKey << mutual_ephemeral_keys.OuterFunctionMediumEphemeralKey
+    outer_function_medium_ephemeral_key_applied = mutual_keys.Persistent.Medium.OuterFunctionMediumKey << mutual_keys.Ephemeral.Medium.OuterFunctionMediumEphemeralKey
 
     rx_data = darc_message < outer_position_shuffle_ephemeral_key_applied
 
     inner_key = client_shuffle_medium_key_x
     operand = rx_data
-    operand1 = server_persistent_keys.ServerMediumKey < outer_function_medium_ephemeral_key_applied
+    operand1 = server_keys.Persistent.Medium.ServerMediumKey < outer_function_medium_ephemeral_key_applied
-    operand2 = server_ephemeral_keys.ServerMediumEphemeralKey < outer_function_medium_ephemeral_key_applied
+    operand2 = server_keys.Ephemeral.Medium.ServerMediumEphemeralKey < outer_function_medium_ephemeral_key_applied
-    operand3 = mutual_persistent_keys.MutualMediumKey < outer_function_medium_ephemeral_key_applied
+    operand3 = mutual_keys.Persistent.Medium.MutualMediumKey < outer_function_medium_ephemeral_key_applied
-    operand4 = mutual_ephemeral_keys.MutualMediumKey < outer_function_medium_ephemeral_key_applied
+    operand4 = mutual_keys.Ephemeral.Medium.MutualMediumKey < outer_function_medium_ephemeral_key_applied
 
     rx_data = operand ^ (operand1 << inner_key) ^ (operand2 << inner_key) ^ (operand3 << inner_key) ^ (operand4 << inner_key)
 
-    position_function_ephemeral_key_applied = mutual_persistent_keys.PositionFunctionMediumKey << mutual_ephemeral_keys.PositionFunctionMediumEphemeralKey
+    position_function_ephemeral_key_applied = mutual_keys.Persistent.Medium.PositionFunctionMediumKey << mutual_keys.Ephemeral.Medium.PositionFunctionMediumEphemeralKey
     rx_data = rx_data << (~(position_shuffle_ephemeral_key_applied) << (~position_function_ephemeral_key_applied < outer_position_function_ephemeral_key_applied))
 
-    client_shuffle_key_x = mutual_persistent_keys.ClientShuffleKeyX < outer_server_shuffle_function_ephemeral_key_applied
+    client_shuffle_key_x = mutual_keys.Persistent.Data.ClientShuffleKeyX < outer_server_shuffle_function_ephemeral_key_applied
-    outer_function_function_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionFunctionKey << mutual_ephemeral_keys.OuterFunctionFunctionKey
+    outer_function_function_ephemeral_key_applied = mutual_keys.Persistent.Data.OuterFunctionFunctionKey << mutual_keys.Ephemeral.Data.OuterFunctionFunctionKey
 
-    function_ephemeral_key_applied = mutual_persistent_keys.Inner1 << mutual_ephemeral_keys.Inner1
+    function_ephemeral_key_applied = mutual_keys.Persistent.Data.Inner1 << mutual_keys.Ephemeral.Data.Inner1
     function_ephemeral_key_applied = (function_ephemeral_key_applied < outer_function_function_ephemeral_key_applied) << client_shuffle_key_x
-    server_shuffle_ephemeral_key_applied = ~(server_persistent_keys.ServerShuffleKey << mutual_persistent_keys.ClientShuffleKeyX) << ~(server_ephemeral_keys.ServerShuffleEphemeralKey)
+    server_shuffle_ephemeral_key_applied = ~(server_keys.Persistent.Data.ServerShuffleKey << mutual_keys.Persistent.Data.ClientShuffleKeyX) << ~(server_keys.Ephemeral.Data.ServerShuffleEphemeralKey)
     server_shuffle_ephemeral_key_applied = ~(server_shuffle_ephemeral_key_applied < outer_server_shuffle_function_ephemeral_key_applied)
 
-    outer_server_shuffle_ephemeral_key_applied = server_persistent_keys.OuterServerShuffleKey << server_ephemeral_keys.OuterServerShuffleEphemeralKey
+    outer_server_shuffle_ephemeral_key_applied = server_keys.Persistent.Data.OuterServerShuffleKey << server_keys.Ephemeral.Data.OuterServerShuffleEphemeralKey
     alpha_prep = (alphabet < outer_server_shuffle_ephemeral_key_applied) << server_shuffle_ephemeral_key_applied
 
-    outer_function_ephemeral_key_applied = mutual_persistent_keys.OuterFunctionKey << mutual_ephemeral_keys.OuterFunctionKey
+    outer_function_ephemeral_key_applied = mutual_keys.Persistent.Data.OuterFunctionKey << mutual_keys.Ephemeral.Data.OuterFunctionKey
 
     inner_key = function_ephemeral_key_applied
     operand = alpha_prep
-    operand1 = server_persistent_keys.ServerKey < outer_function_ephemeral_key_applied
+    operand1 = server_keys.Persistent.Data.ServerKey < outer_function_ephemeral_key_applied
-    operand2 = server_ephemeral_keys.ServerEphemeralKey < outer_function_ephemeral_key_applied
+    operand2 = server_keys.Ephemeral.Data.ServerEphemeralKey < outer_function_ephemeral_key_applied
-    operand3 = mutual_persistent_keys.MutualKey < outer_function_ephemeral_key_applied
+    operand3 = mutual_keys.Persistent.Data.MutualKey < outer_function_ephemeral_key_applied
-    operand4 = mutual_ephemeral_keys.MutualKey < outer_function_ephemeral_key_applied
+    operand4 = mutual_keys.Ephemeral.Data.MutualKey < outer_function_ephemeral_key_applied
     alpha_prep = operand ^ (operand1 << inner_key) ^ (operand2 << inner_key) ^ (operand3 << inner_key) ^ (operand4 << inner_key)
 
     return resolve_message(alpha_prep.matrix, rx_data.matrix)
@@ -325,56 +330,157 @@ def resolve_message(translated_alphabet, translated_messasge):
             break
     return message
 
+
 if __name__ == "__main__":
-#    with open("../darc_key_json/client_persistent_keys.json") as fp:
+    with open("../darc_key_json/client_persistent_keys.json") as fp:
-#        client_persistent_keys = json.load(fp)
+        client_persistent_keys = json.load(fp)
-#
-#    with open("../darc_key_json/client_ephemeral_keys.json") as fp:
-#        client_ephemeral_keys = json.load(fp)
-#
-#    with open("../darc_key_json/server_persistent_keys.json") as fp:
-#        server_persistent_keys = json.load(fp)
-#
-#    with open("../darc_key_json/server_ephemeral_keys.json") as fp:
-#        server_ephemeral_keys = json.load(fp)
-#
-#    with open("../darc_key_json/mutual_ephemeral_keys.json") as fp:
-#        mutual_ephemeral_keys = json.load(fp)
 
-#    client_persistent_keys = {k: {"matrix": v} for k, v in client_persistent_keys.items()}
+    with open("../darc_key_json/client_ephemeral_keys.json") as fp:
-#    client_ephemeral_keys = {k: {"matrix": v} for k, v in client_ephemeral_keys.items()}
+        client_ephemeral_keys = json.load(fp)
-#    server_persistent_keys = {k: {"matrix": v} for k, v in server_persistent_keys.items()}
-#    server_ephemeral_keys = {k: {"matrix": v} for k, v in server_ephemeral_keys.items()}
-#    mutual_ephemeral_keys = {k: {"matrix": v} for k, v in mutual_ephemeral_keys.items()}
 
-#    client_persistent_keys = ClientPersistentKeys(**client_persistent_keys)
+    with open("../darc_key_json/server_persistent_keys.json") as fp:
-#    client_ephemeral_keys = ClientEphemeralKeys(**client_ephemeral_keys)
+        server_persistent_keys = json.load(fp)
-#    server_persistent_keys = ServerPersistentKeys(**server_persistent_keys)
-#    server_ephemeral_keys = ServerEphemeralKeys(**server_ephemeral_keys)
-#    mutual_ephemeral_keys = MutualEphemeralKeys(**mutual_ephemeral_keys)
 
-    client_persistent_keys = ClientPersistentKeys.random_init(height, width)
+    with open("../darc_key_json/server_ephemeral_keys.json") as fp:
-    client_ephemeral_keys = ClientEphemeralKeys.random_init(height, width)
+        server_ephemeral_keys = json.load(fp)
-    server_persistent_keys = ServerPersistentKeys.random_init(height, width)
-    server_ephemeral_keys = ServerEphemeralKeys.random_init(height, width)
-    mutual_ephemeral_keys = MutualEphemeralKeys.random_init(height, width)
-    mutual_persistent_keys = MutualPersistentKeys.random_init(height, width)
 
-    server_persistent_keys.ServerKey = server_persistent_keys.ServerKey ^ mutual_persistent_keys.MutualKey
+    with open("../darc_key_json/mutual_ephemeral_keys.json") as fp:
-    server_persistent_keys.ServerMediumKey = server_persistent_keys.ServerMediumKey ^ mutual_persistent_keys.MutualMediumKey
+        mutual_ephemeral_keys = json.load(fp)
 
-    mutual_persistent_keys.MutualKey = mutual_persistent_keys.MutualKey ^ client_persistent_keys.ClientKey
-    mutual_persistent_keys.MutualMediumKey = mutual_persistent_keys.MutualMediumKey ^ client_persistent_keys.ClientMediumKey
 
-    alphabet = AlphabetKey.init_matrix(width, height, 255)
+#    client_persistent_keys = ClientPersistentKeys.random_init(height, width)
-    (phase1_alphabet, phase1_medium) = darc_phase1(alphabet, server_persistent_keys, server_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+#    client_ephemeral_keys = ClientEphemeralKeys.random_init(height, width)
-    (phase2_alphabet, phase2_medium) = darc_phase2(phase1_alphabet, phase1_medium, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+#    server_persistent_keys = ServerPersistentKeys.random_init(height, width)
-    (phase3_alphabet, phase3_medium) = darc_phase3(phase2_alphabet, phase2_medium, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+#    server_ephemeral_keys = ServerEphemeralKeys.random_init(height, width)
+#    mutual_ephemeral_keys = MutualEphemeralKeys.random_init(height, width)
+#    mutual_persistent_keys = MutualPersistentKeys.random_init(height, width)
 
-    original_message = [0, 2, 4, 6, 7, 8, 9]
+    client_persistent_keys = {k: {"matrix": v} for k, v in client_persistent_keys.items()}
-    darc_message = merge_message(phase3_alphabet, phase3_medium, client_persistent_keys, client_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys, original_message)
+    client_ephemeral_keys = {k: {"matrix": v} for k, v in client_ephemeral_keys.items()}
+    server_persistent_keys = {k: {"matrix": v} for k, v in server_persistent_keys.items()}
+    server_ephemeral_keys = {k: {"matrix": v} for k, v in server_ephemeral_keys.items()}
+    mutual_ephemeral_keys = {k: {"matrix": v} for k, v in mutual_ephemeral_keys.items()}
 
-    message = darc_phase_4(alphabet, darc_message, server_persistent_keys, server_ephemeral_keys, mutual_persistent_keys, mutual_ephemeral_keys)
+    client_keys = ClientKeys(
+        Persistent=ClientPersistentKeys(
+            Data=ClientPersistentDataKeys(
+                OuterClientShuffleKey=client_persistent_keys["OuterClientShuffleKey"],
+                OuterClientShuffleFunctionKey=client_persistent_keys["OuterClientShuffleFunctionKey"],
+                ClientKey=client_persistent_keys["ClientKey"],
+                ClientShuffleKeyA=client_persistent_keys["ClientShuffleKeyA"]
+
+            ),
+            Medium=ClientPersistentMediumKeys(
+                OuterClientShuffleMediumKey=client_persistent_keys["OuterClientShuffleMediumKey"],
+                OuterClientShuffleFunctionMediumKey=client_persistent_keys["OuterClientShuffleFunctionMediumKey"],
+                ClientShuffleMediumKeyA=client_persistent_keys["ClientShuffleMediumKeyA"],
+                ClientMediumKey=client_persistent_keys["ClientMediumKey"]
+            )
+        ),
+        Ephemeral=ClientEphemeralKeys(
+            Data=ClientEphemeralDataKeys(
+                OuterClientShuffleEphemeralKey=client_ephemeral_keys["OuterClientShuffleEphemeralKey"],
+                OuterClientShuffleFunctionEphemeralKey=client_ephemeral_keys["OuterClientShuffleFunctionEphemeralKey"],
+                ClientEphemeralKey=client_ephemeral_keys["ClientEphemeralKey"],
+                ClientShuffleEphemeralKeyA=client_ephemeral_keys["ClientShuffleEphemeralKeyA"]
+            ),
+            Medium=ClientEphemeralMediumKeys(
+                OuterClientShuffleMediumEphemeralKey=client_ephemeral_keys["OuterClientShuffleMediumEphemeralKey"],
+                OuterClientShuffleFunctionMediumEphemeralKey=client_ephemeral_keys["OuterClientShuffleFunctionMediumEphemeralKey"],
+                ClientShuffleMediumEphemeralKeyA=client_ephemeral_keys["ClientShuffleMediumEphemeralKeyA"],
+                ClientMediumEphemeralKey=client_ephemeral_keys["ClientMediumEphemeralKey"]
+            )
+        )
+    )
+
+    server_keys = ServerKeys(
+        Persistent=ServerPersistentKeys(
+            Data=ServerPersistentDataKeys(
+                OuterServerShuffleKey=server_persistent_keys["OuterServerShuffleKey"],
+                ServerKey=server_persistent_keys["ServerKey"],
+                ServerShuffleKey=server_persistent_keys["ServerShuffleKey"]
+            ),
+            Medium=ServerPersistentMediumKeys(
+                ServerMediumKey=server_persistent_keys["ServerMediumKey"],
+            )
+        ),
+        Ephemeral=ServerEphemeralKeys(
+            Data=ServerEphemeralDataKeys(
+                OuterServerShuffleEphemeralKey=server_ephemeral_keys["OuterServerShuffleEphemeralKey"],
+                ServerEphemeralKey=server_ephemeral_keys["ServerEphemeralKey"],
+                ServerShuffleEphemeralKey=server_ephemeral_keys["ServerShuffleEphemeralKey"]
+            ),
+            Medium=ServerEphemeralMediumKeys(
+                ServerMediumEphemeralKey=server_ephemeral_keys["ServerMediumEphemeralKey"],
+            )
+        )
+    )
+
+    mutual_keys = MutualKeys(
+        Persistent=MutualPersistentKeys(
+            Data=MutualPersistentDataKeys(
+                OuterFunctionKey=server_persistent_keys["OuterFunctionKey"],
+                OuterFunctionFunctionKey=server_persistent_keys["OuterFunctionFunctionKey"],
+                OuterServerShuffleFunctionKey=server_persistent_keys["OuterServerShuffleFunctionKey"],
+                MutualKey=server_persistent_keys["MutualKey"],
+                Inner1=server_persistent_keys["FunctionKey"],
+                ClientShuffleKeyX=server_persistent_keys["ClientShuffleKeyX"],
+            ),
+            Medium=MutualPersistentMediumKeys(
+                MutualMediumKey=server_persistent_keys["MutualMediumKey"],
+                OuterFunctionMediumKey=server_persistent_keys["OuterFunctionMediumKey"],
+                OuterFunctionFunctionMediumKey=server_persistent_keys["OuterFunctionFunctionMediumKey"],
+                OuterServerShuffleFunctionMediumKey=server_persistent_keys["OuterServerShuffleFunctionMediumKey"],
+                FunctionMediumKey=server_persistent_keys["FunctionMediumKey"],
+                ClientShuffleMediumKeyX=server_persistent_keys["ClientShuffleMediumKeyX"],
+                OuterPositionShuffleMediumKey=server_persistent_keys["OuterPositionShuffleMediumKey"],
+                OuterPositionShuffleFunctionMediumKey=server_persistent_keys["OuterPositionShuffleFunctionMediumKey"],
+                OuterPositionFunctionMediumKey=server_persistent_keys["OuterPositionFunctionMediumKey"],
+                PositionFunctionMediumKey=server_persistent_keys["PositionFunctionMediumKey"],
+                PositionShuffleMediumKey=server_persistent_keys["PositionShuffleMediumKey"],
+            )
+        ),
+        Ephemeral=MutualEphemeralKeys(
+            Data=MutualEphemeralDataKeys(
+                MutualKey=mutual_ephemeral_keys["MutualEphemeralKey"],
+                Inner1=mutual_ephemeral_keys["FunctionEphemeralKey"],
+                OuterFunctionKey=mutual_ephemeral_keys["OuterFunctionEphemeralKey"],
+                OuterFunctionFunctionKey=mutual_ephemeral_keys["OuterFunctionFunctionEphemeralKey"],
+                OuterServerShuffleFunctionKey=mutual_ephemeral_keys["OuterServerShuffleFunctionEphemeralKey"]
+            ),
+            Medium=MutualEphemeralMediumKeys(
+                MutualMediumKey=mutual_ephemeral_keys["MutualMediumEphemeralKey"],
+                FunctionMediumKey=mutual_ephemeral_keys["FunctionMediumEphemeralKey"],
+                PositionFunctionMediumEphemeralKey=mutual_ephemeral_keys["PositionFunctionMediumEphemeralKey"],
+                OuterFunctionMediumEphemeralKey=mutual_ephemeral_keys["OuterFunctionMediumEphemeralKey"],
+                OuterFunctionFunctionMediumEphemeralKey=mutual_ephemeral_keys["OuterFunctionFunctionMediumEphemeralKey"],
+                OuterPositionFunctionMediumEphemeralKey=mutual_ephemeral_keys["OuterPositionFunctionMediumEphemeralKey"],
+                OuterServerShuffleFunctionMediumEphemeralKey=mutual_ephemeral_keys["OuterServerShuffleFunctionMediumEphemeralKey"],
+                OuterPositionShuffleFunctionMediumEphemeralKey=mutual_ephemeral_keys["OuterPositionShuffleFunctionMediumEphemeralKey"],
+                PositionShuffleMediumEphemeralKey=mutual_ephemeral_keys["PositionShuffleMediumEphemeralKey"],
+                OuterPositionShuffleMediumEphemeralKey=mutual_ephemeral_keys["OuterPositionShuffleMediumEphemeralKey"]
+
+            )
+        )
+    )
+
+
+    #server_keys.Persistent.Data.ServerKey = server_keys.Persistent.Data.ServerKey ^ mutual_keys.Persistent.Data.MutualKey
+    #server_keys.Persistent.Medium.ServerMediumKey = server_keys.Persistent.Medium.ServerMediumKey ^ mutual_keys.Persistent.Medium.MutualMediumKey
+
+    #mutual_keys.Persistent.Data.MutualKey = mutual_keys.Persistent.Data.MutualKey ^ client_keys.Persistent.Data.ClientKey
+    #mutual_keys.Persistent.Medium.MutualMediumKey = mutual_keys.Persistent.Medium.MutualMediumKey ^ client_keys.Persistent.Medium.ClientMediumKey
+
+    #alphabet = AlphabetKey.init_matrix(width, height, 255)
+    alphabet = AlphabetKey(**server_ephemeral_keys["Alphabet"])
+    (phase1_alphabet, phase1_medium) = darc_phase1(alphabet, server_keys, mutual_keys)
+    (phase2_alphabet, phase2_medium) = darc_phase2(phase1_alphabet, phase1_medium, client_keys, mutual_keys)
+    (phase3_alphabet, phase3_medium) = darc_phase3(phase2_alphabet, phase2_medium, client_keys, mutual_keys)
+
+    original_message = [ 0, 2, 4, 6, 0, 5, 9, 9, 1, 7 ]
+    darc_message = merge_message(phase3_alphabet, phase3_medium, client_keys, mutual_keys, original_message)
+
+    message = darc_phase_4(alphabet, darc_message, server_keys, mutual_keys)
 
     print(original_message)
     print(message)

src/models.py

@@ -145,29 +145,53 @@ class AlphabetKey(DarcKey):
         )
 
 
-class ServerPersistentKeys(BaseModel):
+class ClientEphemeralDataKeys(BaseModel):
-    OuterServerShuffleKey: OuterShuffleKey
+    OuterClientShuffleEphemeralKey: OuterShuffleKey
-    ServerKey: AlphabetKey
+    OuterClientShuffleFunctionEphemeralKey: OuterShuffleKey
-    ServerShuffleKey: InnerShuffleKey
+    ClientEphemeralKey: AlphabetKey
-
+    ClientShuffleEphemeralKeyA: InnerShuffleKey
-    ServerMediumKey: AlphabetKey
 
     @classmethod
     def random_init(cls, height: int, width: int):
-        return ServerPersistentKeys(
+        return ClientEphemeralDataKeys(
-            OuterServerShuffleKey=OuterShuffleKey.init_matrix(height),
+            OuterClientShuffleEphemeralKey=OuterShuffleKey.init_matrix(height),
-            ServerKey=AlphabetKey.init_matrix(width, height, 255),
+            OuterClientShuffleFunctionEphemeralKey=OuterShuffleKey.init_matrix(height),
-            ServerShuffleKey=InnerShuffleKey.init_matrix(width, height),
+            ClientEphemeralKey=AlphabetKey.init_matrix(width, height, 255),
-            ServerMediumKey=AlphabetKey.init_matrix(width, height, 255)
+            ClientShuffleEphemeralKeyA=InnerShuffleKey.init_matrix(width, height),
         )
 
 
-class ClientPersistentKeys(BaseModel):
+class ClientEphemeralMediumKeys(BaseModel):
+    OuterClientShuffleMediumEphemeralKey: OuterShuffleKey
+    OuterClientShuffleFunctionMediumEphemeralKey: OuterShuffleKey
+    ClientShuffleMediumEphemeralKeyA: InnerShuffleKey
+    ClientMediumEphemeralKey: AlphabetKey
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ClientEphemeralMediumKeys(
+            OuterClientShuffleMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            OuterClientShuffleFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            ClientShuffleMediumEphemeralKeyA=InnerShuffleKey.init_matrix(width, height),
+            ClientMediumEphemeralKey=AlphabetKey.init_matrix(width, height, 255)
+        )
+
+class ClientPersistentDataKeys(BaseModel):
     ClientKey: AlphabetKey
     ClientShuffleKeyA: InnerShuffleKey
     OuterClientShuffleKey: OuterShuffleKey
     OuterClientShuffleFunctionKey: OuterShuffleKey
 
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ClientPersistentDataKeys(
+            ClientKey=AlphabetKey.init_matrix(width, height, 255),
+            ClientShuffleKeyA=InnerShuffleKey.init_matrix(width, height),
+            OuterClientShuffleKey=OuterShuffleKey.init_matrix(height),
+            OuterClientShuffleFunctionKey=OuterShuffleKey.init_matrix(height),
+        )
+
+class ClientPersistentMediumKeys(BaseModel):
     OuterClientShuffleMediumKey: OuterShuffleKey
     OuterClientShuffleFunctionMediumKey: OuterShuffleKey
     ClientShuffleMediumKeyA: InnerShuffleKey
@@ -175,19 +199,102 @@ class ClientPersistentKeys(BaseModel):
 
     @classmethod
     def random_init(cls, height: int, width: int):
-        return ClientPersistentKeys(
+        return ClientPersistentMediumKeys(
-            ClientKey=AlphabetKey.init_matrix(width, height, 255),
-            ClientShuffleKeyA=InnerShuffleKey.init_matrix(width, height),
-            OuterClientShuffleKey=OuterShuffleKey.init_matrix(height),
-            OuterClientShuffleFunctionKey=OuterShuffleKey.init_matrix(height),
             OuterClientShuffleMediumKey=OuterShuffleKey.init_matrix(height),
             OuterClientShuffleFunctionMediumKey=OuterShuffleKey.init_matrix(height),
             ClientShuffleMediumKeyA=InnerShuffleKey.init_matrix(width, height),
             ClientMediumKey=AlphabetKey.init_matrix(width, height, 255)
         )
 
+class ServerEphemeralDataKeys(BaseModel):
+    OuterServerShuffleEphemeralKey: OuterShuffleKey
+    ServerEphemeralKey: AlphabetKey
+    ServerShuffleEphemeralKey: InnerShuffleKey
 
-class MutualPersistentKeys(BaseModel):
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ServerEphemeralDataKeys(
+            OuterServerShuffleEphemeralKey=OuterShuffleKey.init_matrix(height),
+            ServerEphemeralKey=AlphabetKey.init_matrix(width, height, 255),
+            ServerShuffleEphemeralKey=InnerShuffleKey.init_matrix(width, height),
+        )
+
+class ServerEphemeralMediumKeys(BaseModel):
+    ServerMediumEphemeralKey: AlphabetKey
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ServerEphemeralMediumKeys(
+            ServerMediumEphemeralKey=AlphabetKey.init_matrix(width, height, 255)
+        )
+
+class ServerPersistentDataKeys(BaseModel):
+    OuterServerShuffleKey: OuterShuffleKey
+    ServerKey: AlphabetKey
+    ServerShuffleKey: InnerShuffleKey
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ServerPersistentDataKeys(
+            OuterServerShuffleKey=OuterShuffleKey.init_matrix(height),
+            ServerKey=AlphabetKey.init_matrix(width, height, 255),
+            ServerShuffleKey=InnerShuffleKey.init_matrix(width, height),
+        )
+
+class ServerPersistentMediumKeys(BaseModel):
+    ServerMediumKey: AlphabetKey
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ServerPersistentMediumKeys(
+            ServerMediumKey=AlphabetKey.init_matrix(width, height, 255)
+        )
+
+class MutualEphemeralDataKeys(BaseModel):
+    MutualKey: AlphabetKey
+    Inner1: InnerShuffleKey
+    OuterFunctionKey: OuterShuffleKey
+    OuterFunctionFunctionKey: OuterShuffleKey
+    OuterServerShuffleFunctionKey: OuterShuffleKey
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return MutualEphemeralDataKeys(
+            MutualKey=AlphabetKey.init_matrix(width, height, 255),
+            Inner1=InnerShuffleKey.init_matrix(width, height),
+            OuterFunctionKey=OuterShuffleKey.init_matrix(height),
+            OuterFunctionFunctionKey=OuterShuffleKey.init_matrix(height),
+            OuterServerShuffleFunctionKey=OuterShuffleKey.init_matrix(height),
+        )
+
+class MutualEphemeralMediumKeys(BaseModel):
+    MutualMediumKey: AlphabetKey
+    FunctionMediumKey: InnerShuffleKey
+    PositionFunctionMediumEphemeralKey: InnerShuffleKey
+    OuterFunctionMediumEphemeralKey: OuterShuffleKey
+    OuterFunctionFunctionMediumEphemeralKey: OuterShuffleKey
+    OuterPositionFunctionMediumEphemeralKey: OuterShuffleKey
+    OuterServerShuffleFunctionMediumEphemeralKey: OuterShuffleKey
+    OuterPositionShuffleFunctionMediumEphemeralKey: OuterShuffleKey
+    PositionShuffleMediumEphemeralKey: InnerShuffleKey
+    OuterPositionShuffleMediumEphemeralKey: OuterShuffleKey
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return MutualEphemeralMediumKeys(
+            MutualMediumKey=AlphabetKey.init_matrix(width, height, 255),
+            FunctionMediumKey=InnerShuffleKey.init_matrix(width, height),
+            PositionFunctionMediumEphemeralKey=InnerShuffleKey.init_matrix(width, height),
+            OuterFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            OuterFunctionFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            OuterPositionFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            OuterServerShuffleFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            OuterPositionShuffleFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+            PositionShuffleMediumEphemeralKey=InnerShuffleKey.init_matrix(width, height),
+            OuterPositionShuffleMediumEphemeralKey=OuterShuffleKey.init_matrix(height)
+        )
+
+class MutualPersistentDataKeys(BaseModel):
     OuterFunctionKey: OuterShuffleKey
     OuterFunctionFunctionKey: OuterShuffleKey
     OuterServerShuffleFunctionKey: OuterShuffleKey
@@ -195,6 +302,19 @@ class MutualPersistentKeys(BaseModel):
     Inner1: InnerShuffleKey
     ClientShuffleKeyX: InnerShuffleKey
 
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return MutualPersistentDataKeys(
+            OuterFunctionKey=OuterShuffleKey.init_matrix(height),
+            OuterFunctionFunctionKey=OuterShuffleKey.init_matrix(height),
+            OuterServerShuffleFunctionKey=OuterShuffleKey.init_matrix(height),
+            MutualKey=AlphabetKey.init_matrix(width, height, 255),
+            Inner1=InnerShuffleKey.init_matrix(width, height),
+            ClientShuffleKeyX=InnerShuffleKey.init_matrix(width, height),
+        )
+
+
+class MutualPersistentMediumKeys(BaseModel):
     MutualMediumKey: AlphabetKey
     OuterFunctionMediumKey: OuterShuffleKey
     OuterFunctionFunctionMediumKey: OuterShuffleKey
@@ -209,13 +329,7 @@ class MutualPersistentKeys(BaseModel):
 
     @classmethod
     def random_init(cls, height: int, width: int):
-        return MutualPersistentKeys(
+        return MutualPersistentMediumKeys(
-            OuterFunctionKey=OuterShuffleKey.init_matrix(height),
-            OuterFunctionFunctionKey=OuterShuffleKey.init_matrix(height),
-            OuterServerShuffleFunctionKey=OuterShuffleKey.init_matrix(height),
-            MutualKey=AlphabetKey.init_matrix(width, height, 255),
-            Inner1=InnerShuffleKey.init_matrix(width, height),
-            ClientShuffleKeyX=InnerShuffleKey.init_matrix(width, height),
             MutualMediumKey=AlphabetKey.init_matrix(width, height, 255),
             OuterFunctionMediumKey=OuterShuffleKey.init_matrix(height),
             OuterFunctionFunctionMediumKey=OuterShuffleKey.init_matrix(height),
@@ -229,83 +343,109 @@ class MutualPersistentKeys(BaseModel):
             PositionShuffleMediumKey=InnerShuffleKey.init_matrix(width, height),
         )
 
+class ServerPersistentKeys(BaseModel):
+    Data: ServerPersistentDataKeys
+    Medium: ServerPersistentMediumKeys
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ServerPersistentKeys(
+            Data=ServerPersistentDataKeys.random_init(height, width),
+            Medium=ServerPersistentMediumKeys.random_init(height, width)
+        )
+
+
+class ClientPersistentKeys(BaseModel):
+    Data: ClientPersistentDataKeys
+    Medium: ClientPersistentMediumKeys
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ClientPersistentKeys(
+            Data=ClientPersistentDataKeys.random_init(height, width),
+            Medium=ClientPersistentMediumKeys.random_init(height, width)
+        )
+
+
+class MutualPersistentKeys(BaseModel):
+    Data: MutualPersistentDataKeys
+    Medium: MutualPersistentMediumKeys
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return MutualPersistentKeys(
+            Data=MutualPersistentDataKeys.random_init(height, width),
+            Medium=MutualPersistentMediumKeys.random_init(height, width)
+        )
+
 
 class ServerEphemeralKeys(BaseModel):
-    OuterServerShuffleEphemeralKey: OuterShuffleKey
+    Data: ServerEphemeralDataKeys
-    ServerEphemeralKey: AlphabetKey
+    Medium: ServerEphemeralMediumKeys
-    ServerShuffleEphemeralKey: InnerShuffleKey
-
-    ServerMediumEphemeralKey: AlphabetKey
 
     @classmethod
     def random_init(cls, height: int, width: int):
         return ServerEphemeralKeys(
-            OuterServerShuffleEphemeralKey=OuterShuffleKey.init_matrix(height),
+            Data=ServerEphemeralDataKeys.random_init(height, width),
-            ServerEphemeralKey=AlphabetKey.init_matrix(width, height, 255),
+            Medium=ServerEphemeralMediumKeys.random_init(height, width)
-            ServerShuffleEphemeralKey=InnerShuffleKey.init_matrix(width, height),
-            ServerMediumEphemeralKey=AlphabetKey.init_matrix(width, height, 255),
         )
 
 
 class MutualEphemeralKeys(BaseModel):
-    MutualKey: AlphabetKey
+    Data: MutualEphemeralDataKeys
-    Inner1: InnerShuffleKey
+    Medium: MutualEphemeralMediumKeys
-    OuterFunctionKey: OuterShuffleKey
-    OuterFunctionFunctionKey: OuterShuffleKey
-    OuterServerShuffleFunctionKey: OuterShuffleKey
-
-    MutualMediumKey: AlphabetKey
-    FunctionMediumKey: InnerShuffleKey
-    PositionFunctionMediumEphemeralKey: InnerShuffleKey
-    OuterFunctionMediumEphemeralKey: OuterShuffleKey
-    OuterFunctionFunctionMediumEphemeralKey: OuterShuffleKey
-    OuterPositionFunctionMediumEphemeralKey: OuterShuffleKey
-    OuterServerShuffleFunctionMediumEphemeralKey: OuterShuffleKey
-    OuterPositionShuffleFunctionMediumEphemeralKey: OuterShuffleKey
-    PositionShuffleMediumEphemeralKey: InnerShuffleKey
-    OuterPositionShuffleMediumEphemeralKey: OuterShuffleKey
 
     @classmethod
     def random_init(cls, height: int, width: int):
         return MutualEphemeralKeys(
-            MutualKey=AlphabetKey.init_matrix(width, height, 255),
+            Data=MutualEphemeralDataKeys.random_init(height, width),
-            Inner1=InnerShuffleKey.init_matrix(width, height),
+            Medium=MutualEphemeralMediumKeys.random_init(height, width)
-            OuterFunctionKey=OuterShuffleKey.init_matrix(height),
-            OuterFunctionFunctionKey=OuterShuffleKey.init_matrix(height),
-            OuterServerShuffleFunctionKey=OuterShuffleKey.init_matrix(height),
-            MutualMediumKey=AlphabetKey.init_matrix(width, height, 255),
-            FunctionMediumKey=InnerShuffleKey.init_matrix(width, height),
-            PositionFunctionMediumEphemeralKey=InnerShuffleKey.init_matrix(width, height),
-            OuterFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
-            OuterFunctionFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
-            OuterPositionFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
-            OuterServerShuffleFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
-            OuterPositionShuffleFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
-            PositionShuffleMediumEphemeralKey=InnerShuffleKey.init_matrix(width, height),
-            OuterPositionShuffleMediumEphemeralKey=OuterShuffleKey.init_matrix(height)
         )
 
 
 class ClientEphemeralKeys(BaseModel):
-    OuterClientShuffleEphemeralKey: OuterShuffleKey
+    Data: ClientEphemeralDataKeys
-    OuterClientShuffleFunctionEphemeralKey: OuterShuffleKey
+    Medium: ClientEphemeralMediumKeys
-    ClientEphemeralKey: AlphabetKey
-    ClientShuffleEphemeralKeyA: InnerShuffleKey
-
-    OuterClientShuffleMediumEphemeralKey: OuterShuffleKey
-    OuterClientShuffleFunctionMediumEphemeralKey: OuterShuffleKey
-    ClientShuffleMediumEphemeralKeyA: InnerShuffleKey
-    ClientMediumEphemeralKey: AlphabetKey
 
     @classmethod
     def random_init(cls, height: int, width: int):
         return ClientEphemeralKeys(
-            OuterClientShuffleEphemeralKey=OuterShuffleKey.init_matrix(height),
+            Data=ClientEphemeralDataKeys.random_init(height, width),
-            OuterClientShuffleFunctionEphemeralKey=OuterShuffleKey.init_matrix(height),
+            Medium=ClientEphemeralMediumKeys.random_init(height, width)
-            ClientEphemeralKey=AlphabetKey.init_matrix(width, height, 255),
+        )
-            ClientShuffleEphemeralKeyA=InnerShuffleKey.init_matrix(width, height),
+
-            OuterClientShuffleMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+
-            OuterClientShuffleFunctionMediumEphemeralKey=OuterShuffleKey.init_matrix(height),
+class ServerKeys(BaseModel):
-            ClientShuffleMediumEphemeralKeyA=InnerShuffleKey.init_matrix(width, height),
+    Persistent: ServerPersistentKeys
-            ClientMediumEphemeralKey=AlphabetKey.init_matrix(width, height, 255)
+    Ephemeral: ServerEphemeralKeys
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ServerKeys(
+            Persistent=ServerPersistentKeys.random_init(height, width),
+            Ephemeral=ServerEphemeralKeys.random_init(height, width)
+        )
+
+
+class MutualKeys(BaseModel):
+    Persistent: MutualPersistentKeys
+    Ephemeral: MutualEphemeralKeys
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return MutualKeys(
+            Persistent=MutualPersistentKeys.random_init(height, width),
+            Ephemeral=MutualEphemeralKeys.random_init(height, width)
+        )
+
+
+class ClientKeys(BaseModel):
+    Persistent: ClientPersistentKeys
+    Ephemeral: ClientEphemeralKeys
+
+    @classmethod
+    def random_init(cls, height: int, width: int):
+        return ClientKeys(
+            Persistent=ClientPersistentKeys.random_init(height, width),
+            Ephemeral=ClientEphemeralKeys.random_init(height, width)
         )