style: apply black lint

Author: LVivona

binding/python/py/synlink/crypto/ed25519.py

@@ -7,7 +7,10 @@
 
 from nacl.signing import SigningKey, VerifyKey
 from nacl.encoding import HexEncoder
-from synlink.crypto.exception import CryptoException
+from synlink.crypto.exception import (
+    CryptoBaseException,
+    SignatureVerificationError,
+)
 from synlink.crypto.kind import Kind
 from synlink.crypto.typing import PrivateKey as IPrivateKey
 from synlink.crypto.typing import PublicKey as IPublicKey
@@ -21,16 +24,20 @@
 Message = bytes
 Signiture = bytes
 
-__all__ = ["PublicKey", "PrivateKey", "KeyPair", "create_new_ed25519_key_pair",
-           "create_new_ed25519_key_pair_from_seed"]
-
-
+__all__ = [
+    "PublicKey",
+    "PrivateKey",
+    "KeyPair",
+    "create_new_ed25519_key_pair",
+    "create_new_ed25519_key_pair_from_seed",
+]
 
 class PublicKey(IPublicKey):
     """
     Represents an ED25519 public key, providing methods for verification
     and various conversions. This class wraps nacl.signing.VerifyKey.
     """
+
     def __init__(self, impl: VerifyKey):
         """
         Initializes a PublicKey object.
@@ -41,25 +48,21 @@ def __init__(self, impl: VerifyKey):
         super().__init__()
         self._impl: VerifyKey = impl
         self._kind = Kind.ED25519
-
     def get_kind(self) -> Kind:
         """
         Returns the kind of this cryptographic key.
         """
         return self._kind
-
     def to_bytes(self) -> bytes:
         """
         Converts the public key to its raw byte representation.
         """
         return bytes(self._impl)
-
     def __bytes__(self) -> bytes:
         """
         Allows the PublicKey object to be converted to bytes using bytes().
         """
         return self.to_bytes()
-
     @classmethod
     def from_bytes(cls, data: bytes) -> Self:
         """
@@ -72,7 +75,28 @@ def from_bytes(cls, data: bytes) -> Self:
             A new PublicKey instance.
         """
         return cls(VerifyKey(data))
+    def try_verify(self, data: bytes, signature: bytes) -> bool:
+        """
+        Attempts to verify the signature against the signed message.
+
+        Args:
+            data: The original message bytes that were signed.
+            signature: The raw signature bytes.
+
+        Returns:
+            True if the signature is valid.
 
+        Raises:
+            SignatureVerificationError: If the signature is forged or corrupt.
+            CryptoBaseException: For other unexpected verification errors.
+        """
+        try:
+            self._impl.verify(data, signature)
+            return True
+        except BadSignatureError as e:
+            raise SignatureVerificationError(f"{e}") from e
+        except Exception as e:
+            raise CryptoBaseException(f"{e}") from e
     def verify(self, data: bytes, signature: bytes) -> bool:
         """
         Verifies the signature against the signed message.
@@ -94,31 +118,28 @@ def verify(self, data: bytes, signature: bytes) -> bool:
             # Catch other potential exceptions during verification
             # print(f"An unexpected error occurred during verification: {e}") # For debugging
             return False
-
-
     def __str__(self) -> str:
         """
         Returns a human-readable string representation of the public key.
         """
-        output = self._impl \
-                     .encode(encoder=HexEncoder()) \
-                     .decode('utf-8')
+        output = self._impl.encode(encoder=HexEncoder()).decode("utf-8")
         return f"PublicKey({output})"
-
     def __repr__(self) -> str:
         """
         Returns a detailed string representation for debugging.
         """
-        output = self._impl.encode(encoder=HexEncoder()).decode('utf-8')
+        output = self._impl.encode(encoder=HexEncoder()).decode("utf-8")
         # Show a truncated hex representation for brevity in repr
-        return f"<synlink.crypto.ed25519.PublicKey {output[:8]}...{output[-8:]}>"
-
+        return (
+            f"<synlink.crypto.ed25519.PublicKey {output[:8]}...{output[-8:]}>"
+        )
 
 class PrivateKey(IPrivateKey):
     """
     Represents an ED25519 private key, providing methods for signing
     and various conversions. This class wraps nacl.signing.SigningKey.
     """
