Encryptors 2.81.2__tar.gz → 2.81.3__tar.gz

{encryptors-2.81.2 → encryptors-2.81.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.81.2
+Version: 2.81.3
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.81.2 → encryptors-2.81.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 # ANDERSON REVISAR EL CACHE LOCAL DEL KEYVAULT PARA VALIDAR SI FUNCIONA
 setup(
     name="Encryptors", 
-    version="2.81.2",
+    version="2.81.3",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.81.2 → encryptors-2.81.3}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.81.2
+Version: 2.81.3
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.81.2 → encryptors-2.81.3}/src/Encryptors.egg-info/SOURCES.txt

@@ -35,8 +35,8 @@ src/Osdental/Helpers/GrpcConnection.py
 src/Osdental/Helpers/Resilience.py
 src/Osdental/Helpers/ResponseDecryptor.py
 src/Osdental/Helpers/__init__.py
-src/Osdental/Helpers/extract_auth_token.py
-src/Osdental/Helpers/tenant_policy.py
+src/Osdental/Helpers/authorization_helpers.py
+src/Osdental/Helpers/request_decryption.py
 src/Osdental/Helpers/token_validation_service.py
 src/Osdental/Http/Constants.py
 src/Osdental/Http/Exceptions.py

{encryptors-2.81.2 → encryptors-2.81.3}/src/Osdental/Decorators/SecureResolver.py

@@ -1,14 +1,13 @@
-import json
 from functools import wraps
 from typing import Callable
 from Osdental.Models.Response import Response
 from Osdental.Shared.Enums.Profile import Profile
 from Osdental.Exception.ControlledException import (
-    OSDException, AccessDeniedException, UnauthorizedException
+    OSDException, AccessDeniedException
 )
-from Osdental.Encryptor.Aes import AES
 from Osdental.Models.base_graphql_context import BaseGraphQLContext
-from Osdental.Helpers.tenant_policy import TenantPolicy
+from Osdental.Helpers.authorization_helpers import tenant_context_resolver
+from Osdental.Helpers.request_decryption import decrypt_payload
 from Osdental.Secrets import ISecretProvider
 from Osdental.Shared.Logger import logger
 
@@ -29,67 +28,34 @@ def resolver(action=None):
                             error="User not allowed to perform this action"
                         )
                     
-                # Get secrets
                 secret_service: ISecretProvider = context.container.secret_service
