[implem-python] Conformité PEP8

Surtout la capitalisation des noms de fonction.

Retrait des lignes de '#' ; si  il y a des séparations à faire, autant
ajouter des modules.

Correction de _MessageTweak.BLOCK en passant.

6 files changed, 140 insertions, 144 deletions

diff --git a/src/add_python/lilliput/ae_mode_1.py b/src/add_python/lilliput/ae_mode_1.py
index c2fdd9e..cc550e8 100644
--- a/src/add_python/lilliput/ae_mode_1.py
+++ b/src/add_python/lilliput/ae_mode_1.py
@@ -22,12 +22,12 @@ from enum import Enum
 
 from .constants import BLOCK_BYTES, NONCE_BYTES
 from .helpers import (
-    ArrayToBlockbytesMatrix,
-    BlockbytesMatrixToBytes,
-    BuildAuth,
-    Padding10LSB,
+    bytes_to_block_matrix,
+    block_matrix_to_bytes,
+    build_auth,
+    pad10,
     TagValidationError,
-    XorState
+    xor_state
 )
 from . import tbc
 
@@ -36,7 +36,7 @@ TWEAK_BITS = 192
 TWEAK_BYTES = TWEAK_BITS//8
 
 
-def _LowPart(array, number_bits):
+def _low_part(array, number_bits):
     shifted = 0
     for byte in range(0, len(array)):
         shifted |= (array[byte] << (8 * byte))
@@ -61,13 +61,13 @@ def _LowPart(array, number_bits):
 
 
 class _MessageTweak(Enum):
-    BLOCK = 0b000
+    BLOCK = 0b0000
     NO_PADDING = 0b0001
     PAD = 0b0100
     FINAL = 0b0101
 
 
-def _TweakMessage(N, j, padding):
+def _tweak_message(N, j, padding):
     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
@@ -82,90 +82,89 @@ def _TweakMessage(N, j, padding):
     return tweak
 
 
-def _TreatMessageEnc(M, N, key):
+def _treat_message_enc(M, N, key):
     checksum = [0 for byte in range(0, BLOCK_BYTES)]
 
     l = len(M)//BLOCK_BYTES
     padding_bytes = len(M)%BLOCK_BYTES
 
-    M = ArrayToBlockbytesMatrix(M)
+    M = bytes_to_block_matrix(M)
     C = []
 
     for j in range(0, l):
-        checksum = XorState(checksum, M[j])
-        tweak = _TweakMessage(N, j, _MessageTweak.BLOCK)
+        checksum = xor_state(checksum, M[j])
+        tweak = _tweak_message(N, j, _MessageTweak.BLOCK)
         C.append(tbc.encrypt(tweak, key, M[j]))
 
     if padding_bytes == 0:
-        tweak = _TweakMessage(N, l, _MessageTweak.NO_PADDING)
+        tweak = _tweak_message(N, l, _MessageTweak.NO_PADDING)
         Final = tbc.encrypt(tweak, key, checksum)
 
     else:
-        m_padded = Padding10LSB(M[l])
-        checksum = XorState(checksum, m_padded)
-        tweak = _TweakMessage(N, l, _MessageTweak.PAD)
+        m_padded = pad10(M[l])
+        checksum = xor_state(checksum, m_padded)
+        tweak = _tweak_message(N, l, _MessageTweak.PAD)
         pad = tbc.encrypt(tweak, key, [0 for byte in range(0, BLOCK_BYTES)])
 
-        lower_part = _LowPart(pad, padding_bytes*8)
-        C.append(XorState(M[l], lower_part))
-        tweak_final = _TweakMessage(N, l+1, _MessageTweak.FINAL)
+        lower_part = _low_part(pad, padding_bytes*8)
+        C.append(xor_state(M[l], lower_part))
+        tweak_final = _tweak_message(N, l+1, _MessageTweak.FINAL)
         Final = tbc.encrypt(tweak_final, key, checksum)
 
     return (Final, C)
 
 
-def _TreatMessageDec(C, N, key):
+def _treat_message_dec(C, N, key):
     checksum = [0 for byte in range(0, BLOCK_BYTES)]
 
     l = len(C)//BLOCK_BYTES
     padding_bytes = len(C)%BLOCK_BYTES
 
-    C = ArrayToBlockbytesMatrix(C)
+    C = bytes_to_block_matrix(C)
     M = []
 
     for j in range(0, l):
