purepython-aes 0.1.0__py3-none-any.whl

purepython_aes/__init__.py

@@ -0,0 +1,33 @@
+from purepython_aes.aes import (
+    Aes,
+    Aes128,
+    Aes192,
+    Aes256,
+    AesMode,
+    AnsiX923Padding,
+    BasePadding,
+    BlockCipherMode,
+    EcbMode,
+    Iso7816Padding,
+    Iso10126Padding,
+    NoPadding,
+    Pkcs7Padding,
+    ZeroPadding,
+)
+
+__all__: list[str] = [
+    'Aes',
+    'Aes128',
+    'Aes192',
+    'Aes256',
+    'AesMode',
+    'AnsiX923Padding',
+    'BasePadding',
+    'BlockCipherMode',
+    'EcbMode',
+    'Iso7816Padding',
+    'Iso10126Padding',
+    'NoPadding',
+    'Pkcs7Padding',
+    'ZeroPadding',
+]

purepython_aes/aes/__init__.py

@@ -0,0 +1,29 @@
+from purepython_aes.aes.algorithms import Aes128, Aes192, Aes256
+from purepython_aes.aes.interface import Aes
+from purepython_aes.aes.modes import AesMode, BlockCipherMode, EcbMode
+from purepython_aes.aes.padding import (
+    AnsiX923Padding,
+    BasePadding,
+    Iso7816Padding,
+    Iso10126Padding,
+    NoPadding,
+    Pkcs7Padding,
+    ZeroPadding,
+)
+
+__all__: list[str] = [
+    'Aes128',
+    'Aes192',
+    'Aes256',
+    'Aes',
+    'AesMode',
+    'BlockCipherMode',
+    'EcbMode',
+    'AnsiX923Padding',
+    'BasePadding',
+    'Iso7816Padding',
+    'Iso10126Padding',
+    'NoPadding',
+    'Pkcs7Padding',
+    'ZeroPadding',
+]

purepython_aes/aes/algorithms/__init__.py

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

purepython_aes/aes/algorithms/aes128.py

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

purepython_aes/aes/algorithms/aes192.py

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

purepython_aes/aes/algorithms/aes256.py

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

purepython_aes/aes/core/__init__.py

@@ -0,0 +1,3 @@
+from purepython_aes.aes.core.aes import AesCore
+
+__all__: list[str] = ['AesCore']

purepython_aes/aes/core/aes.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+
+from purepython_aes.aes.core.expansion import expand_key
+from purepython_aes.aes.core.state import AesState
+from purepython_aes.aes.interface import Aes
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+@dataclass(init=False, slots=True)
+class AesCore(Aes):
+    """Implement `encrypt_block` and `decrypt_block` methods."""
+
+    __round_keys: tuple[bytes, ...]
+
+    def __init__(self, key: bytes) -> None:
+        if len(key) != self.__key_size__:
+            raise ValueError(
+                f'expected len(key) == {self.__key_size__}, got {len(key)}'
+            )
+        self.__round_keys = expand_key(key, self.__round_count__)
+
+    def encrypt_block(self, plaintext: bytes) -> bytes:
+        if len(plaintext) != AES_BLOCK_SIZE:
+            raise ValueError(
+                f'Expected len(plaintext) == {AES_BLOCK_SIZE}, got {len(plaintext)}'
+            )
+        state: AesState = AesState.from_bytes(plaintext)
+        state.add_round_key(self.__round_keys[0])
+        for round_index in range(1, self.__round_count__):
+            state.subs_bytes()
+            state.shift_rows()
+            state.mix_columns()
+            state.add_round_key(self.__round_keys[round_index])
+        state.subs_bytes()
+        state.shift_rows()
+        state.add_round_key(self.__round_keys[self.__round_count__])
+        return state.to_bytes()
+
+    def decrypt_block(self, ciphertext: bytes) -> bytes:
+        if len(ciphertext) != AES_BLOCK_SIZE:
+            raise ValueError(
+                f'Expected len(ciphertext) == {AES_BLOCK_SIZE}, got {len(ciphertext)}'
+            )
+        state: AesState = AesState.from_bytes(ciphertext)
+        state.add_round_key(self.__round_keys[self.__round_count__])
+        for round_index in range(self.__round_count__ - 1, 0, -1):
+            state.inverse_shift_rows()
+            state.inverse_subs_bytes()
+            state.add_round_key(self.__round_keys[round_index])
+            state.inverse_mix_columns()
+        state.inverse_shift_rows()
+        state.inverse_subs_bytes()
+        state.add_round_key(self.__round_keys[0])
+        return state.to_bytes()

purepython_aes/aes/core/expansion.py