+
     def __init__(self, impl: SigningKey):
         """
         Initializes a PrivateKey object.
@@ -129,13 +150,11 @@ def __init__(self, impl: SigningKey):
         super().__init__()
         self._kind = Kind.ED25519
         self._impl: SigningKey = impl
-
     def get_kind(self) -> Kind:
         """
         Returns the kind of this cryptographic key.
         """
         return self._kind
-
     @classmethod
     def generate(cls) -> Self:
         """
@@ -146,7 +165,6 @@ def generate(cls) -> Self:
         """
         impl = SigningKey.generate()
         return cls(impl)
-
     @classmethod
     def from_seed(cls, seed: Optional[bytes] = None) -> Self:
         """
@@ -171,7 +189,6 @@ def from_seed(cls, seed: Optional[bytes] = None) -> Self:
         ), "PrivateKey seed must be a 32 bytes long binary sequence"
         impl = ImplPrivateKey.from_seed(seed)
         return cls(SigningKey(bytes(impl)))
-
     @classmethod
     def from_bytes(cls, data: bytes) -> Self:
         """
@@ -185,16 +202,14 @@ def from_bytes(cls, data: bytes) -> Self:
         """
         impl = SigningKey(data)
         return cls(impl)
-
     def get_public_key(self) -> IPublicKey:
         """
         Returns the public key corresponding to this private key.
         """
         if not isinstance(self._impl, SigningKey):
-            raise CryptoException("Invalid private key implementation.")
+            raise CryptoBaseException("Invalid private key implementation.")
         # Return a PublicKey wrapping the VerifyKey derived from this SigningKey
         return PublicKey(self._impl.verify_key)
-
     def sign(self, data: bytes) -> Tuple[Message, Signiture]:
         """
         Signs data with the private key and returns the raw signature.
@@ -206,76 +221,95 @@ def sign(self, data: bytes) -> Tuple[Message, Signiture]:
             The raw signature bytes.
         """
         if not isinstance(self._impl, SigningKey):
-            raise CryptoException("Invalid private key implementation.")
+            raise CryptoBaseException("Invalid private key implementation.")
         # Direct signing using the wrapped SigningKey
         signed_message = self._impl.sign(data)
         return signed_message.message, signed_message.signature
-
     def to_bytes(self) -> bytes:
         """
         Converts the private key to its raw byte representation.
         """
         return bytes(self._impl)
-
     def __bytes__(self) -> bytes:
         """
         Allows the PrivateKey object to be converted to bytes using bytes().
         """
         return self.to_bytes()
-
     def __str__(self) -> str:
         """
         Returns a human-readable string representation of the private key.
         """
         # For security, avoid showing private key material in str.
         return "PrivateKey(ED25519)"
-
     def __repr__(self) -> str:
         """
         Returns a detailed string representation for debugging.
         """
         # For security, avoid showing private key material in repr.
         return "<synlink.crypto.ed25519.PrivateKey>"
 
-
 @dataclass(frozen=True, repr=False)
 class KeyPair(object):
     """
     Represents an ED25519 key pair, containing both a private and public key.
     """
-    secret : PrivateKey
-    public  : PublicKey
 
-    def try_verify(self, message : bytes, signature : bytes) -> bool:
-        try:
-            return self.public.verify(data=message, signature=signature)
-        except BadSignatureError as e:
-            raise e
+    secret: PrivateKey
+    public: PublicKey
+
+    def try_verify(self, message: bytes, signature: bytes) -> bool:
+        """
+        Try to verifies the signature against the signed message.
+
+        Args:
+            data: The original message bytes that were signed.
+            signature: The raw signature bytes.
 
-    def verify(self, message : bytes, signature : bytes) -> bool:
+        Returns:
+            Always True if the signature is valid.
+
+        Rasies:
+            BadSignatureError: Signature was forged or otherwise corrupt.
+            Exception: base class for all non-exit exceptions.
+        """
+        return self.public.try_verify(data=message, signature=signature)
+    def verify(self, message: bytes, signature: bytes) -> bool:
+        """
+        Verifies the signature against the signed message.
+
+        Args:
+            data: The original message bytes that were signed.
+            signature: The raw signature bytes.
+
+        Returns:
+            True if the signature is valid, False otherwise.
+        """
         try:
             return self.public.verify(data=message, signature=signature)
         except BadSignatureError:
             return False