-        tweak = _TweakMessage(N, j, _MessageTweak.BLOCK)
+        tweak = _tweak_message(N, j, _MessageTweak.BLOCK)
         M.append(tbc.decrypt(tweak, key, C[j]))
-        checksum = XorState(checksum, M[j])
+        checksum = xor_state(checksum, M[j])
 
     if padding_bytes == 0:
-        tweak = _TweakMessage(N, l, _MessageTweak.NO_PADDING)
+        tweak = _tweak_message(N, l, _MessageTweak.NO_PADDING)
         Final = tbc.encrypt(tweak, key, checksum)
 
     else:
-        tweak = _TweakMessage(N, l, _MessageTweak.PAD)
+        tweak = _tweak_message(N, l, _MessageTweak.PAD)
         pad = tbc.encrypt(tweak, key, [0 for byte in range(0, BLOCK_BYTES)])
-        lower_part = _LowPart(pad, padding_bytes*8)
-        M.append(XorState(C[l], lower_part))
+        lower_part = _low_part(pad, padding_bytes*8)
+        M.append(xor_state(C[l], lower_part))
 
-        m_padded = Padding10LSB(M[l])
-        checksum = XorState(checksum, m_padded)
-        tweak_final = _TweakMessage(N, l+1, _MessageTweak.FINAL)
+        m_padded = pad10(M[l])
+        checksum = xor_state(checksum, m_padded)
+        tweak_final = _tweak_message(N, l+1, _MessageTweak.FINAL)
         Final = tbc.encrypt(tweak_final, key, checksum)
 
     return (Final, M)
 
 
-################################################################################
 def encrypt(A, M, N, key):
     K = list(key)
 
-    Auth = BuildAuth(TWEAK_BITS, A, K)
-    (Final, C) = _TreatMessageEnc(M, N, K)
-    tag = XorState(Auth, Final)
+    Auth = build_auth(TWEAK_BITS, A, K)
+    (Final, C) = _treat_message_enc(M, N, K)
+    tag = xor_state(Auth, Final)
 
-    return BlockbytesMatrixToBytes(C), bytes(tag)
+    return block_matrix_to_bytes(C), bytes(tag)
 
 
 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)
-    tag2 = XorState(Auth, Final)
+    Auth = build_auth(TWEAK_BITS, A, K)
+    (Final, M) = _treat_message_dec(C, N, K)
+    tag2 = xor_state(Auth, Final)
 
     if tag != tag2:
         raise TagValidationError(tag, tag2)
 
-    return BlockbytesMatrixToBytes(M)
+    return block_matrix_to_bytes(M)
diff --git a/src/add_python/lilliput/ae_mode_2.py b/src/add_python/lilliput/ae_mode_2.py
index fb6feff..4d5e499 100644
--- a/src/add_python/lilliput/ae_mode_2.py
+++ b/src/add_python/lilliput/ae_mode_2.py
@@ -20,12 +20,12 @@ using Lilliput-AE's nonce-misuse-resistant mode based on SCT-2.
 
 from .constants import BLOCK_BYTES
 from .helpers import (
-    ArrayToBlockbytesMatrix,
-    BlockbytesMatrixToBytes,
-    BuildAuth,
-    Padding10LSB,
+    bytes_to_block_matrix,
+    block_matrix_to_bytes,
+    build_auth,
+    pad10,
     TagValidationError,
-    XorState
+    xor_state
 )
 from . import tbc
 
@@ -34,7 +34,7 @@ TWEAK_BITS = 128
 TWEAK_BYTES = TWEAK_BITS//8
 
 
-def _TweakTag(j, padded):
+def _tweak_tag(j, padded):
     tweak = [0 for byte in range(0, TWEAK_BYTES)]
 
     tweak[TWEAK_BYTES - 1] |= ((j >> 120) & 0xf)
@@ -47,7 +47,7 @@ def _TweakTag(j, padded):
     return tweak
 
 
-def _TweakTagEnd(N):
+def _tweak_tag_end(N):
     tweak = [0 for byte in range(0, TWEAK_BYTES)]
 
     for byte in range(0, TWEAK_BYTES - 1):
@@ -57,61 +57,61 @@ def _TweakTagEnd(N):
     return tweak
 
 
