[implem-python] Retrait des variables globales de lilliput_tbc

On  peut tout  déduire  de len(tweak)  / len(key)  ;  la seule  raison
d'utiliser autant de constantes en C est que les tableaux se dégradent
en  pointeurs,  donc  c'est  où  les  constantes,  où  une  tétrachiée
d'arguments.

3 files changed, 35 insertions, 86 deletions

diff --git a/python/lilliput_ae_1.py b/python/lilliput_ae_1.py
index 9eb5460..4d2d2dc 100644
--- a/python/lilliput_ae_1.py
+++ b/python/lilliput_ae_1.py
@@ -225,18 +225,10 @@ def OCB3Enc(A, M, N, key) :
 
     A = ArrayToBlockbytesMatrix(A)
     M = ArrayToBlockbytesMatrix(M)
+    K = list(key)
 
-    ltbc.KEY_BITS = KEY_BITS
-    ltbc.TWEAK_BITS = TWEAK_BITS
-    ltbc.LANES = LANES
-
-    ltbc.TWEAKEY_BITS = TWEAKEY_BITS
-    ltbc.KEY_BYTES = KEY_BYTES
-    ltbc.TWEAK_BYTES = TWEAK_BYTES
-    ltbc.TWEAKEY_BYTES = TWEAKEY_BYTES
-
-    Auth = BuildAuth(A, key)
-    (Final, C) = TreatMessageEnc(M, N, key)
+    Auth = BuildAuth(A, K)
+    (Final, C) = TreatMessageEnc(M, N, K)
     tag = XorState(Auth, Final)
 
     return BlockbytesMatrixToBytes(C), bytes(tag)
@@ -253,18 +245,10 @@ def OCB3Dec(A, C, N, tag, key) :
 
     A = ArrayToBlockbytesMatrix(A)
     C = ArrayToBlockbytesMatrix(C)
+    K = list(key)
 
-    ltbc.KEY_BITS = KEY_BITS
-    ltbc.TWEAK_BITS = TWEAK_BITS
-    ltbc.LANES = LANES
-
-    ltbc.TWEAKEY_BITS = TWEAKEY_BITS
-    ltbc.KEY_BYTES = KEY_BYTES
-    ltbc.TWEAK_BYTES = TWEAK_BYTES
-    ltbc.TWEAKEY_BYTES = TWEAKEY_BYTES
-
-    Auth = BuildAuth(A, key)
-    (Final, M) = TreatMessageDec(C, N, key)
+    Auth = BuildAuth(A, K)
+    (Final, M) = TreatMessageDec(C, N, K)
     tag2 = XorState(Auth, Final)
 
     if(tag == tag2) :
diff --git a/python/lilliput_ae_2.py b/python/lilliput_ae_2.py
index ed57cdf..aeebe27 100644
--- a/python/lilliput_ae_2.py
+++ b/python/lilliput_ae_2.py
@@ -221,19 +221,11 @@ def SCT2Enc(A, M, N, key) :
 
     A = ArrayToBlockbytesMatrix(A)
     M = ArrayToBlockbytesMatrix(M)
+    K = list(key)
 
-    ltbc.KEY_BITS = KEY_BITS
-    ltbc.TWEAK_BITS = TWEAK_BITS
-    ltbc.LANES = LANES
-
-    ltbc.TWEAKEY_BITS = TWEAKEY_BITS
-    ltbc.KEY_BYTES = KEY_BYTES
-    ltbc.TWEAK_BYTES = TWEAK_BYTES
-    ltbc.TWEAKEY_BYTES = TWEAKEY_BYTES
-
-    Auth = BuildAuth(A, key)
-    tag = MesssageAuthTag(M, N, Auth, key)
-    C = MessageEncryption(M, N, tag, key)
+    Auth = BuildAuth(A, K)
+    tag = MesssageAuthTag(M, N, Auth, K)
+    C = MessageEncryption(M, N, tag, K)
 
     return BlockbytesMatrixToBytes(C), bytes(tag)
 
@@ -249,19 +241,11 @@ def SCT2Dec(A, C, N, tag, key) :
 
     A = ArrayToBlockbytesMatrix(A)
     C = ArrayToBlockbytesMatrix(C)
+    K = list(key)
 