-                keys = await secret_service.get_many(
+                secrets = await secret_service.get_many(
                     ["AES-KEY-AUTH", "AES-KEY-USER", "AUTH-JWT-USER-KEY"]
                 )
-                #
-
-                encrypted_payload = kwargs.get("data")
-    
-                decrypted_payload = None
-
-                if encrypted_payload is not None:
-
-                    if not isinstance(encrypted_payload, str):
-                        raise ValueError("Encrypted payload must be a string")
-
-                    if not context.aes_auth:
-                        raise ValueError("Missing AES configuration")
-
-                    try:
-                        decrypted = AES.decrypt(context.aes_auth, encrypted_payload)
-                    except Exception:
-                        raise ValueError("Invalid encrypted payload")
-
-                    if isinstance(decrypted, dict):
-                        decrypted_payload = decrypted
-
-                    elif isinstance(decrypted, str):
-                        try:
-                            decrypted_payload = json.loads(decrypted)
-                        except Exception:
-                            raise ValueError("Decrypted payload is not valid JSON")
-
-                    else:
-                        raise ValueError("Unsupported decrypted payload type")
+                
+                decrypted_payload = decrypt_payload(
+                    encrypted_payload=kwargs.get("data"),
+                    aes_auth_aes_key=secrets["AES-KEY-AUTH"]
+                )
                             
                 if decrypted_payload is not None:
                     kwargs["data"] = decrypted_payload
 
-                # token
-                try:
-                    original_token = await token_service.authenticate(
-                        request.headers,
-                        keys["AUTH-JWT-USER-KEY"],
-                        keys["AES-KEY-USER"],
-                    )
-                except Exception:
-                    original_token = None
-
-                token = TenantPolicy.resolve(
+
+                original_token = await token_service.authenticate(
+                    request.headers,
+                    secrets["AUTH-JWT-USER-KEY"],
+                    secrets["AES-KEY-USER"],
+                )
+
+                token = tenant_context_resolver(
                     token=original_token,
                     headers=request.headers,
                     decrypted_payload=decrypted_payload,
                     operation_type=info.operation.operation.value
                 )
-
-                if not token:
-                    raise UnauthorizedException(
-                        error="Authorization required"
-                    )
-                # token
+                
+                context.token = token
 
                 result = await func(obj, info, **kwargs)
 

encryptors-2.81.3/src/Osdental/Helpers/authorization_helpers.py

@@ -0,0 +1,53 @@
+from typing import Dict, Any
+from uuid import UUID
+from starlette.datastructures import Headers
+from graphql import OperationType
+from starlette.datastructures import Headers
+from Osdental.Encryptor.Aes import AES
+from Osdental.Models.Token import AuthToken
+from Osdental.Shared.Enums.Profile import Profile
+
+def get_auth_token(headers: Headers) -> str:
+
+    authorization = headers.get("authorization")
+    if not authorization or not authorization.startswith("Bearer "):
+        raise ValueError("Missing Bearer token")
+        
+    return authorization.split(" ")[1]
+
+
+def tenant_context_resolver(
+    token: AuthToken, 
+    headers: Headers, 
+    decrypted_payload: Dict[str, Any], 
+    operation_type: str
+) -> AuthToken:
+
+    final_id = None
+    dynamic_client_id = headers.get("dynamicClientId", None)
+    external_enterprise_req = (
+        decrypted_payload.get("idExternalEnterprise")
+        if decrypted_payload else None
+    )
+
+    if external_enterprise_req:
+        final_id = external_enterprise_req
+
+
+    elif token.abbreviation.startswith(
+        (Profile.MARKETING, Profile.SUPER_ADMIN, Profile.ADMIN_OSD)
+    ) and dynamic_client_id:
+        decrypted_mk_id = AES.decrypt(token.aes_key_auth, dynamic_client_id)
+        final_id = decrypted_mk_id
+        token.mk_id_external_enterprise = decrypted_mk_id
+
+    elif (
+        token.abbreviation.startswith((Profile.SUPER_ADMIN, Profile.ADMIN_OSD)) 
+        and operation_type == OperationType.QUERY.value and not dynamic_client_id
+    ):
+        final_id = str(UUID(int=0))
+
+    if final_id:
+        token.id_external_enterprise = final_id
+
+    return token

encryptors-2.81.3/src/Osdental/Helpers/request_decryption.py

@@ -0,0 +1,32 @@
+import json
+from Osdental.Encryptor.Aes import AES
+
+
+def decrypt_payload(encrypted_payload: str, aes_auth_aes_key: str):
+    decrypted_payload = None
+
+    if encrypted_payload is not None:
+
+        if not isinstance(encrypted_payload, str):
+            raise ValueError("Encrypted payload must be a string")
+        
+        if not aes_auth_aes_key:
+            raise ValueError("Missing AES configuration")
+        
+        try:
+            decrypted = AES.decrypt(aes_auth_aes_key, encrypted_payload)
+        except Exception:
+            raise ValueError("Invalid encrypted payload")
+        
+        if isinstance(decrypted, dict):
+            decrypted_payload = decrypted
+
+        elif isinstance(decrypted, str):
+            try:
+                decrypted_payload = json.loads(decrypted)
+            except Exception:
+                raise ValueError("Decrypted payload is not valid JSON")
+        else:
+            raise ValueError("Unsupported decrypted payload type")
+        
+    return decrypted_payload

encryptors-2.81.3/src/Osdental/Helpers/token_validation_service.py

@@ -0,0 +1,51 @@
+from starlette.datastructures import Headers
+from Osdental.Encryptor.Aes import AES
+from Osdental.Encryptor.Jwt import JWT
+from Osdental.Models.Token import AuthToken
+from Osdental.Helpers.authorization_helpers import get_auth_token
+from Osdental.Exception.ControlledException import UnauthorizedException
+
+class TokenValidationService:
+
+    def __init__(self, auth_validator):
+        self.auth_validator = auth_validator
+
+    async def authenticate(
+        self,
+        headers: Headers,
+        jwt_user_key: str,
+        aes_user: str
+    ) -> AuthToken:
+        
+        encrypted_token = get_auth_token(headers)
+
+        user_token = AES.decrypt(aes_user, encrypted_token)
+        claims = JWT.extract_payload(user_token, jwt_user_key)
+
+        token = AuthToken(
+            id_token=claims.get("idToken"),
+            id_user=claims.get("idUser"),
+            id_external_enterprise=claims.get("idExternalEnterprise"),
+            id_profile=claims.get("idProfile"),
+            id_legacy=claims.get("idLegacy"),
+            id_authorization=claims.get("idAuthorization"),
+            id_item_report=claims.get("idItemReport"),
+            id_enterprise=claims.get("idEnterprise"),
+            user_full_name=claims.get("userFullName"),
+            abbreviation=claims.get("abbreviation"),
+            aes_key_auth=claims.get("aesKeyAuth"),
+            aes_key_user=claims.get("aesKeyUser"),
+            base_id_external_enterprise=claims.get("idExternalEnterprise")
+        )
+
+        # Validate via RPC
+        payload = {
+            "idToken": token.id_token,
+            "idUser": token.id_user
+        }
+        
+        is_valid = await self.auth_validator.validate_auth_token(payload)
+        if not int(is_valid):
+            raise UnauthorizedException(error="The session token has expired or is invalid.")
+
+        return token

{encryptors-2.81.2 → encryptors-2.81.3}/src/Osdental/Models/Token.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from dataclasses import dataclass
 
 @dataclass
@@ -14,7 +13,7 @@ class AuthToken:
     user_full_name: str
     abbreviation: str
     aes_key_auth: str
-    aes_key_user: Optional[str] = None
-    access_token: Optional[str] = None
-    base_id_external_enterprise: Optional[str] = None
-    mk_id_external_enterprise: Optional[str] = None
+    aes_key_user: str | None = None
+    access_token: str | None = None
+    base_id_external_enterprise: str | None = None
+    mk_id_external_enterprise: str | None = None

encryptors-2.81.2/src/Osdental/Helpers/extract_auth_token.py

@@ -1,11 +0,0 @@
-from starlette.datastructures import Headers
-
-class ExtractAuthToken:
-
-    @staticmethod
-    def get_auth_token(headers: Headers) -> str:
-        authorization = headers.get("authorization")
-        if not authorization or not authorization.startswith("Bearer "):
-            raise ValueError("Missing Bearer token")
-        
-        return authorization.split(" ")[1]

encryptors-2.81.2/src/Osdental/Helpers/tenant_policy.py

@@ -1,46 +0,0 @@
-from typing import Dict, Any
-from uuid import UUID
-from graphql import OperationType
-from starlette.datastructures import Headers
-from Osdental.Encryptor.Aes import AES
-from Osdental.Models.Token import AuthToken
-from Osdental.Shared.Enums.Profile import Profile
-
-class TenantPolicy:
-
-    @staticmethod
-    def resolve(
-        token: AuthToken, 
-        headers: Headers, 
-        decrypted_payload: Dict[str, Any], 
-        operation_type: str
-    ) -> AuthToken:
-
-        final_id = None
-        dynamic_client_id = headers.get("dynamicClientId", None)
-        external_enterprise_req = (
-            decrypted_payload.get("idExternalEnterprise")
-            if decrypted_payload else None
-        )
-
-        if external_enterprise_req:
-            final_id = external_enterprise_req
-
-
-        elif token.abbreviation.startswith(
-            (Profile.MARKETING, Profile.SUPER_ADMIN, Profile.ADMIN_OSD)
-        ) and dynamic_client_id:
-            decrypted_mk_id = AES.decrypt(token.aes_key_auth, dynamic_client_id)
-            final_id = decrypted_mk_id
-            token.mk_id_external_enterprise = decrypted_mk_id
-
-        elif (
-            token.abbreviation.startswith((Profile.SUPER_ADMIN, Profile.ADMIN_OSD)) 
-            and operation_type == OperationType.QUERY.value and not dynamic_client_id
-        ):
-            final_id = str(UUID(int=0))
-
-        if final_id:
-            token.id_external_enterprise = final_id
-
-        return token

encryptors-2.81.2/src/Osdental/Helpers/token_validation_service.py

@@ -1,49 +0,0 @@
-from starlette.datastructures import Headers
-from Osdental.Encryptor.Aes import AES
-from Osdental.Encryptor.Jwt import JWT
-from Osdental.Models.Token import AuthToken
-from Osdental.Helpers.extract_auth_token import ExtractAuthToken
-
-class TokenValidationService:
-
-    def __init__(self, auth_validator):
-        self.auth_validator = auth_validator
-
-    async def authenticate(
-        self,
-        headers: Headers,
-        jwt_user_key: str,
-        aes_user: str
-    ) -> AuthToken:
-        
-        encrypted_token = ExtractAuthToken.get_auth_token(headers)
-
-        user_token = AES.decrypt(aes_user, encrypted_token)
-        payload = JWT.extract_payload(user_token, jwt_user_key)
-
-        token = AuthToken(
-            id_token=payload.get("idToken"),
-            id_user=payload.get("idUser"),
-            id_external_enterprise=payload.get("idExternalEnterprise"),
-            id_profile=payload.get("idProfile"),
-            id_legacy=payload.get("idLegacy"),
-            id_authorization=payload.get("idAuthorization"),
-            id_item_report=payload.get("idItemReport"),
-            id_enterprise=payload.get("idEnterprise"),
-            user_full_name=payload.get("userFullName"),
-            abbreviation=payload.get("abbreviation"),
-            aes_key_auth=payload.get("aesKeyAuth"),
-            aes_key_user=payload.get("aesKeyUser"),
-            base_id_external_enterprise=payload.get("idExternalEnterprise")
-        )
-
-        # Validate via RPC
-        payload = {
-            "idToken": token.id_token,
-            "idUser": token.id_user
-        }
-        is_valid = await self.auth_validator.validate_auth_token(payload)
-        if not int(is_valid):
-            raise ValueError("You are not authorized to access this portal.")
-
-        return token