-def _AddTagJ(tag, j):
+def _add_tag_j(tag, j):
     array_j = [0 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)
+    xorr = xor_state(tag, array_j)
 
     xorr[TWEAK_BYTES - 1] |= 0x80
 
     return xorr
 
 
-def _MesssageAuthTag(M, N, Auth, key):
+def _message_auth_tag(M, N, Auth, key):
     l = len(M)//BLOCK_BYTES
     need_padding = len(M)%BLOCK_BYTES > 0
 
     tag = list(Auth)
-    M = ArrayToBlockbytesMatrix(M)
+    M = bytes_to_block_matrix(M)
 
     for j in range(0, l):
-        tweak = _TweakTag(j, False)
+        tweak = _tweak_tag(j, False)
         encryption = tbc.encrypt(tweak, key, M[j])
-        tag = XorState(tag, encryption)
+        tag = xor_state(tag, encryption)
 
     if need_padding:
-        tweak = _TweakTag(l, True)
-        m_padded = Padding10LSB(M[l])
+        tweak = _tweak_tag(l, True)
+        m_padded = pad10(M[l])
         encryption = tbc.encrypt(tweak, key, m_padded)
-        tag = XorState(tag, encryption)
+        tag = xor_state(tag, encryption)
 
-    tweak = _TweakTagEnd(N)
+    tweak = _tweak_tag_end(N)
     encryption = tbc.encrypt(tweak, key, tag)
     tag = encryption
 
     return tag
 
 
-def _MessageEncryption(M, N, tag, key):
+def _message_encryption(M, N, tag, key):
     l = len(M)//BLOCK_BYTES
     need_padding = len(M)%BLOCK_BYTES > 0
 
-    M = ArrayToBlockbytesMatrix(M)
+    M = bytes_to_block_matrix(M)
     C = []
 
     for j in range(0, l):
-        tweak = _AddTagJ(tag, j)
+        tweak = _add_tag_j(tag, j)
         padded_nonce = list(N) + [0x00]
         encryption = tbc.encrypt(tweak, key, padded_nonce)
-        C.append(XorState(M[j], encryption))
+        C.append(xor_state(M[j], encryption))
 
     if need_padding:
-        tweak = _AddTagJ(tag, l)
+        tweak = _add_tag_j(tag, l)
         padded_nonce = list(N) + [0x00]
         encryption = tbc.encrypt(tweak, key, padded_nonce)
-        C.append(XorState(M[l], encryption))
+        C.append(xor_state(M[l], encryption))
 
     return C
 
@@ -120,22 +120,22 @@ def _MessageEncryption(M, N, tag, key):
 def encrypt(A, M, N, key):
     K = list(key)
 
-    Auth = BuildAuth(TWEAK_BITS, A, K)
-    tag = _MesssageAuthTag(M, N, Auth, K)
-    C = _MessageEncryption(M, N, tag, K)
+    Auth = build_auth(TWEAK_BITS, A, K)
+    tag = _message_auth_tag(M, N, Auth, K)
+    C = _message_encryption(M, N, tag, K)
 
-    return BlockbytesMatrixToBytes(C), bytes(tag)
+    return block_matrix_to_bytes(C), bytes(tag)
 
 
 def decrypt(A, C, N, tag, key):
     K = list(key)
     tag = list(tag)
 