+    def sign(self, message: bytes) -> Tuple[Message, Signiture]:
+        """
+        Signs data with the private key and returns the raw signature.
 
-    def sign(self, message : bytes) -> Tuple[Message, Signiture]:
-        return self.secret.sign(
-            data=message
-        )
+        Args:
+            data: The message bytes to sign.
 
+        Returns:
+            The raw signature bytes.
+        """
+        return self.secret.sign(data=message)
     def __bytes__(self) -> bytes:
         """
         Returns the raw bytes of the secret (private) key.
         """
         return bytes(self.secret)
-
     def __repr__(self) -> str:
         """
         Returns a detailed string representation for debugging.
         """
         # Include the public key's repr for better context
-        return f"<synlink.crypto.ed25519.KeyPair public={self.public!r}>"
-
+        return f"<synlink.crypto.ed25519.KeyPair public={self.public!s}>"
 
 def create_new_ed25519_key_pair() -> KeyPair:
     """
@@ -288,8 +322,9 @@ def create_new_ed25519_key_pair() -> KeyPair:
     public = secret.get_public_key()
     return KeyPair(secret, public)
 
-
-def create_new_ed25519_key_pair_from_seed(seed: Optional[bytes] = None) -> KeyPair:
+def create_new_ed25519_key_pair_from_seed(
+    seed: Optional[bytes] = None,
+) -> KeyPair:
     """
     Creates a new ED25519 key pair from an optional 32-byte seed.
 

binding/python/py/synlink/crypto/exception.py

@@ -1,5 +1,11 @@
 from synlink.error import SynlinkBaseException
 
+class CryptoBaseException(SynlinkBaseException):
+    """Base exception for all cryptographic errors."""
+
+    pass
+
+class SignatureVerificationError(CryptoBaseException):
+    """Raised when signature verification fails."""
 
-class CryptoException(SynlinkBaseException):
     pass

binding/python/py/synlink/crypto/io.py

@@ -1,36 +1,35 @@
-
 import os
 import pathlib
 
 from typing import Union, Optional
 
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import (
-    ed25519 as ED25519, 
+    ed25519 as ED25519,
 )
 
 import synlink.crypto.ed25519 as ed25519
 from synlink.crypto.typing import KeyPair
 
-HOME_DIR : str = pathlib.Path.home().__str__()
+HOME_DIR: str = pathlib.Path.home().__str__()
 SSH_DEFAULT_DIRECTORY = os.path.join(HOME_DIR, ".ssh")
 
 __all__ = ["load_open_ssh_private_key"]
 
 def load_ssh_private_key(
-        file : Union[str, os.PathLike] = SSH_DEFAULT_DIRECTORY, 
-        password : Optional[Union[str, bytes]] = None,
-        ) -> KeyPair:
+    file: Union[str, os.PathLike] = SSH_DEFAULT_DIRECTORY,
+    password: Optional[Union[str, bytes]] = None,
+) -> KeyPair:
     """Load private key from OpenSSL custom encoding, and reconstruct
     key pair.
-    
+
     Args:
         ssh_dir: Path to SSH directory (default: ~/.ssh)
         key_name: Base name of key files (default: id_rsa)
-        
+
     Returns:
         KeyPair containing the loaded public and private keys
-        
+
     Raises:
         FileNotFoundError: If key files don't exist
         ValueError: If keys are malformed or incompatible
@@ -51,9 +50,7 @@ def load_ssh_private_key(
         )
 
         if isinstance(buffer, ED25519.Ed25519PrivateKey):
-            secret = ed25519.PrivateKey.from_bytes(
-                buffer.private_bytes_raw()    
-            )
+            secret = ed25519.PrivateKey.from_bytes(buffer.private_bytes_raw())
             public = secret.get_public_key()
             return ed25519.KeyPair(secret=secret, public=public)
         else: