lilliput-ae-reference-implementation

commit 6d62f24fc34dae3c28f1b1cfed664bde3edbb1ec
parent 60707e26d3068a43e0caa7973a4fb88428443738
Author: Kévin Le Gouguec <kevin.legouguec@airbus.com>
Date:   Thu, 14 Mar 2019 17:17:50 +0100

[implem-python] Ajustement de l'API externe

Utilisation  d'une  enum,  pour   que  les  valeurs  possibles  soient
explicites.

Renommage  des  points  d'entrée   pour  qu'ils  soient  uniformes  et
interchangeables.

Transformation du  tag en liste  plus bas  pour que lilliput.py  ne se
soucie pas des détails d'implémentation des fonctions en-dessous.

Diffstat:
M
python/genkat_aead.py
 | 
16
+++++++++++-----
M
python/lilliput.py
 | 
41
+++++++++++++++++------------------------
M
python/lilliput_ae_1.py
 | 
5
+++--
M
python/lilliput_ae_2.py
 | 
5
+++--

4 files changed, 34 insertions(+), 33 deletions(-)
diff --git a/python/genkat_aead.py b/python/genkat_aead.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-import lilliput
+from lilliput import encrypt, decrypt, LilliputAeMode
 from os import makedirs, path
 
 
@@ -10,6 +10,12 @@ MAX_ADATA_LENGTH = 32
 CRYPTO_NPUBBYTES = 120//8
 
 
+MODE_SUFFIXES = {
+    LilliputAeMode.lilliput_1: 'i',
+    LilliputAeMode.lilliput_2: 'ii'
+}
+
+
 def bstr(buf):
     return ''.join('{:02X}'.format(b) for b in buf)
 
@@ -37,7 +43,7 @@ def generate_test_vectors(mode, keylen):
     print('generating for', mode, keylen)
 
     directory = 'crypto_aead/lilliputae{mode}{keylen}v1'.format(
-        mode=mode*'i', keylen=keylen
+        mode=MODE_SUFFIXES[mode], keylen=keylen
     )
 
     makedirs(directory, exist_ok=True)
@@ -64,11 +70,11 @@ def generate_test_vectors(mode, keylen):
                 print_bstr(output, 'PT', msg)
                 print_bstr(output, 'AD', ad)
 
-                ct, tag = lilliput.mainEnc(msg, ad, key, nonce, mode)
+                ct, tag = encrypt(msg, ad, key, nonce, mode)
 
                 print_bstr(output, 'CT', ct+tag)
 
-                msg2 = lilliput.mainDec(ct, tag, ad, key, nonce, mode)
+                msg2 = decrypt(ct, tag, ad, key, nonce, mode)
 
                 if msg != msg2:
                     raise DecryptionError(msg, msg2, mode, keylen)
@@ -79,6 +85,6 @@ def generate_test_vectors(mode, keylen):
 
 
 if __name__ == '__main__':
-    for mode in 1, 2:
+    for mode in LilliputAeMode:
         for keylen in 128, 192, 256:
             generate_test_vectors(mode, keylen)
diff --git a/python/lilliput.py b/python/lilliput.py
@@ -1,40 +1,33 @@
+from enum import Enum
+
 import lilliput_ae_1
 import lilliput_ae_2
 from constants import NONCE_BYTES
 
 
-def _checkInputs(key, nonce):
+class LilliputAeMode(Enum):
+    lilliput_1 = lilliput_ae_1
+    lilliput_2 = lilliput_ae_2
+
+
+def _checkInputs(key, mode, nonce):
     valid_key_lengths = (128, 192, 256)
 
     if len(key)*8 not in valid_key_lengths:
         raise ValueError('invalid key size: {} not in {}'.format(len(key)*8, valid_key_lengths))
 
+    if mode.name not in LilliputAeMode.__members__:
+        raise ValueError('invalid mode: use a member of the LilliputAeMode enumeration')
+
     if len(nonce) != NONCE_BYTES:
         raise ValueError('nonce must be {}-byte long'.format(NONCE_BYTES))
 
 
-def mainEnc(plaintext, adata, key, nonce, mode):
-    _checkInputs(key, nonce)
-
-    A = adata
-    M = plaintext
-    N = nonce
-
-    if(mode == 1) :
-        return lilliput_ae_1.OCB3Enc(A, M, N, key)
-    if(mode == 2) :
-        return lilliput_ae_2.SCT2Enc(A, M, N, key)
-
-
-def mainDec(ciphertext, tag, adata, key, nonce, mode):
-    _checkInputs(key, nonce)
+def encrypt(plaintext, adata, key, nonce, mode):
+    _checkInputs(key, mode, nonce)
+    return mode.value.encrypt(adata, plaintext, nonce, key)
 
-    A = adata
-    C = ciphertext
-    N = nonce
-    tag = list(tag)
 
-    if(mode == 1) :
-        return lilliput_ae_1.OCB3Dec(A, C, N, tag, key)
-    if(mode == 2) :
-        return lilliput_ae_2.SCT2Dec(A, C, N, tag, key)
+def decrypt(ciphertext, tag, adata, key, nonce, mode):
+    _checkInputs(key, mode, nonce)
+    return mode.value.decrypt(adata, ciphertext, nonce, tag, key)
diff --git a/python/lilliput_ae_1.py b/python/lilliput_ae_1.py
@@ -129,7 +129,7 @@ def TreatMessageDec(C, N, key) :
 
 
 ################################################################################
-def OCB3Enc(A, M, N, key) :
+def encrypt(A, M, N, key) :
     K = list(key)
 
     Auth = BuildAuth(TWEAK_BITS, A, K)
@@ -139,8 +139,9 @@ def OCB3Enc(A, M, N, key) :
     return BlockbytesMatrixToBytes(C), bytes(tag)
 
 
-def OCB3Dec(A, C, N, tag, key) :
+def decrypt(A, C, N, tag, key) :
     K = list(key)
+    tag = list(tag)
 
     Auth = BuildAuth(TWEAK_BITS, A, K)
     (Final, M) = TreatMessageDec(C, N, K)
diff --git a/python/lilliput_ae_2.py b/python/lilliput_ae_2.py
@@ -98,7 +98,7 @@ def MessageEncryption(M, N, tag, key) :
     return C
 
 ################################################################################
-def SCT2Enc(A, M, N, key) :
+def encrypt(A, M, N, key) :
     K = list(key)
 
     Auth = BuildAuth(TWEAK_BITS, A, K)
@@ -108,8 +108,9 @@ def SCT2Enc(A, M, N, key) :
     return BlockbytesMatrixToBytes(C), bytes(tag)
 
 
-def SCT2Dec(A, C, N, tag, key) :
+def decrypt(A, C, N, tag, key) :
     K = list(key)
+    tag = list(tag)
 
     M = BlockbytesMatrixToBytes(
         MessageEncryption(C, N, tag, K)