maleo-foundation 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

maleo_foundation/client/services/encryption/aes.py

@@ -2,15 +2,22 @@ import os
 from base64 import b64decode, b64encode
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-from maleo_foundation.expanded_types.encryption.aes import MaleoFoundationAESEncryptionResultsTypes
+from maleo_foundation.expanded_types.encryption.aes \
+    import MaleoFoundationAESEncryptionResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.encryption import MaleoFoundationEncryptionSchemas
-from maleo_foundation.models.transfers.parameters.encryption.aes import MaleoFoundationAESEncryptionParametersTransfers
-from maleo_foundation.models.transfers.results.encryption.aes import EncryptData, MaleoFoundationAESEncryptionResultsTransfers
+from maleo_foundation.models.schemas.encryption \
+    import MaleoFoundationEncryptionSchemas
+from maleo_foundation.models.transfers.parameters.encryption.aes \
+    import MaleoFoundationAESEncryptionParametersTransfers
+from maleo_foundation.models.transfers.results.encryption.aes \
+    import EncryptData, MaleoFoundationAESEncryptionResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 
 class MaleoFoundationAESEncryptionClientService(ClientService):
-    def encrypt(self, parameters:MaleoFoundationAESEncryptionParametersTransfers.Encrypt) -> MaleoFoundationAESEncryptionResultsTypes.Encrypt:
+    def encrypt(
+        self,
+        parameters:MaleoFoundationAESEncryptionParametersTransfers.Encrypt
+    ) -> MaleoFoundationAESEncryptionResultsTypes.Encrypt:
         """Encrypt a plaintext using AES algorithm."""
         @BaseExceptions.service_exception_handler(
             operation="encrypting plaintext",
@@ -22,18 +29,34 @@ class MaleoFoundationAESEncryptionClientService(ClientService):
             key_bytes = os.urandom(32)
             initialization_vector_bytes = os.urandom(16)
             #* Encrypt message with encryptor instance
-            cipher = Cipher(algorithms.AES(key_bytes), modes.CFB(initialization_vector_bytes), backend=default_backend())
+            cipher = Cipher(
+                algorithm=algorithms.AES(key_bytes),
+                mode=modes.CFB(initialization_vector_bytes),
+                backend=default_backend()
+            )
             encryptor = cipher.encryptor()
-            ciphertext = b64encode(encryptor.update(parameters.plaintext.encode()) + encryptor.finalize()).decode('utf-8')
+            ciphertext = (
+                b64encode(
+                    encryptor
+                    .update(parameters.plaintext.encode()) + encryptor.finalize()
+                )
+                .decode('utf-8'))
             #* Encode the results to base64 strings
             key = b64encode(key_bytes).decode('utf-8')
             initialization_vector = b64encode(initialization_vector_bytes).decode('utf-8')
-            data = EncryptData(key=key, initialization_vector=initialization_vector, ciphertext=ciphertext)
+            data = EncryptData(
+                key=key,
+                initialization_vector=initialization_vector,
+                ciphertext=ciphertext
+            )
             self._logger.info("Plaintext successfully encrypted")
             return MaleoFoundationAESEncryptionResultsTransfers.Encrypt(data=data)
         return _impl()
 
-    def decrypt(self, parameters:MaleoFoundationAESEncryptionParametersTransfers.Decrypt) -> MaleoFoundationAESEncryptionResultsTypes.Decrypt:
+    def decrypt(
+        self,
+        parameters:MaleoFoundationAESEncryptionParametersTransfers.Decrypt
+    ) -> MaleoFoundationAESEncryptionResultsTypes.Decrypt:
         """Decrypt a ciphertext using AES algorithm."""
         @BaseExceptions.service_exception_handler(
             operation="verify single encryption",
@@ -45,9 +68,16 @@ class MaleoFoundationAESEncryptionClientService(ClientService):
             key_bytes = b64decode(parameters.key)
             initialization_vector_bytes = b64decode(parameters.initialization_vector)
             #* Decrypt message with decryptor instance
-            cipher = Cipher(algorithms.AES(key_bytes), modes.CFB(initialization_vector_bytes), backend=default_backend())
+            cipher = Cipher(
+                algorithm=algorithms.AES(key_bytes),
+                mode=modes.CFB(initialization_vector_bytes),
+                backend=default_backend()
+            )
             decryptor = cipher.decryptor()
-            plaintext = decryptor.update(b64decode(parameters.ciphertext)) + decryptor.finalize()
+            plaintext = (
+                decryptor
+                .update(b64decode(parameters.ciphertext)) + decryptor.finalize()
+            )
             data = MaleoFoundationEncryptionSchemas.Plaintext(plaintext=plaintext)
             self._logger.info("Ciphertext successfully decrypted")
             return MaleoFoundationAESEncryptionResultsTransfers.Decrypt(data=data)

maleo_foundation/client/services/encryption/rsa.py

@@ -2,16 +2,23 @@ from base64 import b64decode, b64encode
 from Crypto.Cipher import PKCS1_OAEP
 from Crypto.Hash import SHA256
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.expanded_types.encryption.rsa import MaleoFoundationRSAEncryptionResultsTypes
+from maleo_foundation.expanded_types.encryption.rsa \
+    import MaleoFoundationRSAEncryptionResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.encryption import MaleoFoundationEncryptionSchemas
-from maleo_foundation.models.transfers.parameters.encryption.rsa import MaleoFoundationRSAEncryptionParametersTransfers
-from maleo_foundation.models.transfers.results.encryption.rsa import MaleoFoundationRSAEncryptionResultsTransfers
+from maleo_foundation.models.schemas.encryption \
+    import MaleoFoundationEncryptionSchemas
+from maleo_foundation.models.transfers.parameters.encryption.rsa \
+    import MaleoFoundationRSAEncryptionParametersTransfers
+from maleo_foundation.models.transfers.results.encryption.rsa \
+    import MaleoFoundationRSAEncryptionResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
 class MaleoFoundationRSAEncryptionClientService(ClientService):
-    def encrypt(self, parameters:MaleoFoundationRSAEncryptionParametersTransfers.Encrypt) -> MaleoFoundationRSAEncryptionResultsTypes.Encrypt:
+    def encrypt(
+        self,
+        parameters:MaleoFoundationRSAEncryptionParametersTransfers.Encrypt
+    ) -> MaleoFoundationRSAEncryptionResultsTypes.Encrypt:
         """Encrypt a plaintext using RSA algorithm."""
         @BaseExceptions.service_exception_handler(
             operation="encrypting plaintext",
@@ -20,26 +27,48 @@ class MaleoFoundationRSAEncryptionClientService(ClientService):
         )
         def _impl():
             try:
-                public_key = RSAKeyLoader.load_with_pycryptodome(type=BaseEnums.KeyType.PUBLIC, extern_key=parameters.key)
+                public_key = RSAKeyLoader.load_with_pycryptodome(
+                    type=BaseEnums.KeyType.PUBLIC,
+                    extern_key=parameters.key
+                )
             except TypeError:
                 message = "Invalid key type"
                 description = "A public key must be used for encrypting a plaintext"
                 other = "Ensure the given key is of type public key"
-                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
             except Exception as e:
                 self._logger.error("Unexpected error occured while trying to import key:\n'%s'", str(e), exc_info=True)
                 message = "Invalid key"
                 description = "Unexpected error occured while trying to import key"
                 other = "Ensure given key is valid"
-                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(message=message, description=description, other=other)
-            cipher = PKCS1_OAEP.new(public_key, hashAlgo=SHA256) #* Initialize cipher with OAEP padding and SHA-256
-            ciphertext = b64encode(cipher.encrypt(parameters.plaintext.encode('utf-8'))).decode('utf-8') #* Encrypt the plaintext and return as base64-encoded string
+                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
+            #* Initialize cipher with OAEP padding and SHA-256
+            cipher = PKCS1_OAEP.new(public_key, hashAlgo=SHA256)
+            #* Encrypt the plaintext and return as base64-encoded string
+            ciphertext = (
+                b64encode(
+                    cipher
+                    .encrypt(parameters.plaintext.encode('utf-8'))
+                )
+                .decode('utf-8')
+            )
             data = MaleoFoundationEncryptionSchemas.Ciphertext(ciphertext=ciphertext)
             self._logger.info("Plaintext successfully encrypted")
             return MaleoFoundationRSAEncryptionResultsTransfers.Encrypt(data=data)
         return _impl()
 
-    def decrypt(self, parameters:MaleoFoundationRSAEncryptionParametersTransfers.Decrypt) -> MaleoFoundationRSAEncryptionResultsTypes.Decrypt:
+    def decrypt(
+        self,
+        parameters:MaleoFoundationRSAEncryptionParametersTransfers.Decrypt
+    ) -> MaleoFoundationRSAEncryptionResultsTypes.Decrypt:
         """Decrypt a ciphertext using RSA algorithm."""
         @BaseExceptions.service_exception_handler(
             operation="verify single encryption",
@@ -48,20 +77,34 @@ class MaleoFoundationRSAEncryptionClientService(ClientService):
         )
         def _impl():
             try:
-                private_key = RSAKeyLoader.load_with_pycryptodome(type=BaseEnums.KeyType.PRIVATE, extern_key=parameters.key, passphrase=parameters.password)
+                private_key = RSAKeyLoader.load_with_pycryptodome(
+                    type=BaseEnums.KeyType.PRIVATE,
+                    extern_key=parameters.key,
+                    passphrase=parameters.password
+                )
             except TypeError:
                 message = "Invalid key type"
                 description = "A private key must be used for decrypting a ciphertext"
                 other = "Ensure the given key is of type private key"
-                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
             except Exception as e:
                 self._logger.error("Unexpected error occured while trying to import key:\n'%s'", str(e), exc_info=True)
                 message = "Invalid key"
                 description = "Unexpected error occured while trying to import key"
                 other = "Ensure given key is valid"
-                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(message=message, description=description, other=other)
-            cipher = PKCS1_OAEP.new(private_key, hashAlgo=SHA256) #* Initialize cipher with OAEP padding and SHA-256
-            plaintext = cipher.decrypt(b64decode(parameters.ciphertext)) #* Decode the base64-encoded ciphertext and then decrypt
+                return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
+            #* Initialize cipher with OAEP padding and SHA-256
+            cipher = PKCS1_OAEP.new(private_key, hashAlgo=SHA256)
+            #* Decode the base64-encoded ciphertext and then decrypt
+            plaintext = cipher.decrypt(b64decode(parameters.ciphertext))
             data = MaleoFoundationEncryptionSchemas.Plaintext(plaintext=plaintext)
             self._logger.info("Ciphertext successfully decrypted")
             return MaleoFoundationRSAEncryptionResultsTransfers.Decrypt(data=data)

maleo_foundation/client/services/hash/bcrypt.py

@@ -1,13 +1,20 @@
 import bcrypt
-from maleo_foundation.expanded_types.hash import MaleoFoundationHashResultsTypes
+from maleo_foundation.expanded_types.hash \
+    import MaleoFoundationHashResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
-from maleo_foundation.models.transfers.parameters.hash.bcrypt import MaleoFoundationBcryptHashParametersTransfers
-from maleo_foundation.models.transfers.results.hash import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.schemas.hash import \
+    MaleoFoundationHashSchemas
+from maleo_foundation.models.transfers.parameters.hash.bcrypt \
+    import MaleoFoundationBcryptHashParametersTransfers
+from maleo_foundation.models.transfers.results.hash \
+    import MaleoFoundationHashResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 
 class MaleoFoundationBcryptHashClientService(ClientService):
-    def hash(self, parameters:MaleoFoundationBcryptHashParametersTransfers.Hash) -> MaleoFoundationHashResultsTypes.Hash:
+    def hash(
+        self,
+        parameters:MaleoFoundationBcryptHashParametersTransfers.Hash
+    ) -> MaleoFoundationHashResultsTypes.Hash:
         """Generate a bcrypt hash for the given message."""
         @BaseExceptions.service_exception_handler(
             operation="hashing single message",
@@ -15,14 +22,19 @@ class MaleoFoundationBcryptHashClientService(ClientService):
             fail_result_class=MaleoFoundationHashResultsTransfers.Fail
         )
         def _impl():
-            salt = bcrypt.gensalt()
-            hash = bcrypt.hashpw(parameters.message.encode(), salt).decode()
+            hash = bcrypt.hashpw(
+                password=parameters.message.encode(),
+                salt=bcrypt.gensalt()
+            ).decode()
             data = MaleoFoundationHashSchemas.Hash(hash=hash)
             self._logger.info("Message successfully hashed")
             return MaleoFoundationHashResultsTransfers.Hash(data=data)
         return _impl()
 
-    def verify(self, parameters:MaleoFoundationBcryptHashParametersTransfers.Verify) -> MaleoFoundationHashResultsTypes.Verify:
+    def verify(
+        self,
+        parameters:MaleoFoundationBcryptHashParametersTransfers.Verify
+    ) -> MaleoFoundationHashResultsTypes.Verify:
         """Verify a message against the given message hash."""
         @BaseExceptions.service_exception_handler(
             operation="verify single hash",
@@ -30,7 +42,10 @@ class MaleoFoundationBcryptHashClientService(ClientService):
             fail_result_class=MaleoFoundationHashResultsTransfers.Fail
         )
         def _impl():
-            is_valid = bcrypt.checkpw(parameters.message.encode(), parameters.hash.encode())
+            is_valid = bcrypt.checkpw(
+                password=parameters.message.encode(),
+                hashed_password=parameters.hash.encode()
+            )
             data = MaleoFoundationHashSchemas.IsValid(is_valid=is_valid)
             self._logger.info("Hash successfully verified")
             return MaleoFoundationHashResultsTransfers.Verify(data=data)

maleo_foundation/client/services/hash/hmac.py

@@ -1,13 +1,20 @@
 from Crypto.Hash import HMAC, SHA256
-from maleo_foundation.expanded_types.hash import MaleoFoundationHashResultsTypes
+from maleo_foundation.expanded_types.hash \
+    import MaleoFoundationHashResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
-from maleo_foundation.models.transfers.parameters.hash.hmac import MaleoFoundationHMACHashParametersTransfers
-from maleo_foundation.models.transfers.results.hash import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.schemas.hash import \
+    MaleoFoundationHashSchemas
+from maleo_foundation.models.transfers.parameters.hash.hmac \
+    import MaleoFoundationHMACHashParametersTransfers
+from maleo_foundation.models.transfers.results.hash \
+    import MaleoFoundationHashResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 
 class MaleoFoundationHMACHashClientService(ClientService):
-    def hash(self, parameters:MaleoFoundationHMACHashParametersTransfers.Hash) -> MaleoFoundationHashResultsTypes.Hash:
+    def hash(
+        self,
+        parameters:MaleoFoundationHMACHashParametersTransfers.Hash
+    ) -> MaleoFoundationHashResultsTypes.Hash:
         """Generate a hmac hash for the given message."""
         @BaseExceptions.service_exception_handler(
             operation="hashing single message",
@@ -15,13 +22,20 @@ class MaleoFoundationHMACHashClientService(ClientService):
             fail_result_class=MaleoFoundationHashResultsTransfers.Fail
         )
         def _impl():
-            hash = HMAC.new(parameters.key.encode(), parameters.message.encode(), SHA256).hexdigest()
+            hash = HMAC.new(
+                key=parameters.key.encode(),
+                msg=parameters.message.encode(),
+                digestmod=SHA256
+            ).hexdigest()
             data = MaleoFoundationHashSchemas.Hash(hash=hash)
             self._logger.info("Message successfully hashed")
             return MaleoFoundationHashResultsTransfers.Hash(data=data)
         return _impl()
 
-    def verify(self, parameters:MaleoFoundationHMACHashParametersTransfers.Verify) -> MaleoFoundationHashResultsTypes.Verify:
+    def verify(
+        self,
+        parameters:MaleoFoundationHMACHashParametersTransfers.Verify
+    ) -> MaleoFoundationHashResultsTypes.Verify:
         """Verify a message against the given message hash."""
         @BaseExceptions.service_exception_handler(
             operation="verify single hash",
@@ -29,7 +43,11 @@ class MaleoFoundationHMACHashClientService(ClientService):
             fail_result_class=MaleoFoundationHashResultsTransfers.Fail
         )
         def _impl():
-            computed_hash = HMAC.new(parameters.key.encode(), parameters.message.encode(), SHA256).hexdigest()
+            computed_hash = HMAC.new(
+                key=parameters.key.encode(),
+                msg=parameters.message.encode(),
+                digestmod=SHA256
+            ).hexdigest()
             is_valid = computed_hash == parameters.hash
             data = MaleoFoundationHashSchemas.IsValid(is_valid=is_valid)
             self._logger.info("Hash successfully verified")

maleo_foundation/client/services/hash/sha256.py

@@ -1,13 +1,20 @@
 from Crypto.Hash import SHA256
-from maleo_foundation.expanded_types.hash import MaleoFoundationHashResultsTypes
+from maleo_foundation.expanded_types.hash \
+    import MaleoFoundationHashResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
-from maleo_foundation.models.transfers.parameters.hash.sha256 import MaleoFoundationSHA256HashParametersTransfers
-from maleo_foundation.models.transfers.results.hash import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.schemas.hash \
+    import MaleoFoundationHashSchemas
+from maleo_foundation.models.transfers.parameters.hash.sha256 \
+    import MaleoFoundationSHA256HashParametersTransfers
+from maleo_foundation.models.transfers.results.hash \
+    import MaleoFoundationHashResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 
 class MaleoFoundationSHA256HashClientService(ClientService):
-    def hash(self, parameters:MaleoFoundationSHA256HashParametersTransfers.Hash) -> MaleoFoundationHashResultsTypes.Hash:
+    def hash(
+        self,
+        parameters:MaleoFoundationSHA256HashParametersTransfers.Hash
+    ) -> MaleoFoundationHashResultsTypes.Hash:
         """Generate a sha256 hash for the given message."""
         @BaseExceptions.service_exception_handler(
             operation="hashing single message",
@@ -21,7 +28,10 @@ class MaleoFoundationSHA256HashClientService(ClientService):
             return MaleoFoundationHashResultsTransfers.Hash(data=data)
         return _impl()
 
-    def verify(self, parameters:MaleoFoundationSHA256HashParametersTransfers.Verify) -> MaleoFoundationHashResultsTypes.Verify:
+    def verify(
+        self,
+        parameters:MaleoFoundationSHA256HashParametersTransfers.Verify
+    ) -> MaleoFoundationHashResultsTypes.Verify:
         """Verify a message against the given message hash."""
         @BaseExceptions.service_exception_handler(
             operation="verify single hash",

maleo_foundation/client/services/key.py

@@ -1,15 +1,22 @@
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization
-from maleo_foundation.expanded_types.key import MaleoFoundationKeyResultsTypes
+from maleo_foundation.expanded_types.key \
+    import MaleoFoundationKeyResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.transfers.general.key import MaleoFoundationKeyGeneralTransfers
-from maleo_foundation.models.transfers.parameters.key import MaleoFoundationKeyParametersTransfers
-from maleo_foundation.models.transfers.results.key import MaleoFoundationKeyResultsTransfers
+from maleo_foundation.models.transfers.general.key \
+    import MaleoFoundationKeyGeneralTransfers
+from maleo_foundation.models.transfers.parameters.key \
+    import MaleoFoundationKeyParametersTransfers
+from maleo_foundation.models.transfers.results.key \
+    import MaleoFoundationKeyResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 
 class MaleoFoundationKeyClientService(ClientService):
-    def create_private(self, parameters:MaleoFoundationKeyParametersTransfers.CreatePrivateOrPair) -> MaleoFoundationKeyResultsTypes.CreatePrivate:
+    def create_private(
+        self,
+        parameters:MaleoFoundationKeyParametersTransfers.CreatePrivateOrPair
+    ) -> MaleoFoundationKeyResultsTypes.CreatePrivate:
         """Create an RSA private key with X.509 encoding in .pem format."""
         @BaseExceptions.service_exception_handler(
             operation="creating private key",
@@ -27,7 +34,9 @@ class MaleoFoundationKeyClientService(ClientService):
             if parameters.password is None:
                 encryption_algorithm = serialization.NoEncryption()
             else:
-                encryption_algorithm = serialization.BestAvailableEncryption(parameters.password.encode())
+                encryption_algorithm = serialization.BestAvailableEncryption(
+                    parameters.password.encode()
+                )
 
             #* Serialize private key to PEM format
             private_key_bytes = private_key.private_bytes(
@@ -37,11 +46,16 @@ class MaleoFoundationKeyClientService(ClientService):
             )
 
             self._logger.info("Successfully created private key")
-            data = MaleoFoundationKeyGeneralTransfers.PrivateKey(value=private_key_bytes.decode())
+            data = MaleoFoundationKeyGeneralTransfers.PrivateKey(
+                value=private_key_bytes.decode()
+            )
             return MaleoFoundationKeyResultsTransfers.CreatePrivate(data=data)
         return _impl()
 
-    def create_public(self, parameters:MaleoFoundationKeyParametersTransfers.CreatePublic) -> MaleoFoundationKeyResultsTypes.CreatePublic:
+    def create_public(
+        self,
+        parameters:MaleoFoundationKeyParametersTransfers.CreatePublic
+    ) -> MaleoFoundationKeyResultsTypes.CreatePublic:
         """Create an RSA public key with X.509 encoding in .pem format."""
         @BaseExceptions.service_exception_handler(
             operation="creating public key",
@@ -66,7 +80,9 @@ class MaleoFoundationKeyClientService(ClientService):
             )
 
             self._logger.info("Successfully created public key")
-            data = MaleoFoundationKeyGeneralTransfers.PublicKey(value=public_key_bytes.decode())
+            data = MaleoFoundationKeyGeneralTransfers.PublicKey(
+                value=public_key_bytes.decode()
+            )
             return MaleoFoundationKeyResultsTransfers.CreatePublic(data=data)
         return _impl()
 
@@ -88,7 +104,9 @@ class MaleoFoundationKeyClientService(ClientService):
             if parameters.password is None:
                 encryption_algorithm = serialization.NoEncryption()
             else:
-                encryption_algorithm = serialization.BestAvailableEncryption(parameters.password.encode())
+                encryption_algorithm = serialization.BestAvailableEncryption(
+                    parameters.password.encode()
+                )
 
             #* Serialize private key to PEM format
             private_key_bytes = private_key.private_bytes(
@@ -96,7 +114,9 @@ class MaleoFoundationKeyClientService(ClientService):
                 format=serialization.PrivateFormat.PKCS8,
                 encryption_algorithm=encryption_algorithm
             )
-            private = MaleoFoundationKeyGeneralTransfers.PrivateKey(value=private_key_bytes.decode())
+            private = MaleoFoundationKeyGeneralTransfers.PrivateKey(
+                value=private_key_bytes.decode()
+            )
 
             public_key = private_key.public_key() #* Create public key
 
@@ -105,7 +125,9 @@ class MaleoFoundationKeyClientService(ClientService):
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PublicFormat.SubjectPublicKeyInfo
             )
-            public = MaleoFoundationKeyGeneralTransfers.PublicKey(value=public_key_bytes.decode())
+            public = MaleoFoundationKeyGeneralTransfers.PublicKey(
+                value=public_key_bytes.decode()
+            )
 
             self._logger.info("Successfully created key pair")
             data = MaleoFoundationKeyGeneralTransfers.KeyPair(private=private, public=public)

maleo_foundation/client/services/signature.py

@@ -2,16 +2,23 @@ from base64 import b64decode, b64encode
 from Crypto.Hash import SHA256
 from Crypto.Signature import pkcs1_15
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.expanded_types.signature import MaleoFoundationSignatureResultsTypes
+from maleo_foundation.expanded_types.signature \
+    import MaleoFoundationSignatureResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.signature import MaleoFoundationSignatureSchemas
-from maleo_foundation.models.transfers.parameters.signature import MaleoFoundationSignatureParametersTransfers
-from maleo_foundation.models.transfers.results.signature import MaleoFoundationSignatureResultsTransfers
+from maleo_foundation.models.schemas.signature \
+    import MaleoFoundationSignatureSchemas
+from maleo_foundation.models.transfers.parameters.signature \
+    import MaleoFoundationSignatureParametersTransfers
+from maleo_foundation.models.transfers.results.signature \
+    import MaleoFoundationSignatureResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
 class MaleoFoundationSignatureClientService(ClientService):
-    def sign(self, parameters:MaleoFoundationSignatureParametersTransfers.Sign) -> MaleoFoundationSignatureResultsTypes.Sign:
+    def sign(
+        self,
+        parameters:MaleoFoundationSignatureParametersTransfers.Sign
+    ) -> MaleoFoundationSignatureResultsTypes.Sign:
         @BaseExceptions.service_exception_handler(
             operation="signing single message",
             logger=self._logger,
@@ -19,18 +26,30 @@ class MaleoFoundationSignatureClientService(ClientService):
         )
         def _impl():
             try:
-                private_key = RSAKeyLoader.load_with_pycryptodome(type=BaseEnums.KeyType.PRIVATE, extern_key=parameters.key, passphrase=parameters.password)
+                private_key = RSAKeyLoader.load_with_pycryptodome(
+                    type=BaseEnums.KeyType.PRIVATE,
+                    extern_key=parameters.key,
+                    passphrase=parameters.password
+                )
             except TypeError:
                 message = "Invalid key type"
                 description = "A private key must be used for signing a message"
                 other = "Ensure the given key is of type private key"
-                return MaleoFoundationSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationSignatureResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
             except Exception as e:
                 self._logger.error("Unexpected error occured while trying to import key:\n'%s'", str(e), exc_info=True)
                 message = "Invalid key"
                 description = "Unexpected error occured while trying to import key"
                 other = "Ensure given key is valid"
-                return MaleoFoundationSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationSignatureResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
             hash = SHA256.new(parameters.message.encode()) #* Generate message hash
             signature = b64encode(pkcs1_15.new(private_key).sign(hash)).decode() #* Sign the hashed message
             data = MaleoFoundationSignatureSchemas.Signature(signature=signature)
@@ -38,7 +57,10 @@ class MaleoFoundationSignatureClientService(ClientService):
             return MaleoFoundationSignatureResultsTransfers.Sign(data=data)
         return _impl()
 
-    def verify(self, parameters:MaleoFoundationSignatureParametersTransfers.Verify) -> MaleoFoundationSignatureResultsTypes.Verify:
+    def verify(
+        self,
+        parameters:MaleoFoundationSignatureParametersTransfers.Verify
+    ) -> MaleoFoundationSignatureResultsTypes.Verify:
         @BaseExceptions.service_exception_handler(
             operation="verify single signature",
             logger=self._logger,
@@ -46,18 +68,29 @@ class MaleoFoundationSignatureClientService(ClientService):
         )
         def _impl():
             try:
-                public_key = RSAKeyLoader.load_with_pycryptodome(type=BaseEnums.KeyType.PUBLIC, extern_key=parameters.key)
+                public_key = RSAKeyLoader.load_with_pycryptodome(
+                    type=BaseEnums.KeyType.PUBLIC,
+                    extern_key=parameters.key
+                )
             except TypeError:
                 message = "Invalid key type"
                 description = "A public key must be used for verifying a signature"
                 other = "Ensure the given key is of type public key"
-                return MaleoFoundationSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationSignatureResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
             except Exception as e:
                 self._logger.error("Unexpected error occured while trying to import key:\n'%s'", str(e), exc_info=True)
                 message = "Invalid key"
                 description = "Unexpected error occured while trying to import key"
                 other = "Ensure given key is valid"
-                return MaleoFoundationSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationSignatureResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
             hash = SHA256.new(parameters.message.encode()) #* Generate message hash
             #* Verify the hashed message and decoded signature
             try: