purepython-aes 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

purepython_aes/__init__.py

@@ -14,6 +14,9 @@ from purepython_aes.aes import (
     NoPadding,
     PcbcMode,
     Pkcs7Padding,
+    ReferenceAes128,
+    ReferenceAes192,
+    ReferenceAes256,
     ZeroPadding,
 )
 
@@ -33,5 +36,8 @@ __all__: list[str] = [
     'NoPadding',
     'PcbcMode',
     'Pkcs7Padding',
+    'ReferenceAes128',
+    'ReferenceAes192',
+    'ReferenceAes256',
     'ZeroPadding',
 ]

purepython_aes/aes/__init__.py

@@ -1,5 +1,12 @@
-from purepython_aes.aes.algorithms import Aes128, Aes192, Aes256
-from purepython_aes.aes.interface import Aes
+from purepython_aes.aes.core import (
+    Aes,
+    Aes128,
+    Aes192,
+    Aes256,
+    ReferenceAes128,
+    ReferenceAes192,
+    ReferenceAes256,
+)
 from purepython_aes.aes.modes import (
     AesMode,
     BlockCipherMode,
@@ -18,10 +25,13 @@ from purepython_aes.aes.padding import (
 )
 
 __all__: list[str] = [
+    'Aes',
     'Aes128',
     'Aes192',
     'Aes256',
-    'Aes',
+    'ReferenceAes128',
+    'ReferenceAes192',
+    'ReferenceAes256',
     'AesMode',
     'BlockCipherMode',
     'CbcMode',

purepython_aes/aes/core/__init__.py

@@ -1,3 +1,20 @@
-from purepython_aes.aes.core.aes import AesCore
+from purepython_aes.aes.core.fast import Aes128, Aes192, Aes256, FastAesCore
+from purepython_aes.aes.core.interface import Aes
+from purepython_aes.aes.core.reference import (
+    AesCore,
+    ReferenceAes128,
+    ReferenceAes192,
+    ReferenceAes256,
+)
 
-__all__: list[str] = ['AesCore']
+__all__: list[str] = [
+    'FastAesCore',
+    'Aes128',
+    'Aes192',
+    'Aes256',
+    'Aes',
+    'AesCore',
+    'ReferenceAes128',
+    'ReferenceAes192',
+    'ReferenceAes256',
+]

purepython_aes/aes/core/fast/__init__.py

@@ -0,0 +1,4 @@
+from purepython_aes.aes.core.fast.aes import FastAesCore
+from purepython_aes.aes.core.fast.algorithms import Aes128, Aes192, Aes256
+
+__all__: list[str] = ['FastAesCore', 'Aes128', 'Aes192', 'Aes256']

purepython_aes/aes/core/fast/aes.py

@@ -0,0 +1,214 @@
+from dataclasses import dataclass
+
+from purepython_aes.aes.core.fast.expansion import (
+    expand_aes128_key,
+    expand_aes192_key,
+    expand_aes256_key,
+)
+from purepython_aes.aes.core.fast.keys import (
+    build_decryption_round_keys,
+    RoundKey,
+    RoundKeys,
+)
+from purepython_aes.aes.core.fast.ttables import (
+    DECRYPTION_TABLE_0,
+    DECRYPTION_TABLE_1,
+    DECRYPTION_TABLE_2,
+    DECRYPTION_TABLE_3,
+    ENCRYPTION_TABLE_0,
+    ENCRYPTION_TABLE_1,
+    ENCRYPTION_TABLE_2,
+    ENCRYPTION_TABLE_3,
+)
+from purepython_aes.aes.core.interface import Aes
+from purepython_aes.const import (
+    AES_128_KEY_SIZE,
+    AES_192_KEY_SIZE,
+    AES_256_KEY_SIZE,
+    AES_BLOCK_SIZE,
+    INVERSE_SBOX,
+    SBOX,
+)
+
+
+@dataclass(init=False, slots=True)
+class FastAesCore(Aes):
+    """Implement optimized `encrypt_block` and `decrypt_block` methods."""
+
+    __decryption_round_keys: RoundKeys
+    __encryption_round_keys: RoundKeys
+
+    def __init__(self, key: bytes) -> None:
+        if len(key) != self.__key_size__:
+            raise ValueError(
+                f'expected len(key) == {self.__key_size__}, got {len(key)}'
+            )
+        key_size: int = len(key)
+        if key_size == AES_128_KEY_SIZE:
+            self.__encryption_round_keys = expand_aes128_key(key)
+        if key_size == AES_192_KEY_SIZE:
+            self.__encryption_round_keys = expand_aes192_key(key)
+        if key_size == AES_256_KEY_SIZE:
+            self.__encryption_round_keys = expand_aes256_key(key)
+        self.__decryption_round_keys = build_decryption_round_keys(
+            self.__encryption_round_keys
+        )
+
+    def encrypt_block(self, plaintext: bytes) -> bytes:
+        """Encrypt one 16-byte block using fused T-table rounds."""
+
+        if len(plaintext) != AES_BLOCK_SIZE:
+            raise ValueError(
+                f'expected len(plaintext) == {AES_BLOCK_SIZE}, got {len(plaintext)}'
+            )
+        round_keys: RoundKeys = self.__encryption_round_keys
+        plaintext_integer: int = int.from_bytes(plaintext, byteorder='big')
+        initial_round_key: RoundKey = round_keys[0]
+        state_0: int = (plaintext_integer >> 96) ^ initial_round_key[0]
+        state_1: int = ((plaintext_integer >> 64) & 0xFFFFFFFF) ^ initial_round_key[1]
+        state_2: int = ((plaintext_integer >> 32) & 0xFFFFFFFF) ^ initial_round_key[2]
+        state_3: int = (plaintext_integer & 0xFFFFFFFF) ^ initial_round_key[3]
+        for round_index in range(1, self.__round_count__):
+            round_key: RoundKey = round_keys[round_index]
+            next_state_0: int = (
+                ENCRYPTION_TABLE_0[(state_0 >> 24) & 0xFF]
+                ^ ENCRYPTION_TABLE_1[(state_1 >> 16) & 0xFF]
+                ^ ENCRYPTION_TABLE_2[(state_2 >> 8) & 0xFF]
+                ^ ENCRYPTION_TABLE_3[state_3 & 0xFF]
+                ^ round_key[0]
+            )
+            next_state_1: int = (
+                ENCRYPTION_TABLE_0[(state_1 >> 24) & 0xFF]
+                ^ ENCRYPTION_TABLE_1[(state_2 >> 16) & 0xFF]
+                ^ ENCRYPTION_TABLE_2[(state_3 >> 8) & 0xFF]
+                ^ ENCRYPTION_TABLE_3[state_0 & 0xFF]
+                ^ round_key[1]
+            )
+            next_state_2: int = (
+                ENCRYPTION_TABLE_0[(state_2 >> 24) & 0xFF]
+                ^ ENCRYPTION_TABLE_1[(state_3 >> 16) & 0xFF]
+                ^ ENCRYPTION_TABLE_2[(state_0 >> 8) & 0xFF]
+                ^ ENCRYPTION_TABLE_3[state_1 & 0xFF]
+                ^ round_key[2]
+            )
+            next_state_3: int = (
+                ENCRYPTION_TABLE_0[(state_3 >> 24) & 0xFF]
+                ^ ENCRYPTION_TABLE_1[(state_0 >> 16) & 0xFF]
+                ^ ENCRYPTION_TABLE_2[(state_1 >> 8) & 0xFF]
+                ^ ENCRYPTION_TABLE_3[state_2 & 0xFF]
+                ^ round_key[3]
+            )
+            state_0 = next_state_0
+            state_1 = next_state_1
+            state_2 = next_state_2
+            state_3 = next_state_3
+        final_round_key: RoundKey = round_keys[self.__round_count__]
+        output_0: int = (
+            (SBOX[(state_0 >> 24) & 0xFF] << 24)
+            | (SBOX[(state_1 >> 16) & 0xFF] << 16)
+            | (SBOX[(state_2 >> 8) & 0xFF] << 8)
+            | SBOX[state_3 & 0xFF]
+        ) ^ final_round_key[0]
+        output_1: int = (
+            (SBOX[(state_1 >> 24) & 0xFF] << 24)
+            | (SBOX[(state_2 >> 16) & 0xFF] << 16)
+            | (SBOX[(state_3 >> 8) & 0xFF] << 8)
+            | SBOX[state_0 & 0xFF]
+        ) ^ final_round_key[1]
+        output_2: int = (
+            (SBOX[(state_2 >> 24) & 0xFF] << 24)
+            | (SBOX[(state_3 >> 16) & 0xFF] << 16)
+            | (SBOX[(state_0 >> 8) & 0xFF] << 8)
+            | SBOX[state_1 & 0xFF]
+        ) ^ final_round_key[2]
+        output_3: int = (
+            (SBOX[(state_3 >> 24) & 0xFF] << 24)
+            | (SBOX[(state_0 >> 16) & 0xFF] << 16)
+            | (SBOX[(state_1 >> 8) & 0xFF] << 8)
+            | SBOX[state_2 & 0xFF]
+        ) ^ final_round_key[3]
+        output_integer: int = (
+            (output_0 << 96) | (output_1 << 64) | (output_2 << 32) | output_3
+        )
+        return output_integer.to_bytes(AES_BLOCK_SIZE, byteorder='big')
+
+    def decrypt_block(self, ciphertext: bytes) -> bytes:
+        """Decrypt one block using equivalent-inverse T-table rounds."""
+
+        if len(ciphertext) != AES_BLOCK_SIZE:
+            raise ValueError(
+                f'expected len(ciphertext) == {AES_BLOCK_SIZE}, got {len(ciphertext)}'
+            )
+        round_keys: RoundKeys = self.__decryption_round_keys
+        ciphertext_integer: int = int.from_bytes(
+            ciphertext,
+            byteorder='big',
+        )
+        initial_round_key: RoundKey = round_keys[0]
+        state_0: int = (ciphertext_integer >> 96) ^ initial_round_key[0]
+        state_1: int = ((ciphertext_integer >> 64) & 0xFFFFFFFF) ^ initial_round_key[1]
+        state_2: int = ((ciphertext_integer >> 32) & 0xFFFFFFFF) ^ initial_round_key[2]
+        state_3: int = (ciphertext_integer & 0xFFFFFFFF) ^ initial_round_key[3]
+        for round_index in range(1, self.__round_count__):
+            round_key: RoundKey = round_keys[round_index]
+            next_state_0: int = (
+                DECRYPTION_TABLE_0[(state_0 >> 24) & 0xFF]
+                ^ DECRYPTION_TABLE_1[(state_3 >> 16) & 0xFF]
+                ^ DECRYPTION_TABLE_2[(state_2 >> 8) & 0xFF]
+                ^ DECRYPTION_TABLE_3[state_1 & 0xFF]
+                ^ round_key[0]
+            )
+            next_state_1: int = (
+                DECRYPTION_TABLE_0[(state_1 >> 24) & 0xFF]
+                ^ DECRYPTION_TABLE_1[(state_0 >> 16) & 0xFF]
+                ^ DECRYPTION_TABLE_2[(state_3 >> 8) & 0xFF]
+                ^ DECRYPTION_TABLE_3[state_2 & 0xFF]
+                ^ round_key[1]
+            )
+            next_state_2: int = (
+                DECRYPTION_TABLE_0[(state_2 >> 24) & 0xFF]
+                ^ DECRYPTION_TABLE_1[(state_1 >> 16) & 0xFF]
+                ^ DECRYPTION_TABLE_2[(state_0 >> 8) & 0xFF]
+                ^ DECRYPTION_TABLE_3[state_3 & 0xFF]
+                ^ round_key[2]
+            )
+            next_state_3: int = (
+                DECRYPTION_TABLE_0[(state_3 >> 24) & 0xFF]
+                ^ DECRYPTION_TABLE_1[(state_2 >> 16) & 0xFF]
+                ^ DECRYPTION_TABLE_2[(state_1 >> 8) & 0xFF]
+                ^ DECRYPTION_TABLE_3[state_0 & 0xFF]
+                ^ round_key[3]
+            )
+            state_0 = next_state_0
+            state_1 = next_state_1
+            state_2 = next_state_2
+            state_3 = next_state_3
+        final_round_key: RoundKey = round_keys[self.__round_count__]
+        output_0: int = (
+            (INVERSE_SBOX[(state_0 >> 24) & 0xFF] << 24)
+            | (INVERSE_SBOX[(state_3 >> 16) & 0xFF] << 16)
+            | (INVERSE_SBOX[(state_2 >> 8) & 0xFF] << 8)
+            | INVERSE_SBOX[state_1 & 0xFF]
+        ) ^ final_round_key[0]
+        output_1: int = (
+            (INVERSE_SBOX[(state_1 >> 24) & 0xFF] << 24)
+            | (INVERSE_SBOX[(state_0 >> 16) & 0xFF] << 16)
+            | (INVERSE_SBOX[(state_3 >> 8) & 0xFF] << 8)
+            | INVERSE_SBOX[state_2 & 0xFF]
+        ) ^ final_round_key[1]
+        output_2: int = (
+            (INVERSE_SBOX[(state_2 >> 24) & 0xFF] << 24)
+            | (INVERSE_SBOX[(state_1 >> 16) & 0xFF] << 16)
+            | (INVERSE_SBOX[(state_0 >> 8) & 0xFF] << 8)
+            | INVERSE_SBOX[state_3 & 0xFF]
+        ) ^ final_round_key[2]
+        output_3: int = (
+            (INVERSE_SBOX[(state_3 >> 24) & 0xFF] << 24)
+            | (INVERSE_SBOX[(state_2 >> 16) & 0xFF] << 16)
+            | (INVERSE_SBOX[(state_1 >> 8) & 0xFF] << 8)
+            | INVERSE_SBOX[state_0 & 0xFF]
+        ) ^ final_round_key[3]
+        output_integer: int = (
+            (output_0 << 96) | (output_1 << 64) | (output_2 << 32) | output_3
+        )
+        return output_integer.to_bytes(AES_BLOCK_SIZE, byteorder='big')

purepython_aes/aes/core/fast/algorithms/__init__.py

@@ -0,0 +1,5 @@
+from purepython_aes.aes.core.fast.algorithms.aes128 import Aes128
+from purepython_aes.aes.core.fast.algorithms.aes192 import Aes192
+from purepython_aes.aes.core.fast.algorithms.aes256 import Aes256
+
+__all__: list[str] = ['Aes128', 'Aes192', 'Aes256']

purepython_aes/aes/{algorithms → core/fast/algorithms}/aes128.py

@@ -1,12 +1,12 @@
 from dataclasses import dataclass
 from typing import ClassVar
 
-from purepython_aes.aes.core import AesCore
+from purepython_aes.aes.core.fast.aes import FastAesCore
 from purepython_aes.const import AES_128_KEY_SIZE, AES_128_ROUND_COUNT
 
 
 @dataclass(init=False, slots=True)
-class Aes128(AesCore):
+class Aes128(FastAesCore):
     """AES-128 encryption algorithm."""
 
     __key_size__: ClassVar[int] = AES_128_KEY_SIZE

purepython_aes/aes/{algorithms → core/fast/algorithms}/aes192.py

@@ -1,12 +1,12 @@
 from dataclasses import dataclass
 from typing import ClassVar
 
-from purepython_aes.aes.core import AesCore
+from purepython_aes.aes.core.fast.aes import FastAesCore
 from purepython_aes.const import AES_192_KEY_SIZE, AES_192_ROUND_COUNT
 
 
 @dataclass(init=False, slots=True)
-class Aes192(AesCore):
+class Aes192(FastAesCore):
     """AES-192 encryption algorithm."""
 
     __key_size__: ClassVar[int] = AES_192_KEY_SIZE

purepython_aes/aes/{algorithms → core/fast/algorithms}/aes256.py

@@ -1,12 +1,12 @@
 from dataclasses import dataclass
 from typing import ClassVar
 
-from purepython_aes.aes.core import AesCore
+from purepython_aes.aes.core.fast.aes import FastAesCore
 from purepython_aes.const import AES_256_KEY_SIZE, AES_256_ROUND_COUNT
 
 
 @dataclass(init=False, slots=True)
-class Aes256(AesCore):
+class Aes256(FastAesCore):
     """AES-256 encryption algorithm."""
 
     __key_size__: ClassVar[int] = AES_256_KEY_SIZE

purepython_aes/aes/core/fast/expansion.py

@@ -0,0 +1,156 @@
+from struct import unpack
+from typing import Final
+
+from purepython_aes.const import AES_128_ROUND_COUNT, AES_256_ROUND_COUNT, SBOX
+from purepython_aes.types import RoundKey, RoundKeys
+
+AES_192_EXPANSION_COUNT: Final[int] = 8
+
+ROUND_CONSTANT_WORDS: Final[tuple[int, ...]] = (
+    0x00000000,
+    0x01000000,
+    0x02000000,
+    0x04000000,
+    0x08000000,
+    0x10000000,
+    0x20000000,
+    0x40000000,
+    0x80000000,
+    0x1B000000,
+    0x36000000,
+)
+
+
+def expand_aes128_key(key: bytes) -> RoundKeys:
+    """Expand one AES-128 key directly into four-word round keys."""
+
+    initial_words: tuple[int, ...] = unpack('>4I', key)
+    word_0: int = initial_words[0]
+    word_1: int = initial_words[1]
+    word_2: int = initial_words[2]
+    word_3: int = initial_words[3]
+    round_keys: list[RoundKey] = [initial_words]  # type: ignore[list-item]
+    for round_index in range(1, AES_128_ROUND_COUNT + 1):
+        transformed_word: int = (
+            (SBOX[(word_3 >> 16) & 0xFF] << 24)
+            | (SBOX[(word_3 >> 8) & 0xFF] << 16)
+            | (SBOX[word_3 & 0xFF] << 8)
+            | SBOX[(word_3 >> 24) & 0xFF]
+        ) ^ ROUND_CONSTANT_WORDS[round_index]
+        word_0 ^= transformed_word
+        word_1 ^= word_0
+        word_2 ^= word_1
+        word_3 ^= word_2
+        round_keys.append((word_0, word_1, word_2, word_3))
+    return round_keys
+
+
+def expand_aes192_key(key: bytes) -> RoundKeys:
+    """Expand one AES-192 key directly into four-word round keys."""
+
+    (
+        source_word_0,
+        source_word_1,
+        source_word_2,
+        source_word_3,
+        source_word_4,
+        source_word_5,
+    ) = unpack('>6I', key)
+    leftover_word_0: int = source_word_4
+    leftover_word_1: int = source_word_5
+    round_keys: list[RoundKey] = [
+        (source_word_0, source_word_1, source_word_2, source_word_3),
+    ]
+    for round_constant_index in range(1, AES_192_EXPANSION_COUNT):
+        transformed_word: int = (
+            (SBOX[(source_word_5 >> 16) & 0xFF] << 24)
+            | (SBOX[(source_word_5 >> 8) & 0xFF] << 16)
+            | (SBOX[source_word_5 & 0xFF] << 8)
+            | SBOX[(source_word_5 >> 24) & 0xFF]
+        ) ^ ROUND_CONSTANT_WORDS[round_constant_index]
+        next_word_0: int = source_word_0 ^ transformed_word
+        next_word_1: int = source_word_1 ^ next_word_0
+        next_word_2: int = source_word_2 ^ next_word_1
+        next_word_3: int = source_word_3 ^ next_word_2
+        next_word_4: int = source_word_4 ^ next_word_3
+        next_word_5: int = source_word_5 ^ next_word_4
+        if round_constant_index % 2 == 1:
+            round_keys.append(
+                (leftover_word_0, leftover_word_1, next_word_0, next_word_1),
+            )
+            round_keys.append((next_word_2, next_word_3, next_word_4, next_word_5))
+        else:
+            round_keys.append((next_word_0, next_word_1, next_word_2, next_word_3))
+            leftover_word_0 = next_word_4
+            leftover_word_1 = next_word_5
+        source_word_0 = next_word_0
+        source_word_1 = next_word_1
+        source_word_2 = next_word_2
+        source_word_3 = next_word_3
+        source_word_4 = next_word_4
+        source_word_5 = next_word_5
+    final_transformed_word: int = (
+        (SBOX[(source_word_5 >> 16) & 0xFF] << 24)
+        | (SBOX[(source_word_5 >> 8) & 0xFF] << 16)
+        | (SBOX[source_word_5 & 0xFF] << 8)
+        | SBOX[(source_word_5 >> 24) & 0xFF]
+    ) ^ ROUND_CONSTANT_WORDS[AES_192_EXPANSION_COUNT]
+    final_word_0: int = source_word_0 ^ final_transformed_word
+    final_word_1: int = source_word_1 ^ final_word_0
+    final_word_2: int = source_word_2 ^ final_word_1
+    round_keys.append(
+        (final_word_0, final_word_1, final_word_2, source_word_3 ^ final_word_2),
+    )
+    return round_keys
+
+
+def expand_aes256_key(key: bytes) -> RoundKeys:
+    """Expand one AES-256 key directly into four-word round keys."""
+
+    (
+        source_word_0,
+        source_word_1,
+        source_word_2,
+        source_word_3,
+        previous_word_0,
+        previous_word_1,
+        previous_word_2,
+        previous_word_3,
+    ) = unpack('>8I', key)
+    round_keys: list[RoundKey] = [
+        (source_word_0, source_word_1, source_word_2, source_word_3),
+        (previous_word_0, previous_word_1, previous_word_2, previous_word_3),
+    ]
+    for round_index in range(2, AES_256_ROUND_COUNT + 1):
+        transformed_word: int = (
+            (
+                (
+                    (SBOX[(previous_word_3 >> 16) & 0xFF] << 24)
+                    | (SBOX[(previous_word_3 >> 8) & 0xFF] << 16)
+                    | (SBOX[previous_word_3 & 0xFF] << 8)
+                    | SBOX[(previous_word_3 >> 24) & 0xFF]
+                )
+                ^ ROUND_CONSTANT_WORDS[round_index >> 1]
+            )
+            if round_index & 0x01 == 0
+            else (
+                (SBOX[(previous_word_3 >> 24) & 0xFF] << 24)
+                | (SBOX[(previous_word_3 >> 16) & 0xFF] << 16)
+                | (SBOX[(previous_word_3 >> 8) & 0xFF] << 8)
+                | SBOX[previous_word_3 & 0xFF]
+            )
+        )
+        next_word_0: int = source_word_0 ^ transformed_word
+        next_word_1: int = source_word_1 ^ next_word_0
+        next_word_2: int = source_word_2 ^ next_word_1
+        next_word_3: int = source_word_3 ^ next_word_2
+        round_keys.append((next_word_0, next_word_1, next_word_2, next_word_3))
+        source_word_0 = previous_word_0
+        source_word_1 = previous_word_1
+        source_word_2 = previous_word_2
+        source_word_3 = previous_word_3
+        previous_word_0 = next_word_0
+        previous_word_1 = next_word_1
+        previous_word_2 = next_word_2
+        previous_word_3 = next_word_3
+    return round_keys

purepython_aes/aes/core/fast/keys.py

@@ -0,0 +1,49 @@
+from purepython_aes.aes.core.fast.ttables import (
+    DECRYPTION_TABLE_0,
+    DECRYPTION_TABLE_1,
+    DECRYPTION_TABLE_2,
+    DECRYPTION_TABLE_3,
+)
+from purepython_aes.const import SBOX
+from purepython_aes.types import RoundKey, RoundKeys
+
+
+def build_decryption_round_keys(
+    encryption_round_keys: RoundKeys,
+) -> RoundKeys:
+    """Build the equivalent-inverse decryption key schedule."""
+
+    round_count: int = len(encryption_round_keys) - 1
+    decryption_round_keys: list[RoundKey] = [encryption_round_keys[round_count]]
+    for encryption_round_index in range(round_count - 1, 0, -1):
+        word_0, word_1, word_2, word_3 = encryption_round_keys[encryption_round_index]
+        decryption_round_keys.append(
+            (
+                (
+                    DECRYPTION_TABLE_0[SBOX[(word_0 >> 24) & 0xFF]]
+                    ^ DECRYPTION_TABLE_1[SBOX[(word_0 >> 16) & 0xFF]]
+                    ^ DECRYPTION_TABLE_2[SBOX[(word_0 >> 8) & 0xFF]]
+                    ^ DECRYPTION_TABLE_3[SBOX[word_0 & 0xFF]]
+                ),
+                (
+                    DECRYPTION_TABLE_0[SBOX[(word_1 >> 24) & 0xFF]]
+                    ^ DECRYPTION_TABLE_1[SBOX[(word_1 >> 16) & 0xFF]]
+                    ^ DECRYPTION_TABLE_2[SBOX[(word_1 >> 8) & 0xFF]]
+                    ^ DECRYPTION_TABLE_3[SBOX[word_1 & 0xFF]]
+                ),
+                (
+                    DECRYPTION_TABLE_0[SBOX[(word_2 >> 24) & 0xFF]]
+                    ^ DECRYPTION_TABLE_1[SBOX[(word_2 >> 16) & 0xFF]]
+                    ^ DECRYPTION_TABLE_2[SBOX[(word_2 >> 8) & 0xFF]]
+                    ^ DECRYPTION_TABLE_3[SBOX[word_2 & 0xFF]]
+                ),
+                (
+                    DECRYPTION_TABLE_0[SBOX[(word_3 >> 24) & 0xFF]]
+                    ^ DECRYPTION_TABLE_1[SBOX[(word_3 >> 16) & 0xFF]]
+                    ^ DECRYPTION_TABLE_2[SBOX[(word_3 >> 8) & 0xFF]]
+                    ^ DECRYPTION_TABLE_3[SBOX[word_3 & 0xFF]]
+                ),
+            )
+        )
+    decryption_round_keys.append(encryption_round_keys[0])
+    return decryption_round_keys