-    M = BlockbytesMatrixToBytes(
-        _MessageEncryption(C, N, tag, K)
+    M = block_matrix_to_bytes(
+        _message_encryption(C, N, tag, K)
     )
-    Auth = BuildAuth(TWEAK_BITS, A, K)
-    tag2 = _MesssageAuthTag(M, N, Auth, K)
+    Auth = build_auth(TWEAK_BITS, A, K)
+    tag2 = _message_auth_tag(M, N, Auth, K)
 
     if tag != tag2:
         raise TagValidationError(tag, tag2)
diff --git a/src/add_python/lilliput/constants.py b/src/add_python/lilliput/constants.py
index 0c9b89f..5e07e96 100644
--- a/src/add_python/lilliput/constants.py
+++ b/src/add_python/lilliput/constants.py
@@ -4,7 +4,7 @@ NONCE_BYTES = 15
 TAG_BYTES = 16
 
 
-Sbox = [
+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,
diff --git a/src/add_python/lilliput/helpers.py b/src/add_python/lilliput/helpers.py
index 8677f06..65989d0 100644
--- a/src/add_python/lilliput/helpers.py
+++ b/src/add_python/lilliput/helpers.py
@@ -2,7 +2,7 @@ from .constants import BLOCK_BITS, BLOCK_BYTES
 from . import tbc
 
 
-def ArrayToBlockbytesMatrix(array):
+def bytes_to_block_matrix(array):
     vector = list(array)
 
     blocks_nb = len(vector)//BLOCK_BYTES
@@ -24,20 +24,20 @@ def ArrayToBlockbytesMatrix(array):
     return matrix
 
 
-def BlockbytesMatrixToBytes(matrix):
+def block_matrix_to_bytes(matrix):
     return bytes(byte for block in matrix for byte in block)
 
 
-def XorState(state1, state2):
+def xor_state(state1, state2):
     return [s1^s2 for (s1, s2) in zip(state1, state2)]
 
 
-def Padding10LSB(X):
+def pad10(X):
     zeroes = [0] * (BLOCK_BYTES-len(X)-1)
     return zeroes + [0b10000000] + X
 
 
-def _tweakAssociatedData(t, i, padded):
+def _tweak_associated_data(t, i, padded):
     t_bytes = t//8
     tweak = [0]*(t_bytes)
 
@@ -56,25 +56,25 @@ def _tweakAssociatedData(t, i, padded):
     return tweak
 
 
-def BuildAuth(t, A, key):
+def build_auth(t, A, key):
     Auth = [0 for byte in range(0, BLOCK_BYTES)]
     l_a = len(A)//BLOCK_BYTES
     need_padding = len(A)%BLOCK_BYTES > 0
 
-    A = ArrayToBlockbytesMatrix(A)
+    A = bytes_to_block_matrix(A)
 
     for i in range(0, l_a):
-        tweak = _tweakAssociatedData(t, i, padded=False)
+        tweak = _tweak_associated_data(t, i, padded=False)
         enc = tbc.encrypt(tweak, key, A[i])
-        Auth = XorState(Auth, enc)
+        Auth = xor_state(Auth, enc)
 
     if not need_padding:
         return Auth
 
-    tweak = _tweakAssociatedData(t, l_a, padded=True)
-    ad_padded = Padding10LSB(A[l_a])
+    tweak = _tweak_associated_data(t, l_a, padded=True)
+    ad_padded = pad10(A[l_a])
     enc = tbc.encrypt(tweak, key, ad_padded)
-    Auth = XorState(Auth, enc)
+    Auth = xor_state(Auth, enc)
 
     return Auth
 
diff --git a/src/add_python/lilliput/multiplications.py b/src/add_python/lilliput/multiplications.py
index c5f1e44..dfdc3cb 100644
--- a/src/add_python/lilliput/multiplications.py
+++ b/src/add_python/lilliput/multiplications.py
@@ -1,6 +1,6 @@
 
-# Multiply by matrix M
-def _multiplyM(lane):
+
+def _multiply_M(lane):
     multiplied_lane = [lane[(byte-1) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[6] << 2) & 0xff)
@@ -9,7 +9,8 @@ def _multiplyM(lane):
 
     return multiplied_lane
 
-def _multiplyM2(lane):
+
+def _multiply_M2(lane):
     multiplied_lane = [lane[(byte-2) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[5] << 2) & 0xff)
@@ -35,7 +36,7 @@ def _multiplyM2(lane):
     return multiplied_lane
 
 
-def _multiplyM3(lane):
+def _multiply_M3(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 +87,7 @@ def _multiplyM3(lane):
     return multiplied_lane
 
 
-def _multiplyMR(lane):
+def _multiply_MR(lane):
     multiplied_lane = [lane[(byte+1) % 8] for byte in range(0, 8)]
 
     multiplied_lane[2] ^= ((lane[4] >> 3) & 0xff)
@@ -96,7 +97,7 @@ def _multiplyMR(lane):
     return multiplied_lane
 
 
-def _multiplyMR2(lane):
+def _multiply_MR2(lane):
     multiplied_lane = [lane[(byte+2) % 8] for byte in range(0, 8)]
 
     multiplied_lane[1] ^= ((lane[4] >> 3) & 0xff)
@@ -120,7 +121,8 @@ def _multiplyMR2(lane):
 
     return multiplied_lane
 
-def _multiplyMR3(lane):
+
+def _multiply_MR3(lane):
     multiplied_lane = [lane[(byte+3) % 8] for byte in range(0, 8)]
 
     multiplied_lane[0] ^= ((lane[4] >> 3) & 0xff)
@@ -177,10 +179,10 @@ def _multiplyMR3(lane):
 
 ALPHAS = (
     list,                       # Identity.
-    _multiplyM,
-    _multiplyM2,
-    _multiplyM3,
-    _multiplyMR,
-    _multiplyMR2,
-    _multiplyMR3
+    _multiply_M,
+    _multiply_M2,
+    _multiply_M3,
+    _multiply_MR,
+    _multiply_MR2,
+    _multiply_MR3
 )
diff --git a/src/add_python/lilliput/tbc.py b/src/add_python/lilliput/tbc.py
index 50f9e2f..c607e45 100644
--- a/src/add_python/lilliput/tbc.py
+++ b/src/add_python/lilliput/tbc.py
@@ -17,35 +17,33 @@
 This module provides functions to encrypt and decrypt blocks of 128 bits.
 """
 
-from .constants import BLOCK_BYTES, Sbox
+from .constants import BLOCK_BYTES, SBOX
 from .multiplications import ALPHAS
 
 
-_permutation = [14, 11, 12, 10, 8, 9, 13, 15, 3, 1, 4, 5, 6, 0, 2, 7]
-_permutationInv = [13, 9, 14, 8, 10, 11, 12, 15, 4, 5, 3, 1, 2, 6 ,0 ,7]
+_PERMUTATION = [14, 11, 12, 10, 8, 9, 13, 15, 3, 1, 4, 5, 6, 0, 2, 7]
+_PERMUTATION_INV = [13, 9, 14, 8, 10, 11, 12, 15, 4, 5, 3, 1, 2, 6 ,0 ,7]
 
-################################################################################
 
-def _BuildTweakey(tweak, key):
+def _build_tweakey(tweak, key):
     return tweak+key
 
-#############################
 
-def _Lane(TK, j):
+def _lane(TK, j):
     return TK[j*8:(j+1)*8]
 
 
-def _RoundTweakeySchedule(tweakey):
+def _round_tweakey_schedule(tweakey):
     p = len(tweakey)//8
 
     multiplied_lanes = (
-        ALPHAS[j](_Lane(tweakey, j)) for j in range(p)
+        ALPHAS[j](_lane(tweakey, j)) for j in range(p)
     )
 
     return [byte for lane in multiplied_lanes for byte in lane]
 
 
-def _SubTweakeyExtract(tweakey, Ci):
+def _subtweakey_extract(tweakey, Ci):
     RTKi = [0]*8
 
     for j, byte in enumerate(tweakey):
@@ -56,22 +54,20 @@ def _SubTweakeyExtract(tweakey, Ci):
     return RTKi
 
 
-def _TweakeyScheduleWhole(tweakey, r):
+def _tweakey_schedule_whole(tweakey, r):
     # Store the initial tweakey in TKs[0], and the corresponding round tweakey
     # in RTKs[0].
     TKs = [tweakey]
-    RTKs = [_SubTweakeyExtract(TKs[0], 0)]
+    RTKs = [_subtweakey_extract(TKs[0], 0)]
 
     for i in range(1, r):
-        TKs.append(_RoundTweakeySchedule(TKs[i-1]))
-        RTKs.append(_SubTweakeyExtract(TKs[i], i))
+        TKs.append(_round_tweakey_schedule(TKs[i-1]))
+        RTKs.append(_subtweakey_extract(TKs[i], i))
 
     return RTKs
 
 
-################################################################################
-
-def _NonLinearLayer(state, subtweakey):
+def _non_linear_layer(state, subtweakey):
 
     variables_xored = [0 for byte in range(0, 8)]
     for byte in range(0,8):
@@ -79,7 +75,7 @@ def _NonLinearLayer(state, subtweakey):
 
     variables_sboxed = [0 for byte in range(0, 8)]
     for byte in range(0, 8):
-        variables_sboxed[byte] = Sbox[variables_xored[byte]]
+        variables_sboxed[byte] = SBOX[variables_xored[byte]]
 
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
     for byte in range(0,BLOCK_BYTES):
@@ -90,7 +86,7 @@ def _NonLinearLayer(state, subtweakey):
     return state_output
 
 
-def _LinearLayer(state):
+def _linear_layer(state):
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
     for byte in range(0, BLOCK_BYTES):
         state_output[byte] = state[byte]
@@ -104,44 +100,46 @@ def _LinearLayer(state):
     return state_output
 
 
-def _PermutationLayerEnc(state):
+def _permutation_layer_enc(state):
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
     for byte in range(0, BLOCK_BYTES):
-        state_output[byte] = state[_permutation[byte]]
+        state_output[byte] = state[_PERMUTATION[byte]]
 
     return state_output
 
-def _PermutationLayerDec(state):
+
+def _permutation_layer_dec(state):
     state_output = [0 for byte in range(0, BLOCK_BYTES)]
     for byte in range(0, BLOCK_BYTES):
-        state_output[byte] = state[_permutationInv[byte]]
+        state_output[byte] = state[_PERMUTATION_INV[byte]]
 
     return state_output
 
 
-def _OneRoundEGFNEnc(state, subtweakey):
-    state_non_linear = _NonLinearLayer(state, subtweakey)
-    state_linear = _LinearLayer(state_non_linear)
-    state_permutation = _PermutationLayerEnc(state_linear)
+def _one_round_egfn_enc(state, subtweakey):
+    state_non_linear = _non_linear_layer(state, subtweakey)
+    state_linear = _linear_layer(state_non_linear)
+    state_permutation = _permutation_layer_enc(state_linear)
 
     return state_permutation
 
-def _LastRoundEGFN(state, subtweakey):
-    state_non_linear = _NonLinearLayer(state, subtweakey)
-    state_linear = _LinearLayer(state_non_linear)
+
+def _last_round_egfn(state, subtweakey):
+    state_non_linear = _non_linear_layer(state, subtweakey)
+    state_linear = _linear_layer(state_non_linear)
 
     return state_linear
 
 
-def _OneRoundEGFNDec(state, subtweakey):
-    state_non_linear = _NonLinearLayer(state, subtweakey)
-    state_linear = _LinearLayer(state_non_linear)
-    state_permutation = _PermutationLayerDec(state_linear)
+def _one_round_egfn_dec(state, subtweakey):
+    state_non_linear = _non_linear_layer(state, subtweakey)
+    state_linear = _linear_layer(state_non_linear)
+    state_permutation = _permutation_layer_dec(state_linear)
 
     return state_permutation
 
 
-def _Rounds(key_bytes):
+def _rounds(key_bytes):
     rounds = {
         128: 32,
         192: 36,
@@ -150,46 +148,43 @@ def _Rounds(key_bytes):
     return rounds[key_bytes*8]
 
 
-################################################################################
-
-
 def encrypt(tweak, key, message):
-    r = _Rounds(len(key))
+    r = _rounds(len(key))
 
-    tweakey = _BuildTweakey(tweak, key)
-    RTKs = _TweakeyScheduleWhole(tweakey, r)
+    tweakey = _build_tweakey(tweak, key)
+    RTKs = _tweakey_schedule_whole(tweakey, r)
 
     state = [0 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):
-        state_output = _OneRoundEGFNEnc(state, RTKs[i])
+        state_output = _one_round_egfn_enc(state, RTKs[i])
 
         for byte in range(0, BLOCK_BYTES):
             state[byte] = state_output[byte]
 
-    state_output = _LastRoundEGFN(state, RTKs[r-1])
+    state_output = _last_round_egfn(state, RTKs[r-1])
 
     return state_output
 
 
 def decrypt(tweak, key, cipher):
-    r = _Rounds(len(key))
+    r = _rounds(len(key))
 
-    tweakey = _BuildTweakey(tweak, key)
-    RTKs = _TweakeyScheduleWhole(tweakey, r)
+    tweakey = _build_tweakey(tweak, key)
+    RTKs = _tweakey_schedule_whole(tweakey, r)
 
     state = [0 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):
-        state_output = _OneRoundEGFNDec(state, RTKs[r-i-1])
+        state_output = _one_round_egfn_dec(state, RTKs[r-i-1])
 
         for byte in range(0, BLOCK_BYTES):
             state[byte] = state_output[byte]
 
-    state_output = _LastRoundEGFN(state, RTKs[0])
+    state_output = _last_round_egfn(state, RTKs[0])
 
     return state_output