maleo-foundation 0.1.69__tar.gz → 0.1.71__tar.gz

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.69
+Version: 0.1.71
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation/authentication.py

@@ -1,7 +1,5 @@
-from starlette.authentication import (
-    AuthCredentials,
-    BaseUser
-)
+from pydantic import BaseModel, Field
+from starlette.authentication import AuthCredentials, BaseUser
 from typing import Optional, Sequence
 from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
 from maleo_foundation.types import BaseTypes
@@ -46,4 +44,11 @@ class User(BaseUser):
 
     @property
     def identity(self) -> str:
-        return self._email
+        return self._email
+
+class Authentication(BaseModel):
+    credentials:Credentials = Field(..., description="Credentials's information")
+    user:User = Field(..., description="User's information")
+
+    class Config:
+        arbitrary_types_allowed=True

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation/client/services/signature.py

@@ -1,13 +1,14 @@
 from base64 import b64decode, b64encode
-from Crypto.PublicKey import RSA
 from Crypto.Hash import SHA256
 from Crypto.Signature import pkcs1_15
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.expanded_types.signature import BaseSignatureResultsTypes
+from maleo_foundation.managers.client.base import ClientService
 from maleo_foundation.models.schemas.signature import BaseSignatureSchemas
 from maleo_foundation.models.transfers.parameters.signature import BaseSignatureParametersTransfers
 from maleo_foundation.models.transfers.results.signature import BaseSignatureResultsTransfers
-from maleo_foundation.expanded_types.signature import BaseSignatureResultsTypes
-from maleo_foundation.managers.client.base import ClientService
 from maleo_foundation.utils.exceptions import BaseExceptions
+from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
 class MaleoFoundationSignatureClientService(ClientService):
     def sign(self, parameters:BaseSignatureParametersTransfers.Sign) -> BaseSignatureResultsTypes.Sign:
@@ -18,14 +19,12 @@ class MaleoFoundationSignatureClientService(ClientService):
         )
         def _impl():
             try:
-                #* Load RSA key using PyCryptodome's RSA.import_key
-                private_key = RSA.import_key(extern_key=parameters.key, passphrase=parameters.password)
-                #* Validate the key type
-                if not private_key.has_private():
-                    message = "Invalid key type"
-                    description = "A private key must be used for RSA Verify"
-                    other = "Ensure the given key is of type private key"
-                    return BaseSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+                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 BaseSignatureResultsTransfers.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"
@@ -39,7 +38,7 @@ class MaleoFoundationSignatureClientService(ClientService):
             return BaseSignatureResultsTransfers.Sign(data=data)
         return _impl()
 
-    def verify(self, parameters:BaseSignatureParametersTransfers.Verify) -> BaseSignatureResultsTypes.Verify:
+    def decode(self, parameters:BaseSignatureParametersTransfers.Verify) -> BaseSignatureResultsTypes.Verify:
         @BaseExceptions.service_exception_handler(
             operation="verify single signature",
             logger=self._logger,
@@ -47,14 +46,12 @@ class MaleoFoundationSignatureClientService(ClientService):
         )
         def _impl():
             try:
-                #* Load RSA key using PyCryptodome's RSA.import_key
-                public_key = RSA.import_key(parameters.key)
-                #* Validate the key type
-                if public_key.has_private():
-                    message = "Invalid key type"
-                    description = "A public key must be used for RSA Sign"
-                    other = "Ensure the given key is of type public key"
-                    return BaseSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+                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 BaseSignatureResultsTransfers.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"

maleo_foundation-0.1.71/maleo_foundation/client/services/token.py

