Encryptors 2.65__tar.gz → 2.67__tar.gz

{encryptors-2.65 → encryptors-2.67}/PKG-INFO

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

{encryptors-2.65 → encryptors-2.67}/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.65",
+    version="2.67",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.65 → encryptors-2.67}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.65 → encryptors-2.67}/src/Encryptors.egg-info/SOURCES.txt

@@ -29,7 +29,7 @@ src/Osdental/Encryptor/Rsa.py
 src/Osdental/Encryptor/Sha512.py
 src/Osdental/Encryptor/__init__.py
 src/Osdental/Enums/AuditType.py
-src/Osdental/Enums/ErrorSource.py
+src/Osdental/Enums/CipherType.py
 src/Osdental/Enums/FileType.py
 src/Osdental/Enums/GrahpqlOperation.py
 src/Osdental/Enums/Profile.py
@@ -42,10 +42,10 @@ src/Osdental/Helpers/AuditHelper.py
 src/Osdental/Helpers/AuditQueue.py
 src/Osdental/Helpers/AuthTokenProcessor.py
 src/Osdental/Helpers/AzureClassifier.py
+src/Osdental/Helpers/CipherHelper.py
 src/Osdental/Helpers/GrpcConnection.py
 src/Osdental/Helpers/JwtTokenHelper.py
 src/Osdental/Helpers/Resilience.py
-src/Osdental/Helpers/ResponseDecryptor.py
 src/Osdental/Helpers/__init__.py
 src/Osdental/Http/APIClient.py
 src/Osdental/Http/__init__.py

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Decorators/SecureResolver.py

@@ -4,7 +4,7 @@ from typing import Callable
 from graphql import GraphQLResolveInfo
 from Osdental.Models.Response import Response
 from Osdental.Models.Graphql import BaseGraphQLContext
-from Osdental.Models.TokenClaims import UserTokenClaims
+from Osdental.Models.TokenClaims import UserTokenClaims, AccessTokenClaims
 from Osdental.Models.Token import AuthToken
 from Osdental.Enums.Profile import Profile
 from Osdental.Exception.ControlledException import (
@@ -39,16 +39,27 @@ def resolver(public: bool = False, action=None):
                 settings = container.settings
 
                 token: type[AuthToken] | None = None
+                aes_key = None
+                claims: UserTokenClaims | AccessTokenClaims
 
                 # ── 1. AUTENTICACIÓN ──────────────────────────────
+                token_service: IAuthTokenService = container.auth_token_service
                 if not public:
 
-                    token_service: IAuthTokenService = container.auth_token_service
-                    user_token = extract_bearer_token(headers)
-                    
-                    claims: UserTokenClaims = await token_service.validate_internal_access_token(
+                    user_token = extract_bearer_token(headers)                    
+                    claims = await token_service.validate_internal_access_token(
                         user_token
                     )
+                    aes_key = claims.aes_key_auth
+
+                else:
+
+                    access_token = request.get("Accesstoken")
+                    claims = await token_service.validate_external_access_token(
+                        access_token
+                    )
+                    aes_key = claims.aes_key
+                    context.access_token = claims
 
                 # ── 2. DECRYPT DEL PAYLOAD ────────────────────────
                 body = await request.json()
@@ -56,9 +67,9 @@ def resolver(public: bool = False, action=None):
                 encrypted_payload = kwargs.get("data") or variables.get("data")
                 decrypted_payload = None
 
-                if not public and encrypted_payload is not None:
+                if encrypted_payload is not None:
                     decrypted_payload = decrypt_and_parse_payload(
-                        aes_key_auth=claims.aes_key_auth,
+                        aes_key_auth=aes_key,
                         encrypted_payload=encrypted_payload
                     )
 
@@ -73,6 +84,8 @@ def resolver(public: bool = False, action=None):
                         decrypted_payload=decrypted_payload,
                         operation_type=info.operation.operation.value
                     )
+                    
+                    context.token = token
 
                 # ── 4. CONTROL DE ACCESO POR ROL ─────────────────
                 if not public and action:

encryptors-2.67/src/Osdental/Enums/CipherType.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+class CipherType(StrEnum):
+    AES = "AES"
+    RSA = "RSA"
+    PLAIN = "PLAIN"

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Exception/ControlledException.py

@@ -1,7 +1,7 @@
 from typing import Any
 from Osdental.Enums.StatusCode import StatusCode
 from Osdental.Constants.Message import Message
-from Osdental.Enums.ErrorSource import ErrorSource
+
 
 class OSDException(Exception):
     """ Base class for all custom exceptions. """
@@ -9,29 +9,19 @@ class OSDException(Exception):
         self, 
         message: str = Message.UNEXPECTED_ERROR_MSG, 
         error: str = None, 
-        status_code: Any = StatusCode.INTERNAL_SERVER_ERROR,
-        source: ErrorSource = ErrorSource.INTERNAL,
-        raw_status_code: Any = None,
+        status_code: Any = StatusCode.INTERNAL_SERVER_ERROR
     ):
         super().__init__(error)
         self.message = message
         self.error = error
         self.status_code = status_code
