purepython-aes 0.4.0__tar.gz → 0.6.0__tar.gz

{purepython_aes-0.4.0/src/purepython_aes.egg-info → purepython_aes-0.6.0}/PKG-INFO

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

{purepython_aes-0.4.0 → purepython_aes-0.6.0}/src/purepython_aes/__init__.py

@@ -10,10 +10,12 @@ from purepython_aes.aes import (
     CbcMode,
     CfbMode,
     CipherMode,
+    CtrMode,
     EcbMode,
     Iso7816Padding,
     Iso10126Padding,
     NoPadding,
+    OfbMode,
     PcbcMode,
     Pkcs7Padding,
     ReferenceAes128,
@@ -35,10 +37,12 @@ __all__: list[str] = [
     'CbcMode',
     'CfbMode',
     'CipherMode',
+    'CtrMode',
     'EcbMode',
     'Iso7816Padding',
     'Iso10126Padding',
     'NoPadding',
+    'OfbMode',
     'PcbcMode',
     'Pkcs7Padding',
     'ReferenceAes128',

{purepython_aes-0.4.0 → purepython_aes-0.6.0}/src/purepython_aes/aes/__init__.py

@@ -13,7 +13,9 @@ from purepython_aes.aes.modes import (
     CbcMode,
     CfbMode,
     CipherMode,
+    CtrMode,
     EcbMode,
+    OfbMode,
     PcbcMode,
     StreamCipherMode,
 )
@@ -40,7 +42,9 @@ __all__: list[str] = [
     'CbcMode',
     'CfbMode',
     'CipherMode',
+    'CtrMode',
     'EcbMode',
+    'OfbMode',
     'PcbcMode',
     'StreamCipherMode',
     'AnsiX923Padding',

{purepython_aes-0.4.0 → purepython_aes-0.6.0}/src/purepython_aes/aes/modes/__init__.py

@@ -1,6 +1,6 @@
 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, StreamCipherMode
+from purepython_aes.aes.modes.stream import CfbMode, CtrMode, OfbMode, StreamCipherMode
 
 __all__: list[str] = [
     'AesMode',
@@ -10,5 +10,7 @@ __all__: list[str] = [
     'EcbMode',
     'PcbcMode',
     'CfbMode',
+    'CtrMode',
+    'OfbMode',
     'StreamCipherMode',
 ]

purepython_aes-0.6.0/src/purepython_aes/aes/modes/stream/__init__.py

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

{purepython_aes-0.4.0 → purepython_aes-0.6.0}/src/purepython_aes/aes/modes/stream/_base.py

@@ -10,17 +10,17 @@ from purepython_aes.const import AES_BLOCK_SIZE
 class StreamCipherMode(CipherMode, ABC):
     def encrypt(self, plaintext: bytes) -> bytes:
         iv: bytes = token_bytes(AES_BLOCK_SIZE)
-        ciphertext: bytes = self.transform_for_encryption(iv, plaintext)
+        ciphertext: bytes = self.__encrypt_stream__(iv, plaintext)
         return iv + ciphertext
 
     def decrypt(self, ciphertext: bytes) -> bytes:
-        return self.transform_for_decryption(
+        return self.__decrypt_stream__(
             initialization_value=ciphertext[:AES_BLOCK_SIZE],
             ciphertext=ciphertext[AES_BLOCK_SIZE:],
         )
 
     @abstractmethod
-    def transform_for_encryption(
+    def __encrypt_stream__(
         self,
         initialization_value: bytes,
         plaintext: bytes,
@@ -30,7 +30,7 @@ class StreamCipherMode(CipherMode, ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def transform_for_decryption(
+    def __decrypt_stream__(
         self,
         initialization_value: bytes,
         ciphertext: bytes,

{purepython_aes-0.4.0 → purepython_aes-0.6.0}/src/purepython_aes/aes/modes/stream/cfb.py

@@ -25,7 +25,7 @@ class CfbMode(StreamCipherMode):
                 )
             )
 
-    def transform_for_encryption(
+    def __encrypt_stream__(
         self,
         initialization_value: bytes,
         plaintext: bytes,
@@ -50,7 +50,7 @@ class CfbMode(StreamCipherMode):
             )
         return bytes(ciphertext)
 
-    def transform_for_decryption(
+    def __decrypt_stream__(
         self,
         initialization_value: bytes,
         ciphertext: bytes,

purepython_aes-0.6.0/src/purepython_aes/aes/modes/stream/ctr.py

@@ -0,0 +1,50 @@
+# src/purepython_aes/aes/modes/stream/ctr.py
+from dataclasses import dataclass
+from typing import final
+
+from purepython_aes.aes.modes.operations import xor
+from purepython_aes.aes.modes.stream._base import StreamCipherMode
+from purepython_aes.const import AES_BLOCK_SIZE
+
+
+@final
+@dataclass(slots=True)
+class CtrMode(StreamCipherMode):
+    """Counter mode of operation."""
+
+    def __encrypt_stream__(
+        self,
+        initialization_value: bytes,
+        plaintext: bytes,
+    ) -> bytes:
+        return self.transform(initialization_value, plaintext)
+
+    def __decrypt_stream__(
+        self,
+        initialization_value: bytes,
+        ciphertext: bytes,
+    ) -> bytes:
+        return self.transform(initialization_value, ciphertext)
+
+    def transform(
+        self,
+        initialization_value: bytes,
+        data: bytes,
+    ) -> bytes:
+        """XOR data with the counter-generated keystream."""
+
+        block_count: int = (len(data) + AES_BLOCK_SIZE - 1) // AES_BLOCK_SIZE
+        initial_counter: int = int.from_bytes(initialization_value, byteorder='big')
+        transformed_data: bytearray = bytearray()
+        for block_index in range(block_count):
+            block_start: int = block_index * AES_BLOCK_SIZE
+            data_block: bytes = data[block_start : (block_start + AES_BLOCK_SIZE)]
+            counter: int = initial_counter + block_index
+            counter_block: bytes = counter.to_bytes(AES_BLOCK_SIZE, byteorder='big')
+            keystream_block: bytes = self.algorithm.encrypt_block(counter_block)
+            transformed_block: bytes = xor(
+                data_block,
+                keystream_block[: len(data_block)],
+            )
+            transformed_data.extend(transformed_block)
+        return bytes(transformed_data)

purepython_aes-0.6.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.4.0 → purepython_aes-0.6.0/src/purepython_aes.egg-info}/PKG-INFO

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

{purepython_aes-0.4.0 → purepython_aes-0.6.0}/src/purepython_aes.egg-info/SOURCES.txt

@@ -47,6 +47,8 @@ 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/ctr.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
@@ -98,6 +100,8 @@ 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_ctr.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.4.0 → purepython_aes-0.6.0}/src/purepython_aes.egg-info/scm_file_list.json

@@ -48,8 +48,10 @@
     "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/ctr.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",
@@ -98,6 +100,8 @@
     "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/stream/test_ctr.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.4.0 → purepython_aes-0.6.0}/src/purepython_aes.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.4.0",
+  "tag": "0.6.0",
   "distance": 0,
-  "node": "ge127baa0ad018fcbb3e51110b1a486ae5ffe9daa",
+  "node": "g0b685541a28a77cde6c306ae0d3077cfeb784035",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-14"

{purepython_aes-0.4.0 → purepython_aes-0.6.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.4.0 → purepython_aes-0.6.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.4.0 → purepython_aes-0.6.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.4.0 → purepython_aes-0.6.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.4.0 → purepython_aes-0.6.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.4.0 → purepython_aes-0.6.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.4.0 → purepython_aes-0.6.0}/tests/unit/aes/modes/block/test_pcbc.py

@@ -50,11 +50,11 @@ class TestPcbcMode:
         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 TestPcbcMode:
         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.4.0 → purepython_aes-0.6.0}/tests/unit/aes/modes/stream/test_cfb.py

@@ -44,5 +44,5 @@ class TestCfbMode:
         key: bytes,
         data: bytes,
     ) -> None:
-        ecb: CfbMode = CfbMode(aes(key[:aes.__key_size__]), segment_size)  # fmt: skip
-        assert ecb.decrypt(ecb.encrypt(data)) == data
+        cfb: CfbMode = CfbMode(aes(key[:aes.__key_size__]), segment_size)  # fmt: skip
+        assert cfb.decrypt(cfb.encrypt(data)) == data

purepython_aes-0.6.0/tests/unit/aes/modes/stream/test_ctr.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,
+    CtrMode,
+    ReferenceAes128,
+    ReferenceAes192,
+    ReferenceAes256,
+)
+from tests.unit.aes.strategies import aes256key
+
+
+@mark.quick
+class TestCtrMode:
+    @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:
+        ctr: CtrMode = CtrMode(aes(key[:aes.__key_size__]))  # fmt: skip
+        assert ctr.decrypt(ctr.encrypt(data)) == data

purepython_aes-0.6.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.4.0 → purepython_aes-0.6.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.4.0/src/purepython_aes/aes/modes/stream/__init__.py

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