maleo-foundation 0.1.70__py3-none-any.whl → 0.1.72__py3-none-any.whl

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/client/services/token.py

@@ -1,11 +1,13 @@
 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.expanded_types.token import BaseTokenResultsTypes
-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 MaleoFoundationTokenClientService(ClientService):
     def encode(self, parameters:BaseTokenParametersTransfers.Encode) -> BaseTokenResultsTypes.Encode:
@@ -15,8 +17,21 @@ class MaleoFoundationTokenClientService(ClientService):
             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=parameters.key, algorithm="RS256")
+            token = jwt.encode(payload=payload, key=private_key.export_key(), algorithm="RS256")
             data = BaseTokenSchemas.Token(token=token)
             return BaseTokenResultsTransfers.Encode(data=data)
         return _impl()
@@ -28,7 +43,20 @@ class MaleoFoundationTokenClientService(ClientService):
             fail_result_class=BaseTokenResultsTransfers.Fail
         )
         def _impl():
-            payload = jwt.decode(jwt=parameters.token, key=parameters.key, algorithms=["RS256"])
+            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/managers/client/base.py

@@ -1,10 +1,21 @@
 import httpx
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, Field
-from typing import AsyncGenerator
+from typing import AsyncGenerator, Generator
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import ClientLogger, SimpleConfig
 
+class BearerAuth(httpx.Auth):
+    def __init__(self, token:str) -> None:
+        self._auth_header = self._build_auth_header(token)
+
+    def auth_flow(self, request:httpx.Request) -> Generator[httpx.Request, httpx.Response, None]:
+        request.headers["Authorization"] = self._auth_header
+        yield request
+
+    def _build_auth_header(self, token:str) -> str:
+        return f"Bearer {token}"
+
 class URL(BaseModel):
     base:str = Field(..., description="Base URL")
 

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/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/utils/loaders/key/__init__.py

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

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.70.dist-info → maleo_foundation-0.1.72.dist-info}/METADATA

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

{maleo_foundation-0.1.70.dist-info → maleo_foundation-0.1.72.dist-info}/RECORD

@@ -7,8 +7,8 @@ maleo_foundation/types.py,sha256=aKXnIgEhYGSfFqNMGLc4qIKGkINBRpkOo9R9cb2CbwI,241
 maleo_foundation/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/client/manager.py,sha256=3YO2uoBLoC9nbe1yNuqPjhgORSDwb5Zu68KLS2zvKXY,1206
 maleo_foundation/client/services/__init__.py,sha256=SUGBVhs_Zu9rNUxWIxcjGmi54W6RRlwSTqW4h8E0vW0,540
-maleo_foundation/client/services/signature.py,sha256=W9ZF_FGGOMXw03jaRlZJPkakCw0grZk52P8IAkOxYLs,4373
-maleo_foundation/client/services/token.py,sha256=KJcA6aTW12JovrbBf0KoKMDgOopz-mZ_SmCRHhWLS_k,1894
+maleo_foundation/client/services/signature.py,sha256=HGFhdva-4FkEx5s4QSwI2U8y0i2hIyRQCCWLWKQwGp8,4300
+maleo_foundation/client/services/token.py,sha256=p1cA60ofeFJeL2MVKnAjnggIFniVSp2Hbd7VTYE255E,3880
 maleo_foundation/expanded_types/__init__.py,sha256=lm_r7rxlLA0sgSTGQBMR9ZbZbVDpD7Te-UYb3oRVi1g,364
 maleo_foundation/expanded_types/client.py,sha256=To0kRXp3QTmuSu5rWKaCiTsMK9qkYiyYKYbHfw-y1fY,2396
 maleo_foundation/expanded_types/general.py,sha256=bjIBREYTS73tvS-Key7P7db82a2HHlSJ1XBAvKuYmT0,826
@@ -21,13 +21,13 @@ maleo_foundation/managers/db.py,sha256=Pn5EZ-c1Hy6-BihN7KokHJWmBIt3Ty96fZ0zF-srt
 maleo_foundation/managers/middleware.py,sha256=ODIQU1Hpu-Xempjjo_VRbVtxiD5oi74mNuoWuDawRh0,4250
 maleo_foundation/managers/service.py,sha256=X2NgK5yVRkO5HSVGhN6PgoN-1sGn9w-_PDx1lFVGj2c,16844
 maleo_foundation/managers/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo_foundation/managers/client/base.py,sha256=qfWu_wxoPSSzgZwuTEwRiXERg60diAkz65Qk3fnQej4,3972
