purepython-aes 0.3.1__tar.gz → 0.5.0__tar.gz

{purepython_aes-0.3.1/src/purepython_aes.egg-info → purepython_aes-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: purepython-aes
-Version: 0.3.1
+Version: 0.5.0
 Summary: Pure-Python implementation of AES encryption algorithm.
 Author-email: Emelianov Artem <penguin5726@proton.me>
 License-Expression: MIT

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes/__init__.py

@@ -8,15 +8,19 @@ from purepython_aes.aes import (
     BasePadding,
     BlockCipherMode,
     CbcMode,
+    CfbMode,
+    CipherMode,
     EcbMode,
     Iso7816Padding,
     Iso10126Padding,
     NoPadding,
+    OfbMode,
     PcbcMode,
     Pkcs7Padding,
     ReferenceAes128,
     ReferenceAes192,
     ReferenceAes256,
+    StreamCipherMode,
     ZeroPadding,
 )
 
@@ -30,14 +34,18 @@ __all__: list[str] = [
     'BasePadding',
     'BlockCipherMode',
     'CbcMode',
+    'CfbMode',
+    'CipherMode',
     'EcbMode',
     'Iso7816Padding',
     'Iso10126Padding',
     'NoPadding',
+    'OfbMode',
     'PcbcMode',
     'Pkcs7Padding',
     'ReferenceAes128',
     'ReferenceAes192',
     'ReferenceAes256',
+    'StreamCipherMode',
     'ZeroPadding',
 ]

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes/aes/__init__.py

@@ -11,8 +11,12 @@ from purepython_aes.aes.modes import (
     AesMode,
     BlockCipherMode,
     CbcMode,
+    CfbMode,
+    CipherMode,
     EcbMode,
+    OfbMode,
     PcbcMode,
+    StreamCipherMode,
 )
 from purepython_aes.aes.padding import (
     AnsiX923Padding,
@@ -35,8 +39,12 @@ __all__: list[str] = [
     'AesMode',
     'BlockCipherMode',
     'CbcMode',
+    'CfbMode',
+    'CipherMode',
     'EcbMode',
+    'OfbMode',
     'PcbcMode',
+    'StreamCipherMode',
     'AnsiX923Padding',
     'BasePadding',
     'Iso7816Padding',

purepython_aes-0.5.0/src/purepython_aes/aes/modes/__init__.py

@@ -0,0 +1,15 @@
+from purepython_aes.aes.modes._base import AesMode, CipherMode
+from purepython_aes.aes.modes.block import BlockCipherMode, CbcMode, EcbMode, PcbcMode
+from purepython_aes.aes.modes.stream import CfbMode, OfbMode, StreamCipherMode
+
+__all__: list[str] = [
+    'AesMode',
+    'CipherMode',
+    'BlockCipherMode',
+    'CbcMode',
+    'EcbMode',
+    'PcbcMode',
+    'CfbMode',
+    'OfbMode',
+    'StreamCipherMode',
+]

purepython_aes-0.5.0/src/purepython_aes/aes/modes/_base.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from purepython_aes.aes.core.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."""
+
+
+@dataclass(slots=True)
+class CipherMode(AesMode):
+    """Base class for all AES Cipher modes of operation."""
+
+    @abstractmethod
+    def encrypt(self, plaintext: bytes) -> bytes:
+        """Encrypt a byte string."""
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """Decrypt a byte string."""
+
+        raise NotImplementedError

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes/aes/modes/block/_base.py

@@ -1,13 +1,13 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
-from purepython_aes.aes.modes._base import AesMode
+from purepython_aes.aes.modes._base import CipherMode
 from purepython_aes.aes.padding import BasePadding
 from purepython_aes.const import AES_BLOCK_SIZE
 
 
 @dataclass(slots=True)
-class BlockCipherMode(AesMode, ABC):
+class BlockCipherMode(CipherMode, ABC):
     padding: BasePadding
 
     @abstractmethod
@@ -23,13 +23,9 @@ class BlockCipherMode(AesMode, ABC):
         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-0.5.0/src/purepython_aes/aes/modes/stream/__init__.py

@@ -0,0 +1,5 @@
+from purepython_aes.aes.modes.stream._base import StreamCipherMode
+from purepython_aes.aes.modes.stream.cfb import CfbMode
+from purepython_aes.aes.modes.stream.ofb import OfbMode
+
+__all__: list[str] = ['StreamCipherMode', 'CfbMode', 'OfbMode']

purepython_aes-0.5.0/src/purepython_aes/aes/modes/stream/_base.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from secrets import token_bytes
+
+from purepython_aes.aes.modes._base import CipherMode
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+@dataclass(slots=True)
+class StreamCipherMode(CipherMode, ABC):
+    def encrypt(self, plaintext: bytes) -> bytes:
+        iv: bytes = token_bytes(AES_BLOCK_SIZE)
+        ciphertext: bytes = self.__encrypt_stream__(iv, plaintext)
+        return iv + ciphertext
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        return self.__decrypt_stream__(
+            initialization_value=ciphertext[:AES_BLOCK_SIZE],
+            ciphertext=ciphertext[AES_BLOCK_SIZE:],
+        )
+
+    @abstractmethod
+    def __encrypt_stream__(
+        self,
+        initialization_value: bytes,
+        plaintext: bytes,
+    ) -> bytes:
+        """Transform plaintext into ciphertext."""
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def __decrypt_stream__(
+        self,
+        initialization_value: bytes,
+        ciphertext: bytes,
+    ) -> bytes:
+        """Transform ciphertext into plaintext."""
+
+        raise NotImplementedError

purepython_aes-0.5.0/src/purepython_aes/aes/modes/stream/cfb.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from typing import final
+
+from purepython_aes.aes.modes.stream._base import StreamCipherMode
+from purepython_aes.const import AES_BLOCK_SIZE
+from purepython_aes.types import CfbSegmentSize
+
+
+@final
+@dataclass(slots=True)
+class CfbMode(StreamCipherMode):
+    """Cipher FeedBack mode of operation."""
+
+    segment_size: CfbSegmentSize = AES_BLOCK_SIZE  # type: ignore[assignment]
+    """Feedback segment size in bytes."""
+
+    def __post_init__(self) -> None:
+        if self.segment_size < 1 or self.segment_size > AES_BLOCK_SIZE:
+            raise ValueError(
+                ', '.join(
+                    (
+                        f'expected 1 <= segment_size <= {AES_BLOCK_SIZE}',
+                        f'got {self.segment_size}',
+                    )
+                )
+            )
+
+    def __encrypt_stream__(
+        self,
+        initialization_value: bytes,
+        plaintext: bytes,
+    ) -> bytes:
+        feedback_register: bytes = initialization_value
+        plaintext_size: int = len(plaintext)
+        ciphertext: bytearray = bytearray(plaintext_size)
+        for segment_start in range(0, plaintext_size, self.segment_size):
+            segment_end: int = min(segment_start + self.segment_size, plaintext_size)
+            segment_length: int = segment_end - segment_start
+            encrypted_register: bytes = self.algorithm.encrypt_block(feedback_register)
+            for segment_index in range(segment_length):
+                ciphertext[segment_start + segment_index] = (
+                    plaintext[segment_start + segment_index]
+                    ^ encrypted_register[segment_index]
+                )
+            ciphertext_segment: bytes = bytes(ciphertext[segment_start:segment_end])
+            feedback_register = (
+                feedback_register[segment_length:] + bytes(ciphertext_segment)
+                if segment_length != AES_BLOCK_SIZE
+                else ciphertext_segment
+            )
+        return bytes(ciphertext)
+
+    def __decrypt_stream__(
+        self,
+        initialization_value: bytes,
+        ciphertext: bytes,
+    ) -> bytes:
+        feedback_register: bytes = initialization_value
+        ciphertext_size: int = len(ciphertext)
+        plaintext: bytearray = bytearray(ciphertext_size)
+        for segment_start in range(0, ciphertext_size, self.segment_size):
+            segment_end: int = min(segment_start + self.segment_size, ciphertext_size)
+            segment_length: int = segment_end - segment_start
+            encrypted_register: bytes = self.algorithm.encrypt_block(feedback_register)
+            for segment_index in range(segment_length):
+                plaintext[segment_start + segment_index] = (
+                    ciphertext[segment_start + segment_index]
+                    ^ encrypted_register[segment_index]
+                )
+            ciphertext_segment: bytes = ciphertext[segment_start:segment_end]
+            feedback_register = (
+                feedback_register[segment_length:] + ciphertext_segment
+                if segment_length != AES_BLOCK_SIZE
+                else ciphertext_segment
+            )
+        return bytes(plaintext)

purepython_aes-0.5.0/src/purepython_aes/aes/modes/stream/ofb.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import final
+
+from purepython_aes.aes.modes.stream._base import StreamCipherMode
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+@final
+@dataclass(slots=True)
+class OfbMode(StreamCipherMode):
+    """Output FeedBack mode of operation."""
+
+    def __encrypt_stream__(
+        self,
+        initialization_value: bytes,
+        plaintext: bytes,
+    ) -> bytes:
+        return self.__transform_stream__(initialization_value, plaintext)
+
+    def __decrypt_stream__(
+        self,
+        initialization_value: bytes,
+        ciphertext: bytes,
+    ) -> bytes:
+        return self.__transform_stream__(initialization_value, ciphertext)
+
+    def __transform_stream__(
+        self,
+        initialization_value: bytes,
+        data: bytes,
+    ) -> bytes:
+        """XOR data with the OFB keystream."""
+
+        feedback_register: bytes = initialization_value
+        data_size: int = len(data)
+        transformed_data: bytearray = bytearray(data_size)
+        for block_start in range(0, data_size, AES_BLOCK_SIZE):
+            block_end: int = min(block_start + AES_BLOCK_SIZE, data_size)
+            block_length: int = block_end - block_start
+            feedback_register = self.algorithm.encrypt_block(feedback_register)
+            for block_index in range(block_length):
+                transformed_data[block_start + block_index] = (
+                    data[block_start + block_index] ^ feedback_register[block_index]
+                )
+        return bytes(transformed_data)

purepython_aes-0.5.0/src/purepython_aes/types/__init__.py

@@ -0,0 +1,9 @@
+# noqa: A005
+from purepython_aes.types.finite import (
+    CfbSegmentSize,
+    IntLookupTable256,
+    RoundKey,
+    RoundKeys,
+)
+
+__all__: list[str] = ['CfbSegmentSize', 'IntLookupTable256', 'RoundKey', 'RoundKeys']

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes/types/finite/__init__.py

@@ -1,3 +1,4 @@
 from purepython_aes.types.finite.aliases import IntLookupTable256, RoundKey, RoundKeys
+from purepython_aes.types.finite.literals import CfbSegmentSize
 
-__all__: list[str] = ['IntLookupTable256', 'RoundKey', 'RoundKeys']
+__all__: list[str] = ['IntLookupTable256', 'RoundKey', 'RoundKeys', 'CfbSegmentSize']

purepython_aes-0.5.0/src/purepython_aes/types/finite/literals.py

@@ -0,0 +1,6 @@
+from typing import Literal, TypeAlias
+
+CfbSegmentSize: TypeAlias = Literal[
+    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
+]
+"""Allowed value for `segment_size` field of CfbMode."""

{purepython_aes-0.3.1 → purepython_aes-0.5.0/src/purepython_aes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: purepython-aes
-Version: 0.3.1
+Version: 0.5.0
 Summary: Pure-Python implementation of AES encryption algorithm.
 Author-email: Emelianov Artem <penguin5726@proton.me>
 License-Expression: MIT

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes.egg-info/SOURCES.txt

@@ -44,6 +44,10 @@ src/purepython_aes/aes/modes/block/_base.py
 src/purepython_aes/aes/modes/block/cbc.py
 src/purepython_aes/aes/modes/block/ecb.py
 src/purepython_aes/aes/modes/block/pcbc.py
+src/purepython_aes/aes/modes/stream/__init__.py
+src/purepython_aes/aes/modes/stream/_base.py
+src/purepython_aes/aes/modes/stream/cfb.py
+src/purepython_aes/aes/modes/stream/ofb.py
 src/purepython_aes/aes/padding/__init__.py
 src/purepython_aes/aes/padding/_base.py
 src/purepython_aes/aes/padding/ansix923.py
@@ -58,6 +62,7 @@ src/purepython_aes/const/sbox.py
 src/purepython_aes/types/__init__.py
 src/purepython_aes/types/finite/__init__.py
 src/purepython_aes/types/finite/aliases.py
+src/purepython_aes/types/finite/literals.py
 tests/__init__.py
 tests/test_initial.py
 tests/unit/__init__.py
@@ -92,6 +97,9 @@ tests/unit/aes/modes/block/__init__.py
 tests/unit/aes/modes/block/test_cbc.py
 tests/unit/aes/modes/block/test_ecb.py
 tests/unit/aes/modes/block/test_pcbc.py
+tests/unit/aes/modes/stream/__init__.py
+tests/unit/aes/modes/stream/test_cfb.py
+tests/unit/aes/modes/stream/test_ofb.py
 tests/unit/aes/padding/__init__.py
 tests/unit/aes/padding/conftest.py
 tests/unit/aes/padding/strategies.py

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes.egg-info/scm_file_list.json

@@ -11,6 +11,7 @@
     "src/purepython_aes/types/__init__.py",
     "src/purepython_aes/types/finite/aliases.py",
     "src/purepython_aes/types/finite/__init__.py",
+    "src/purepython_aes/types/finite/literals.py",
     "src/purepython_aes/const/__init__.py",
     "src/purepython_aes/const/aes.py",
     "src/purepython_aes/const/sbox.py",
@@ -46,6 +47,10 @@
     "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/stream/_base.py",
+    "src/purepython_aes/aes/modes/stream/cfb.py",
+    "src/purepython_aes/aes/modes/stream/__init__.py",
+    "src/purepython_aes/aes/modes/stream/ofb.py",
     "src/purepython_aes/aes/modes/block/_base.py",
     "src/purepython_aes/aes/modes/block/__init__.py",
     "src/purepython_aes/aes/modes/block/cbc.py",
@@ -92,6 +97,9 @@
     "tests/unit/aes/padding/test_no.py",
     "tests/unit/aes/modes/test_operations.py",
     "tests/unit/aes/modes/__init__.py",
+    "tests/unit/aes/modes/stream/test_cfb.py",
+    "tests/unit/aes/modes/stream/__init__.py",
+    "tests/unit/aes/modes/stream/test_ofb.py",
     "tests/unit/aes/modes/block/__init__.py",
     "tests/unit/aes/modes/block/test_pcbc.py",
     "tests/unit/aes/modes/block/test_ecb.py",

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/src/purepython_aes.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.3.1",
+  "tag": "0.5.0",
   "distance": 0,
-  "node": "g35d4036fe4f9868f92a439cff80b412c016aa475",
+  "node": "g393fbd90ca44525a385004d5d26622a21b782356",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-14"

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/core/fast/test_keys.py

@@ -19,11 +19,11 @@ from tests.unit.aes.strategies import aes128key, aes192key, aes256key
 @mark.quick
 @mark.parametrize(
     'round_count',
-    (
+    [
         AES_128_ROUND_COUNT,
         AES_192_ROUND_COUNT,
         AES_256_ROUND_COUNT,
-    ),
+    ],
 )
 def test_preserves_round_key_count(round_count: int) -> None:
     encryption_round_keys: RoundKeys = [

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/core/reference/test_expansion.py

@@ -13,15 +13,15 @@ from purepython_aes.const import (
     AES_BLOCK_SIZE,
 )
 
-AES_CONFIGURATIONS: Final[tuple[tuple[int, int], tuple[int, int], tuple[int, int]]] = (
+AES_CONFIGURATIONS: Final[list[tuple[int, int]]] = [
     (AES_128_KEY_SIZE, AES_128_ROUND_COUNT),
     (AES_192_KEY_SIZE, AES_192_ROUND_COUNT),
     (AES_256_KEY_SIZE, AES_256_ROUND_COUNT),
-)
+]
 
 
 @mark.quick
-@mark.parametrize(('key_size', 'round_count'), AES_CONFIGURATIONS)
+@mark.parametrize(['key_size', 'round_count'], AES_CONFIGURATIONS)
 def test_expand_key_returns_corrent_number_of_keys(
     key_size: int,
     round_count: int,
@@ -31,14 +31,14 @@ def test_expand_key_returns_corrent_number_of_keys(
 
 
 @mark.quick
-@mark.parametrize(('key_size', 'round_count'), AES_CONFIGURATIONS)
+@mark.parametrize(['key_size', 'round_count'], AES_CONFIGURATIONS)
 def test_expand_key_returns_16_byte_round_keys(key_size: int, round_count: int) -> None:
     round_keys: tuple[bytes, ...] = expand_key(bytes(key_size), round_count)
     assert all(len(round_key) == AES_BLOCK_SIZE for round_key in round_keys)
 
 
 @mark.quick
-@mark.parametrize(('key_size', 'round_count'), AES_CONFIGURATIONS)
+@mark.parametrize(['key_size', 'round_count'], AES_CONFIGURATIONS)
 def test_expanded_schedule_starts_with_original_key(
     key_size: int,
     round_count: int,

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/core/reference/test_operations.py

@@ -29,8 +29,8 @@ def xor_columns(
 
 @mark.quick
 @mark.parametrize(
-    ('left', 'right', 'expected'),
-    (
+    ['left', 'right', 'expected'],
+    [
         (0x00, 0x00, 0x00),
         (0x00, 0x01, 0x00),
         (0x01, 0x00, 0x00),
@@ -45,7 +45,7 @@ def xor_columns(
         (0xFF, 0xFF, 0x13),
         (0x80, 0x02, 0x1B),
         (0x80, 0x80, 0x9A),
-    ),
+    ],
 )
 def test_galois256_multiply_known_values(left: int, right: int, expected: int) -> None:
     assert galois256_multiply(left, right) == expected
@@ -107,8 +107,8 @@ def test_galois256_multiply_right_distributes_over_xor() -> None:
 
 @mark.quick
 @mark.parametrize(
-    ('values', 'expected'),
-    (
+    ['values', 'expected'],
+    [
         ((), 0x00),
         ((0x00,), 0x00),
         ((0x57,), 0x57),
@@ -117,7 +117,7 @@ def test_galois256_multiply_right_distributes_over_xor() -> None:
         ((0xFF, 0x0F, 0xF0), 0x00),
         ((0x01, 0x02, 0x04, 0x08), 0x0F),
         ((0xDE, 0xAD, 0xBE, 0xEF), 0x22),
-    ),
+    ],
 )
 def test_xor_bytes_known_values(values: tuple[int, ...], expected: int) -> None:
     assert xor_bytes(*values) == expected

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/core/reference/test_state.py

@@ -17,7 +17,7 @@ class TestAesState:
         assert state.to_bytes() == block
 
     @staticmethod
-    @mark.parametrize('block', (bytes(), bytes(1), bytes(15), bytes(17), bytes(32)))
+    @mark.parametrize('block', [bytes(), bytes(1), bytes(15), bytes(17), bytes(32)])
     def test_from_bytes_rejects_invalid_block_lengths(block: bytes) -> None:
         with raises(
             expected_exception=ValueError,

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/modes/block/test_cbc.py

@@ -50,11 +50,11 @@ class TestCbcMode:
         key: bytes,
         data: bytes,
     ) -> None:
-        ecb: CbcMode = CbcMode(aes(key[:aes.__key_size__]), padding())  # fmt: skip
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        cbc: CbcMode = CbcMode(aes(key[:aes.__key_size__]), padding())  # fmt: skip
+        assert cbc.decrypt(cbc.encrypt(data)) == data
 
     @staticmethod
-    @mark.parametrize(['aes'], [[Aes128], [Aes192], [Aes256]])
+    @mark.parametrize('aes', [Aes128, Aes192, Aes256])
     @given(key=aes256key, data=binary())
     def test_decrypt_inverts_encrypt_zero_padding(
         aes: type[Aes],
@@ -62,16 +62,16 @@ class TestCbcMode:
         data: bytes,
     ) -> None:
         assume(not data.endswith(bytes(1)))
-        ecb: CbcMode = CbcMode(aes(key[:aes.__key_size__]), ZeroPadding())  # fmt: skip
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        cbc: CbcMode = CbcMode(aes(key[:aes.__key_size__]), ZeroPadding())  # fmt: skip
+        assert cbc.decrypt(cbc.encrypt(data)) == data
 
     @staticmethod
-    @mark.parametrize(['aes'], [[Aes128], [Aes192], [Aes256]])
+    @mark.parametrize('aes', [Aes128, Aes192, Aes256])
     @given(key=aes256key, data=aes_blocks)
     def test_decrypt_inverts_encrypt_no_padding(
         aes: type[Aes],
         key: bytes,
         data: bytes,
     ) -> None:
-        ecb: CbcMode = CbcMode(aes(key[:aes.__key_size__]), NoPadding())  # fmt: skip
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        cbc: CbcMode = CbcMode(aes(key[:aes.__key_size__]), NoPadding())  # fmt: skip
+        assert cbc.decrypt(cbc.encrypt(data)) == data

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/modes/block/test_ecb.py

@@ -54,7 +54,7 @@ class TestEcbMode:
         assert ecb.decrypt(ecb.encrypt(data)) == data
 
     @staticmethod
-    @mark.parametrize(['aes'], [[Aes128], [Aes192], [Aes256]])
+    @mark.parametrize('aes', [Aes128, Aes192, Aes256])
     @given(key=aes256key, data=binary())
     def test_decrypt_inverts_encrypt_zero_padding(
         aes: type[Aes],
@@ -66,7 +66,7 @@ class TestEcbMode:
         assert ecb.decrypt(ecb.encrypt(data)) == data
 
     @staticmethod
-    @mark.parametrize(['aes'], [[Aes128], [Aes192], [Aes256]])
+    @mark.parametrize('aes', [Aes128, Aes192, Aes256])
     @given(key=aes256key, data=aes_blocks)
     def test_decrypt_inverts_encrypt_no_padding(
         aes: type[Aes],

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/modes/block/test_pcbc.py

@@ -25,7 +25,7 @@ from tests.unit.aes.strategies import aes256key, aes_blocks
 
 
 @mark.quick
-class TestCbcMode:
+class TestPcbcMode:
     @staticmethod
     @mark.parametrize(
         ['aes', 'padding'],
@@ -50,11 +50,11 @@ class TestCbcMode:
         key: bytes,
         data: bytes,
     ) -> None:
-        ecb: PcbcMode = PcbcMode(aes(key[:aes.__key_size__]), padding())  # fmt: skip
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        pcbc: PcbcMode = PcbcMode(aes(key[:aes.__key_size__]), padding())  # fmt: skip
+        assert pcbc.decrypt(pcbc.encrypt(data)) == data
 
     @staticmethod
-    @mark.parametrize(['aes'], [[Aes128], [Aes192], [Aes256]])
+    @mark.parametrize('aes', [Aes128, Aes192, Aes256])
     @given(key=aes256key, data=binary())
     def test_decrypt_inverts_encrypt_zero_padding(
         aes: type[Aes],
@@ -62,19 +62,19 @@ class TestCbcMode:
         data: bytes,
     ) -> None:
         assume(not data.endswith(bytes(1)))
-        ecb: PcbcMode = PcbcMode(
+        pcbc: PcbcMode = PcbcMode(
             algorithm=aes(key[:aes.__key_size__]),  # fmt: skip
             padding=ZeroPadding(),
         )
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        assert pcbc.decrypt(pcbc.encrypt(data)) == data
 
     @staticmethod
-    @mark.parametrize(['aes'], [[Aes128], [Aes192], [Aes256]])
+    @mark.parametrize('aes', [Aes128, Aes192, Aes256])
     @given(key=aes256key, data=aes_blocks)
     def test_decrypt_inverts_encrypt_no_padding(
         aes: type[Aes],
         key: bytes,
         data: bytes,
     ) -> None:
-        ecb: PcbcMode = PcbcMode(aes(key[:aes.__key_size__]), NoPadding())  # fmt: skip
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        pcbc: PcbcMode = PcbcMode(aes(key[:aes.__key_size__]), NoPadding())  # fmt: skip
+        assert pcbc.decrypt(pcbc.encrypt(data)) == data

purepython_aes-0.5.0/tests/unit/aes/modes/stream/test_cfb.py

@@ -0,0 +1,48 @@
+from itertools import product
+
+from hypothesis import given
+from hypothesis.strategies import binary
+from pytest import mark
+
+from purepython_aes import (
+    Aes,
+    Aes128,
+    Aes192,
+    Aes256,
+    CfbMode,
+    ReferenceAes128,
+    ReferenceAes192,
+    ReferenceAes256,
+)
+from purepython_aes.types import CfbSegmentSize
+from tests.unit.aes.strategies import aes256key
+
+
+@mark.quick
+class TestCfbMode:
+    @staticmethod
+    @mark.parametrize(
+        ['aes', 'segment_size'],
+        tuple(
+            product(
+                [
+                    Aes128,
+                    Aes192,
+                    Aes256,
+                    ReferenceAes128,
+                    ReferenceAes192,
+                    ReferenceAes256,
+                ],
+                [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+            ),
+        ),
+    )
+    @given(key=aes256key, data=binary())
+    def test_decrypt_inverts_encrypt(
+        aes: type[Aes],
+        segment_size: CfbSegmentSize,
+        key: bytes,
+        data: bytes,
+    ) -> None:
+        cfb: CfbMode = CfbMode(aes(key[:aes.__key_size__]), segment_size)  # fmt: skip
+        assert cfb.decrypt(cfb.encrypt(data)) == data

purepython_aes-0.5.0/tests/unit/aes/modes/stream/test_ofb.py

@@ -0,0 +1,28 @@
+from hypothesis import given
+from hypothesis.strategies import binary
+from pytest import mark
+
+from purepython_aes import (
+    Aes,
+    Aes128,
+    Aes192,
+    Aes256,
+    OfbMode,
+    ReferenceAes128,
+    ReferenceAes192,
+    ReferenceAes256,
+)
+from tests.unit.aes.strategies import aes256key
+
+
+@mark.quick
+class TestOfbMode:
+    @staticmethod
+    @mark.parametrize(
+        'aes',
+        [Aes128, Aes192, Aes256, ReferenceAes128, ReferenceAes192, ReferenceAes256],
+    )
+    @given(key=aes256key, data=binary())
+    def test_decrypt_inverts_encrypt(aes: type[Aes], key: bytes, data: bytes) -> None:
+        ofb: OfbMode = OfbMode(aes(key[:aes.__key_size__]))  # fmt: skip
+        assert ofb.decrypt(ofb.encrypt(data)) == data

{purepython_aes-0.3.1 → purepython_aes-0.5.0}/tests/unit/aes/modes/test_operations.py

@@ -13,7 +13,7 @@ def test_xor_empty_inputs() -> None:
 
 @mark.quick
 @mark.parametrize(
-    ('left', 'right', 'expected'),
+    ['left', 'right', 'expected'],
     [
         (b'\x00', b'\x00', b'\x00'),
         (b'\x00', b'\xff', b'\xff'),
@@ -45,7 +45,7 @@ def test_xor_known_values(left: bytes, right: bytes, expected: bytes) -> None:
 
 @mark.quick
 @mark.parametrize(
-    ('left', 'right'),
+    ['left', 'right'],
     [
         (b'\x00', bytes(0)),
         (bytes(0), b'\x00'),

purepython_aes-0.3.1/src/purepython_aes/aes/modes/__init__.py

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

purepython_aes-0.3.1/src/purepython_aes/aes/modes/_base.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC
-from dataclasses import dataclass
-
-from purepython_aes.aes.core.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-0.3.1/src/purepython_aes/types/__init__.py

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