Code formatting

Author: scheibling

src/sshkey_tools/cert.py

@@ -8,6 +8,7 @@
     _EX.NoPrivateKeyException: The certificate contains no private key
     _EX.NotSignedException: The certificate is not signed and cannot be exported
 """
+
 from base64 import b64decode, b64encode
 from dataclasses import dataclass
 from typing import Tuple, Union

src/sshkey_tools/fields.py

@@ -1704,9 +1704,7 @@ def __bytes__(self) -> bytes:
     def __validate_value__(self) -> Union[bool, Exception]:
         try:
             if ensure_bytestring(self.value)[:6] != b"SSHSIG":
-                return _EX.InvalidDataException(
-                    "Invalid SSH signature magic preamble"
-                )
+                return _EX.InvalidDataException("Invalid SSH signature magic preamble")
         except TypeError:
             return _EX.InvalidDataException("Invalid SSH signature magic preamble")
         return True
@@ -1744,9 +1742,7 @@ def __validate_value__(self) -> Union[bool, Exception]:
                 f"{self.get_name()} Could not validate value, invalid type"
             )
         if not self.value:
-            return _EX.InvalidDataException(
-                "Signature namespace must not be empty"
-            )
+            return _EX.InvalidDataException("Signature namespace must not be empty")
         return True
 
 

src/sshkey_tools/signatures.py

@@ -11,59 +11,54 @@
 from .cert import Fieldset, dataclass, Union
 from prettytable import PrettyTable
 from .utils import concat_to_bytestring, ensure_bytestring
-from . import (
-    fields as _FIELD,
-    keys as _KEY,
-    exceptions as _EX,
-    utils as _U
-)
+from . import fields as _FIELD, keys as _KEY, exceptions as _EX, utils as _U
+
 
 @dataclass
 class SignatureFieldset(Fieldset):
     """Fields for SSH Signature"""
-    
+
     DECODE_ORDER = [
         "magic_preamble",
         "sig_version",
         "public_key",
         "namespace",
         "reserved",
         "hash_algorithm",
-        "signature"
+        "signature",
     ]
-    
+
     magic_preamble: _FIELD.SshsigField = _FIELD.SshsigField.factory
     sig_version: _FIELD.SignatureVersionField = _FIELD.SignatureVersionField.factory
     public_key: _FIELD.PublicKeyField = _FIELD.PublicKeyField.factory
-    
+
     namespace: _FIELD.SignatureNamespaceField = _FIELD.SignatureNamespaceField.factory
     reserved: _FIELD.ReservedField = _FIELD.ReservedField.factory
-    hash_algorithm: _FIELD.SignatureHashAlgorithmField = _FIELD.SignatureHashAlgorithmField.factory
+    hash_algorithm: _FIELD.SignatureHashAlgorithmField = (
+        _FIELD.SignatureHashAlgorithmField.factory
+    )
     signature: _FIELD.SignatureField = _FIELD.SignatureField.factory
 
     def __bytes__(self):
         return concat_to_bytestring(
             bytes(self.magic_preamble),
             bytes(self.namespace),
             bytes(self.reserved),
-            bytes(self.hash_algorithm)
+            bytes(self.hash_algorithm),
         )
-    
+
     def format_pubkey(self):
-        pubkey = self.public_key.value.to_string().split(' ')
-        
-        return _FIELD.StringField.encode(concat_to_bytestring(
-            pubkey[0],
-            ' ',
-            b64decode(pubkey[1]))
+        pubkey = self.public_key.value.to_string().split(" ")
+
+        return _FIELD.StringField.encode(
+            concat_to_bytestring(pubkey[0], " ", b64decode(pubkey[1]))
         )
-        
-        
+
         # return _FIELD.BytestringField.encode(concat_to_bytestring(
         #     _FIELD.StringField.encode(pubkey[0]),
         #     _FIELD.StringField.encode(b64decode(pubkey[1]))
         # ))
-    
+
     def bytes_out(self):
         return concat_to_bytestring(
             bytes(self.magic_preamble),
@@ -72,7 +67,7 @@ def bytes_out(self):
             bytes(self.namespace),
             bytes(self.reserved),
             bytes(self.hash_algorithm),
-            bytes(self.signature)
+            bytes(self.signature),
         )
 
     @classmethod
@@ -126,29 +121,35 @@ def decode(cls, data: bytes):
 
         return cl_instance, data
 
+
 class SSHSignature:
     """
     General class for SSH Signatures, used for loading and parsing.
     """
+
     data: bytes = None
-    
+
     def __init__(
-        self, signer_privkey: _KEY.PrivateKey = None,
-        fields: SignatureFieldset = SignatureFieldset
+        self,
+        signer_privkey: _KEY.PrivateKey = None,
+        fields: SignatureFieldset = SignatureFieldset,
     ):
         self.fields = fields() if isinstance(fields, type) else fields
-        
+
         if signer_privkey is not None:
             self.fields.replace_field(
                 "signature", _FIELD.SignatureField.from_object(signer_privkey)
             )
-            self.fields.replace_field("public_key", _FIELD.PublicKeyField.from_object(signer_privkey.public_key))    
-    
+            self.fields.replace_field(
+                "public_key",
+                _FIELD.PublicKeyField.from_object(signer_privkey.public_key),
+            )
+
         if issubclass(type(self.fields.public_key.value), type(self.fields.public_key)):
             self.fields.public_key = self.fields.public_key.value
 
     @classmethod
-    def from_file(cls, path: str, encoding: str = 'none') -> "SSHSignature":
+    def from_file(cls, path: str, encoding: str = "none") -> "SSHSignature":
         """
         Loads an existing SSH Signature from a file
 
