dkelly/pydarc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

document alphabet phase 1-3. clean code

Browse Source
This commit is contained in:
Donovan
2024-05-25 09:11:54 -05:00
parent 4de3ece8c9
commit c58a0a1ba7
4 changed files with 254 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
README.md Normal file
View File

@@ -0,0 +1,40 @@
# DARC
### translate data
```
alpha_phase_1 = si1_mo3(so1[alphabet]) ^ mi1_mo2(mo1[s_a ^ m_a ^ se_a])
```
### receive alphabet
recall:
- `server_persistent_key.alpha = s_a ^ m_a`
- `mutual_persistent_key.alpha = m_a ^ c_a`
- `client_persistent_key.alpha = c_a`
```
result = alpha_phase_1 ^ mi1_mo2(mo1[ce_a ^ c_a ^ m_a ^ c_a])
result = alpha_phase_1 ^ mi1_mo2(mo1[ce_a ^ m_a]) # c_a cancels
result = si1_mo3(so1[alphabet]) ^ mi1_mo2(mo1[s_a ^ m_a ^ se_a]) ^ mi1_mo2(mo1[ce_a ^ m_a]) # expand alpha phase 1
result = si1_mo3(so1[alphabet]) ^ mi1_mo2(mo1[s_a ^ se_a ^ ce_a]) # client_ephemeral_alpha added and m_a cancels
expr1 = result
alpha_phase_2 = mo3_co1_co2[ci1(nmo3[expr1])]
```
### transmit alphabet
```
result = nceil_ncpi1_mpi2_mo3_co1_co2(alpha_phase_2)
result = nceil_ncpi1_mpi2_mo3_co1_co2(mo3_co1_co2[ci1(nmo3[expr1])])
result = mo3_co1_co2[nceil_ncpi1_mpi2(ci1(nmo3[expr1]))]
result = mo3_co1_co2[mpi2(nmo3[expr1])]
result = mo3_co1_co2[mpi2(nmo3[ si1_mo3(so1[alphabet]) ^ mi1_mo2(mo1[s_a ^ se_a ^ ce_a])])]
result = mo3_co1_co2[mpi2(si1(so1[alphabet]) ^ nmo3[mi1_mo2(mo1[s_a ^ se_a ^ ce_a])])]
alpha_phase_3 = result ^ co1_co2[mi1_mo2_mpi2_mo3(mo1[ce_a ^ c_a ^ m_a ^ c_a])]
alpha_phase_3 = result ^ co1_co2[mi1_mo2_mpi2_mo3(mo1[ce_a ^ m_a])]
alpha_phase_3 = mo3_co1_co2[mpi2(si1(so1[alphabet]) ^ nmo3[mi1_mo2(mo1[s_a ^ se_a ^ ce_a])])] ^ co1_co2[mi1_mo2_mpi2_mo3(mo1[ce_a ^ m_a])]
alpha_phase_3 = co1_co2[ si1_mpi2_mo3(so1[alphabet]) ^ mi1_mo2_mpi2_mo3(mo1[s_a ^ se_a ^ ce_a]) ^ mi1_mo2_mpi2_mo3(mo1[ce_a ^ m_a])]
alpha_phase_3 = co1_co2[ si1_mpi2_mo3(so1[alphabet]) ^ mi1_mo2_mpi2_mo3(mo1[s_a ^ se_a ^ m_a])]
```

191
src/mimick_csharp_test.py
View File

