remove global functions

src/mimick_csharp_test.py

@@ -24,23 +24,20 @@ def outer_inner(outer_key: OuterKey, inner_key: InnerKey):
 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):
-    global server_func_1
+    so1 = server_persistent_keys.outer_key_1 << server_ephemeral_keys.outer_key_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
-
     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
 
-    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)
+
+    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) ^
@@ -73,8 +70,11 @@ 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):
-    global mutual_func_1
+    mo2 = mutual_persistent_keys.outer_key_2 << mutual_ephemeral_keys.outer_key_2
-    global client_func_1
+    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 = (
@@ -188,6 +188,59 @@ def transmit_medium(medium: DarcKey, client_persistent_keys: ClientPersistentMed
     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
@@ -241,7 +294,7 @@ def merge_message(alphabet: DarcKey, medium: DarcKey, client_keys: ClientKeys, m
     return message
 
 
-def darc_phase_4(alphabet: AlphabetKey, darc_message: AlphabetKey, server_keys: ServerKeys, mutual_keys: MutualKeys):
+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
 
@@ -441,7 +494,7 @@ if __name__ == "__main__":
     #        )
     #    )
     #)
-    #alphabet = AlphabetKey(**server_ephemeral_keys["Alphabet"])
+    #darc_phase2 = AlphabetKey(**server_ephemeral_keys["Alphabet"])
 
     server_keys = ServerKeys.random_init(height, width)
     mutual_keys = MutualKeys.random_init(height, width)
@@ -454,6 +507,7 @@ if __name__ == "__main__":
     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)

src/models.py

@@ -89,6 +89,23 @@ class DarcKey(BaseModel):
             key_type=self.key_type
         )
 
+    def __eq__(self, other) -> bool:
+        if self.key_type != other.key_type:
+            return False
+
+        if len(self.matrix) != len(other.matrix):
+            return False
+
+        if len(self.matrix[0]) != len(other.matrix[0]):
+            return False
+
+        for i in range(len(self.matrix)):
+            for j in range(len(self.matrix[0])):
+                if self.matrix[i][j] != other.matrix[i][j]:
+                    return False
+
+        return True
+
     def column_substitution(self, column: int, substitution: list[int]):
         assert len(substitution) == len(self.matrix)
         assert len(self.matrix[0]) > column >= 0

src/test.py

@@ -1,13 +1,47 @@
-from models import OuterKey
+from models import OuterKey, InnerKey, AlphabetKey
+
+height = 10
+width = 7
+
+a0 = AlphabetKey.init_matrix(width, height, 255)
+
+o0 = OuterKey.init_matrix(height)
+
+i0 = InnerKey.init_matrix(width, height)
+i1 = InnerKey.init_matrix(width, height)
+i2 = InnerKey.init_matrix(width, height)
+
+a0_i0_o0_v0 = a0 << (i0 < o0)
+
+a0_i0_o0_v1 = ((a0 < ~o0) << i0) < o0
+
+print(a0_i0_o0_v0 == a0_i0_o0_v1)
+
+a0_o0_i0_v0 = (a0 < o0) << i0
+a0_o0_i0_v1 = (a0 << (i0 < ~o0)) < o0
+print(a0_i0_o0_v0 == a0_i0_o0_v1)
 
 
-outer_shuffle_key = OuterKey(
+a0_o0_i0_v0 = (a0 < o0) << i0
-    matrix=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]],
-)
 
-random_outer_shuffle_key = OuterKey.init_matrix(10)
 
-applied_outer_shuffle_key = outer_shuffle_key << random_outer_shuffle_key
+a0_o0_i0_v1 = (a0 << (i0 < ~o0)) < o0
+print(a0_o0_i0_v0 == a0_o0_i0_v1)
 
-print(applied_outer_shuffle_key)
+n_i0_i1 = ~(i0 << i1)
-print(applied_outer_shuffle_key << outer_shuffle_key)
+
+ni1_ni0 = ~i1 << ~i0
+
+print(ni1_ni0 == n_i0_i1)
+
+i0_i1_i2_v0 = i0 << i1 << i2
+i0_i1_i2_v1 = i0 << (i1 << i2)
+i0_i1_i2_v2 = (i0 << i1) << i2
+
+print(i0_i1_i2_v0 == i0_i1_i2_v1 == i0_i1_i2_v2)
+
+i0_i2_i1 = i0 << i2 << i1
+print(i0_i2_i1 == i0_i1_i2_v0)
+
+print(i0 == i0_i2_i1 << ~(i2 << i1))
+print(i0 == i0_i2_i1 << ~i1 << ~i2)