[implem-python] Nettoyage PEP8

- espaces avant ':'
- espaces en trop après ','
- parenthèses dans les if
- levée d'exception plutôt que 'return None' implicite

Simplification  de genkat_aead.py  grâce  à l'exception  levée par  le
module.

7 files changed, 131 insertions, 130 deletions

diff --git a/python/constants.py b/python/constants.py
index 764febb..c61dfe0 100644
--- a/python/constants.py
+++ b/python/constants.py
@@ -3,35 +3,37 @@ BLOCK_BYTES = BLOCK_BITS//8
 NONCE_BYTES = 15
 
 
-Sbox = [32,  0,   178, 133, 59,  53,  166, 164,
-    48,  228, 106, 44,  255, 89,  226, 14,
-    248, 30,  122, 128, 21,  189, 62,  177,
-    232, 243, 162, 194, 218, 81,  42,  16,
-    33,  1,   35,  120, 92,  36,  39,  181,
-    55,  199, 43,  31,  174, 10,  119, 95,
-    111, 9,   157, 129, 4,   90,  41,  220,
-    57,  156, 5,   87,  151, 116, 121, 23,
-    68,  198, 230, 233, 221, 65,  242, 138,
-    84,  202, 110, 74,  225, 173, 182, 136,
-    28,  152, 126, 206, 99,  73,  58,  93,
-    12,  239, 246, 52,  86,  37,  46,  214,
-    103, 117, 85,  118, 184, 210, 97,  217,
-    113, 139, 205, 11,  114, 108, 49,  75,
-    105, 253, 123, 109, 96,  60,  47,  98,
-    63,  34,  115, 19,  201, 130, 127, 83,
-    50,  18,  160, 124, 2,   135, 132, 134,
-    147, 78,  104, 70,  141, 195, 219, 236,
-    155, 183, 137, 146, 167, 190, 61,  216,
-    234, 80,  145, 241, 51,  56,  224, 169,
-    163, 131, 161, 27,  207, 6,   149, 7,
-    158, 237, 185, 245, 76,  192, 244, 45,
-    22,  250, 180, 3,   38,  179, 144, 79,
-    171, 101, 252, 254, 20,  247, 227, 148,
-    238, 172, 140, 26,  222, 203, 40,  64,
-    125, 200, 196, 72,  107, 223, 165, 82,
-    229, 251, 215, 100, 249, 240, 211, 94,
-    102, 150, 143, 29,  69,  54,  204, 197,
-    77,  159, 191, 15,  209, 8,   235, 67,
-    66,  25,  231, 153, 168, 142, 88,  193,
-    154, 212, 24,  71,  170, 175, 188, 91,
-    213, 17,  208, 176, 112, 187, 13,  186]
+Sbox = [
+    0x20, 0x00, 0xb2, 0x85, 0x3b, 0x35, 0xa6, 0xa4,
+    0x30, 0xe4, 0x6a, 0x2c, 0xff, 0x59, 0xe2, 0x0e,
+    0xf8, 0x1e, 0x7a, 0x80, 0x15, 0xbd, 0x3e, 0xb1,
+    0xe8, 0xf3, 0xa2, 0xc2, 0xda, 0x51, 0x2a, 0x10,
+    0x21, 0x01, 0x23, 0x78, 0x5c, 0x24, 0x27, 0xb5,
+    0x37, 0xc7, 0x2b, 0x1f, 0xae, 0x0a, 0x77, 0x5f,
+    0x6f, 0x09, 0x9d, 0x81, 0x04, 0x5a, 0x29, 0xdc,
+    0x39, 0x9c, 0x05, 0x57, 0x97, 0x74, 0x79, 0x17,
+    0x44, 0xc6, 0xe6, 0xe9, 0xdd, 0x41, 0xf2, 0x8a,
+    0x54, 0xca, 0x6e, 0x4a, 0xe1, 0xad, 0xb6, 0x88,
+    0x1c, 0x98, 0x7e, 0xce, 0x63, 0x49, 0x3a, 0x5d,
+    0x0c, 0xef, 0xf6, 0x34, 0x56, 0x25, 0x2e, 0xd6,
+    0x67, 0x75, 0x55, 0x76, 0xb8, 0xd2, 0x61, 0xd9,
+    0x71, 0x8b, 0xcd, 0x0b, 0x72, 0x6c, 0x31, 0x4b,
+    0x69, 0xfd, 0x7b, 0x6d, 0x60, 0x3c, 0x2f, 0x62,
+    0x3f, 0x22, 0x73, 0x13, 0xc9, 0x82, 0x7f, 0x53,
+    0x32, 0x12, 0xa0, 0x7c, 0x02, 0x87, 0x84, 0x86,
+    0x93, 0x4e, 0x68, 0x46, 0x8d, 0xc3, 0xdb, 0xec,
+    0x9b, 0xb7, 0x89, 0x92, 0xa7, 0xbe, 0x3d, 0xd8,
+    0xea, 0x50, 0x91, 0xf1, 0x33, 0x38, 0xe0, 0xa9,
+    0xa3, 0x83, 0xa1, 0x1b, 0xcf, 0x06, 0x95, 0x07,
+    0x9e, 0xed, 0xb9, 0xf5, 0x4c, 0xc0, 0xf4, 0x2d,
+    0x16, 0xfa, 0xb4, 0x03, 0x26, 0xb3, 0x90, 0x4f,
+    0xab, 0x65, 0xfc, 0xfe, 0x14, 0xf7, 0xe3, 0x94,
+    0xee, 0xac, 0x8c, 0x1a, 0xde, 0xcb, 0x28, 0x40,
+    0x7d, 0xc8, 0xc4, 0x48, 0x6b, 0xdf, 0xa5, 0x52,
+    0xe5, 0xfb, 0xd7, 0x64, 0xf9, 0xf0, 0xd3, 0x5e,
+    0x66, 0x96, 0x8f, 0x1d, 0x45, 0x36, 0xcc, 0xc5,
+    0x4d, 0x9f, 0xbf, 0x0f, 0xd1, 0x08, 0xeb, 0x43,
+    0x42, 0x19, 0xe7, 0x99, 0xa8, 0x8e, 0x58, 0xc1,
+    0x9a, 0xd4, 0x18, 0x47, 0xaa, 0xaf, 0xbc, 0x5b,
+    0xd5, 0x11, 0xd0, 0xb0, 0x70, 0xbb, 0x0d, 0xba
+]
diff --git a/python/genkat_aead.py b/python/genkat_aead.py
index daa48f8..8b38d9b 100755
--- a/python/genkat_aead.py
+++ b/python/genkat_aead.py
@@ -16,27 +16,8 @@ MODE_SUFFIXES = {
 }
 
 
