from src.models import ServerEphemeralKeys, ServerPersistentKeys, ClientEphemeralKeys, ClientPersistentKeys, \ MutualEphemeralKeys, AlphabetKey, DarcKey, OuterKey, MutualPersistentKeys, ClientKeys, ServerKeys, \ MutualKeys, ServerPersistentDataKeys, ServerEphemeralDataKeys, MutualPersistentDataKeys, MutualEphemeralDataKeys, \ ServerPersistentMediumKeys, ServerEphemeralMediumKeys, MutualPersistentMediumKeys, MutualEphemeralMediumKeys, \ ClientPersistentDataKeys, ClientEphemeralDataKeys, ClientEphemeralMediumKeys, ClientPersistentMediumKeys, InnerKey import json height = 256 width = 7 block_size = 10 def darc_phase1(alphabet: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys): 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_keys.persistent.medium, server_keys.ephemeral.medium, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium) return alphabet_phase1, medium def outer_inner_op(operand: AlphabetKey, outer_key: OuterKey, inner_key: InnerKey) -> AlphabetKey: return (operand < outer_key) << inner_key def outer_inner(outer_key: OuterKey, inner_key: InnerKey): return lambda x: (x < outer_key) << inner_key def inner_outer(inner_key: InnerKey, outer_key: OuterKey): return lambda x: (x << inner_key) < outer_key def translate_data(alphabet: AlphabetKey, server_persistent_keys: ServerPersistentDataKeys, server_ephemeral_keys: ServerEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys): so1 = server_persistent_keys.outer_key_1 << server_ephemeral_keys.outer_key_1 mo3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 si1_mo3: InnerKey = (server_persistent_keys.inner_key_1 << server_ephemeral_keys.inner_key_1) < mo3 server_func_1 = outer_inner(so1, si1_mo3) mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 mi1_mo2: InnerKey = (mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1) < mo2 mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 mutual_func_1 = outer_inner(mo1, mi1_mo2) substitution = server_persistent_keys.alpha_key ^ server_ephemeral_keys.alpha_key alpha_phase1 = ( server_func_1(alphabet) ^ mutual_func_1(substitution) ) return alpha_phase1 def translate_medium(server_persistent_keys: ServerPersistentMediumKeys, server_ephemeral_keys: ServerEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys): mutual_inner_key = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1 mutual_outer_key_1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 mutual_outer_key_2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 medium = AlphabetKey(matrix=[[0 for _ in range(width)] for _ in range(height)]) operand1 = server_persistent_keys.alpha_key < mutual_outer_key_1 operand2 = server_ephemeral_keys.alpha_key < mutual_outer_key_1 mutual_inner_key = mutual_inner_key < mutual_outer_key_2 operand = medium ^ (operand1 << mutual_inner_key) ^ (operand2 << mutual_inner_key) 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: AlphabetKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys): mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 mi1_mo2: InnerKey = (mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1) < mo2 mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 mutual_func_1 = outer_inner(mo1, mi1_mo2) substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key result = ( alphabet ^ mutual_func_1(substitution) ) mo3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 result = result < ~mo3 ci1 = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1 co1 = client_persistent_keys.outer_key_1 << client_ephemeral_keys.outer_key_1 co2 = client_persistent_keys.outer_key_2 << client_ephemeral_keys.outer_key_2 mo3_co1_co2 = mo3 << co1 << co2 client_func_1 = inner_outer(ci1, mo3_co1_co2) return client_func_1(result) def receive_medium(medium: AlphabetKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys): mutual_inner_key = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1 mutual_outer_key_1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 mutual_outer_key_2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 mutual_outer_key_3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 mutual_inner_key = mutual_inner_key < mutual_outer_key_2 operand1 = client_ephemeral_keys.alpha_key < mutual_outer_key_1 operand2 = client_persistent_keys.alpha_key < mutual_outer_key_1 operand3 = mutual_persistent_keys.alpha_key < mutual_outer_key_1 result = medium ^ (operand1 << mutual_inner_key) ^ (operand2 << mutual_inner_key) ^ (operand3 << mutual_inner_key) client_inner_key = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1 client_inner_key = client_inner_key < mutual_outer_key_3 result = result << client_inner_key client_outer_key_1 = client_persistent_keys.outer_key_1 << client_ephemeral_keys.outer_key_1 client_outer_key2 = client_persistent_keys.outer_key_2 << client_ephemeral_keys.outer_key_2 client_outer_key_1 = client_outer_key_1 << client_outer_key2 result = result < client_outer_key_1 return result def darc_phase3(alphabet: AlphabetKey, medium: AlphabetKey, client_keys: ClientKeys, mutual_keys: MutualKeys): alphabet_phase3 = transmit_alphabet(alphabet, client_keys.persistent.data, client_keys.ephemeral.data, mutual_keys.persistent.data, mutual_keys.ephemeral.data) medium = transmit_medium(medium, client_keys.persistent.medium, client_keys.ephemeral.medium, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium) return alphabet_phase3, medium def transmit_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys): mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 mo3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 co1 = client_persistent_keys.outer_key_1 << client_ephemeral_keys.outer_key_1 co2 = client_persistent_keys.outer_key_2 << client_ephemeral_keys.outer_key_2 co1_co2 = co1 << co2 mo3_co1_co2 = mo3 << co1 << co2 ncei1_ncpi1_mpi2 = ~client_ephemeral_keys.inner_key_1 << ~client_persistent_keys.inner_key_1 << mutual_persistent_keys.inner_key_2 ncei1_ncpi1_mpi2__mo3_co1_co2 = ncei1_ncpi1_mpi2 < mo3_co1_co2 result = alphabet << ncei1_ncpi1_mpi2__mo3_co1_co2 mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key mi1_mo2_mpi2_mo3 = (((mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1) < mo2) << (mutual_persistent_keys.inner_key_2 < mo3)) #< co1_co2 client_func_2 = outer_inner(mo1, mi1_mo2_mpi2_mo3) result = result ^ (client_func_2(substitution) < co1_co2) return result def transmit_medium(medium: DarcKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys): client_inner_key_1 = ~client_ephemeral_keys.inner_key_1 mutual_outer_key_3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 client_outer_key_1 = client_persistent_keys.outer_key_1 << client_ephemeral_keys.outer_key_1 client_outer_key_2 = client_persistent_keys.outer_key_2 << client_ephemeral_keys.outer_key_2 outer_key_1 = client_outer_key_1 << client_outer_key_2 outer_key_2 = mutual_outer_key_3 << outer_key_1 mutual_outer_key_2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 outer_key_3 = mutual_outer_key_2 << outer_key_1 mutual_inner_key_1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1 mutual_inner_key_1 = mutual_inner_key_1 < outer_key_3 mutual_inner_key_2 = mutual_persistent_keys.inner_key_2 < outer_key_2 inner_key_1 = mutual_inner_key_1 << mutual_inner_key_2 inner_key_2 = (~client_persistent_keys.inner_key_1) << mutual_persistent_keys.inner_key_2 inner_key_3 = client_inner_key_1 << inner_key_2 inner_key_3 = inner_key_3 < outer_key_2 medium = medium << inner_key_3 mutual_outer_key_1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 outer_key_3 = mutual_outer_key_1 << outer_key_1 operand1 = client_ephemeral_keys.alpha_key < outer_key_3 operand2 = client_persistent_keys.alpha_key < outer_key_3 operand3 = mutual_ephemeral_keys.alpha_key < outer_key_3 result = medium ^ (operand1 << inner_key_1) ^ (operand2 << inner_key_1) ^ (operand3 << inner_key_1) return result def transeive_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys): mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 mi1_mo2: InnerKey = (mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1) < mo2 mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 mutual_func_1 = outer_inner(mo1, mi1_mo2) substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key result = ( alphabet ^ mutual_func_1(substitution) ) mo3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 result = result < ~mo3 ci1 = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1 co1 = client_persistent_keys.outer_key_1 << client_ephemeral_keys.outer_key_1 co2 = client_persistent_keys.outer_key_2 << client_ephemeral_keys.outer_key_2 mo3_co1_co2 = mo3 << co1 << co2 client_func_1 = inner_outer(ci1, mo3_co1_co2) darc_phase2 = client_func_1(result) mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2 mi1_mo2: InnerKey = (mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1) < mo2 mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1 mutual_func_1 = outer_inner(mo1, mi1_mo2) substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key result = ( darc_phase2 ^ mutual_func_1(substitution) ) mo3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3 result = result < ~mo3 ci1 = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1 co1 = client_persistent_keys.outer_key_1 << client_ephemeral_keys.outer_key_1 co2 = client_persistent_keys.outer_key_2 << client_ephemeral_keys.outer_key_2 mo3_co1_co2 = mo3 << co1 << co2 client_func_1 = inner_outer(ci1, mo3_co1_co2) return client_func_1(result) def merge_message(alphabet: DarcKey, medium: DarcKey, client_keys: ClientKeys, mutual_keys: MutualKeys, input_sequence: list[int]): client_outer_key_1 = client_keys.persistent.data.outer_key_1 << client_keys.ephemeral.data.outer_key_1 client_outer_key_2 = client_keys.persistent.data.outer_key_2 << client_keys.ephemeral.data.outer_key_2 client_outer_key_1 = ~(client_outer_key_1 << client_outer_key_2) msg_len = len(input_sequence) eof_arr = AlphabetKey.init_matrix(width, height, 255).matrix[0] if msg_len < height: padded_input_sequence = OuterKey.init_matrix(height) padded_input_sequence.matrix = [input_sequence + padded_input_sequence.matrix[0][msg_len:]] else: padded_input_sequence = OuterKey(matrix=[input_sequence]) client_outer_key_1 = client_outer_key_1 << padded_input_sequence client_med_outer_key_1 = client_keys.persistent.medium.outer_key_1 << client_keys.ephemeral.medium.outer_key_1 client_med_outer_key_2 = client_keys.persistent.medium.outer_key_2 << client_keys.ephemeral.medium.outer_key_2 client_med_outer_key_1 = client_med_outer_key_1 << client_med_outer_key_2 client_outer_key_1 = client_outer_key_1 << client_med_outer_key_1 message = alphabet < client_outer_key_1 message_pad_key = ~client_med_outer_key_1 if msg_len < height: message.matrix[message_pad_key.matrix[0][msg_len]] = eof_arr mutual_inner_key_3 = mutual_keys.persistent.medium.inner_key_3 << mutual_keys.ephemeral.medium.inner_key_3 mutual_outer_key_6 = mutual_keys.persistent.medium.outer_key_6 << mutual_keys.ephemeral.medium.outer_key_6 mutual_outer_key_4 = mutual_keys.persistent.medium.outer_key_4 << mutual_keys.ephemeral.medium.outer_key_4 outer_key_1 = mutual_outer_key_4 << mutual_outer_key_6 client_med_outer_key_1 = ~client_med_outer_key_1 outer_key_1 = ~(client_med_outer_key_1 << outer_key_1) mutual_inner_key_3 = mutual_inner_key_3 < outer_key_1 message = medium ^ (message << mutual_inner_key_3) mutual_outer_key_5 = mutual_keys.persistent.medium.outer_key_5 << mutual_keys.ephemeral.medium.outer_key_5 mutual_inner_key = mutual_keys.persistent.medium.inner_key_4 << mutual_keys.ephemeral.medium.inner_key_2 mutual_outer_key_4 = client_med_outer_key_1 << mutual_outer_key_4 outer_key_2 = mutual_outer_key_5 << outer_key_1 message = message << (mutual_inner_key < outer_key_2) message = message < mutual_outer_key_4 return message def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys) -> DarcKey: mutual_med_outer_key_6 = mutual_keys.persistent.medium.outer_key_6 << mutual_keys.ephemeral.medium.outer_key_6 mutual_med_outer_key_4 = mutual_keys.persistent.medium.outer_key_4 << mutual_keys.ephemeral.medium.outer_key_4 outer_key_1 = ~(mutual_med_outer_key_4 << mutual_med_outer_key_6) mutual_med_outer_key_4 = ~mutual_med_outer_key_4 mutual_med_outer_key_5 = mutual_keys.persistent.medium.outer_key_5 << mutual_keys.ephemeral.medium.outer_key_5 mutual_med_outer_key_5 = mutual_med_outer_key_5 << outer_key_1 mutual_med_outer_key_2 = mutual_keys.persistent.medium.outer_key_2 << mutual_keys.ephemeral.medium.outer_key_2 mutual_outer_key_3 = mutual_keys.persistent.data.outer_key_3 << mutual_keys.ephemeral.data.outer_key_3 mutual_med_outer_key_3 = mutual_keys.persistent.medium.outer_key_3 << mutual_keys.ephemeral.medium.outer_key_3 mutual_med_inner_key_1 = mutual_keys.persistent.medium.inner_key_1 << mutual_keys.ephemeral.medium.inner_key_1 mutual_med_inner_key_2 = mutual_keys.persistent.medium.inner_key_2 < mutual_med_outer_key_3 inner_key_1 = (mutual_med_inner_key_1 < mutual_med_outer_key_2) << mutual_med_inner_key_2 inner_key_2 = mutual_keys.persistent.medium.inner_key_4 << mutual_keys.ephemeral.medium.inner_key_2 inner_key_2 = inner_key_2 < mutual_med_outer_key_5 inner_key_3 = inner_key_1 << inner_key_2 mutual_med_outer_key_1 = mutual_keys.persistent.medium.outer_key_1 << mutual_keys.ephemeral.medium.outer_key_1 message = darc_message < mutual_med_outer_key_4 operand1 = server_keys.persistent.medium.alpha_key < mutual_med_outer_key_1 operand2 = server_keys.ephemeral.medium.alpha_key < mutual_med_outer_key_1 operand3 = mutual_keys.persistent.medium.alpha_key < mutual_med_outer_key_1 operand4 = mutual_keys.ephemeral.medium.alpha_key < mutual_med_outer_key_1 message = message ^ (operand1 << inner_key_3) ^ (operand2 << inner_key_3) ^ (operand3 << inner_key_3) ^ (operand4 << inner_key_3) mutual_med_inner_key_3 = mutual_keys.persistent.medium.inner_key_3 << mutual_keys.ephemeral.medium.inner_key_3 message = message << (~inner_key_2 << (~mutual_med_inner_key_3 < outer_key_1)) mutual_inner_key_2 = mutual_keys.persistent.data.inner_key_2 < mutual_outer_key_3 mutual_outer_key_2 = mutual_keys.persistent.data.outer_key_2 << mutual_keys.ephemeral.data.outer_key_2 mutual_inner_key_1 = mutual_keys.persistent.data.inner_key_1 << mutual_keys.ephemeral.data.inner_key_1 inner_key_4 = (mutual_inner_key_1 < mutual_outer_key_2) << mutual_inner_key_2 inner_key_5 = ~(server_keys.ephemeral.data.inner_key_1 << mutual_keys.persistent.data.inner_key_2) << ~(server_keys.persistent.data.inner_key_1) inner_key_5 = ~(inner_key_5 < mutual_outer_key_3) server_outer_key_1 = server_keys.persistent.data.outer_key_1 << server_keys.ephemeral.data.outer_key_1 translated_alpha = (alphabet < server_outer_key_1) << inner_key_5 mutual_outer_key_1 = mutual_keys.persistent.data.outer_key_1 << mutual_keys.ephemeral.data.outer_key_1 operand1 = server_keys.persistent.data.alpha_key < mutual_outer_key_1 operand2 = server_keys.ephemeral.data.alpha_key < mutual_outer_key_1 operand3 = mutual_keys.persistent.data.alpha_key < mutual_outer_key_1 operand4 = mutual_keys.ephemeral.data.alpha_key < mutual_outer_key_1 translated_alpha = translated_alpha ^ (operand1 << inner_key_4) ^ (operand2 << inner_key_4) ^ (operand3 << inner_key_4) ^ (operand4 << inner_key_4) return resolve_message(translated_alpha.matrix, message.matrix) def resolve_message(translated_alphabet, translated_messasge): alphabet_map = {str(key): idx for idx, key in enumerate(translated_alphabet)} encoded_message = [str(alpha) for alpha in translated_messasge] message = [] for alpha in encoded_message: if alpha in alphabet_map.keys(): message.append(alphabet_map[alpha]) else: break return message if __name__ == "__main__": #with open("../darc_key_json/client_persistent_keys.json") as 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()} #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()} #client_keys = ClientKeys( # persistent=ClientPersistentKeys( # data=ClientPersistentDataKeys( # outer_key_1=client_persistent_keys["outer_key_1"], # outer_key_2=client_persistent_keys["outer_key_2"], # alpha_key=client_persistent_keys["alpha_key"], # inner_key_2=client_persistent_keys["inner_key_2"] # ), # medium=ClientPersistentMediumKeys( # outer_key_1=client_persistent_keys["outer_key_1"], # outer_key_2=client_persistent_keys["outer_key_2"], # inner_key_2=client_persistent_keys["inner_key_2"], # alpha_key=client_persistent_keys["alpha_key"] # ) # ), # ephemeral=ClientEphemeralKeys( # data=ClientEphemeralDataKeys( # outer_key_1=client_ephemeral_keys["outer_key_1"], # outer_key_2=client_ephemeral_keys["outer_key_2"], # alpha_key=client_ephemeral_keys["alpha_key"], # inner_key_2=client_ephemeral_keys["inner_key_2"] # ), # medium=ClientEphemeralMediumKeys( # outer_key_1=client_ephemeral_keys["outer_key_1"], # outer_key_2=client_ephemeral_keys["outer_key_2"], # inner_key_2=client_ephemeral_keys["inner_key_2"], # alpha_key=client_ephemeral_keys["alpha_key"] # ) # ) #) #server_keys = ServerKeys( # persistent=ServerPersistentKeys( # data=ServerPersistentDataKeys( # outer_key_1=server_persistent_keys["outer_key_1"], # alpha_key=server_persistent_keys["alpha_key"], # inner_key_2=server_persistent_keys["inner_key_2"] # ), # medium=ServerPersistentMediumKeys( # alpha_key=server_persistent_keys["alpha_key"], # ) # ), # ephemeral=ServerEphemeralKeys( # data=ServerEphemeralDataKeys( # outer_key_1=server_ephemeral_keys["outer_key_1"], # alpha_key=server_ephemeral_keys["alpha_key"], # inner_key_2=server_ephemeral_keys["inner_key_2"] # ), # medium=ServerEphemeralMediumKeys( # alpha_key=server_ephemeral_keys["alpha_key"], # ) # ) #) #mutual_keys = MutualKeys( # persistent=MutualPersistentKeys( # data=MutualPersistentDataKeys( # outer_key_1=server_persistent_keys["outer_key_1"], # outer_key_2=server_persistent_keys["outer_key_2"], # outer_key_6=server_persistent_keys["outer_key_6"], # alpha_key=server_persistent_keys["alpha_key"], # inner_key_2=server_persistent_keys["FunctionKey"], # inner_key_1=server_persistent_keys["inner_key_1"], # ), # medium=MutualPersistentMediumKeys( # alpha_key=server_persistent_keys["alpha_key"], # outer_key_1=server_persistent_keys["outer_key_1"], # outer_key_2=server_persistent_keys["outer_key_2"], # outer_key_6=server_persistent_keys["outer_key_6"], # inner_key_2=server_persistent_keys["inner_key_2"], # inner_key_1=server_persistent_keys["inner_key_1"], # outer_key_3=server_persistent_keys["outer_key_3"], # outer_key_5=server_persistent_keys["outer_key_5"], # outer_key_4=server_persistent_keys["outer_key_4"], # inner_key_3=server_persistent_keys["inner_key_3"], # inner_key_1=server_persistent_keys["inner_key_1"], # ) # ), # ephemeral=MutualEphemeralKeys( # data=MutualEphemeralDataKeys( # alpha_key=mutual_ephemeral_keys["MutualEphemeralKey"], # inner_key_2=mutual_ephemeral_keys["FunctionEphemeralKey"], # outer_key_1=mutual_ephemeral_keys["OuterFunctionEphemeralKey"], # outer_key_2=mutual_ephemeral_keys["OuterFunctionFunctionEphemeralKey"], # outer_key_6=mutual_ephemeral_keys["OuterServerShuffleFunctionEphemeralKey"] # ), # medium=MutualEphemeralMediumKeys( # alpha_key=mutual_ephemeral_keys["MutualMediumEphemeralKey"], # inner_key_2=mutual_ephemeral_keys["FunctionMediumEphemeralKey"], # inner_key_3=mutual_ephemeral_keys["inner_key_3"], # outer_key_1=mutual_ephemeral_keys["outer_key_1"], # outer_key_2=mutual_ephemeral_keys["outer_key_2"], # outer_key_6=mutual_ephemeral_keys["outer_key_6"], # outer_key_3=mutual_ephemeral_keys["outer_key_3"], # outer_key_5=mutual_ephemeral_keys["outer_key_5"], # inner_key_2=mutual_ephemeral_keys["inner_key_2"], # outer_key_4=mutual_ephemeral_keys["outer_key_4"] # ) # ) #) #darc_phase2 = AlphabetKey(**server_ephemeral_keys["Alphabet"]) server_keys = ServerKeys.random_init(height, width) mutual_keys = MutualKeys.random_init(height, width) client_keys = ClientKeys.random_init(height, width) alphabet = AlphabetKey.init_matrix(width, height, 255) server_keys.persistent.data.alpha_key = server_keys.persistent.data.alpha_key ^ mutual_keys.persistent.data.alpha_key server_keys.persistent.medium.alpha_key = server_keys.persistent.medium.alpha_key ^ mutual_keys.persistent.medium.alpha_key mutual_keys.persistent.data.alpha_key = mutual_keys.persistent.data.alpha_key ^ client_keys.persistent.data.alpha_key mutual_keys.persistent.medium.alpha_key = mutual_keys.persistent.medium.alpha_key ^ client_keys.persistent.medium.alpha_key #phase3_alphabet = transeive_alphabet(alphabet, client_keys.persistent.data, client_keys.ephemeral.data, mutual_keys.persistent.data, mutual_keys.ephemeral.data) (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 = OuterKey.init_matrix(height).matrix[0] 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)