refactor code and implement unit tests

This commit is contained in:
2024-05-29 07:18:30 -05:00
parent 4f3b37642f
commit 4fd3e6cc5a
16 changed files with 540 additions and 601 deletions

View File

@@ -1,4 +1,4 @@
from models import OuterKey, InnerKey, AlphabetKey from src.models import OuterKey, InnerKey, AlphabetKey
height = 10 height = 10
width = 7 width = 7

View File

@@ -0,0 +1,170 @@
from src.models import AlphabetKey, ClientKeys, MutualKeys, ClientPersistentDataKeys, ClientEphemeralDataKeys, \
MutualPersistentDataKeys, MutualEphemeralDataKeys, ClientPersistentMediumKeys, ClientEphemeralMediumKeys, \
MutualPersistentMediumKeys, MutualEphemeralMediumKeys, DarcKey, OuterKey
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_phase1: 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 = (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
substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key
result = (
alphabet_phase1 ^
((substitution < mo1) << mi1_mo2)
)
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
alphabet_phase2 = (result << ci1) < mo3_co1_co2
return alphabet_phase2
def receive_medium(medium_phase1: AlphabetKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
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
mi1_mo2 = mi1 < mo2
substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key
sub_mo1_mi1_mo2 = (substitution < mo1) << mi1_mo2
result = medium_phase1 ^ sub_mo1_mi1_mo2
ci1 = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1
ci1_mo3 = ci1 < mo3
result = result << ci1_mo3
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
medium_phase2 = result < (co1 << co2)
return medium_phase2
def transmit_alphabet(alphabet_phase2: 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_phase2 << 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
alphabet_phase3 = result ^ (((substitution < mo1) << mi1_mo2_mpi2_mo3 ) < co1_co2)
return alphabet_phase3
def transmit_medium(medium_phase2: DarcKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
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
mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mi1_mo2 = mi1 < mo2
mpi1_mo3 = mutual_persistent_keys.inner_key_2 < mo3
mi1_mo2_mpi1_mo3 = mi1_mo2 << mpi1_mo3
ncei1_ncpi2 = ~(client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1) << mutual_persistent_keys.inner_key_2
ncei1_ncpi2__mo3 = ncei1_ncpi2 < mo3
result = (medium_phase2 < ~co1_co2) << ncei1_ncpi2__mo3
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
sub = client_persistent_keys.alpha_key ^ client_ephemeral_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
sub_mo1 = sub < mo1
sub_mo1_mi1_mo2_mpi1_mo3 = (sub_mo1 << mi1_mo2_mpi1_mo3)
medium_phase3 = (result ^ sub_mo1_mi1_mo2_mpi1_mo3) < co1_co2
return medium_phase3
def darc_phase3(alphabet_phase2: AlphabetKey, medium_phase2: AlphabetKey, client_keys: ClientKeys, mutual_keys: MutualKeys):
alphabet_phase3 = transmit_alphabet(alphabet_phase2, client_keys.persistent.data, client_keys.ephemeral.data, mutual_keys.persistent.data, mutual_keys.ephemeral.data)
medium_phase3 = transmit_medium(medium_phase2, client_keys.persistent.medium, client_keys.ephemeral.medium, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium)
return alphabet_phase3, medium_phase3
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)
height = len(alphabet.matrix)
width = len(alphabet.matrix[0])
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_4
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

View File

@@ -0,0 +1,75 @@
from src.models import DarcKey, MutualKeys, OuterKey, AlphabetKey, \
MutualPersistentDataKeys, MutualEphemeralDataKeys
def merge_message_no_client(alphabet: DarcKey, medium: DarcKey, mutual_keys: MutualKeys, input_sequence: list[int]):
msg_len = len(input_sequence)
height = len(alphabet.matrix)
width = len(alphabet.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])
input_seq = padded_input_sequence
a_i = alphabet < input_seq
eof_arr = AlphabetKey.init_matrix(width, height, 255).matrix[0]
if msg_len < height:
a_i.matrix[msg_len] = eof_arr
mmi3 = mutual_keys.persistent.medium.inner_key_3 << mutual_keys.ephemeral.medium.inner_key_3
mmo6 = mutual_keys.persistent.medium.outer_key_6 << mutual_keys.ephemeral.medium.outer_key_6
mmo4 = mutual_keys.persistent.medium.outer_key_4 << mutual_keys.ephemeral.medium.outer_key_4
mmo5 = mutual_keys.persistent.medium.outer_key_5 << mutual_keys.ephemeral.medium.outer_key_5
mmi4 = mutual_keys.persistent.medium.inner_key_4 << mutual_keys.ephemeral.medium.inner_key_4
nmmo6 = ~mmo6
message = medium ^ (a_i << (mmi3 < ~(mmo4 << mmo6)))
mmo5_nmmo6 = mmo5 << nmmo6
message = (message < mmo4) << (mmi4 < mmo5_nmmo6)
return message
def darc_phase_2_3(alphabet_phase1: AlphabetKey, medium_phase1: AlphabetKey, mutual_keys: MutualKeys) -> AlphabetKey:
phase3_alphabet = transceive_alphabet(alphabet_phase1, mutual_keys.persistent.data, mutual_keys.ephemeral.data)
phase3_medium = transceive_medium(medium_phase1, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium)
return (phase3_alphabet, phase3_medium)
def transceive_alphabet(alphabet_phase1: DarcKey, 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
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
ma = mutual_persistent_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
ma_mo1_mi1_mo2 = (ma < mo1) << (mi1 < mo2)
alphabet_phase3 = (alphabet_phase1 ^ ma_mo1_mi1_mo2) << (mutual_persistent_keys.inner_key_2 < mo3)
return alphabet_phase3
def transceive_medium(medium_phase1: DarcKey, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
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
mi1_mo2 = mi1 < mo2
ma = mutual_persistent_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
ma_mo1_mi1_mo2 = (ma < mo1) << mi1_mo2
result = medium_phase1 ^ ma_mo1_mi1_mo2
mpi1_mo3 = mutual_persistent_keys.inner_key_2 < mo3
medium_phase3 = (result << mpi1_mo3)
return medium_phase3

View File

@@ -1,510 +0,0 @@
from src.models import (AlphabetKey, DarcKey, OuterKey, 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_phase1: 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 = (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_phase1 ^
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)
alphabet_phase2 = client_func_1(result)
return alphabet_phase2
def receive_medium(medium_phase1: AlphabetKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
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
mi1_mo2 = mi1 < mo2
substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key
sub_mo1_mi1_mo2 = (substitution < mo1) << mi1_mo2
result = medium_phase1 ^ sub_mo1_mi1_mo2
ci1 = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1
ci1_mo3 = ci1 < mo3
result = result << ci1_mo3
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
medium_phase2 = result < (co1 << co2)
return medium_phase2
def darc_phase3(alphabet_phase2: AlphabetKey, medium_phase2: AlphabetKey, client_keys: ClientKeys, mutual_keys: MutualKeys):
alphabet_phase3 = transmit_alphabet(alphabet_phase2, client_keys.persistent.data, client_keys.ephemeral.data, mutual_keys.persistent.data, mutual_keys.ephemeral.data)
medium_phase3 = transmit_medium(medium_phase2, client_keys.persistent.medium, client_keys.ephemeral.medium, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium)
return alphabet_phase3, medium_phase3
def transmit_alphabet(alphabet_phase2: 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_phase2 << 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)
alphabet_phase3 = result ^ (client_func_2(substitution) < co1_co2)
return alphabet_phase3
def transmit_medium(medium_phase2: DarcKey, client_persistent_keys: ClientPersistentMediumKeys, client_ephemeral_keys: ClientEphemeralMediumKeys, mutual_persistent_keys: MutualPersistentMediumKeys, mutual_ephemeral_keys: MutualEphemeralMediumKeys):
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
mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mi1_mo2 = mi1 < mo2
mpi1_mo3 = mutual_persistent_keys.inner_key_2 < mo3
mi1_mo2_mpi1_mo3 = mi1_mo2 << mpi1_mo3
ncei1_ncpi2 = ~(client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1) << mutual_persistent_keys.inner_key_2
ncei1_ncpi2__mo3 = ncei1_ncpi2 < mo3
result = (medium_phase2 < ~co1_co2) << ncei1_ncpi2__mo3
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
sub = client_persistent_keys.alpha_key ^ client_ephemeral_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
sub_mo1 = sub < mo1
sub_mo1_mi1_mo2_mpi1_mo3 = (sub_mo1 << mi1_mo2_mpi1_mo3)
medium_phase3 = (result ^ sub_mo1_mi1_mo2_mpi1_mo3) < co1_co2
return medium_phase3
def transceive_alphabet(alphabet_phase1: 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
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
ma = mutual_persistent_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
ma_mo1_mi1_mo2 = (ma < mo1) << (mi1 < mo2)
alphabet_phase3 = (alphabet_phase1 ^ ma_mo1_mi1_mo2) << (mutual_persistent_keys.inner_key_2 < mo3)
return alphabet_phase3
def transceive_medium(medium_phase1: DarcKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
mi1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
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
mi1_mo2 = mi1 < mo2
ma = mutual_persistent_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
ma_mo1_mi1_mo2 = (ma < mo1) << mi1_mo2
result = medium_phase1 ^ ma_mo1_mi1_mo2
mpi1_mo3 = mutual_persistent_keys.inner_key_2 < mo3
medium_phase3 = (result << mpi1_mo3)
return medium_phase3
def merge_message_no_client(alphabet: DarcKey, medium: DarcKey, client_keys: ClientKeys, mutual_keys: MutualKeys, input_sequence: list[int]):
msg_len = len(input_sequence)
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])
input_seq = padded_input_sequence
a_i = alphabet < input_seq
eof_arr = AlphabetKey.init_matrix(width, height, 255).matrix[0]
if msg_len < height:
a_i.matrix[msg_len] = eof_arr
mmi3 = mutual_keys.persistent.medium.inner_key_3 << mutual_keys.ephemeral.medium.inner_key_3
mmo6 = mutual_keys.persistent.medium.outer_key_6 << mutual_keys.ephemeral.medium.outer_key_6
mmo4 = mutual_keys.persistent.medium.outer_key_4 << mutual_keys.ephemeral.medium.outer_key_4
mmo5 = mutual_keys.persistent.medium.outer_key_5 << mutual_keys.ephemeral.medium.outer_key_5
mmi4 = mutual_keys.persistent.medium.inner_key_4 << mutual_keys.ephemeral.medium.inner_key_4
nmmo6 = ~mmo6
message = medium ^ (a_i << (mmi3 < ~(mmo4 << mmo6)))
mmo5_nmmo6 = mmo5 << nmmo6
message = (message < mmo4) << (mmi4 < mmo5_nmmo6)
return message
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_4
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:
mmo6 = mutual_keys.persistent.medium.outer_key_6 << mutual_keys.ephemeral.medium.outer_key_6
mmo4 = mutual_keys.persistent.medium.outer_key_4 << mutual_keys.ephemeral.medium.outer_key_4
nmmo6_nmmo4 = ~(mmo4 << mmo6)
mmo5 = mutual_keys.persistent.medium.outer_key_5 << mutual_keys.ephemeral.medium.outer_key_5
mmo5_nmmo6_nmmo4 = mmo5 << nmmo6_nmmo4
mmo2 = mutual_keys.persistent.medium.outer_key_2 << mutual_keys.ephemeral.medium.outer_key_2
mmo3 = mutual_keys.persistent.medium.outer_key_3 << mutual_keys.ephemeral.medium.outer_key_3
mmi3 = mutual_keys.persistent.medium.inner_key_3 << mutual_keys.ephemeral.medium.inner_key_3
mmi1 = mutual_keys.persistent.medium.inner_key_1 << mutual_keys.ephemeral.medium.inner_key_1
mpmi2 = mutual_keys.persistent.medium.inner_key_2 < mmo3
mmi4 = mutual_keys.persistent.medium.inner_key_4 << mutual_keys.ephemeral.medium.inner_key_4
mmo1 = mutual_keys.persistent.medium.outer_key_1 << mutual_keys.ephemeral.medium.outer_key_1
sub_med_mmo1 = (server_keys.persistent.medium.alpha_key ^ server_keys.ephemeral.medium.alpha_key ^ mutual_keys.persistent.medium.alpha_key ^ mutual_keys.ephemeral.medium.alpha_key) < mmo1
medium_unwrapped = (((darc_message < ~mmo4) << ~(mmi4 < mmo5_nmmo6_nmmo4)) ^ (sub_med_mmo1 << ((mmi1 < mmo2) << mpmi2))) << (~mmi3 < nmmo6_nmmo4)
mdo3 = mutual_keys.persistent.data.outer_key_3 << mutual_keys.ephemeral.data.outer_key_3
mpi2_mdo3 = mutual_keys.persistent.data.inner_key_2 < mdo3
mdo2 = mutual_keys.persistent.data.outer_key_2 << mutual_keys.ephemeral.data.outer_key_2
mdi1 = mutual_keys.persistent.data.inner_key_1 << mutual_keys.ephemeral.data.inner_key_1
mdi1_mdo2_mpi2_mdo3 = (mdi1 < mdo2) << mpi2_mdo3
sdi1_mpdi2__mdo3 = (server_keys.persistent.data.inner_key_1 << server_keys.ephemeral.data.inner_key_1 << mutual_keys.persistent.data.inner_key_2) < mdo3
sdo1 = server_keys.persistent.data.outer_key_1 << server_keys.ephemeral.data.outer_key_1
alpha_sdo1__sdi1_mpdi2__mdo3 = (alphabet < sdo1) << sdi1_mpdi2__mdo3
mdo1 = mutual_keys.persistent.data.outer_key_1 << mutual_keys.ephemeral.data.outer_key_1
sub_mdo1 = (server_keys.persistent.data.alpha_key ^ server_keys.ephemeral.data.alpha_key ^ mutual_keys.persistent.data.alpha_key ^ mutual_keys.ephemeral.data.alpha_key) < mdo1
translated_alpha = alpha_sdo1__sdi1_mpdi2__mdo3 ^ (sub_mdo1 << mdi1_mdo2_mpi2_mdo3)
return resolve_message(
translated_alpha.matrix,
medium_unwrapped.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_4=client_persistent_keys["inner_key_4"]
# ),
# medium_phase2=ClientPersistentMediumKeys(
# outer_key_1=client_persistent_keys["outer_key_1"],
# outer_key_2=client_persistent_keys["outer_key_2"],
# inner_key_4=client_persistent_keys["inner_key_4"],
# 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_4=client_ephemeral_keys["inner_key_4"]
# ),
# medium_phase2=ClientEphemeralMediumKeys(
# outer_key_1=client_ephemeral_keys["outer_key_1"],
# outer_key_2=client_ephemeral_keys["outer_key_2"],
# inner_key_4=client_ephemeral_keys["inner_key_4"],
# 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_4=server_persistent_keys["inner_key_4"]
# ),
# medium_phase2=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_4=server_ephemeral_keys["inner_key_4"]
# ),
# medium_phase2=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_4=server_persistent_keys["FunctionKey"],
# inner_key_1=server_persistent_keys["inner_key_1"],
# ),
# medium_phase2=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_4=server_persistent_keys["inner_key_4"],
# 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_4=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_phase2=MutualEphemeralMediumKeys(
# alpha_key=mutual_ephemeral_keys["MutualMediumEphemeralKey"],
# inner_key_4=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_4=mutual_ephemeral_keys["inner_key_4"],
# 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
(alphabet_phase1, medium_phase1) = darc_phase1(alphabet, server_keys, mutual_keys)
(alphabet_phase2, medium_phase2) = darc_phase2(alphabet_phase1, medium_phase1, client_keys, mutual_keys)
(phase3_alphabet, phase3_medium) = darc_phase3(alphabet_phase2, medium_phase2, client_keys, mutual_keys)
#phase3_medium = transceive_medium(medium_phase1, client_keys.persistent.medium, client_keys.ephemeral.medium, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium)
#phase3_alphabet = transceive_alphabet(alphabet_phase1, client_keys.persistent.data, client_keys.ephemeral.data, mutual_keys.persistent.data, mutual_keys.ephemeral.data)
original_message = OuterKey.init_matrix(height).matrix[0]
#darc_message = merge_message_no_client(phase3_alphabet, phase3_medium, client_keys, mutual_keys, original_message)
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)

View File

@@ -0,0 +1,107 @@
from src.models import AlphabetKey, ServerPersistentDataKeys, ServerEphemeralDataKeys, MutualPersistentDataKeys, \
MutualEphemeralDataKeys, InnerKey, ServerKeys, MutualKeys, ServerPersistentMediumKeys, ServerEphemeralMediumKeys, \
MutualPersistentMediumKeys, MutualEphemeralMediumKeys, DarcKey
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
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
substitution = server_persistent_keys.alpha_key ^ server_ephemeral_keys.alpha_key
alpha_phase1 = (
((alphabet< so1) << si1_mo3) ^
((substitution < mo1) << mi1_mo2)
)
return alpha_phase1
def translate_medium(height, width, 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_phase1(alphabet: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys):
height = len(alphabet.matrix)
width = len(alphabet.matrix[0])
alphabet_phase1 = translate_data(alphabet, server_keys.persistent.data, server_keys.ephemeral.data, mutual_keys.persistent.data, mutual_keys.ephemeral.data)
medium = translate_medium(height, width, server_keys.persistent.medium, server_keys.ephemeral.medium, mutual_keys.persistent.medium, mutual_keys.ephemeral.medium)
return alphabet_phase1, medium
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
def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys) -> DarcKey:
mmo6 = mutual_keys.persistent.medium.outer_key_6 << mutual_keys.ephemeral.medium.outer_key_6
mmo4 = mutual_keys.persistent.medium.outer_key_4 << mutual_keys.ephemeral.medium.outer_key_4
nmmo6_nmmo4 = ~(mmo4 << mmo6)
mmo5 = mutual_keys.persistent.medium.outer_key_5 << mutual_keys.ephemeral.medium.outer_key_5
mmo5_nmmo6_nmmo4 = mmo5 << nmmo6_nmmo4
mmo2 = mutual_keys.persistent.medium.outer_key_2 << mutual_keys.ephemeral.medium.outer_key_2
mmo3 = mutual_keys.persistent.medium.outer_key_3 << mutual_keys.ephemeral.medium.outer_key_3
mmi3 = mutual_keys.persistent.medium.inner_key_3 << mutual_keys.ephemeral.medium.inner_key_3
mmi1 = mutual_keys.persistent.medium.inner_key_1 << mutual_keys.ephemeral.medium.inner_key_1
mpmi2 = mutual_keys.persistent.medium.inner_key_2 < mmo3
mmi4 = mutual_keys.persistent.medium.inner_key_4 << mutual_keys.ephemeral.medium.inner_key_4
mmo1 = mutual_keys.persistent.medium.outer_key_1 << mutual_keys.ephemeral.medium.outer_key_1
sub_med_mmo1 = (server_keys.persistent.medium.alpha_key ^ server_keys.ephemeral.medium.alpha_key ^ mutual_keys.persistent.medium.alpha_key ^ mutual_keys.ephemeral.medium.alpha_key) < mmo1
medium_unwrapped = (((darc_message < ~mmo4) << ~(mmi4 < mmo5_nmmo6_nmmo4)) ^ (sub_med_mmo1 << ((mmi1 < mmo2) << mpmi2))) << (~mmi3 < nmmo6_nmmo4)
mdo3 = mutual_keys.persistent.data.outer_key_3 << mutual_keys.ephemeral.data.outer_key_3
mpi2_mdo3 = mutual_keys.persistent.data.inner_key_2 < mdo3
mdo2 = mutual_keys.persistent.data.outer_key_2 << mutual_keys.ephemeral.data.outer_key_2
mdi1 = mutual_keys.persistent.data.inner_key_1 << mutual_keys.ephemeral.data.inner_key_1
mdi1_mdo2_mpi2_mdo3 = (mdi1 < mdo2) << mpi2_mdo3
sdi1_mpdi2__mdo3 = (server_keys.persistent.data.inner_key_1 << server_keys.ephemeral.data.inner_key_1 << mutual_keys.persistent.data.inner_key_2) < mdo3
sdo1 = server_keys.persistent.data.outer_key_1 << server_keys.ephemeral.data.outer_key_1
alpha_sdo1__sdi1_mpdi2__mdo3 = (alphabet < sdo1) << sdi1_mpdi2__mdo3
mdo1 = mutual_keys.persistent.data.outer_key_1 << mutual_keys.ephemeral.data.outer_key_1
sub_mdo1 = (server_keys.persistent.data.alpha_key ^ server_keys.ephemeral.data.alpha_key ^ mutual_keys.persistent.data.alpha_key ^ mutual_keys.ephemeral.data.alpha_key) < mdo1
translated_alpha = alpha_sdo1__sdi1_mpdi2__mdo3 ^ (sub_mdo1 << mdi1_mdo2_mpi2_mdo3)
return resolve_message(
translated_alpha.matrix,
medium_unwrapped.matrix
)

View File

@@ -1,90 +0,0 @@
import secrets
def random_number(min_val: int, max_val: int) -> int:
""" originally secure_rand """
return min_val + secrets.randbelow(max_val - min_val + 1)
def random_shuffle(array: list[int]) -> list[int]:
for i in range(len(array) - 1, 0, -1):
j = random_number(0, i)
array[i], array[j] = array[j], array[i]
return array
def mask_array(array_len: int) -> list[int]:
new_array = []
for i in range(array_len):
random_val = random_number(0, array_len)
new_array.append(random_val)
return new_array
def build_shuffle_matrix(row_length: int, column_length: int) -> list[list[int]]:
""" originally buildRandom """
output = []
for i in range(column_length):
output.append(random_shuffle(list(range(row_length))))
return output
def build_mask_matrix(row_length: int, column_length: int, max_value: int) -> list[list[int]]:
""" originally buildScramble """
output = []
for i in range(column_length):
row = [random_number(0, max_value - 1) for _ in range(row_length)]
output.append(row)
return output
def mapped_transform(operand: list[list[int]], function_map: list[list[int]]):
""" originally transpose """
assert len(operand) == len(function_map)
assert len(operand[0]) == len(function_map[0])
output = []
for i, el in enumerate(function_map):
row = []
for j, el2 in enumerate(el):
row.append(operand[el2][j])
output.append(row)
return output
def chain_map_transform(functions: list[list[list[int]]]) -> list[list[int]]:
""" originally chainMap """
output = functions[0]
for i in range(1, len(functions)):
output = mapped_transform(output, functions[i])
return output
if __name__ == "__main__":
alphabet = "abcd"
bytes_per_char = 4
alphabet_len = len(alphabet)
functionKey = build_shuffle_matrix(bytes_per_char, alphabet_len)
functionEphemeralKey = build_shuffle_matrix(bytes_per_char, alphabet_len)
outerFunctionFunctionKey = build_shuffle_matrix(alphabet_len, 1)
outerFunctionFunctionEphemeralKey = build_shuffle_matrix(alphabet_len, 1)
outerServerShuffleKey = build_shuffle_matrix(alphabet_len, 1)
outerServerShuffleEphemeralKey = build_shuffle_matrix(alphabet_len, 1)
serverKey = build_mask_matrix(bytes_per_char, alphabet_len, 255)
serverEphemeralKey = build_mask_matrix(bytes_per_char, alphabet_len, 255)
interfaceConfig = build_mask_matrix(bytes_per_char, alphabet_len, alphabet_len)
outerFunctionFunctionEphemeralKeyApplied = mapped_transform(outerFunctionFunctionKey,
outerFunctionFunctionEphemeralKey)
outerServerShuffleEphemeralKeyApplied = mapped_transform(outerServerShuffleKey, outerServerShuffleEphemeralKey)
inputData = mapped_transform(interfaceConfig, outerServerShuffleEphemeralKeyApplied)

0
test/__init__.py Normal file
View File

132
test/get_hard_coded_json.py Normal file
View File

@@ -0,0 +1,132 @@
import json
from src.models import MutualEphemeralDataKeys, MutualEphemeralMediumKeys, MutualEphemeralKeys, \
MutualPersistentMediumKeys, MutualPersistentDataKeys, MutualPersistentKeys, MutualKeys, ServerEphemeralMediumKeys, \
ServerEphemeralDataKeys, ServerEphemeralKeys, ServerPersistentMediumKeys, ServerPersistentDataKeys, ServerKeys, \
ServerPersistentKeys, ClientEphemeralMediumKeys, ClientEphemeralDataKeys, ClientEphemeralKeys, \
ClientPersistentMediumKeys, ClientKeys, ClientPersistentKeys, ClientPersistentDataKeys, AlphabetKey
def keys():
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_4=client_persistent_keys["inner_key_4"]
),
medium_phase2=ClientPersistentMediumKeys(
outer_key_1=client_persistent_keys["outer_key_1"],
outer_key_2=client_persistent_keys["outer_key_2"],
inner_key_4=client_persistent_keys["inner_key_4"],
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_4=client_ephemeral_keys["inner_key_4"]
),
medium_phase2=ClientEphemeralMediumKeys(
outer_key_1=client_ephemeral_keys["outer_key_1"],
outer_key_2=client_ephemeral_keys["outer_key_2"],
inner_key_4=client_ephemeral_keys["inner_key_4"],
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_4=server_persistent_keys["inner_key_4"]
),
medium_phase2=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_4=server_ephemeral_keys["inner_key_4"]
),
medium_phase2=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_4=server_persistent_keys["FunctionKey"],
inner_key_1=server_persistent_keys["inner_key_1"],
),
medium_phase2=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_4=server_persistent_keys["inner_key_4"],
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"],
)
),
ephemeral=MutualEphemeralKeys(
data=MutualEphemeralDataKeys(
alpha_key=mutual_ephemeral_keys["MutualEphemeralKey"],
inner_key_4=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_phase2=MutualEphemeralMediumKeys(
alpha_key=mutual_ephemeral_keys["MutualMediumEphemeralKey"],
inner_key_4=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"],
outer_key_4=mutual_ephemeral_keys["outer_key_4"]
)
)
)
darc_phase2 = AlphabetKey(**server_ephemeral_keys["Alphabet"])

55
test/test_darc.py Normal file
View File

@@ -0,0 +1,55 @@
from src.client_darc_noclient import merge_message_no_client, darc_phase_2_3
from src.client_darc import merge_message, darc_phase2, darc_phase3
from src.models import (AlphabetKey, OuterKey, ClientKeys, ServerKeys,
MutualKeys)
from src.server_darc import darc_phase1, darc_phase_4
import pytest
@pytest.mark.parametrize("height, width", [(256, 10), (100, 70), (40, 50)])
def test_darc(height, width):
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
original_message = OuterKey.init_matrix(height).matrix[0]
(alphabet_phase1, medium_phase1) = darc_phase1(alphabet, server_keys, mutual_keys)
(alphabet_phase2, medium_phase2) = darc_phase2(alphabet_phase1, medium_phase1, client_keys, mutual_keys)
(phase3_alphabet, phase3_medium) = darc_phase3(alphabet_phase2, medium_phase2, client_keys, mutual_keys)
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)
assert original_message == message
@pytest.mark.parametrize("height, width", [(256, 10), (100, 70), (40, 50)])
def test_darc_no_client(height, width):
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
original_message = OuterKey.init_matrix(height).matrix[0]
(alphabet_phase1, medium_phase1) = darc_phase1(alphabet, server_keys, mutual_keys)
(phase3_alphabet, phase3_medium) = darc_phase_2_3(alphabet_phase1, medium_phase1, mutual_keys)
darc_message = merge_message_no_client(phase3_alphabet, phase3_medium, mutual_keys, original_message)
message = darc_phase_4(alphabet, darc_message, server_keys, mutual_keys)
assert original_message == message