-def bstr(buf):
-    return ''.join('{:02X}'.format(b) for b in buf)
-
-
 def print_bstr(output, label, buf):
-    print('{l} = {b}'.format(l=label, b=bstr(buf)), file=output)
-
-
-class DecryptionError(Exception):
-    def __init__(self, expected, actual, mode, keylen):
-        self.expected = expected
-        self.actual = actual
-        self.mode = mode
-        self.keylen = keylen
-        
-    def __str__(self):
-        return '({s.mode} / {s.keylen}) Expected {exp}; got {act}'.format(
-            s=self,
-            exp=bstr(self.expected) if self.expected is not None else 'NONE',
-            act=bstr(self.actual) if self.actual is not None else 'NONE'
-        )
+    print('{l} = {b}'.format(l=label, b=buf.hex().upper()), file=output)
 
 
 def generate_test_vectors(mode, keylen):
@@ -74,10 +55,7 @@ def generate_test_vectors(mode, keylen):
 
                 print_bstr(output, 'CT', ct+tag)
 
-                msg2 = decrypt(ct, tag, ad, key, nonce, mode)
-
-                if msg != msg2:
-                    raise DecryptionError(msg, msg2, mode, keylen)
+                decrypt(ct, tag, ad, key, nonce, mode)
 
                 count+=1
 
diff --git a/python/helpers.py b/python/helpers.py
index 45c48c9..b02bea4 100644
--- a/python/helpers.py
+++ b/python/helpers.py
@@ -2,20 +2,20 @@ from constants import BLOCK_BITS, BLOCK_BYTES
 from lilliput_tbc import LilliputTBCEnc
 
 
-def ArrayToBlockbytesMatrix(array) :
+def ArrayToBlockbytesMatrix(array):
     length = len(array)
     pad = 0
-    if(length % BLOCK_BYTES == 0) :
+    if length % BLOCK_BYTES == 0:
         number_blocks = int(length / BLOCK_BYTES)
-    else :
+    else:
         number_blocks = int((length + (BLOCK_BYTES - (length % BLOCK_BYTES))) / BLOCK_BYTES)
         pad = 1
 
     matrix = [[0] * BLOCK_BYTES for block in range(0, number_blocks - pad)]