-    ltbc.KEY_BITS = KEY_BITS
-    ltbc.TWEAK_BITS = TWEAK_BITS
-    ltbc.LANES = LANES
-
-    ltbc.TWEAKEY_BITS = TWEAKEY_BITS
-    ltbc.KEY_BYTES = KEY_BYTES
-    ltbc.TWEAK_BYTES = TWEAK_BYTES
-    ltbc.TWEAKEY_BYTES = TWEAKEY_BYTES
-
-    M = MessageEncryption(C, N, tag, key)
-    Auth = BuildAuth(A, key)
-    tag2 = MesssageAuthTag(M, N, Auth, key)
+    M = MessageEncryption(C, N, tag, K)
+    Auth = BuildAuth(A, K)
+    tag2 = MesssageAuthTag(M, N, Auth, K)
 
     if(tag == tag2) :
         return BlockbytesMatrixToBytes(M)
diff --git a/python/lilliput_tbc.py b/python/lilliput_tbc.py
index 515a671..0dbfb31 100644
--- a/python/lilliput_tbc.py
+++ b/python/lilliput_tbc.py
@@ -4,17 +4,6 @@
 from constants import BLOCK_BYTES, Sbox
 import multiplications
 
-KEY_BITS = 128
-TWEAK_BITS = 192
-LANE_BITS = 64
-LANE_BYTES = LANE_BITS / 8
-LANES = int((TWEAK_BITS+KEY_BITS) / LANE_BITS)
-
-TWEAKEY_BITS = KEY_BITS + TWEAK_BITS
-KEY_BYTES = int(KEY_BITS / 8)
-TWEAK_BYTES = int(TWEAK_BITS / 8)
-TWEAKEY_BYTES = int(TWEAKEY_BITS / 8)
-
 MultiplyM = multiplications.MultiplyM
 MultiplyM2 = multiplications.MultiplyM2
 MultiplyM3 = multiplications.MultiplyM3
@@ -28,46 +17,38 @@ permutationInv = [13, 9, 14, 8, 10, 11, 12, 15, 4, 5, 3, 1, 2, 6 ,0 ,7]
 ################################################################################
 
 def BuildTweakey(tweak, key) :
-
-    tweakey = [0 for byte in range(0, TWEAKEY_BYTES)]
-    for byte in range(0, TWEAK_BYTES) :
-        tweakey[byte] = tweak[byte]
-
-    for byte in range(0, KEY_BYTES) :
-        tweakey[byte + TWEAK_BYTES] = key[byte]
-
-    return tweakey
+    return tweak+key
 
 #############################
 
+def _lane(TK, j):
+    return TK[j*8:(j+1)*8]
+
 def RoundTweakeySchedule(tweakey) :
+    p = len(tweakey)//8
 
     # Multiplication
-    lanes = [tweakey[word * 8:(word+1) * 8] for word in range(0, LANES)]
-    tweakey_multiplied = []
-    for word in range(0, LANES) :
-        if word == 0 :
-            tweakey_multiplied += list(lanes[0])
-        elif word == 1 :
-            tweakey_multiplied += MultiplyM(lanes[1])
-        elif word == 2 :
-            tweakey_multiplied += MultiplyM2(lanes[2])
-        elif word == 3 :
-            tweakey_multiplied += MultiplyM3(lanes[3])
-        elif word == 4 :
-            tweakey_multiplied += MultiplyMR(lanes[4])
-        elif word == 5 :
-            tweakey_multiplied += MultiplyMR2(lanes[5])
-        elif word == 6 :
-            tweakey_multiplied += MultiplyMR3(lanes[6])
-
-    return tweakey_multiplied ;
+    alphas = (
+        list,                   # Identity.
+        MultiplyM,
+        MultiplyM2,
+        MultiplyM3,
+        MultiplyMR,
+        MultiplyMR2,
+        MultiplyMR3
+    )
+
+    return [
+        byte 
+        for j in range(p)
+        for byte in alphas[j](_lane(tweakey, j)) 
+    ]
 
 
 def SubTweakeyExtract(tweakey, Ci):
     subtweakey = [0 for byte in range(0, 8)]
 
-    for byte in range(0, TWEAKEY_BYTES) :
+    for byte in range(len(tweakey)):
         subtweakey[byte % 8] ^= tweakey[byte]
 
     subtweakey[0] ^= Ci