@@ -0,0 +1,62 @@
+import jwt
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.expanded_types.token import BaseTokenResultsTypes
+from maleo_foundation.managers.client.base import ClientService
+from maleo_foundation.models.schemas.token import BaseTokenSchemas
+from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
+from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
+from maleo_foundation.models.transfers.results.token import BaseTokenResultsTransfers
+from maleo_foundation.utils.exceptions import BaseExceptions
+from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
+
+class MaleoFoundationTokenClientService(ClientService):
+    def encode(self, parameters:BaseTokenParametersTransfers.Encode) -> BaseTokenResultsTypes.Encode:
+        @BaseExceptions.service_exception_handler(
+            operation="encoding a payload into a token",
+            logger=self._logger,
+            fail_result_class=BaseTokenResultsTransfers.Fail
+        )
+        def _impl():
+            try:
+                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 payload encoding"
+                other = "Ensure the given key is of type private key"
+                return BaseTokenResultsTransfers.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 BaseTokenResultsTransfers.Fail(message=message, description=description, other=other)
+            payload = BaseTokenGeneralTransfers.EncodePayload.model_validate(parameters.payload.model_dump()).model_dump(mode="json")
+            token = jwt.encode(payload=payload, key=private_key.export_key(), algorithm="RS256")
+            data = BaseTokenSchemas.Token(token=token)
+            return BaseTokenResultsTransfers.Encode(data=data)
+        return _impl()
+
+    def decode(self, parameters:BaseTokenParametersTransfers.Decode) -> BaseTokenResultsTypes.Decode:
+        @BaseExceptions.service_exception_handler(
+            operation="decoding a token into a payload",
+            logger=self._logger,
+            fail_result_class=BaseTokenResultsTransfers.Fail
+        )
+        def _impl():
+            try:
+                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 token decoding"
+                other = "Ensure the given key is of type public key"
+                return BaseTokenResultsTransfers.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 BaseTokenResultsTransfers.Fail(message=message, description=description, other=other)
+            payload = jwt.decode(jwt=parameters.token, key=public_key.export_key(), algorithms=["RS256"])
+            data = BaseTokenGeneralTransfers.DecodePayload.model_validate(payload)
+            return BaseTokenResultsTransfers.Decode(data=data)
+        return _impl()

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation/middlewares/authentication.py

@@ -34,7 +34,19 @@ class Backend(AuthenticationBackend):
         if decode_token_result.data.exp_dt <= datetime.now(tz=timezone.utc):
             raise AuthenticationError("Expired Bearer token, request new or refresh token")
 