-    if(pad == 1) :
+    if pad == 1:
         matrix.append([0] * (length % BLOCK_BYTES))
 
-    for byte in range(0, length) :
+    for byte in range(0, length):
         matrix[int(byte / BLOCK_BYTES)][byte % BLOCK_BYTES] = array[byte]
 
     return matrix
@@ -85,3 +85,16 @@ def BuildAuth(t, A, key):
     Auth = XorState(Auth, enc)
 
     return Auth
+
+
+class TagValidationError(Exception):
+    def __init__(self, announced, computed):
+        msg = '\n'.join((
+            'Invalid tag:',
+            announced.hex().upper()+' (announced)',
+            computed.hex().upper()+' (computed)'
+        ))
+
+        super().__init__(msg)
+        self._announced = announced
+        self._computed = computed
diff --git a/python/lilliput_ae_1.py b/python/lilliput_ae_1.py
index 8b618d9..9aad3a6 100644
--- a/python/lilliput_ae_1.py
+++ b/python/lilliput_ae_1.py
@@ -11,6 +11,7 @@ from helpers import (
     BlockbytesMatrixToBytes,
     BuildAuth,
     Padding10LSB,
+    TagValidationError,
     XorState
 )
 
@@ -19,23 +20,23 @@ TWEAK_BITS = 192
 TWEAK_BYTES = TWEAK_BITS//8
 
 
-def LowPart(array, number_bits) :
+def LowPart(array, number_bits):
     shifted = 0
-    for byte in range(0, len(array)) :
+    for byte in range(0, len(array)):
         shifted |= (array[byte] << (8 * byte))
 
     mask = 0
-    for bit in range(0, number_bits) :
+    for bit in range(0, number_bits):
         mask |= (0x1 << bit)
 
     lower_part = shifted & mask
 
     will_padd = 0
-    if (number_bits % 8) != 0 :
+    if number_bits % 8 != 0:
         will_padd = 1
 
-    lower_part_byte = [0 for byte in range(0, int(number_bits / 8)  + will_padd)]
-    for byte in range(0, int(number_bits / 8)  + will_padd) :
+    lower_part_byte = [0 for byte in range(0, int(number_bits / 8) + will_padd)]
+    for byte in range(0, int(number_bits / 8) + will_padd):
         lower_part_byte[byte] = lower_part & 0xff
         lower_part = lower_part >> 8
 
@@ -50,13 +51,13 @@ class _MessageTweak(Enum):
 
 
 def TweakMessage(N, j, padding):
-    tweak = [0 for byte in range(0,  TWEAK_BYTES)]
-    for byte in range(NONCE_BYTES-1, -1, -1) :
+    tweak = [0 for byte in range(0, TWEAK_BYTES)]
+    for byte in range(NONCE_BYTES-1, -1, -1):
         tweak[byte + (TWEAK_BYTES-NONCE_BYTES)] |= (N[byte] & 0xf0) >> 4
         tweak[byte + (TWEAK_BYTES-NONCE_BYTES-1)] |= (N[byte] & 0x0f) << 4
 
     tweak[TWEAK_BYTES-NONCE_BYTES-1] |= ((j >> 64) & 0xf)
-    for byte in range(TWEAK_BYTES-NONCE_BYTES-2, -1, -1) :
+    for byte in range(TWEAK_BYTES-NONCE_BYTES-2, -1, -1):
         tweak[byte] = (j >> (8 * byte)) & 0xff
 
     tweak[-1] |= padding.value<<4
@@ -96,7 +97,7 @@ def TreatMessageEnc(M, N, key):
     return (Final, C)
 
 
-def TreatMessageDec(C, N, key) :
+def TreatMessageDec(C, N, key):
     checksum = [0 for byte in range(0, BLOCK_BYTES)]
 
     l = len(C)//BLOCK_BYTES
@@ -129,7 +130,7 @@ def TreatMessageDec(C, N, key) :
 
 
 ################################################################################
-def encrypt(A, M, N, key) :
+def encrypt(A, M, N, key):
     K = list(key)
 
     Auth = BuildAuth(TWEAK_BITS, A, K)
@@ -139,7 +140,7 @@ def encrypt(A, M, N, key) :
     return BlockbytesMatrixToBytes(C), bytes(tag)
 
 
-def decrypt(A, C, N, tag, key) :
+def decrypt(A, C, N, tag, key):
     K = list(key)
     tag = list(tag)
 
@@ -147,5 +148,7 @@ def decrypt(A, C, N, tag, key) :
     (Final, M) = TreatMessageDec(C, N, K)
     tag2 = XorState(Auth, Final)
 
