summaryrefslogtreecommitdiff
path: root/src/add_python
diff options
context:
space:
mode:
Diffstat (limited to 'src/add_python')
-rw-r--r--src/add_python/lilliput/ae_mode_1.py77
-rw-r--r--src/add_python/lilliput/ae_mode_2.py62
-rw-r--r--src/add_python/lilliput/constants.py2
-rw-r--r--src/add_python/lilliput/helpers.py24
-rw-r--r--src/add_python/lilliput/multiplications.py28
-rw-r--r--src/add_python/lilliput/tbc.py91
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
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-06 21:22:38 +0000