-        self.source = source
-        self.raw_status_code = raw_status_code
+
 
     def __str__(self):
         error_detail = self.error if self.error else "None"
-        return f"[{self.source} | {self.status_code}] {self.message} | {error_detail}]"
+        return f"[{self.status_code}] {self.message} | {error_detail}]"
     
-    @property
-    def is_external(self) -> bool:
-        return self.source == ErrorSource.EXTERNAL
-    
-    @property
-    def audit_status_code(self) -> Any:
-        """El que va a la auditoría: real si existe, propio si no."""
-        return self.raw_status_code if self.raw_status_code is not None else self.status_code
+
     
 class UnauthorizedException(OSDException):
     def __init__(
@@ -134,13 +124,9 @@ class HttpClientException(OSDException):
         message: str = Message.UNEXPECTED_ERROR_MSG, 
         error: str = None, 
         status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
-        source: ErrorSource = ErrorSource.EXTERNAL,
-        raw_status_code: Any = None,
     ):
         super().__init__(
             message=message,
             error=error,
             status_code=status_code,
-            source=source,
-            raw_status_code=raw_status_code
         )

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Helpers/AuditHelper.py

@@ -9,6 +9,7 @@ from Osdental.Exception.ControlledException import OSDException
 from Osdental.Enums.StatusCode import StatusCode
 from Osdental.Enums.AuditType import AuditType
 from Osdental.Enums.ResultType import ResultType