@@ -0,0 +1,44 @@
+from purepython_aes.const import (
+    AES_256_KEY_SIZE,
+    AES_BLOCK_SIZE,
+    AES_WORD_SIZE,
+    ROUND_CONSTANTS,
+    SBOX,
+)
+
+
+def expand_key(key: bytes, round_count: int) -> tuple[bytes, ...]:
+    """Expand an AES key into one 16-byte key for every cipher round."""
+
+    key_word_count: int = len(key) // AES_WORD_SIZE
+    expanded_word_count: int = (AES_BLOCK_SIZE // AES_WORD_SIZE) * (round_count + 1)
+    expanded_key: bytearray = bytearray(expanded_word_count * AES_WORD_SIZE)
+    expanded_key[0 : len(key)] = key
+    for word_index in range(key_word_count, expanded_word_count):
+        previous_offset: int = (word_index - 1) * AES_WORD_SIZE
+        b0: int = expanded_key[previous_offset]
+        b1: int = expanded_key[previous_offset + 1]
+        b2: int = expanded_key[previous_offset + 2]
+        b3: int = expanded_key[previous_offset + 3]
+        position_in_key: int = word_index % key_word_count
+        if position_in_key == 0:
+            round_constant_index: int = word_index // key_word_count
+            b0, b1, b2, b3 = (
+                SBOX[b1] ^ ROUND_CONSTANTS[round_constant_index],
+                SBOX[b2],
+                SBOX[b3],
+                SBOX[b0],
+            )
+        else:
+            if len(key) == AES_256_KEY_SIZE and position_in_key == 4:
+                b0, b1, b2, b3 = SBOX[b0], SBOX[b1], SBOX[b2], SBOX[b3]
+        source_offset: int = (word_index - key_word_count) * AES_WORD_SIZE
+        destination_offset: int = word_index * AES_WORD_SIZE
+        expanded_key[destination_offset] = expanded_key[source_offset] ^ b0
+        expanded_key[destination_offset + 1] = expanded_key[source_offset + 1] ^ b1
+        expanded_key[destination_offset + 2] = expanded_key[source_offset + 2] ^ b2
+        expanded_key[destination_offset + 3] = expanded_key[source_offset + 3] ^ b3
+    return tuple(
+        bytes(expanded_key[offset : offset + AES_BLOCK_SIZE])
+        for offset in range(0, len(expanded_key), AES_BLOCK_SIZE)
+    )

purepython_aes/aes/core/operations.py

@@ -0,0 +1,64 @@
+def galois256_multiply(left: int, right: int) -> int:
+    """Multiply two bytes in the GF(2^8) finite field."""
+
+    result: int = 0
+    for _ in range(8):
+        if right & 1:
+            result ^= left
+        is_high_bit_set: bool = bool(left & 0x80)
+        left = (left << 1) & 0xFF
+        if is_high_bit_set:
+            left ^= 0x1B
+        right >>= 1
+    return result
+
+
+def xor_bytes(*bs: int) -> int:
+    """XOR the supplied bytes."""
+
+    result: int = 0
+    for b in bs:
+        result ^= b
+    return result
+
+
+def mix_column(b0: int, b1: int, b2: int, b3: int) -> tuple[int, int, int, int]:
+    """Apply `MixColumns` to one AES state column."""
+
+    return (
+        xor_bytes(galois256_multiply(0x02, b0), galois256_multiply(0x03, b1), b2, b3),
+        xor_bytes(b0, galois256_multiply(0x02, b1), galois256_multiply(0x03, b2), b3),
+        xor_bytes(b0, b1, galois256_multiply(0x02, b2), galois256_multiply(0x03, b3)),
+        xor_bytes(galois256_multiply(0x03, b0), b1, b2, galois256_multiply(0x02, b3)),
+    )
+
+
+def inverse_mix_column(b0: int, b1: int, b2: int, b3: int) -> tuple[int, int, int, int]:
+    """Apply `InvMixColumns` to one AES state column."""
+
+    return (
+        xor_bytes(
+            galois256_multiply(0x0E, b0),
+            galois256_multiply(0x0B, b1),
+            galois256_multiply(0x0D, b2),
+            galois256_multiply(0x09, b3),
+        ),
+        xor_bytes(
+            galois256_multiply(0x09, b0),
+            galois256_multiply(0x0E, b1),
+            galois256_multiply(0x0B, b2),
+            galois256_multiply(0x0D, b3),
+        ),
+        xor_bytes(
+            galois256_multiply(0x0D, b0),
+            galois256_multiply(0x09, b1),
+            galois256_multiply(0x0E, b2),
+            galois256_multiply(0x0B, b3),
+        ),
+        xor_bytes(
+            galois256_multiply(0x0B, b0),
+            galois256_multiply(0x0D, b1),
+            galois256_multiply(0x09, b2),
+            galois256_multiply(0x0E, b3),
+        ),
+    )

purepython_aes/aes/core/state.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import ClassVar, final
+
+from purepython_aes.aes.core.operations import inverse_mix_column, mix_column
+from purepython_aes.const import AES_BLOCK_SIZE, INVERSE_SBOX, SBOX
+
+
+@dataclass(slots=True)
+@final
+class AesState:
+    __constructor_key: ClassVar[object] = object()
+    __b: list[int]
+
+    @classmethod
+    def from_bytes(cls, block: bytes) -> AesState:
+        """Create `AesState` from a 16-byte block."""
+
+        return cls(cls.__constructor_key, values=list(block))
+
+    def to_bytes(self) -> bytes:
+        """Serialize the AES state in column-major order."""
+
+        return bytes(self.__b)
+
+    def add_round_key(self, key: bytes) -> None:
+        """XOR a round key into this state."""
+
+        if len(key) != AES_BLOCK_SIZE:
+            raise ValueError(f'expected len(key) == {AES_BLOCK_SIZE}, got {len(key)}')
+        for index, key_byte in enumerate(key):
+            self.__b[index] ^= key_byte
+
+    def subs_bytes(self) -> None:
+        """Apply the AES S-box to every state byte."""
+
+        for index in range(AES_BLOCK_SIZE):
+            self.__b[index] = SBOX[self.__b[index]]
+
+    def inverse_subs_bytes(self) -> None:
+        """Apply the inverse AES S-box to every state byte."""
+
+        for index in range(AES_BLOCK_SIZE):
+            self.__b[index] = INVERSE_SBOX[self.__b[index]]
+
+    def shift_rows(self) -> None:
+        """Cyclically shift each AES state row to the left."""
+
+        (
+            self.__b[1],
+            self.__b[5],
+            self.__b[9],
+            self.__b[13],
+            self.__b[2],
+            self.__b[6],
+            self.__b[10],
+            self.__b[14],
+            self.__b[3],
+            self.__b[7],
+            self.__b[11],
+            self.__b[15],
+        ) = (
+            self.__b[5],
+            self.__b[9],
+            self.__b[13],
+            self.__b[1],
+            self.__b[10],
+            self.__b[14],
+            self.__b[2],
+            self.__b[6],
+            self.__b[15],
+            self.__b[3],
+            self.__b[7],
+            self.__b[11],
+        )
+
+    def inverse_shift_rows(self) -> None:
+        """Cyclically shift each AES state row to the right."""
+
+        (
+            self.__b[1],
+            self.__b[5],
+            self.__b[9],
+            self.__b[13],
+            self.__b[2],
+            self.__b[6],
+            self.__b[10],
+            self.__b[14],
+            self.__b[3],
+            self.__b[7],
+            self.__b[11],
+            self.__b[15],
+        ) = (
+            self.__b[13],
+            self.__b[1],
+            self.__b[5],
+            self.__b[9],
+            self.__b[10],
+            self.__b[14],
+            self.__b[2],
+            self.__b[6],
+            self.__b[7],
+            self.__b[11],
+            self.__b[15],
+            self.__b[3],
+        )
+
+    def mix_columns(self) -> None:
+        """Apply the AES `MixColumns` transformation."""
+
+        (
+            self.__b[0],
+            self.__b[1],
+            self.__b[2],
+            self.__b[3],
+        ) = mix_column(
+            self.__b[0],
+            self.__b[1],
+            self.__b[2],
+            self.__b[3],
+        )
+        (
+            self.__b[4],
+            self.__b[5],
+            self.__b[6],
+            self.__b[7],
+        ) = mix_column(
+            self.__b[4],
+            self.__b[5],
+            self.__b[6],
+            self.__b[7],
+        )
+        (
+            self.__b[8],
+            self.__b[9],
+            self.__b[10],
+            self.__b[11],
+        ) = mix_column(
+            self.__b[8],
+            self.__b[9],
+            self.__b[10],
+            self.__b[11],
+        )
+        (
+            self.__b[12],
+            self.__b[13],
+            self.__b[14],
+            self.__b[15],
+        ) = mix_column(
+            self.__b[12],
+            self.__b[13],
+            self.__b[14],
+            self.__b[15],
+        )
+
+    def inverse_mix_columns(self) -> None:
+        """Apply the AES `InvMixColumns` transformation."""
+
+        (
+            self.__b[0],
+            self.__b[1],
+            self.__b[2],
+            self.__b[3],
+        ) = inverse_mix_column(
+            self.__b[0],
+            self.__b[1],
+            self.__b[2],
+            self.__b[3],
+        )
+        (
+            self.__b[4],
+            self.__b[5],
+            self.__b[6],
+            self.__b[7],
+        ) = inverse_mix_column(
+            self.__b[4],
+            self.__b[5],
+            self.__b[6],
+            self.__b[7],
+        )
+        (
+            self.__b[8],
+            self.__b[9],
+            self.__b[10],
+            self.__b[11],
+        ) = inverse_mix_column(
+            self.__b[8],
+            self.__b[9],
+            self.__b[10],
+            self.__b[11],
+        )
+        (
+            self.__b[12],
+            self.__b[13],
+            self.__b[14],
+            self.__b[15],
+        ) = inverse_mix_column(
+            self.__b[12],
+            self.__b[13],
+            self.__b[14],
+            self.__b[15],
+        )
+
+    def __init__(self, __constructor_sentinel: object, /, values: list[int]) -> None:
+        if __constructor_sentinel is not AesState.__constructor_key:
+            raise ValueError(f'{AesState.__name__}() must not be called externally')
+        if len(values) != AES_BLOCK_SIZE:
+            raise ValueError(f'expected {AES_BLOCK_SIZE} values, got {len(values)}')
+        self.__b = values

purepython_aes/aes/interface.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar
+
+
+class Aes(ABC):
+    """Base class for AES-128, AES-192, and AES-256 algorithms."""
+
+    __key_size__: ClassVar[int]
+    """AES key length in bytes."""
+
+    __round_count__: ClassVar[int]
+    """Number of AES rounds."""
+
+    @abstractmethod
+    def encrypt_block(self, plaintext: bytes) -> bytes:
+        """Encrypt one 16-byte AES block."""
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def decrypt_block(self, ciphertext: bytes) -> bytes:
+        """Decrypt one 16-byte AES block."""
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def __init__(self, key: bytes) -> None:
+        raise NotImplementedError

purepython_aes/aes/modes/__init__.py

@@ -0,0 +1,4 @@
+from purepython_aes.aes.modes._base import AesMode
+from purepython_aes.aes.modes.block import BlockCipherMode, EcbMode
+
+__all__: list[str] = ['AesMode', 'BlockCipherMode', 'EcbMode']

purepython_aes/aes/modes/_base.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass
+
+from purepython_aes.aes.interface import Aes
+
+
+@dataclass
+class AesMode(ABC):
+    """Base class for all AES modes of operation."""
+
+    algorithm: Aes
+    """Either AES-128, AES-192, or AES-256."""

purepython_aes/aes/modes/block/__init__.py

@@ -0,0 +1,4 @@
+from purepython_aes.aes.modes.block._base import BlockCipherMode
+from purepython_aes.aes.modes.block.ecb import EcbMode
+
+__all__: list[str] = ['BlockCipherMode', 'EcbMode']

purepython_aes/aes/modes/block/_base.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from purepython_aes.aes.modes._base import AesMode
+from purepython_aes.aes.padding import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+@dataclass(slots=True)
+class BlockCipherMode(AesMode, ABC):
+    padding: BasePadding
+
+    @abstractmethod
+    def encrypt_blocks(self, padded_plaintext: bytes) -> bytes:
+        """Encrypt plaintext containing complete blocks."""
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def decrypt_blocks(self, ciphertext: bytes) -> bytes:
+        """Decrypt ciphertext containing complete blocks."""
+
+        raise NotImplementedError
+
+    def encrypt(self, plaintext: bytes) -> bytes:
+        """Pad and encrypt a byte string."""
+
+        return self.encrypt_blocks(self.padding.pad(plaintext))
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """Decrypt and unpad a byte string."""
+
+        if len(ciphertext) % AES_BLOCK_SIZE != 0:
+            raise ValueError(f'len(ciphertext) % {AES_BLOCK_SIZE} must be 0')
+        return self.padding.unpad(self.decrypt_blocks(ciphertext))

purepython_aes/aes/modes/block/ecb.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import final
+
+from purepython_aes.aes.modes.block._base import BlockCipherMode
+from purepython_aes.aes.modes.operations import split_into_blocks
+
+
+@final
+@dataclass(slots=True)
+class EcbMode(BlockCipherMode):
+    """Electronic Codebook mode of operation."""
+
+    def encrypt_blocks(self, padded_plaintext: bytes) -> bytes:
+        return bytes(0).join(
+            map(self.algorithm.encrypt_block, split_into_blocks(padded_plaintext))
+        )
+
+    def decrypt_blocks(self, ciphertext: bytes) -> bytes:
+        return bytes(0).join(
+            map(self.algorithm.decrypt_block, split_into_blocks(ciphertext))
+        )

purepython_aes/aes/modes/operations.py

@@ -0,0 +1,16 @@
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+def xor(left: bytes, right: bytes) -> bytes:
+    """XOR two equally sized byte strings."""
+
+    return bytes(b0 ^ b1 for b0, b1 in zip(left, right, strict=True))
+
+
+def split_into_blocks(data: bytes) -> tuple[bytes, ...]:
+    """Split data into 16-byte blocks."""
+
+    return tuple(
+        data[block_start : (block_start + AES_BLOCK_SIZE)]
+        for block_start in range(0, len(data), AES_BLOCK_SIZE)
+    )

purepython_aes/aes/padding/__init__.py

@@ -0,0 +1,17 @@
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.aes.padding.ansix923 import AnsiX923Padding
+from purepython_aes.aes.padding.iso7816 import Iso7816Padding
+from purepython_aes.aes.padding.iso10126 import Iso10126Padding
+from purepython_aes.aes.padding.no import NoPadding
+from purepython_aes.aes.padding.pkcs7 import Pkcs7Padding
+from purepython_aes.aes.padding.zero import ZeroPadding
+
+__all__: list[str] = [
+    'AnsiX923Padding',
+    'BasePadding',
+    'Iso10126Padding',
+    'Iso7816Padding',
+    'NoPadding',
+    'Pkcs7Padding',
+    'ZeroPadding',
+]

purepython_aes/aes/padding/_base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class BasePadding(ABC):
+    """Reversible block-padding algorithm."""
+
+    @abstractmethod
+    def pad(self, data: bytes) -> bytes:
+        """Pad data to a multiple of 16 bytes."""
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def unpad(self, data: bytes) -> bytes:
+        """Remove padding from block-aligned data."""
+
+        raise NotImplementedError

purepython_aes/aes/padding/ansix923.py

@@ -0,0 +1,23 @@
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+class AnsiX923Padding(BasePadding):
+    """Implement deterministic ANSI X9.23 block padding."""
+
+    def pad(self, data: bytes) -> bytes:
+        padding_size: int = AES_BLOCK_SIZE - len(data) % AES_BLOCK_SIZE
+        zero_padding: bytes = bytes(padding_size - 1)
+        length_byte: bytes = bytes([padding_size])
+        return data + zero_padding + length_byte
+
+    def unpad(self, data: bytes) -> bytes:
+        if len(data) == 0:
+            raise ValueError('ANSI X9.23 padding expects non-empty data')
+        padding_size: int = data[-1]
+        if padding_size < 1 or padding_size > AES_BLOCK_SIZE:
+            raise ValueError('invalid ANSI X9.23 padding size')
+        zero_padding: bytes = data[(-padding_size):(-1)]
+        if zero_padding != bytes(padding_size - 1):
+            raise ValueError('invalid ANSI X9.23 padding bytes')
+        return data[:(-padding_size)]

purepython_aes/aes/padding/iso10126.py

@@ -0,0 +1,20 @@
+from secrets import token_bytes
+
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+class Iso10126Padding(BasePadding):
+    """Implement legacy ISO 10126 block padding."""
+
+    def pad(self, data: bytes) -> bytes:
+        padding_size: int = AES_BLOCK_SIZE - len(data) % AES_BLOCK_SIZE
+        random_padding: bytes = token_bytes(padding_size - 1)
+        length_byte: bytes = bytes([padding_size])
+        return data + random_padding + length_byte
+
+    def unpad(self, data: bytes) -> bytes:
+        padding_size: int = data[-1]
+        if padding_size < 1 or padding_size > AES_BLOCK_SIZE:
+            raise ValueError('invalid ISO 10126 padding size')
+        return data[:(-padding_size)]

purepython_aes/aes/padding/iso7816.py

@@ -0,0 +1,27 @@
+from typing import Final
+
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+PADDING_START_BYTE: Final[int] = 0x80
+
+
+class Iso7816Padding(BasePadding):
+    """Implement ISO/IEC 7816-4 block padding."""
+
+    def pad(self, data: bytes) -> bytes:
+        padding_size: int = AES_BLOCK_SIZE - len(data) % AES_BLOCK_SIZE
+        zero_padding: bytes = bytes(padding_size - 1)
+        return data + bytes([PADDING_START_BYTE]) + zero_padding
+
+    def unpad(self, data: bytes) -> bytes:
+        padding_start_index: int = len(data) - 1
+        while padding_start_index >= 0 and data[padding_start_index] == 0:
+            padding_start_index -= 1
+        if padding_start_index < 0:
+            raise ValueError('ISO/IEC 7816-4 padding marker not found')
+        if data[padding_start_index] != PADDING_START_BYTE:
+            raise ValueError('invalid ISO/IEC 7816-4 padding marker')
+        if (len(data) - padding_start_index) > AES_BLOCK_SIZE:
+            raise ValueError('invalid ISO/IEC 7816-4 padding size')
+        return data[:padding_start_index]

purepython_aes/aes/padding/no.py

@@ -0,0 +1,16 @@
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+class NoPadding(BasePadding):
+    """Require callers to provide block-aligned data."""
+
+    def pad(self, data: bytes) -> bytes:
+        if len(data) % AES_BLOCK_SIZE != 0:
+            raise ValueError(
+                f'expected len(data) % {AES_BLOCK_SIZE} == 0, got {len(data)}'
+            )
+        return data
+
+    def unpad(self, data: bytes) -> bytes:
+        return data

purepython_aes/aes/padding/pkcs7.py

@@ -0,0 +1,19 @@
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+class Pkcs7Padding(BasePadding):
+    """Implement PKCS#7/CMS block padding."""
+
+    def pad(self, data: bytes) -> bytes:
+        padding_size: int = AES_BLOCK_SIZE - len(data) % AES_BLOCK_SIZE
+        padding: bytes = bytes([padding_size]) * padding_size
+        return data + padding
+
+    def unpad(self, data: bytes) -> bytes:
+        padding_size: int = data[-1]
+        if padding_size < 1 or padding_size > AES_BLOCK_SIZE:
+            raise ValueError('invalid PKCS#7 padding size')
+        if not data.endswith(bytes([padding_size]) * padding_size):
+            raise ValueError('invalid PKCS#7 padding bytes')
+        return data[:(-padding_size)]

purepython_aes/aes/padding/zero.py

@@ -0,0 +1,22 @@
+from purepython_aes.aes.padding._base import BasePadding
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+class ZeroPadding(BasePadding):
+    """Implement ambiguous zero-byte padding."""
+
+    def pad(self, data: bytes) -> bytes:
+        remainder_size: int = len(data) % AES_BLOCK_SIZE
+        if remainder_size == 0:
+            return data
+        return data + bytes(AES_BLOCK_SIZE - remainder_size)
+
+    def unpad(self, data: bytes) -> bytes:
+        if len(data) % AES_BLOCK_SIZE != 0:
+            raise ValueError(
+                f'expected len(data) % {AES_BLOCK_SIZE} == 0, got {len(data)}'
+            )
+        unpadded_size: int = len(data)
+        while unpadded_size > 0 and data[unpadded_size - 1] == 0:
+            unpadded_size -= 1
+        return data[:unpadded_size]

purepython_aes/const/__init__.py

@@ -0,0 +1,26 @@
+from purepython_aes.const.aes import (
+    AES_128_KEY_SIZE,
+    AES_128_ROUND_COUNT,
+    AES_192_KEY_SIZE,
+    AES_192_ROUND_COUNT,
+    AES_256_KEY_SIZE,
+    AES_256_ROUND_COUNT,
+    AES_BLOCK_SIZE,
+    AES_WORD_SIZE,
+    ROUND_CONSTANTS,
+)
+from purepython_aes.const.sbox import INVERSE_SBOX, SBOX
+
+__all__: list[str] = [
+    'AES_128_KEY_SIZE',
+    'AES_128_ROUND_COUNT',
+    'AES_192_KEY_SIZE',
+    'AES_192_ROUND_COUNT',
+    'AES_256_KEY_SIZE',
+    'AES_256_ROUND_COUNT',
+    'AES_BLOCK_SIZE',
+    'AES_WORD_SIZE',
+    'ROUND_CONSTANTS',
+    'INVERSE_SBOX',
+    'SBOX',
+]

purepython_aes/const/aes.py

@@ -0,0 +1,40 @@
+from typing import Final
+
+AES_BLOCK_SIZE: Final[int] = 16
+"""AES block size in bytes."""
+
+AES_WORD_SIZE: Final[int] = 4
+"""Word size in bytes."""
+
+AES_128_KEY_SIZE: Final[int] = 16
+"""Key length in bytes for AES-128."""
+
+AES_128_ROUND_COUNT: Final[int] = 10
+"""Number of rounds for AES-128."""
+
+AES_192_KEY_SIZE: Final[int] = 24
+"""Key length in bytes for AES-192."""
+
+AES_192_ROUND_COUNT: Final[int] = 12
+"""Number of rounds for AES-192."""
+
+AES_256_KEY_SIZE: Final[int] = 32
+"""Key length in bytes for AES-256."""
+
+AES_256_ROUND_COUNT: Final[int] = 14
+"""Number of rounds for AES-256."""
+
+ROUND_CONSTANTS: Final[tuple[int, ...]] = (
+    0x00,
+    0x01,
+    0x02,
+    0x04,
+    0x08,
+    0x10,
+    0x20,
+    0x40,
+    0x80,
+    0x1B,
+    0x36,
+)
+"""Predefined values used during the AES key expansion."""

purepython_aes/const/sbox.py

@@ -0,0 +1,105 @@
+from typing import Final
+
+from purepython_aes.types import IntLookupTable256
+
+SBOX: Final[IntLookupTable256] = (
+    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,  # fmt: skip
+    0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,  # fmt: skip
+    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,  # fmt: skip
+    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,  # fmt: skip
+    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,  # fmt: skip
+    0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,  # fmt: skip
+    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,  # fmt: skip
+    0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,  # fmt: skip
+    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,  # fmt: skip
+    0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,  # fmt: skip
+    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,  # fmt: skip
+    0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,  # fmt: skip
+    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,  # fmt: skip
+    0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,  # fmt: skip
+    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,  # fmt: skip
+    0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,  # fmt: skip
+    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,  # fmt: skip
+    0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,  # fmt: skip
+    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,  # fmt: skip
+    0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,  # fmt: skip
+    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,  # fmt: skip
+    0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,  # fmt: skip
+    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,  # fmt: skip
+    0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,  # fmt: skip
+    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,  # fmt: skip
+    0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,  # fmt: skip
+    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,  # fmt: skip
+    0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,  # fmt: skip
+    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,  # fmt: skip
+    0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,  # fmt: skip
+    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,  # fmt: skip
+    0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,  # fmt: skip
+)
+"""
+Forward AES substitution box (S-box).
+
+This table implements the nonlinear substitution used by the AES `SubBytes`
+round operation and the `SubWord` operation during key expansion.
+
+Internally, the AES S-box is constructed by:
+
+1. Computing the multiplicative inverse of the input byte in the finite field
+   GF(2^8), treating `0x00` as a special case.
+2. Applying the affine transformation defined by the AES specification.
+
+The resulting mapping is a permutation of all 256 possible byte values, meaning
+every byte appears exactly once as an output. Its inverse permutation is stored
+in `INVERSE_SBOX`.
+"""
+
+
+INVERSE_SBOX: Final[IntLookupTable256] = (
+    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,  # fmt: skip
+    0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,  # fmt: skip
+    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,  # fmt: skip
+    0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,  # fmt: skip
+    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,  # fmt: skip
+    0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,  # fmt: skip
+    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,  # fmt: skip
+    0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,  # fmt: skip
+    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,  # fmt: skip
+    0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,  # fmt: skip
+    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,  # fmt: skip
+    0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,  # fmt: skip
+    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,  # fmt: skip
+    0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,  # fmt: skip
+    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,  # fmt: skip
+    0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,  # fmt: skip
+    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,  # fmt: skip
+    0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,  # fmt: skip
+    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,  # fmt: skip
+    0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,  # fmt: skip
+    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,  # fmt: skip
+    0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,  # fmt: skip
+    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,  # fmt: skip
+    0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,  # fmt: skip
+    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,  # fmt: skip
+    0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,  # fmt: skip
+    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,  # fmt: skip
+    0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,  # fmt: skip
+    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,  # fmt: skip
+    0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,  # fmt: skip
+    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,  # fmt: skip
+    0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,  # fmt: skip
+)
+"""
+Inverse AES substitution box (Inverse S-box).
+
+This table implements the inverse substitution transformation used by the
+AES `InvSubBytes` round operation during decryption.
+
+`INVERSE_SBOX` is the exact inverse permutation of `SBOX`. For every
+possible byte value `n`:
+
+    INVERSE_SBOX[SBOX[n]] == n
+    SBOX[INVERSE_SBOX[n]] == n
+
+Like the forward S-box, this table contains exactly 256 entries and represents
+a permutation of every possible byte value.
+"""

purepython_aes/types/__init__.py

@@ -0,0 +1,5 @@
+# noqa: A005
+
+from purepython_aes.types.finite import IntLookupTable256
+
+__all__: list[str] = ['IntLookupTable256']

purepython_aes/types/finite/__init__.py

@@ -0,0 +1,3 @@
+from purepython_aes.types.finite.aliases import IntLookupTable256
+
+__all__: list[str] = ['IntLookupTable256']

purepython_aes/types/finite/aliases.py

@@ -0,0 +1,37 @@
+from typing import TypeAlias
+
+IntLookupTable256: TypeAlias = tuple[
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+    int, int, int, int, int, int, int, int,  # fmt: skip
+]
+"""Type alias describing a fixed-length tuple containing exactly 256 integer values."""

purepython_aes-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: purepython-aes
+Version: 0.1.0
+Summary: Pure-Python implementation of AES encryption algorithm.
+Author-email: Emelianov Artem <penguin5726@proton.me>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Pukhosos/purepython-aes
+Project-URL: Repository, https://github.com/Pukhosos/purepython-aes
+Project-URL: Issues, https://github.com/Pukhosos/purepython-aes/issues
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security :: Cryptography
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: flake8-bugbear; extra == "dev"
+Requires-Dist: flake8-builtins; extra == "dev"
+Requires-Dist: flake8-comprehensions; extra == "dev"
+Requires-Dist: flake8-fixme; extra == "dev"
+Requires-Dist: flake8-pyproject; extra == "dev"
+Requires-Dist: flake8-quotes; extra == "dev"
+Requires-Dist: flake8-simplify; extra == "dev"
+Requires-Dist: pep8-naming; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=9.0; extra == "test"
+Requires-Dist: pytest-env; extra == "test"
+Requires-Dist: pytest-randomly; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: hypothesis; extra == "test"
+Provides-Extra: fuzz
+Requires-Dist: hypofuzz; extra == "fuzz"
+Provides-Extra: build
+Requires-Dist: build; extra == "build"
+Requires-Dist: twine; extra == "build"
+
+# purepython-aes
+
+## License
+
+`purepython-aes` is a free, open-source software distributed under the [MIT License](LICENSE.txt)

purepython_aes-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+purepython_aes/__init__.py,sha256=REYvoTsB3HL3wD6AR0T8NJZKfD51VX8aH4bcxUC_xp0,531
+purepython_aes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+purepython_aes/aes/__init__.py,sha256=lv_RO-dBRo9IPFtRY0csjkycsyUH7DXW41SZMCaHLV0,628
+purepython_aes/aes/interface.py,sha256=OzNhRtS2xu5pOXFF7sAiHkNdSuMHLwaYSRm-0Ldz0Sg,699
+purepython_aes/aes/algorithms/__init__.py,sha256=L21rL4gaCdoRmV2wyFJyuzFpBI4jXry1uQSi0b0eqds,221
+purepython_aes/aes/algorithms/aes128.py,sha256=rmv-LJ2dcHIYmTfSTg2xAn-M94ank89ULYZKgpFuoVs,387
+purepython_aes/aes/algorithms/aes192.py,sha256=Acjoel_K3vHzEuD4gv2idPJdiXWrSMyfHC_6SW_lOG4,387
+purepython_aes/aes/algorithms/aes256.py,sha256=eeTW6Anl_F0b1RhFx__GZ5Uddl6d_5T2endcbBHmlBw,387
+purepython_aes/aes/core/__init__.py,sha256=rCKHARdFJ8Q4e1QTTWSkzejbfIwcuHdo2lpC5QpJpzA,82
+purepython_aes/aes/core/aes.py,sha256=xU1K9cNIek7moVeu-ZDrv3TIQOHTb6SoJsswXX10V3c,2141
+purepython_aes/aes/core/expansion.py,sha256=JmNxuHIV3EzFFDFX2RAnbwKECimovBLrL4O3mfE8UOA,1979
+purepython_aes/aes/core/operations.py,sha256=4jGJZ3xwRb3z0BLMorF-QCbTdPKAWUVPEvxkUe-5JjU,1989
+purepython_aes/aes/core/state.py,sha256=j79LDXRabfGAkF2qx8iVKgrSDfEUfFnfKU1XQ-5OidM,5488
+purepython_aes/aes/modes/__init__.py,sha256=fwEckEnJ9PGVSWNAXIG9M0KVhSSM7onKeFHwFkcvQ18,183
+purepython_aes/aes/modes/_base.py,sha256=L81chTROXrIgNL5GJ1AT9icmixbTT7okfcZ0QyeVaiA,289
+purepython_aes/aes/modes/operations.py,sha256=VYnoYB0Bb9bfwnApE3tL-2koLK6dDRotit1Pc1cAfhA,460
+purepython_aes/aes/modes/block/__init__.py,sha256=TZuLX83Kkf1jhyJztqTIsUsULN8Q56fuUksm6eep_E8,173
+purepython_aes/aes/modes/block/_base.py,sha256=TH6oekojIZluInw8ZLMFpPNuolYQOcxI0QOgsGIWekc,1119
+purepython_aes/aes/modes/block/ecb.py,sha256=lL1gyIjq768Xe_V6QdWeG9xn5w2G-uTQqOX_cs9MYH4,668
+purepython_aes/aes/padding/__init__.py,sha256=X_JqBtvuLm1edPoE7B-DnENBHIgwpemhB7d37ZRDQEY,582
+purepython_aes/aes/padding/_base.py,sha256=dnuNv8OVOBDxAXSUGEeJu5uy9bSFkY2AKkzrK0If8so,408
+purepython_aes/aes/padding/ansix923.py,sha256=xWLzlk85vQn1pPZm5x0wJy3aK46bvtK1YHNCLRC0yfA,991
+purepython_aes/aes/padding/iso10126.py,sha256=OHIywjjWAXFwWcmNASnkGNZNY6xKUm5Y7A5rqETZ0MQ,750
+purepython_aes/aes/padding/iso7816.py,sha256=I_ssvJVOnwriArkPlQlhn9fuRjNwEVR-sdGhJbD9Lyw,1106
+purepython_aes/aes/padding/no.py,sha256=H73EYvOegwxqfpQ_7Xqb02Y4Zo2M3eL_-GlZLE98H4A,487
+purepython_aes/aes/padding/pkcs7.py,sha256=XJk7K48bonCX7E9_UENF_Vva_cgXmhPxyH9BOnmbAjU,762
+purepython_aes/aes/padding/zero.py,sha256=bFStfbwhquROKcZKzlWbK01De6kZb11UEP7Bj_HNZdM,787
+purepython_aes/const/__init__.py,sha256=z5r00PDY5EvyWJGgTd1J4_mPTYwCzVbxWfQzvR3ZWRE,576
+purepython_aes/const/aes.py,sha256=Vhk45-Tf3RXnoQ9qSNz6KLvQ5gkkOHOLakWQdegQMPA,806
+purepython_aes/const/sbox.py,sha256=RaSYzs2mjUKZjv0fbEwCD3YLLkoz7emJhjEbU-RH09o,5399
+purepython_aes/types/__init__.py,sha256=QiuMSx2DaC2lCXoK16RGeEBrfoX4d3jozkx4QV0kFjc,116
+purepython_aes/types/finite/__init__.py,sha256=2cYu5Zxdp5NKAwYbV-MD2qamSaJxfqRYp0jOt657-YY,110
+purepython_aes/types/finite/aliases.py,sha256=gKO8ETbMhV5FX6l3enF8wt246FpMPohreTZ3BPDThBM,1982
+purepython_aes-0.1.0.dist-info/METADATA,sha256=EtqJAtIEueHuNorxAbaDbPVE6OV9B1bW4ho8pqVgMXs,2112
+purepython_aes-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+purepython_aes-0.1.0.dist-info/scm_file_list.json,sha256=kfQDdACHcGFPsm09ncINh7o1yMzqwz4yaugdCuK7RFk,3068
+purepython_aes-0.1.0.dist-info/scm_version.json,sha256=M8rto4eBaxUN90pVC3CaDYQm6j_D1U-WaRS4PcJkfOM,160
+purepython_aes-0.1.0.dist-info/top_level.txt,sha256=IiTUB8OvHhwNXxf6OXKCfUADF7HcQdCRUMfPJC6TS5k,15
+purepython_aes-0.1.0.dist-info/RECORD,,

purepython_aes-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

purepython_aes-0.1.0.dist-info/scm_file_list.json

@@ -0,0 +1,76 @@
+{
+  "files": [
+    ".pre-commit-config.yaml",
+    "README.md",
+    "pyproject.toml",
+    ".gitignore",
+    "LISENCE.txt",
+    "scripts/check-test-marks.sh",
+    "src/purepython_aes/py.typed",
+    "src/purepython_aes/__init__.py",
+    "src/purepython_aes/types/__init__.py",
+    "src/purepython_aes/types/finite/aliases.py",
+    "src/purepython_aes/types/finite/__init__.py",
+    "src/purepython_aes/const/__init__.py",
+    "src/purepython_aes/const/aes.py",
+    "src/purepython_aes/const/sbox.py",
+    "src/purepython_aes/aes/__init__.py",
+    "src/purepython_aes/aes/interface.py",
+    "src/purepython_aes/aes/core/__init__.py",
+    "src/purepython_aes/aes/core/aes.py",
+    "src/purepython_aes/aes/core/state.py",
+    "src/purepython_aes/aes/core/expansion.py",
+    "src/purepython_aes/aes/core/operations.py",
+    "src/purepython_aes/aes/padding/_base.py",
+    "src/purepython_aes/aes/padding/no.py",
+    "src/purepython_aes/aes/padding/pkcs7.py",
+    "src/purepython_aes/aes/padding/__init__.py",
+    "src/purepython_aes/aes/padding/zero.py",
+    "src/purepython_aes/aes/padding/iso10126.py",
+    "src/purepython_aes/aes/padding/iso7816.py",
+    "src/purepython_aes/aes/padding/ansix923.py",
+    "src/purepython_aes/aes/modes/_base.py",
+    "src/purepython_aes/aes/modes/__init__.py",
+    "src/purepython_aes/aes/modes/operations.py",
+    "src/purepython_aes/aes/modes/block/_base.py",
+    "src/purepython_aes/aes/modes/block/__init__.py",
+    "src/purepython_aes/aes/modes/block/ecb.py",
+    "src/purepython_aes/aes/algorithms/aes128.py",
+    "src/purepython_aes/aes/algorithms/__init__.py",
+    "src/purepython_aes/aes/algorithms/aes256.py",
+    "src/purepython_aes/aes/algorithms/aes192.py",
+    "tests/__init__.py",
+    "tests/test_initial.py",
+    "tests/unit/__init__.py",
+    "tests/unit/const/__init__.py",
+    "tests/unit/const/test_sbox.py",
+    "tests/unit/aes/__init__.py",
+    "tests/unit/aes/strategies.py",
+    "tests/unit/aes/core/test_operations.py",
+    "tests/unit/aes/core/__init__.py",
+    "tests/unit/aes/core/strategies.py",
+    "tests/unit/aes/core/test_state.py",
+    "tests/unit/aes/core/test_aes.py",
+    "tests/unit/aes/core/test_expansion.py",
+    "tests/unit/aes/padding/__init__.py",
+    "tests/unit/aes/padding/strategies.py",
+    "tests/unit/aes/padding/test_pkcs7.py",
+    "tests/unit/aes/padding/test_ansix923.py",
+    "tests/unit/aes/padding/test_iso10126.py",
+    "tests/unit/aes/padding/test_zero.py",
+    "tests/unit/aes/padding/conftest.py",
+    "tests/unit/aes/padding/test_iso7816.py",
+    "tests/unit/aes/padding/test_no.py",
+    "tests/unit/aes/modes/test_operations.py",
+    "tests/unit/aes/modes/__init__.py",
+    "tests/unit/aes/modes/block/__init__.py",
+    "tests/unit/aes/modes/block/test_ecb.py",
+    "tests/unit/aes/algorithms/test_aes256.py",
+    "tests/unit/aes/algorithms/__init__.py",
+    "tests/unit/aes/algorithms/test_aes128.py",
+    "tests/unit/aes/algorithms/test_aes192.py",
+    "tests/unit/aes/algorithms/conftest.py",
+    ".github/workflows/release.yml",
+    ".github/workflows/pre-commit.yml"
+  ]
+}

purepython_aes-0.1.0.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.0",
+  "distance": 0,
+  "node": "g18cff6ba62f4743b0f5af672a133edba13f2b244",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-13"
+}

purepython_aes-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+purepython_aes