derivepassphrase.git

@@ -22,6 +22,8 @@ if TYPE_CHECKING:

     import socket

     from collections.abc import Callable

+    from typing_extensions import Buffer

+

 __author__ = 'Marco Ricci <software@the13thletter.info>'

@@ -104,7 +106,7 @@ class Vault:

     def __init__(  # noqa: PLR0913

         self,

         *,

-        phrase: bytes | bytearray | str = b'',

+        phrase: Buffer | str = b'',

         length: int = 20,

         repeat: int = 0,

         lower: int | None = None,

@@ -257,7 +259,7 @@ class Vault:

         return math.ceil(safety_factor * entropy_bound / 8)

     @staticmethod

-    def _get_binary_string(s: bytes | bytearray | str, /) -> bytes:

+    def _get_binary_string(s: Buffer | str, /) -> bytes:

         """Convert the input string to a read-only, binary string.

         If it is a text string, return the string's UTF-8

@@ -277,8 +279,8 @@ class Vault:

     @classmethod

     def create_hash(

         cls,

-        phrase: bytes | bytearray | str,

-        service: bytes | bytearray | str,

+        phrase: Buffer | str,

+        service: Buffer | str,

         *,

         length: int = 32,

     ) -> bytes:

@@ -332,7 +334,7 @@ class Vault:

         """

         phrase = cls._get_binary_string(phrase)

-        assert not isinstance(phrase, str)

+        assert isinstance(phrase, bytes)

         salt = cls._get_binary_string(service) + cls._UUID

         return hashlib.pbkdf2_hmac(

             hash_name='sha1',

@@ -344,10 +346,10 @@ class Vault:

     def generate(

         self,

-        service_name: bytes | bytearray | str,

+        service_name: Buffer | str,

         /,

         *,

-        phrase: bytes | bytearray | str = b'',

+        phrase: Buffer | str = b'',

     ) -> bytes:

         r"""Generate a service passphrase.

@@ -452,7 +454,7 @@ class Vault:

     @staticmethod

     def is_suitable_ssh_key(

-        key: bytes | bytearray,

+        key: Buffer,

         /,

         *,

         client: ssh_agent.SSHAgentClient | None = None,

@@ -477,6 +479,7 @@ class Vault:

             restricted to the indicated SSH agent).

         """

+        key = bytes(key)

         TestFunc: TypeAlias = 'Callable[[bytes | bytearray], bool]'

         deterministic_signature_types: dict[str, TestFunc]

         deterministic_signature_types = {

@@ -515,7 +518,7 @@ class Vault:

     @classmethod

     def phrase_from_key(

         cls,

-        key: bytes | bytearray,

+        key: Buffer,

         /,

         *,

         conn: ssh_agent.SSHAgentClient | socket.socket | None = None,

@@ -593,8 +596,8 @@ class Vault:

     @classmethod

     def phrases_are_interchangable(

         cls,

-        phrase1: bytes | bytearray,

-        phrase2: bytes | bytearray,

+        phrase1: Buffer,

+        phrase2: Buffer,

         /,

     ) -> bool:

         """Return true if the passphrases are interchangable to Vault.

@@ -640,7 +643,7 @@ class Vault:

     @classmethod

     def _phrase_to_hmac_key(

         cls,

-        phrase: bytes | bytearray | str,

+        phrase: Buffer | str,

         /,

     ) -> bytes:

         r"""Return the HMAC key belonging to a passphrase.

@@ -669,8 +672,8 @@ class Vault:

     @staticmethod

     def _subtract(

-        charset: bytes | bytearray,

-        allowed: bytes | bytearray,

+        charset: Buffer,

+        allowed: Buffer,

     ) -> bytearray:

         """Remove the characters in charset from allowed.

@@ -696,6 +699,8 @@ class Vault:

             allowed if isinstance(allowed, bytearray) else bytearray(allowed)

         )

         assert_type(allowed, bytearray)

+        charset = memoryview(charset).toreadonly().cast('c')

+        assert_type(charset, 'memoryview[bytes]')

         msg_dup_characters = 'duplicate characters in set'

         if len(frozenset(allowed)) != len(allowed):

             raise ValueError(msg_dup_characters)

@@ -6,6 +6,7 @@

 from __future__ import annotations

+import array

 import hashlib

 import math

 from typing import TYPE_CHECKING

@@ -19,15 +20,17 @@ import tests

 from derivepassphrase import vault

 if TYPE_CHECKING:

-    from collections.abc import Iterator

+    from collections.abc import Callable, Iterator

+

+    from typing_extensions import Buffer

 BLOCK_SIZE = hashlib.sha1().block_size

 DIGEST_SIZE = hashlib.sha1().digest_size

 def phrases_are_interchangable(

-    phrase1: bytes | bytearray | str,

-    phrase2: bytes | bytearray | str,

+    phrase1: Buffer | str,

+    phrase2: Buffer | str,

     /,

 ) -> bool:

     """Work-alike of [`vault.Vault.phrases_are_interchangable`][].

@@ -358,6 +361,12 @@ class TestVault:

             b'google'

         ) == vault.Vault(phrase=self.phrase).generate(bytearray(b'google'))

+    def test_202c_reproducibility_and_buffer_like_service_name(self) -> None:

+        """Deriving a passphrase works equally for memory views."""

+        assert vault.Vault(phrase=self.phrase).generate(

+            b'google'

+        ) == vault.Vault(phrase=self.phrase).generate(memoryview(b'google'))

+

     @hypothesis.given(

         phrase=strategies.text(

             strategies.characters(min_codepoint=32, max_codepoint=126),

@@ -370,18 +379,65 @@ class TestVault:

             max_size=32,

         ),

     )

-    def test_202c_reproducibility_and_binary_service_name(

+    def test_203a_reproducibility_and_binary_phrases(

         self,

         phrase: str,

         service: str,

     ) -> None:

-        """Deriving a passphrase works equally for byte arrays/strings."""

-        assert vault.Vault(phrase=phrase).generate(service) == vault.Vault(

-            phrase=phrase

-        ).generate(service.encode('utf-8'))

-        assert vault.Vault(phrase=phrase).generate(service) == vault.Vault(

-            phrase=phrase

-        ).generate(bytearray(service.encode('utf-8')))

+        """Binary and text master passphrases generate the same passphrases."""

+        buffer_types: dict[str, Callable[..., Buffer]] = {

+            'bytes': bytes,

+            'bytearray': bytearray,

+            'memoryview': memoryview,

+            'array.array': lambda data: array.array('B', data),

+        }

+        for type_name, buffer_type in buffer_types.items():

+            str_phrase = phrase

+            bytes_phrase = phrase.encode('utf-8')

+            assert vault.Vault(phrase=str_phrase).generate(

+                service

+            ) == vault.Vault(phrase=buffer_type(bytes_phrase)).generate(

+                service

+            ), (

+                f'{str_phrase!r} and {type_name}({bytes_phrase!r}) '

+                'master passphrases generate different passphrases'

+            )

+

+    @hypothesis.given(

+        phrase=strategies.text(

+            strategies.characters(min_codepoint=32, max_codepoint=126),

+            min_size=1,

+            max_size=32,

+        ),

+        service=strategies.text(

+            strategies.characters(min_codepoint=32, max_codepoint=126),

+            min_size=1,

+            max_size=32,

+        ),

+    )

+    def test_203b_reproducibility_and_binary_service_name(

+        self,

+        phrase: str,

+        service: str,

+    ) -> None:

+        """Binary and text service names generate the same passphrases."""

+        buffer_types: dict[str, Callable[..., Buffer]] = {

+            'bytes': bytes,

+            'bytearray': bytearray,

+            'memoryview': memoryview,

+            'array.array': lambda data: array.array('B', data),

+        }

+        for type_name, buffer_type in buffer_types.items():

+            str_service = service

+            bytes_service = service.encode('utf-8')

+            assert vault.Vault(phrase=phrase).generate(

+                str_service

+            ) == vault.Vault(phrase=phrase).generate(

+                buffer_type(bytes_service)

+            ), (

+                f'{str_service!r} and {type_name}({bytes_service!r}) '

+                'service name generate different passphrases'

+            )

     @hypothesis.given(

         phrase=strategies.text(

@@ -396,7 +452,7 @@ class TestVault:

             unique=True,

         ),

     )

-    def test_203a_service_name_dependence(

+    def test_204a_service_name_dependence(

         self,

         phrase: str,

         services: list[bytes],

@@ -421,7 +477,7 @@ class TestVault:

             unique=True,

         ),

     )

-    def test_203b_service_name_dependence_with_config(

+    def test_204b_service_name_dependence_with_config(

         self,

         phrase: str,

         config: dict[str, int],