+from Osdental.Helpers.CipherHelper import decryptor_data
 
 def build_request_payload(
     request: Request, 
@@ -77,16 +78,25 @@ def _build_final_payload(
 
 def _build_success_payload(ctx: Optional[AuditContext], result: Response) -> Dict[str, Any]:
     base = _base_payload(ctx)
+
+    key = result.key if result.key else ctx.decrypted_key
+
+    data = decryptor_data(
+        key=key,
+        data=result.data,
+        encryption_type=result.encryption_type,
+    )
+
     return base | _build_final_payload(
         type_=ResultType.RESPONSE,
         status_code=result.status,
-        result=result.data
+        result=data
     )
 
 def _build_error_payload(ctx: Optional[AuditContext], exc: OSDException) -> Dict[str, Any]:
     base = _base_payload(ctx)
     return base | _build_final_payload(
-        status_code=exc.audit_status_code,
+        status_code=exc.status_code,
         error=exc.error or exc.message
     )
 
@@ -157,7 +167,6 @@ def _build_success_graphql_payload(ctx: Optional[AuditContext], result: Dict[str
         result=result
     )
 
-
 def _build_error_graphql_payload(ctx: Optional[AuditContext], errors: List[Dict[str, Any]]) -> Dict[str, Any]:
     base = _base_payload(ctx, AuditType.EXTERNAL)
     return base | _build_final_payload(

encryptors-2.65/src/Osdental/Helpers/ResponseDecryptor.py → encryptors-2.67/src/Osdental/Helpers/CipherHelper.py

@@ -2,35 +2,39 @@ import logging
 from typing import Dict, Any
 from Osdental.Encryptor.Aes import AES
 from Osdental.Encryptor.Rsa import RSAEncryptor
+from Osdental.Enums.CipherType import CipherType
 
 logger = logging.getLogger(__name__)
 
 
-VALID_TYPES = {"RSA", "AES"}
-
-def encryptor_data(encryption_type: str, key: str, data: Dict[str, Any] | str) -> Any:
+def encryptor_data(key: str, data: Dict[str, Any] | str, encryption_type: CipherType = CipherType.AES) -> Any:
     match encryption_type:
 
-        case "AES":
+        case CipherType.AES:
             return AES.encrypt(key, data)
 
-        case "RSA":
+        case CipherType.RSA:
             return RSAEncryptor.encrypt(data, key)
         
+        case CipherType.PLAIN:
+            return data
+
         case _:
             logger.warning(f"Encryption type '{encryption_type}' not supported.")
-            return data
+
         
-def decryptor_data(encryption_type: str, key: str, data: Dict[str, Any] | str) -> Any:
+def decryptor_data(key: str, data: Dict[str, Any] | str, encryption_type: CipherType = CipherType.AES) -> Any:
     
     match encryption_type:
 
-        case "AES":
+        case CipherType.AES:
             return AES.decrypt(key, data)
 
-        case "RSA":
+        case CipherType.RSA:
             return RSAEncryptor.decrypt(data, key)
         
+        case CipherType.PLAIN:
+            return data
+        
         case _:
-            logger.warning(f"Encryption type '{encryption_type}' not supported.")
-            return data
+            logger.warning(f"Encryption type '{encryption_type}' not supported.")

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Models/AuditContext.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Optional, Dict, Any
 from fastapi import Request
-
+from Osdental.Models.Token import AuthToken
 
 @dataclass
 class AuditContext:
@@ -30,8 +30,8 @@ class AuditContext:
         settings,
         body: Dict,
         operation_type: str,
-        token=None,
-        decrypted_payload=None,
+        token: AuthToken = None,
+        decrypted_payload = None,
     ) -> "AuditContext":
         
         user_ip = request.headers.get("X-Forwarded-For")
@@ -51,7 +51,7 @@ class AuditContext:
             operation_name=body.get("operationName", "UnknownOperation"),
             query=body.get("query"),
             variables=decrypted_payload,
-            user=token.user_full_name if token else "Public",
+            user=token.id_user if token else "00000000-0000-0000-0000-000000000000",
             message_log_id=request.headers.get("Idmessagelog"),
             decrypted_key=token.aes_key_auth if token else None,
             user_ip=user_ip,

encryptors-2.67/src/Osdental/Models/Graphql.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import Optional, Any
+from fastapi import Request
+from Osdental.Models.Token import AuthToken
+from Osdental.Models.TokenClaims import AccessTokenClaims
+
+@dataclass
+class BaseGraphQLContext:
+    request: Request
+    container: Any
+    access_token: Optional[AccessTokenClaims] = None
+    token: Optional[AuthToken] = None

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Models/Response.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass, field, asdict
-from typing import Optional, Any, Literal
+from typing import Optional, Any
 from Osdental.Enums.StatusCode import StatusCode
 from Osdental.Constants.Message import Message
+from Osdental.Enums.CipherType import CipherType
 
 @dataclass
 class Response:
@@ -9,7 +10,7 @@ class Response:
     message: str = field(default=Message.PROCESS_SUCCESS_MSG)
     data: Optional[Any] = None
     error: Optional[str] = None
-    encryption_type: Literal["AES", "RSA", "NORMAL"] = "AES"
+    encryption_type: CipherType = CipherType.AES
     key: Optional[str] = None
 
     def send(self):

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Models/Token.py

@@ -14,7 +14,5 @@ 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

{encryptors-2.65 → encryptors-2.67}/src/Osdental/Services/JwtAuthTokenService.py

@@ -1,7 +1,7 @@
 import asyncio
 
 from Osdental.Models.TokenClaims import (
-    AccessTokenClaims, UserTokenClaims,
+    BaseClaims, AccessTokenClaims, UserTokenClaims,
     ActionTokenClaims, TokenValidationOptions
 )
 
@@ -52,7 +52,7 @@ class JwtAuthTokenService(IAuthTokenService):
 
     async def generate_token(
         self,
-        claims: AccessTokenClaims | UserTokenClaims | ActionTokenClaims,
+        claims: BaseClaims,
         expiration_minutes: int,
     ) -> str:
 

encryptors-2.65/src/Osdental/Enums/ErrorSource.py

@@ -1,5 +0,0 @@
-from enum import Enum
-
-class ErrorSource(str, Enum):
-    INTERNAL = "internal"
-    EXTERNAL = "external"

encryptors-2.65/src/Osdental/Models/Graphql.py

@@ -1,14 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional, Any
-from fastapi import Request
-from Osdental.Models.Token import AuthToken
-
-@dataclass
-class BaseGraphQLContext:
-    request: Request
-    container: Any
-    # valores agregados durante ejecución (AuditExtention)
-    token: Optional[AuthToken] = None
-    decrypted_payload: Optional[dict] = None
-    aes_auth: Optional[str] = None
-    audit_plain_response: Optional[Any] = None