@@ -1,8 +1,8 @@
from src.models import ServerEphemeralKeys, ServerPersistentKeys, ClientEphemeralKeys, ClientPersistentKeys, \
MutualEphemeralKeys, AlphabetKey, DarcKey, OuterShuffleKey, MutualPersistentKeys, ClientKeys, ServerKeys, \
MutualEphemeralKeys, AlphabetKey, DarcKey, OuterKey, MutualPersistentKeys, ClientKeys, ServerKeys, \
MutualKeys, ServerPersistentDataKeys, ServerEphemeralDataKeys, MutualPersistentDataKeys, MutualEphemeralDataKeys, \
ServerPersistentMediumKeys, ServerEphemeralMediumKeys, MutualPersistentMediumKeys, MutualEphemeralMediumKeys, \
ClientPersistentDataKeys, ClientEphemeralDataKeys, ClientEphemeralMediumKeys, ClientPersistentMediumKeys
ClientPersistentDataKeys, ClientEphemeralDataKeys, ClientEphemeralMediumKeys, ClientPersistentMediumKeys, InnerKey
import json
height = 256
@@ -15,26 +15,37 @@ def darc_phase1(alphabet: AlphabetKey, server_keys: ServerKeys, mutual_keys: Mut
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
mutual_func_1 = None
server_func_1 = None
client_func_1 = None
def translate_data(alphabet: AlphabetKey, server_persistent_keys: ServerPersistentDataKeys, server_ephemeral_keys: ServerEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
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
global server_func_1
global mutual_func_1
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
server_inner_key = server_ephemeral_keys.inner_key_1 << server_persistent_keys.inner_key_1 # TODO: should this be the other way around?
server_inner_key = server_inner_key < mutual_outer_key_3
server_outer_key_1 = 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
input_data = alphabet < server_outer_key_1
input_data = input_data << server_inner_key
operand1 = server_persistent_keys.alpha_key_1 < mutual_outer_key_1
operand2 = server_ephemeral_keys.alpha_key_1 < mutual_outer_key_1
mutual_inner_key = mutual_inner_key < mutual_outer_key_2
solution = (operand1 << mutual_inner_key) ^ (operand2 << mutual_inner_key)
alpha_phase1 = input_data ^ solution
so1 = server_persistent_keys.outer_key_1 << server_ephemeral_keys.outer_key_1
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
server_func_1 = outer_inner(so1, si1_mo3)
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
@@ -47,8 +58,8 @@ def translate_medium(server_persistent_keys: ServerPersistentMediumKeys, server_
medium = AlphabetKey(matrix=[[0 for _ in range(width)] for _ in range(height)])
operand1 = server_persistent_keys.alpha_key_1 < mutual_outer_key_1
operand2 = server_ephemeral_keys.alpha_key_1 < mutual_outer_key_1
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)
@@ -62,28 +73,28 @@ def darc_phase2(alphabet: AlphabetKey, medium: AlphabetKey, client_keys: ClientK
def receive_alphabet(alphabet: AlphabetKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
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
global mutual_func_1
global client_func_1
operand1 = client_ephemeral_keys.alpha_key_1 < mutual_outer_key_1
operand2 = client_persistent_keys.alpha_key_1 < mutual_outer_key_1
operand3 = mutual_persistent_keys.alpha_key_1 < mutual_outer_key_1
substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_persistent_keys.alpha_key
result = (
alphabet ^
mutual_func_1(substitution)
)
mutual_inner_key = mutual_inner_key < mutual_outer_key_2
mo3 = mutual_persistent_keys.outer_key_3 << mutual_ephemeral_keys.outer_key_3
result = alphabet ^ (operand1 << mutual_inner_key) ^ (operand2 << mutual_inner_key) ^ (operand3 << mutual_inner_key)
result = result < ~mo3
ci1 = client_persistent_keys.inner_key_1 << client_ephemeral_keys.inner_key_1
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
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
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
result = result < (client_outer_key_1 << client_outer_key_2)
mo3_co1_co2 = mo3 << co1 << co2
return result
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):
@@ -94,9 +105,9 @@ def receive_medium(medium: AlphabetKey, client_persistent_keys: ClientPersistent
mutual_inner_key = mutual_inner_key < mutual_outer_key_2
operand1 = client_ephemeral_keys.alpha_key_1 < mutual_outer_key_1
operand2 = client_persistent_keys.alpha_key_1 < mutual_outer_key_1
operand3 = mutual_persistent_keys.alpha_key_1 < mutual_outer_key_1
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)
@@ -119,38 +130,26 @@ def darc_phase3(alphabet: AlphabetKey, medium: AlphabetKey, client_keys: ClientK
def transmit_alphabet(alphabet: DarcKey, client_persistent_keys: ClientPersistentDataKeys, client_ephemeral_keys: ClientEphemeralDataKeys, mutual_persistent_keys: MutualPersistentDataKeys, mutual_ephemeral_keys: MutualEphemeralDataKeys):
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
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
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
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
client_outer_key = client_outer_key_1 << client_outer_key_2
co1_co2 = co1 << co2
mo3_co1_co2 = mo3 << co1 << co2
mutual_outer_key_3 = mutual_outer_key_3 << client_outer_key
mutual_outer_key_2 = mutual_outer_key_2 << client_outer_key
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
mutual_inner_key_1 = mutual_persistent_keys.inner_key_1 << mutual_ephemeral_keys.inner_key_1
mutual_inner_key_1 = mutual_inner_key_1 < mutual_outer_key_2
mo1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
mutual_inner_key_2 = mutual_persistent_keys.inner_key_2 < mutual_outer_key_3
substitution = client_ephemeral_keys.alpha_key ^ client_persistent_keys.alpha_key ^ mutual_ephemeral_keys.alpha_key
mutual_inner_key = mutual_inner_key_1 << mutual_inner_key_2
inner_key_1 = ~client_persistent_keys.inner_key_1 << mutual_persistent_keys.inner_key_2
inner_key_2 = ~client_ephemeral_keys.inner_key_1
inner_key_3 = inner_key_2 << inner_key_1
inner_key_3 = inner_key_3 < mutual_outer_key_3
result = alphabet << inner_key_3
mutual_outer_key_1 = mutual_persistent_keys.outer_key_1 << mutual_ephemeral_keys.outer_key_1
outer_key_1 = mutual_outer_key_1 << client_outer_key
operand1 = client_ephemeral_keys.alpha_key_1 < outer_key_1
operand2 = client_persistent_keys.alpha_key_1 < outer_key_1
operand3 = mutual_ephemeral_keys.alpha_key_1 < outer_key_1
result = result ^ (operand1 << mutual_inner_key) ^ (operand2 << mutual_inner_key) ^ (operand3 << mutual_inner_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
@@ -181,9 +180,9 @@ def transmit_medium(medium: DarcKey, client_persistent_keys: ClientPersistentMed
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_1 < outer_key_3
operand2 = client_persistent_keys.alpha_key_1 < outer_key_3
operand3 = mutual_ephemeral_keys.alpha_key_1 < outer_key_3
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
@@ -198,10 +197,10 @@ def merge_message(alphabet: DarcKey, medium: DarcKey, client_keys: ClientKeys, m
eof_arr = AlphabetKey.init_matrix(width, height, 255).matrix[0]
if msg_len < height:
padded_input_sequence = OuterShuffleKey.init_matrix(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 = OuterShuffleKey(matrix=[input_sequence])
padded_input_sequence = OuterKey(matrix=[input_sequence])
client_outer_key_1 = client_outer_key_1 << padded_input_sequence
@@ -272,10 +271,10 @@ def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys:
message = darc_message < mutual_med_outer_key_4
operand1 = server_keys.persistent.medium.alpha_key_1 < mutual_med_outer_key_1
operand2 = server_keys.ephemeral.medium.alpha_key_1 < mutual_med_outer_key_1
operand3 = mutual_keys.persistent.medium.alpha_key_1 < mutual_med_outer_key_1
operand4 = mutual_keys.ephemeral.medium.alpha_key_1 < mutual_med_outer_key_1
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)
@@ -287,7 +286,7 @@ def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys:
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.persistent.data.inner_key_1 << mutual_keys.persistent.data.inner_key_2) << ~(server_keys.ephemeral.data.inner_key_1)
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
@@ -295,10 +294,10 @@ def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys:
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_1 < mutual_outer_key_1
operand2 = server_keys.ephemeral.data.alpha_key_1 < mutual_outer_key_1
operand3 = mutual_keys.persistent.data.alpha_key_1 < mutual_outer_key_1
operand4 = mutual_keys.ephemeral.data.alpha_key_1 < mutual_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)
@@ -345,7 +344,7 @@ if __name__ == "__main__":
# data=ClientPersistentDataKeys(
# outer_key_1=client_persistent_keys["outer_key_1"],
# outer_key_2=client_persistent_keys["outer_key_2"],
# alpha_key_1=client_persistent_keys["alpha_key_1"],
# alpha_key=client_persistent_keys["alpha_key"],
# inner_key_2=client_persistent_keys["inner_key_2"]
# ),
@@ -353,21 +352,21 @@ if __name__ == "__main__":
# 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_1=client_persistent_keys["alpha_key_1"]
# 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_1=client_ephemeral_keys["alpha_key_1"],
# 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_1=client_ephemeral_keys["alpha_key_1"]
# alpha_key=client_ephemeral_keys["alpha_key"]
# )
# )
#)
@@ -376,21 +375,21 @@ if __name__ == "__main__":
# persistent=ServerPersistentKeys(
# data=ServerPersistentDataKeys(
# outer_key_1=server_persistent_keys["outer_key_1"],
# alpha_key_1=server_persistent_keys["alpha_key_1"],
# alpha_key=server_persistent_keys["alpha_key"],
# inner_key_2=server_persistent_keys["inner_key_2"]
# ),
# medium=ServerPersistentMediumKeys(
# alpha_key_1=server_persistent_keys["alpha_key_1"],
# alpha_key=server_persistent_keys["alpha_key"],
# )
# ),
# ephemeral=ServerEphemeralKeys(
# data=ServerEphemeralDataKeys(
# outer_key_1=server_ephemeral_keys["outer_key_1"],
# alpha_key_1=server_ephemeral_keys["alpha_key_1"],
# alpha_key=server_ephemeral_keys["alpha_key"],
# inner_key_2=server_ephemeral_keys["inner_key_2"]
# ),
# medium=ServerEphemeralMediumKeys(
# alpha_key_1=server_ephemeral_keys["alpha_key_1"],
# alpha_key=server_ephemeral_keys["alpha_key"],
# )
# )
#)
@@ -401,12 +400,12 @@ if __name__ == "__main__":
# 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_1=server_persistent_keys["alpha_key_1"],
# 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_1=server_persistent_keys["alpha_key_1"],
# 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"],
@@ -421,14 +420,14 @@ if __name__ == "__main__":
# ),
# ephemeral=MutualEphemeralKeys(
# data=MutualEphemeralDataKeys(
# alpha_key_1=mutual_ephemeral_keys["MutualEphemeralKey"],
# 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_1=mutual_ephemeral_keys["MutualMediumEphemeralKey"],
# 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"],
@@ -449,17 +448,17 @@ if __name__ == "__main__":
client_keys = ClientKeys.random_init(height, width)
alphabet = AlphabetKey.init_matrix(width, height, 255)
server_keys.persistent.data.alpha_key_1 = server_keys.persistent.data.alpha_key_1 ^ mutual_keys.persistent.data.alpha_key_1
server_keys.persistent.medium.alpha_key_1 = server_keys.persistent.medium.alpha_key_1 ^ mutual_keys.persistent.medium.alpha_key_1
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_1 = mutual_keys.persistent.data.alpha_key_1 ^ client_keys.persistent.data.alpha_key_1
mutual_keys.persistent.medium.alpha_key_1 = mutual_keys.persistent.medium.alpha_key_1 ^ client_keys.persistent.medium.alpha_key_1
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
(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 = OuterShuffleKey.init_matrix(height).matrix[0]
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)

232
src/models.py
View File

@@ -107,26 +107,26 @@ class DarcKey(BaseModel):
)
class OuterShuffleKey(DarcKey):
class OuterKey(DarcKey):
key_type = DarcKeyTypes.outer_shuffle
@classmethod
def init_matrix(cls, height: int):
""" originally buildRandom """
matrix = [cls._random_shuffle(list(range(height)))]
return OuterShuffleKey(
return OuterKey(
matrix=matrix,
)
class InnerShuffleKey(DarcKey):
class InnerKey(DarcKey):
key_type = DarcKeyTypes.inner_shuffle
@classmethod
def init_matrix(cls, width: int, height: int):
""" originally buildRandom """
matrix = [cls._random_shuffle(list(range(width))) for _ in range(height)]
return InnerShuffleKey(
return InnerKey(
matrix=matrix,
)
@@ -146,214 +146,214 @@ class AlphabetKey(DarcKey):
class ClientEphemeralDataKeys(BaseModel):
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
alpha_key_1: AlphabetKey
inner_key_1: InnerShuffleKey
outer_key_1: OuterKey
outer_key_2: OuterKey
alpha_key: AlphabetKey
inner_key_1: InnerKey
@classmethod
def random_init(cls, height: int, width: int):
return ClientEphemeralDataKeys(
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerKey.init_matrix(width, height),
)
class ClientEphemeralMediumKeys(BaseModel):
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
inner_key_1: InnerShuffleKey
alpha_key_1: AlphabetKey
outer_key_1: OuterKey
outer_key_2: OuterKey
inner_key_1: InnerKey
alpha_key: AlphabetKey
@classmethod
def random_init(cls, height: int, width: int):
return ClientEphemeralMediumKeys(
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
alpha_key_1=AlphabetKey.init_matrix(width, height, 255)
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
inner_key_1=InnerKey.init_matrix(width, height),
alpha_key=AlphabetKey.init_matrix(width, height, 255)
)
class ClientPersistentDataKeys(BaseModel):
alpha_key_1: AlphabetKey
inner_key_1: InnerShuffleKey
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
alpha_key: AlphabetKey
inner_key_1: InnerKey
outer_key_1: OuterKey
outer_key_2: OuterKey
@classmethod
def random_init(cls, height: int, width: int):
return ClientPersistentDataKeys(
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerKey.init_matrix(width, height),
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
)
class ClientPersistentMediumKeys(BaseModel):
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
inner_key_1: InnerShuffleKey
alpha_key_1: AlphabetKey
outer_key_1: OuterKey
outer_key_2: OuterKey
inner_key_1: InnerKey
alpha_key: AlphabetKey
@classmethod
def random_init(cls, height: int, width: int):
return ClientPersistentMediumKeys(
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
alpha_key_1=AlphabetKey.init_matrix(width, height, 255)
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
inner_key_1=InnerKey.init_matrix(width, height),
alpha_key=AlphabetKey.init_matrix(width, height, 255)
)
class ServerEphemeralDataKeys(BaseModel):
outer_key_1: OuterShuffleKey
alpha_key_1: AlphabetKey
inner_key_1: InnerShuffleKey
outer_key_1: OuterKey
alpha_key: AlphabetKey
inner_key_1: InnerKey
@classmethod
def random_init(cls, height: int, width: int):
return ServerEphemeralDataKeys(
outer_key_1=OuterShuffleKey.init_matrix(height),
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
outer_key_1=OuterKey.init_matrix(height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerKey.init_matrix(width, height),
)
class ServerEphemeralMediumKeys(BaseModel):
alpha_key_1: AlphabetKey
alpha_key: AlphabetKey
@classmethod
def random_init(cls, height: int, width: int):
return ServerEphemeralMediumKeys(
alpha_key_1=AlphabetKey.init_matrix(width, height, 255)
alpha_key=AlphabetKey.init_matrix(width, height, 255)
)
class ServerPersistentDataKeys(BaseModel):
outer_key_1: OuterShuffleKey
alpha_key_1: AlphabetKey
inner_key_1: InnerShuffleKey
outer_key_1: OuterKey
alpha_key: AlphabetKey
inner_key_1: InnerKey
@classmethod
def random_init(cls, height: int, width: int):
return ServerPersistentDataKeys(
outer_key_1=OuterShuffleKey.init_matrix(height),
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
outer_key_1=OuterKey.init_matrix(height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerKey.init_matrix(width, height),
)
class ServerPersistentMediumKeys(BaseModel):
alpha_key_1: AlphabetKey
alpha_key: AlphabetKey
@classmethod
def random_init(cls, height: int, width: int):
return ServerPersistentMediumKeys(
alpha_key_1=AlphabetKey.init_matrix(width, height, 255)
alpha_key=AlphabetKey.init_matrix(width, height, 255)
)
class MutualEphemeralDataKeys(BaseModel):
alpha_key_1: AlphabetKey
inner_key_1: InnerShuffleKey
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
outer_key_3: OuterShuffleKey
alpha_key: AlphabetKey
inner_key_1: InnerKey
outer_key_1: OuterKey
outer_key_2: OuterKey
outer_key_3: OuterKey
@classmethod
def random_init(cls, height: int, width: int):
return MutualEphemeralDataKeys(
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
outer_key_3=OuterShuffleKey.init_matrix(height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerKey.init_matrix(width, height),
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
outer_key_3=OuterKey.init_matrix(height),
)
class MutualEphemeralMediumKeys(BaseModel):
alpha_key_1: AlphabetKey
alpha_key: AlphabetKey
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
outer_key_3: OuterShuffleKey
outer_key_4: OuterShuffleKey
outer_key_5: OuterShuffleKey
outer_key_6: OuterShuffleKey
outer_key_1: OuterKey
outer_key_2: OuterKey
outer_key_3: OuterKey
outer_key_4: OuterKey
outer_key_5: OuterKey
outer_key_6: OuterKey
inner_key_1: InnerShuffleKey
inner_key_2: InnerShuffleKey
inner_key_3: InnerShuffleKey
inner_key_1: InnerKey
inner_key_2: InnerKey
inner_key_3: InnerKey
@classmethod
def random_init(cls, height: int, width: int):
return MutualEphemeralMediumKeys(
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
outer_key_3=OuterShuffleKey.init_matrix(height),
outer_key_4=OuterShuffleKey.init_matrix(height),
outer_key_5=OuterShuffleKey.init_matrix(height),
outer_key_6=OuterShuffleKey.init_matrix(height),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
inner_key_2=InnerShuffleKey.init_matrix(width, height),
inner_key_3=InnerShuffleKey.init_matrix(width, height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
outer_key_3=OuterKey.init_matrix(height),
outer_key_4=OuterKey.init_matrix(height),
outer_key_5=OuterKey.init_matrix(height),
outer_key_6=OuterKey.init_matrix(height),
inner_key_1=InnerKey.init_matrix(width, height),
inner_key_2=InnerKey.init_matrix(width, height),
inner_key_3=InnerKey.init_matrix(width, height),
)
class MutualPersistentDataKeys(BaseModel):
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
outer_key_3: OuterShuffleKey
alpha_key_1: AlphabetKey
inner_key_1: InnerShuffleKey
inner_key_2: InnerShuffleKey
outer_key_1: OuterKey
outer_key_2: OuterKey
outer_key_3: OuterKey
alpha_key: AlphabetKey
inner_key_1: InnerKey
inner_key_2: InnerKey
@classmethod
def random_init(cls, height: int, width: int):
return MutualPersistentDataKeys(
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
outer_key_3=OuterShuffleKey.init_matrix(height),
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
inner_key_2=InnerShuffleKey.init_matrix(width, height),
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
outer_key_3=OuterKey.init_matrix(height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
inner_key_1=InnerKey.init_matrix(width, height),
inner_key_2=InnerKey.init_matrix(width, height),
)
class MutualPersistentMediumKeys(BaseModel):
alpha_key_1: AlphabetKey
alpha_key: AlphabetKey
outer_key_1: OuterShuffleKey
outer_key_2: OuterShuffleKey
outer_key_3: OuterShuffleKey
outer_key_4: OuterShuffleKey
outer_key_5: OuterShuffleKey
outer_key_6: OuterShuffleKey
outer_key_1: OuterKey
outer_key_2: OuterKey
outer_key_3: OuterKey
outer_key_4: OuterKey
outer_key_5: OuterKey
outer_key_6: OuterKey
inner_key_1: InnerShuffleKey
inner_key_2: InnerShuffleKey
inner_key_3: InnerShuffleKey
inner_key_4: InnerShuffleKey
inner_key_1: InnerKey
inner_key_2: InnerKey
inner_key_3: InnerKey
inner_key_4: InnerKey
@classmethod
def random_init(cls, height: int, width: int):
return MutualPersistentMediumKeys(
alpha_key_1=AlphabetKey.init_matrix(width, height, 255),
outer_key_1=OuterShuffleKey.init_matrix(height),
outer_key_2=OuterShuffleKey.init_matrix(height),
outer_key_3=OuterShuffleKey.init_matrix(height),
outer_key_4=OuterShuffleKey.init_matrix(height),
outer_key_5=OuterShuffleKey.init_matrix(height),
outer_key_6=OuterShuffleKey.init_matrix(height),
inner_key_1=InnerShuffleKey.init_matrix(width, height),
inner_key_2=InnerShuffleKey.init_matrix(width, height),
inner_key_3=InnerShuffleKey.init_matrix(width, height),
inner_key_4=InnerShuffleKey.init_matrix(width, height),
alpha_key=AlphabetKey.init_matrix(width, height, 255),
outer_key_1=OuterKey.init_matrix(height),
outer_key_2=OuterKey.init_matrix(height),
outer_key_3=OuterKey.init_matrix(height),
outer_key_4=OuterKey.init_matrix(height),
outer_key_5=OuterKey.init_matrix(height),
outer_key_6=OuterKey.init_matrix(height),
inner_key_1=InnerKey.init_matrix(width, height),
inner_key_2=InnerKey.init_matrix(width, height),
inner_key_3=InnerKey.init_matrix(width, height),
inner_key_4=InnerKey.init_matrix(width, height),
)
class ServerPersistentKeys(BaseModel):

6
src/test.py
View File

@@ -1,11 +1,11 @@
from models import OuterShuffleKey
from models import OuterKey
outer_shuffle_key = OuterShuffleKey(
outer_shuffle_key = OuterKey(
matrix=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]],
)
random_outer_shuffle_key = OuterShuffleKey.init_matrix(10)
random_outer_shuffle_key = OuterKey.init_matrix(10)
applied_outer_shuffle_key = outer_shuffle_key << random_outer_shuffle_key