-    if(tag == tag2) :
-        return BlockbytesMatrixToBytes(M)
+    if tag != tag2:
+        raise TagValidationError(tag, tag2)
+
+    return BlockbytesMatrixToBytes(M)
diff --git a/python/lilliput_ae_2.py b/python/lilliput_ae_2.py
index 624fd93..3f72020 100644
--- a/python/lilliput_ae_2.py
+++ b/python/lilliput_ae_2.py
@@ -3,12 +3,13 @@
 """
 
 import lilliput_tbc as ltbc
-from constants import BLOCK_BITS, BLOCK_BYTES
+from constants import BLOCK_BYTES
 from helpers import (
     ArrayToBlockbytesMatrix,
     BlockbytesMatrixToBytes,
     BuildAuth,
     Padding10LSB,
+    TagValidationError,
     XorState
 )
 
@@ -18,30 +19,31 @@ TWEAK_BYTES = TWEAK_BITS//8
 
 
 def TweakTag(j, padded):
-        tweak = [0 for byte in range(0,  TWEAK_BYTES)]
+    tweak = [0 for byte in range(0, TWEAK_BYTES)]
 
-        tweak[TWEAK_BYTES - 1] |= ((j >> 120) & 0xf)
-        for byte in range(TWEAK_BYTES - 2, -1, -1) :
-            tweak[byte] = (j >> (8 * byte)) & 0xff
+    tweak[TWEAK_BYTES - 1] |= ((j >> 120) & 0xf)
+    for byte in range(TWEAK_BYTES - 2, -1, -1):
+        tweak[byte] = (j >> (8 * byte)) & 0xff
 
-        if padded:
-            tweak[TWEAK_BYTES - 1] |= 0x40
+    if padded:
+        tweak[TWEAK_BYTES - 1] |= 0x40
+
+    return tweak
 
-        return tweak
 
-def TweakTagEnd(N) :
-    tweak = [0 for byte in range(0,  TWEAK_BYTES)]
+def TweakTagEnd(N):
+    tweak = [0 for byte in range(0, TWEAK_BYTES)]
 
-    for byte in range(0, TWEAK_BYTES - 1) :
+    for byte in range(0, TWEAK_BYTES - 1):
         tweak[byte] = N[byte]
     tweak[TWEAK_BYTES - 1] = 0x10
 
     return tweak
 
 
-def AddTagJ(tag, j) :
+def AddTagJ(tag, j):
     array_j = [0 for byte in range(0, TWEAK_BYTES)]
-    for byte in range(0, TWEAK_BYTES) :
+    for byte in range(0, TWEAK_BYTES):
         array_j[byte] = (j >> (byte * 8))
 
     xorr = XorState(tag, array_j)
@@ -51,19 +53,19 @@ def AddTagJ(tag, j) :
     return xorr
 
 
-def MesssageAuthTag(M, N, Auth, key) :
+def MesssageAuthTag(M, N, Auth, key):
     l = len(M)//BLOCK_BYTES
     padding_bytes = len(M)%BLOCK_BYTES
 
     tag = list(Auth)
     M = ArrayToBlockbytesMatrix(M)
 
-    for j in range(0, l) :
+    for j in range(0, l):
         tweak = TweakTag(j, False)
         encryption = ltbc.LilliputTBCEnc(tweak, key, M[j])
         tag = XorState(tag, encryption)
 
-    if padding_bytes > 0 :
+    if padding_bytes > 0:
         tweak = TweakTag(l, True)
         m_padded = Padding10LSB(M[l], 8*padding_bytes)
         encryption = ltbc.LilliputTBCEnc(tweak, key, m_padded)
@@ -76,14 +78,14 @@ def MesssageAuthTag(M, N, Auth, key) :
     return tag
 
 
-def MessageEncryption(M, N, tag, key) :
+def MessageEncryption(M, N, tag, key):
     l = len(M)//BLOCK_BYTES
     padding_bytes = len(M)%BLOCK_BYTES
 
     M = ArrayToBlockbytesMatrix(M)
     C = []
 
-    for j in range(0, l) :
+    for j in range(0, l):
         tweak = AddTagJ(tag, j)
         padded_nonce = list(N) + [0x00]
         encryption = ltbc.LilliputTBCEnc(tweak, key, padded_nonce)
@@ -97,8 +99,9 @@ def MessageEncryption(M, N, tag, key) :
 
     return C
 
+
 ################################################################################
-def encrypt(A, M, N, key) :
+def encrypt(A, M, N, key):
     K = list(key)
 
     Auth = BuildAuth(TWEAK_BITS, A, K)
@@ -108,7 +111,7 @@ def encrypt(A, M, N, key) :
     return BlockbytesMatrixToBytes(C), bytes(tag)
 
 
-def decrypt(A, C, N, tag, key) :
+def decrypt(A, C, N, tag, key):
     K = list(key)
     tag = list(tag)
 
@@ -118,5 +121,7 @@ def decrypt(A, C, N, tag, key) :
     Auth = BuildAuth(TWEAK_BITS, A, K)
     tag2 = MesssageAuthTag(M, N, Auth, K)
 
-    if tag == tag2:
-        return M
+    if tag != tag2:
+        raise TagValidationError(tag, tag2)
+
+    return M
diff --git a/python/lilliput_tbc.py b/python/lilliput_tbc.py
index 418d083..9dc7df2 100644
--- a/python/lilliput_tbc.py
+++ b/python/lilliput_tbc.py
@@ -10,7 +10,7 @@ permutationInv = [13, 9, 14, 8, 10, 11, 12, 15, 4, 5, 3, 1, 2, 6 ,0 ,7]
 
 ################################################################################
 
-def BuildTweakey(tweak, key) :
+def BuildTweakey(tweak, key):
     return tweak+key
 
 #############################
@@ -18,7 +18,7 @@ def BuildTweakey(tweak, key) :
 def _lane(TK, j):
     return TK[j*8:(j+1)*8]
 
-def RoundTweakeySchedule(tweakey) :
+def RoundTweakeySchedule(tweakey):
     p = len(tweakey)//8
 
     multiplied_lanes = (
@@ -45,7 +45,7 @@ def TweakeyScheduleWhole(tweakey, r):
     TKs = [tweakey]
     RTKs = [SubTweakeyExtract(TKs[0], 0)]
 
-    for i in range(1, r) :
+    for i in range(1, r):
         TKs.append(RoundTweakeySchedule(TKs[i-1]))
         RTKs.append(SubTweakeyExtract(TKs[i], i))
 
@@ -54,69 +54,69 @@ def TweakeyScheduleWhole(tweakey, r):
 
 ################################################################################
 
-def NonLinearLayer(state, subtweakey) :
+def NonLinearLayer(state, subtweakey):
 
     variables_xored = [0 for byte in range(0, 8)]
-    for byte in range(0,8) :
+    for byte in range(0,8):
         variables_xored[byte] = state[byte] ^ subtweakey[byte]
 
     variables_sboxed = [0 for byte in range(0, 8)]
-    for byte in range(0, 8) :
+    for byte in range(0, 8):
         variables_sboxed[byte] = Sbox[variables_xored[byte]]
 
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
-    for byte in range(0,BLOCK_BYTES) :
+    for byte in range(0,BLOCK_BYTES):
         state_output[byte] = state[byte]
-    for byte in range(0, 8) :
+    for byte in range(0, 8):
         state_output[15 - byte] ^= variables_sboxed[byte]
 
     return state_output
 
 
-def LinearLayer(state) :
+def LinearLayer(state):
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
-    for byte in range(0, BLOCK_BYTES) :
+    for byte in range(0, BLOCK_BYTES):
         state_output[byte] = state[byte]
 
-    for byte in range(1, 8) :
+    for byte in range(1, 8):
         state_output[15] ^= state[byte]
 
-    for byte in range(9, 15) :
+    for byte in range(9, 15):
         state_output[byte] ^= state[7]
 
     return state_output
 
 
-def PermutationLayerEnc(state) :
+def PermutationLayerEnc(state):
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
-    for byte in range(0, BLOCK_BYTES) :
+    for byte in range(0, BLOCK_BYTES):
         state_output[byte] = state[permutation[byte]]
 
     return state_output
 
-def PermutationLayerDec(state) :
+def PermutationLayerDec(state):
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
-    for byte in range(0, BLOCK_BYTES) :
+    for byte in range(0, BLOCK_BYTES):
         state_output[byte] = state[permutationInv[byte]]
 
     return state_output
 
 
-def OneRoundEGFNEnc(state, subtweakey) :
+def OneRoundEGFNEnc(state, subtweakey):
     state_non_linear = NonLinearLayer(state, subtweakey)
     state_linear = LinearLayer(state_non_linear)
     state_permutation = PermutationLayerEnc(state_linear)
 
     return state_permutation
 
-def LastRoundEGFN(state, subtweakey) :
+def LastRoundEGFN(state, subtweakey):
     state_non_linear = NonLinearLayer(state, subtweakey)
     state_linear = LinearLayer(state_non_linear)
 
     return state_linear
 
 
-def OneRoundEGFNDec(state, subtweakey) :
+def OneRoundEGFNDec(state, subtweakey):
     state_non_linear = NonLinearLayer(state, subtweakey)
     state_linear = LinearLayer(state_non_linear)
     state_permutation = PermutationLayerDec(state_linear)
@@ -136,20 +136,20 @@ def _rounds(key_bytes):
 ################################################################################
 # Lilliput TBC
 
-def LilliputTBCEnc(tweak, key, message) :
+def LilliputTBCEnc(tweak, key, message):
     r = _rounds(len(key))
 
     tweakey = BuildTweakey(tweak, key)
     RTKs = TweakeyScheduleWhole(tweakey, r)
 
     state = [0 for byte in range(0, BLOCK_BYTES)]
-    for byte in range(0, BLOCK_BYTES) :
+    for byte in range(0, BLOCK_BYTES):
         state[byte] = message[byte]
 
-    for i in range(0, r-1) :
+    for i in range(0, r-1):
         state_output = OneRoundEGFNEnc(state, RTKs[i])
 
-        for byte in range(0, BLOCK_BYTES) :
+        for byte in range(0, BLOCK_BYTES):
             state[byte] = state_output[byte]
 
     state_output = LastRoundEGFN(state, RTKs[r-1])
@@ -157,20 +157,20 @@ def LilliputTBCEnc(tweak, key, message) :
     return state_output
 
 
-def LilliputTBCDec(tweak, key, cipher) :
+def LilliputTBCDec(tweak, key, cipher):
     r = _rounds(len(key))
 
     tweakey = BuildTweakey(tweak, key)
     RTKs = TweakeyScheduleWhole(tweakey, r)
 
     state = [0 for byte in range(0, BLOCK_BYTES)]
-    for byte in range(0, BLOCK_BYTES) :
+    for byte in range(0, BLOCK_BYTES):
         state[byte] = cipher[byte]
 
-    for i in range(0, r-1) :
+    for i in range(0, r-1):
         state_output = OneRoundEGFNDec(state, RTKs[r-i-1])
 
-        for byte in range(0, BLOCK_BYTES) :
+        for byte in range(0, BLOCK_BYTES):
             state[byte] = state_output[byte]
 
     state_output = LastRoundEGFN(state, RTKs[0])
diff --git a/python/multiplications.py b/python/multiplications.py
index 7babd50..c5f1e44 100644
--- a/python/multiplications.py
+++ b/python/multiplications.py
@@ -1,6 +1,6 @@
 
 # Multiply by matrix M
-def _multiplyM(lane) :
+def _multiplyM(lane):
     multiplied_lane = [lane[(byte-1) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[6] << 2) & 0xff)
@@ -9,7 +9,7 @@ def _multiplyM(lane) :
 
     return multiplied_lane
 
-def _multiplyM2(lane) :
+def _multiplyM2(lane):
     multiplied_lane = [lane[(byte-2) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[5] << 2) & 0xff)
@@ -35,7 +35,7 @@ def _multiplyM2(lane) :
     return multiplied_lane
 
 
-def _multiplyM3(lane) :
+def _multiplyM3(lane):
     multiplied_lane = [lane[(byte-3) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[4] << 2) & 0xff) ^ ((lane[5] << 5) & 0xff)
@@ -86,7 +86,7 @@ def _multiplyM3(lane) :
     return multiplied_lane
 
 
-def _multiplyMR(lane) :
+def _multiplyMR(lane):
     multiplied_lane = [lane[(byte+1) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[4] >> 3) & 0xff)
@@ -96,7 +96,7 @@ def _multiplyMR(lane) :
     return multiplied_lane
 
 
-def _multiplyMR2(lane) :
+def _multiplyMR2(lane):
     multiplied_lane = [lane[(byte+2) % 8] for byte in range(0, 8)]
 
     multiplied_lane[1] ^= ((lane[4] >> 3) & 0xff)
@@ -120,7 +120,7 @@ def _multiplyMR2(lane) :
 
     return multiplied_lane
 
-def _multiplyMR3(lane) :
+def _multiplyMR3(lane):
     multiplied_lane = [lane[(byte+3) % 8] for byte in range(0, 8)]
 
     multiplied_lane[0] ^= ((lane[4] >> 3) & 0xff)