@@ -159,13 +160,15 @@ def from_file(cls, path: str, encoding: str = 'none') -> "SSHSignature":
         Returns:
             SSHSignature: SSH Signature Object
         """
-        with open(path, 'rb' if encoding == 'none' else 'r') as f:
+        with open(path, "rb" if encoding == "none" else "r") as f:
             data = f.read()
 
-        return cls.from_string(data, encoding if encoding != 'none' else None)
-    
+        return cls.from_string(data, encoding if encoding != "none" else None)
+
     @classmethod
-    def from_string(cls, data: Union[str, bytes], encoding: str = 'utf-8') -> "SSHSignature":
+    def from_string(
+        cls, data: Union[str, bytes], encoding: str = "utf-8"
+    ) -> "SSHSignature":
         """
         Loads an existing SSH Signature from file contents/string
 
@@ -177,17 +180,17 @@ def from_string(cls, data: Union[str, bytes], encoding: str = 'utf-8') -> "SSHSi
         """
         if isinstance(data, str):
             data = data.encode(encoding)
-        
-        if b'BEGIN SSH SIGNATURE' in data:
-            data = data.replace(b'-----BEGIN SSH SIGNATURE-----\n', b'')
-        
-        if b'END SSH SIGNATURE' in data:
-            data = data.replace(b'-----END SSH SIGNATURE-----', b'')
-        
+
+        if b"BEGIN SSH SIGNATURE" in data:
+            data = data.replace(b"-----BEGIN SSH SIGNATURE-----\n", b"")
+
+        if b"END SSH SIGNATURE" in data:
+            data = data.replace(b"-----END SSH SIGNATURE-----", b"")
+
         data = data.strip(b"\n \t")
-        
+
         return cls.decode(b64decode(data))
-    
+
     @classmethod
     def decode(cls, data: bytes) -> "SSHSignature":
         """
@@ -201,7 +204,7 @@ def decode(cls, data: bytes) -> "SSHSignature":
         """
         sig_fields, data = SignatureFieldset.decode(data)
         return cls(fields=sig_fields)
-    
+
     def get_signable(self, data: Union[str, bytes]) -> bytes:
         """
         Returns the signable data for the signature or verification
@@ -218,12 +221,12 @@ def get_signable(self, data: Union[str, bytes]) -> bytes:
             raise _EX.InvalidHashAlgorithmException(
                 f"Unknown hash algorithm {self.fields.hash_algorithm}"
             )
-        
+
         return bytes(self.fields) + _FIELD.StringField.encode(hash)
-    
+
     def get_signable_file(self, path: str) -> bytes:
         """
-        Loads the signable content from a file. 
+        Loads the signable content from a file.
         Will be loaded as bytes without encoding.
 
         Args:
@@ -232,11 +235,11 @@ def get_signable_file(self, path: str) -> bytes:
         Returns:
             bytes: The signable data from the file
         """
-        with open(path, 'rb') as f:
+        with open(path, "rb") as f:
             data = f.read()
-        
+
         return self.get_signable(data)
-        
+
     def __str__(self) -> str:
         table = PrettyTable(["Field", "Value"])
 
@@ -257,36 +260,34 @@ def set(self, field: str, data):
             return
 
         raise _EX.InvalidCertificateFieldException(f"Unknown field {field}")
-    
+
     def verify(
         self, data, public_key: _KEY.PublicKey = None, raise_on_error: bool = False
     ) -> bool:
         if not public_key:
-            public_key = self.fields.get('public_key', None)
-            
-        public_key.verify(
-            self.get_signable(data),
-            self.fields.signature.value
-        ) 
-    
+            public_key = self.fields.get("public_key", None)
+
+        public_key.verify(self.get_signable(data), self.fields.signature.value)
+
     def sign(self, data: Union[str, bytes]):
-        signable = self.get_signable(data)      
+        signable = self.get_signable(data)
         self.fields.signature.sign(signable)
-    
+
     def sign_file(self, path: str):
         signable = self.get_signable_file(path)
         self.fields.signature.sign(signable)
-    
+
     def to_string(self):
         content = self.fields.bytes_out()
         content = b64encode(content)
         file_content = b"-----BEGIN SSH SIGNATURE-----\n"
-        file_content += b''.join([content[i:i+70] + b"\n" for i in range(0, len(content), 70)])
+        file_content += b"".join(
+            [content[i : i + 70] + b"\n" for i in range(0, len(content), 70)]
+        )
         file_content += b"-----END SSH SIGNATURE-----"
-        
+
         return file_content
-    
+
     def to_file(self, path: str):
-        with open(path, 'wb') as f:
+        with open(path, "wb") as f:
             f.write(self.to_string())
-            

src/sshkey_tools/utils.py

@@ -14,7 +14,6 @@
 
 from pytimeparse2 import parse as time_parse
 
-
 NoneType = type(None)