+maleo_foundation/managers/client/base.py,sha256=5z9l2GN4QASF0-Lft8o5QQ3SRPXqeNZNT1S1CgaE764,4384
 maleo_foundation/managers/client/maleo.py,sha256=iCM47TLL-RSQ2FkTmHVPdsb2JCd1LebMx6OJvIr4vCQ,2035
 maleo_foundation/managers/client/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/client/google/base.py,sha256=j3W18Pmcu9jJ5wK12bbWBI6r8cVt5f7QmGU9uIJgKrU,1249
 maleo_foundation/managers/client/google/secret.py,sha256=Uh01RoOp8QOIvu8X4AGJzOJRlrfAeXHO8ZFvmKo7A-E,3114
 maleo_foundation/managers/client/google/storage.py,sha256=MPuVpLTl0QJhlBOqpxv5UtD3ANO1WCCE1sRrfHnlCZM,2355
-maleo_foundation/middlewares/authentication.py,sha256=zIq4zeQnrogSURqQDtOMAx7D1cMCcG6ZScYyaFw7onM,3173
+maleo_foundation/middlewares/authentication.py,sha256=6QerNZjdSrwcE-pHin__Ry517rBBj8mhACrsD_z-YAI,3337
 maleo_foundation/middlewares/base.py,sha256=8quBiHK4gYARmxnlmcADoNWhv0eGxGaGOFQs2bofbbU,13281
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
 maleo_foundation/models/__init__.py,sha256=AaKehO7c1HyKhoTGRmNHDddSeBXkW-_YNrpOGBu8Ms8,246
@@ -70,11 +70,12 @@ maleo_foundation/utils/mergers.py,sha256=DniUu3Ot4qkYH_YSw4uD1cn9cfirum4S_Opp8fM
 maleo_foundation/utils/query.py,sha256=ODQ3adOYQNj5E2cRW9ytbjBz56nEDcnfq8mQ6YZbCCM,4375
 maleo_foundation/utils/formatter/__init__.py,sha256=iKf5YCbEdg1qKnFHyKqqcQbqAqEeRUf8mhI3v3dQoj8,78
 maleo_foundation/utils/formatter/case.py,sha256=TmvvlfzGdC_omMTB5vAa40TZBxQ3hnr-SYeo0M52Rlg,1352
-maleo_foundation/utils/loaders/__init__.py,sha256=Dnuv7BWyglSddnbsFb96s-b3KaW7UK1uLsMZfZ8zVi8,203
+maleo_foundation/utils/loaders/__init__.py,sha256=RCfPdfgY-F25VDMSA-TWyoczRVUiIDDXpmui8tv5HxM,213
 maleo_foundation/utils/loaders/json.py,sha256=NsXLq3VZSgzmEf99tV1VtrmiudWdQ8Pzh_hI4Rm0cM8,397
-maleo_foundation/utils/loaders/key.py,sha256=GZ4h1ONfp6Xx8-E8AWoGP4ajAZrwPhZRtidjn_u82Qg,2562
 maleo_foundation/utils/loaders/yaml.py,sha256=jr8v3BlgmRCMTzdNgKhIYt1tnubaJXcDSSGkKVR8pbw,362
-maleo_foundation-0.1.70.dist-info/METADATA,sha256=jU0ANA5E3Lo0a6t3-DFOP6VIEyRqfz68iMETK5Ew-uU,3390
-maleo_foundation-0.1.70.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-maleo_foundation-0.1.70.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.1.70.dist-info/RECORD,,
+maleo_foundation/utils/loaders/key/__init__.py,sha256=G03cA_Oxu02uDsg0WBPfPkIM2uUsxnjwOPgtBKe02kc,110
+maleo_foundation/utils/loaders/key/rsa.py,sha256=gDhyX6iTFtHiluuhFCozaZ3pOLKU2Y9TlrNMK_GVyGU,3796
+maleo_foundation-0.1.72.dist-info/METADATA,sha256=2DYADDD2buTe4fJtuusJSZD62BwOcda2IZvrAMal-CM,3390
+maleo_foundation-0.1.72.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+maleo_foundation-0.1.72.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.1.72.dist-info/RECORD,,

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}")