-        return Credentials(token=token, payload=decode_token_result.data, scopes=["authenticated"]), User(authenticated=True, username=decode_token_result.data.u_u, email=decode_token_result.data.u_e)
+        payload = decode_token_result.data
+        return (
+            Credentials(
+                token=token,
+                payload=payload,
+                scopes=["authenticated", payload.sr]
+            ),
+            User(
+                authenticated=True,
+                username=payload.u_u,
+                email=payload.u_e
+            )
+        )
 
 def add_authentication_middleware(app:FastAPI, keys:BaseGeneralSchemas.RSAKeys, logger:MiddlewareLogger, maleo_foundation:MaleoFoundationClientManager) -> None:
     """

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation/middlewares/base.py

@@ -148,8 +148,8 @@ class BaseMiddleware(BaseHTTPMiddleware):
         response = self._add_response_headers(request, response, request_timestamp, response_timestamp, process_time)
         log_func = getattr(self._logger, log_level)
         log_func(
-            f"Request {authentication_info} | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
-            f"Headers: {dict(request.headers)} - Response | Status: {response.status_code} | "
+            f"Request {authentication_info} | IP: {client_ip} | Host: {request.client.host} | Port: {request.client.port} | Method: {request.method} | URL: {request.url.path} | "
+            f"Headers: {dict(request.headers)} - Response | Status: {response.status_code}"
         )
         return response
 
@@ -179,7 +179,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         )
 
         self._logger.error(
-            f"Request {authentication_info} | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
+            f"Request {authentication_info} | IP: {client_ip} | Host: {request.client.host} | Port: {request.client.port} | Method: {request.method} | URL: {request.url.path} | "
             f"Headers: {dict(request.headers)} - Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
         )
 

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation/utils/loaders/__init__.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 from .json import JSONLoader
-from .key import KeyLoader
+from .key import BaseKeyLoaders
 from .yaml import YAMLLoader
 
 class BaseLoaders:
     Json = JSONLoader
-    Key = KeyLoader
+    Key = BaseKeyLoaders
     Yaml = YAMLLoader

maleo_foundation-0.1.71/maleo_foundation/utils/loaders/key/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+from .rsa import RSAKeyLoader
+
+class BaseKeyLoaders:
+    RSA = RSAKeyLoader

maleo_foundation-0.1.71/maleo_foundation/utils/loaders/key/rsa.py

@@ -0,0 +1,93 @@
+from cryptography.hazmat.primitives import serialization
+from Crypto.PublicKey import RSA
+from pathlib import Path
+from typing import Optional, Union
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.types import BaseTypes
+
+class RSAKeyLoader:
+    @staticmethod
+    def load_with_cryptography(
+        type:BaseEnums.KeyType,
+        data:Optional[Union[bytes, str]] = None,
+        path:Optional[Union[str, Path]] = None,
+        password:Optional[Union[bytes, str]] = None,
+        format:BaseEnums.KeyFormatType = BaseEnums.KeyFormatType.STRING,
+    ) -> Union[bytes, str]:
+        if not isinstance(type, BaseEnums.KeyType):
+            raise TypeError("Invalid key type")
+
+        if data is not None and path is not None:
+            raise ValueError("Only either data or path will be accepted as parameters")
+
+        if data is not None:
+            if isinstance(data, bytes):
+                key_data = data
+            elif isinstance(data, str):
+                key_data = data.encode()
+            else:
+                raise TypeError("Invalid data type")
+
+        if path is not None:
+            file_path = Path(path)
+
+            if not file_path.exists() or not file_path.is_file():
+                raise FileNotFoundError(f"Key file not found: {file_path}")
+
+            key_data = file_path.read_bytes()
+
+        if password is not None and not isinstance(password, (str, bytes)):
+            raise TypeError("Invalid passsword type")
+
+        if not isinstance(format, BaseEnums.KeyFormatType):
+            raise TypeError("Invalid key format type")
+
+        if type == BaseEnums.KeyType.PRIVATE:
+            private_key = serialization.load_pem_private_key(
+                key_data,
+                password=password.encode() if isinstance(password, str) else password,
+            )
+            private_key_bytes = private_key.private_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PrivateFormat.PKCS8,
+                encryption_algorithm=serialization.NoEncryption()
+            )
+            if format == BaseEnums.KeyFormatType.BYTES:
+                return private_key_bytes
+            elif format == BaseEnums.KeyFormatType.STRING:
+                return private_key_bytes.decode()
+
+        if type == BaseEnums.KeyType.PUBLIC:
+            public_key = serialization.load_pem_public_key(key_data)
+            public_key_bytes = public_key.public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+            )
+            if format == BaseEnums.KeyFormatType.BYTES:
+                return public_key_bytes
+            elif format == BaseEnums.KeyFormatType.STRING:
+                return public_key_bytes.decode()
+
+    @staticmethod
+    def load_with_pycryptodome(
+        type:BaseEnums.KeyType,
+        extern_key:Union[bytes, str],
+        passphrase:BaseTypes.OptionalString = None,
+    ) -> RSA.RsaKey:
+        if not isinstance(type, BaseEnums.KeyType):
+            raise TypeError("Invalid key type")
+
+        if not isinstance(extern_key, (str, bytes)):
+            raise TypeError("Invalid external key type")
+
+        if type == BaseEnums.KeyType.PRIVATE:
+            private_key = RSA.import_key(extern_key=extern_key, passphrase=passphrase)
+            if not private_key.has_private():
+                raise TypeError("Invalid chosen key type, the private key did not has private inside it")
+            return private_key
+
+        if type == BaseEnums.KeyType.PUBLIC:
+            public_key = RSA.import_key(extern_key=extern_key)
+            if public_key.has_private():
+                raise TypeError("Invalid chosen key type, the public key did has private inside it")
+            return public_key

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.69
+Version: 0.1.71
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/maleo_foundation.egg-info/SOURCES.txt

@@ -79,5 +79,6 @@ maleo_foundation/utils/formatter/__init__.py
 maleo_foundation/utils/formatter/case.py
 maleo_foundation/utils/loaders/__init__.py
 maleo_foundation/utils/loaders/json.py
-maleo_foundation/utils/loaders/key.py
-maleo_foundation/utils/loaders/yaml.py
+maleo_foundation/utils/loaders/yaml.py
+maleo_foundation/utils/loaders/key/__init__.py
+maleo_foundation/utils/loaders/key/rsa.py

{maleo_foundation-0.1.69 → maleo_foundation-0.1.71}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo_foundation"
-version = "0.1.69"
+version = "0.1.71"
 description = "Foundation package for Maleo"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }

maleo_foundation-0.1.69/maleo_foundation/client/services/token.py

@@ -1,34 +0,0 @@
-import jwt
-from maleo_foundation.models.schemas.token import BaseTokenSchemas
-from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
-from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
-from maleo_foundation.models.transfers.results.token import BaseTokenResultsTransfers
-from maleo_foundation.expanded_types.token import BaseTokenResultsTypes
-from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.utils.exceptions import BaseExceptions
-
-class MaleoFoundationTokenClientService(ClientService):
-    def encode(self, parameters:BaseTokenParametersTransfers.Encode) -> BaseTokenResultsTypes.Encode:
-        @BaseExceptions.service_exception_handler(
-            operation="encoding a payload into a token",
-            logger=self._logger,
-            fail_result_class=BaseTokenResultsTransfers.Fail
-        )
-        def _impl():
-            payload = BaseTokenGeneralTransfers.EncodePayload.model_validate(parameters.payload.model_dump()).model_dump(mode="json")
-            token = jwt.encode(payload=payload, key=parameters.key, algorithm="RS256")
-            data = BaseTokenSchemas.Token(token=token)
-            return BaseTokenResultsTransfers.Encode(data=data)
-        return _impl()
-
-    def decode(self, parameters:BaseTokenParametersTransfers.Decode) -> BaseTokenResultsTypes.Decode:
-        @BaseExceptions.service_exception_handler(
-            operation="decoding a token into a payload",
-            logger=self._logger,
-            fail_result_class=BaseTokenResultsTransfers.Fail
-        )
-        def _impl():
-            payload = jwt.decode(jwt=parameters.token, key=parameters.key, algorithms=["RS256"])
-            data = BaseTokenGeneralTransfers.DecodePayload.model_validate(payload)
-            return BaseTokenResultsTransfers.Decode(data=data)
-        return _impl()

maleo_foundation-0.1.69/maleo_foundation/utils/loaders/key.py

@@ -1,67 +0,0 @@
-from cryptography.hazmat.primitives import serialization
-from pathlib import Path
-from typing import Optional, Union
-from maleo_foundation.enums import BaseEnums
-
-class KeyLoader:
-    @staticmethod
-    def load_rsa(
-        type:BaseEnums.KeyType,
-        path: Union[str, Path],
-        password:Optional[Union[str, bytes]] = None,
-        format:BaseEnums.KeyFormatType = BaseEnums.KeyFormatType.STRING,
-    ) -> Union[bytes, str]:
-        """
-        Load an RSA private or public key strictly from a file.
-
-        Args:
-            path (str | Path): Path to the PEM file.
-            password (str | bytes | None): Password for encrypted private keys (optional).
-
-        Returns:
-            rsa.RSAPrivateKey | rsa.RSAPublicKey
-        """
-        if not isinstance(type, BaseEnums.KeyType):
-            raise TypeError("Invalid key type")
-
-        file_path = Path(path)
-
-        if not file_path.is_file():
-            raise FileNotFoundError(f"Key file not found: {file_path}")
-
-        if password is not None and not isinstance(password, (str, bytes)):
-            raise TypeError("Invalid passsword type")
-
-        if not isinstance(format, BaseEnums.KeyFormatType):
-            raise TypeError("Invalid key format type")
-
-        key_data = file_path.read_bytes()
-
-        if type == BaseEnums.KeyType.PRIVATE:
-            private_key = serialization.load_pem_private_key(
-                key_data,
-                password=password.encode() if isinstance(password, str) else password,
-            )
-            private_key_bytes = private_key.private_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PrivateFormat.PKCS8,
-                encryption_algorithm=serialization.NoEncryption()
-            )
-            if format == BaseEnums.KeyFormatType.BYTES:
-                return private_key_bytes
-            elif format == BaseEnums.KeyFormatType.STRING:
-                return private_key_bytes.decode()
-
-        elif type == BaseEnums.KeyType.PUBLIC:
-            public_key = serialization.load_pem_public_key(key_data)
-            public_key_bytes = public_key.public_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo
-            )
-            if format == BaseEnums.KeyFormatType.BYTES:
-                return public_key_bytes
-            elif format == BaseEnums.KeyFormatType.STRING:
-                return public_key_bytes.decode()
-
-        else:
-            raise ValueError(f"Unsupported key type: {type}")