Encryptors 2.42__tar.gz → 2.44__tar.gz

{encryptors-2.42 → encryptors-2.44}/PKG-INFO

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

{encryptors-2.42 → encryptors-2.44}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 # ANDERSON ESTO YA SE SUBIO Y ESTA ESTABLE, AUN TE QUEDA PENDIENTE LA AUDITORIA CON RSA Y AES DE ACCESSTOKEN
 setup(
     name="Encryptors", 
-    version="2.42",
+    version="2.44",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.42 → encryptors-2.44}/src/Encryptors.egg-info/PKG-INFO

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

encryptors-2.44/src/Osdental/Decorators/SecureResolver.py

@@ -0,0 +1,59 @@
+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
+from Osdental.Shared.Logger import logger
+
+def resolver(public: bool = False, action=None):
+
+    def decorator(func: Callable):
+
+        func._is_public = public
+
+        @wraps(func)
+        async def wrapper(obj, info, **kwargs):
+            try:
+                context = info.context
+                token = getattr(context, "token", None)
+
+                if not public:
+                    if not token:
+                        raise UnauthorizedException(
+                            error="Authorization required"
+                        )
+
+                    if action:
+                        if Profile(token.abbreviation) not in action.allowed_roles:
+                            raise AccessDeniedException(
+                                error="User not allowed to perform this action"
+                            )
+
+                result = await func(obj, info, **kwargs)
+
+                if not isinstance(result, Response):
+                    raise TypeError("Resolver must return a Response instance")
+
+                return result
+
+            except OSDException as e:
+                logger.warning(f"Business error: {str(e)}")
+
+                return Response(
+                    status=e.status_code,
+                    message=e.message,
+                    error=e.error
+                )
+
+            except Exception as e:
+                logger.exception(f"Unexpected error: {str(e)}")
+
+                return Response(
+                    status="DB_ERROR_UNEXPECTED",
+                    message="Could not process request.",
+                    error=str(e)
+                )
+
+        return wrapper
+
+    return decorator

{encryptors-2.42 → encryptors-2.44}/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -1,5 +1,5 @@
+import inspect
 import json
-import copy
 from graphql.pyutils import is_awaitable
 from ariadne.types import Extension
 from Osdental.Shared.Logger import logger
@@ -9,8 +9,8 @@ from Osdental.Rest.Context.RequestContext import (
     current_context,
     RequestContext
 )
+from Osdental.Models.Response import Response
 from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Helpers.ResponseDecryptor import encryptor_data, VALID_TYPES
 from Osdental.Shared.Enums.Constant import Constant
 
 class AuditExtension(Extension):
@@ -39,9 +39,7 @@ class AuditExtension(Extension):
         request = context.request
 
         # cache body
-        if not hasattr(context, "_cached_body"):
-            context._cached_body = await request.json()
-
+        context._cached_body = getattr(context, "_cached_body", None) or await request.json()
         body = context._cached_body
 
         # skip introspection
@@ -57,7 +55,7 @@ class AuditExtension(Extension):
         if is_root:
 
             # identificar resolver público
-            resolver_fn = getattr(next_, "__wrapped__", next_)
+            resolver_fn = inspect.unwrap(next_)
             is_public = getattr(resolver_fn, "_is_public", False)
 
             # inicializar auth UNA SOLA VEZ
@@ -68,27 +66,20 @@ class AuditExtension(Extension):
                 container = context.container
                 token_service = container.token_service
 
-                aes_auth = request.app.state.aes_auth
-                aes_user = request.app.state.aes_user
-
-                if not aes_auth or not aes_user:
-                    aes_auth = None
-                    aes_user = None
-
                 original_token = None
+                context.aes_auth = None
                 if not is_public and headers.get("authorization"):
+                    aes_auth = request.app.state.aes_auth
+                    aes_user = request.app.state.aes_user
+
                     try:
                         original_token = await token_service.authenticate(headers, aes_user)
                     except Exception:
                         original_token = None
 
-                context._original_token = original_token
-                context.token = original_token
-                context.aes_auth = aes_auth
+                    context.aes_auth = aes_auth
 
             # VALIDACIÓN SOLO ROOT
-            original_token = getattr(context, "_original_token", None)
-
             if not is_public and not original_token:
                 raise ValueError("Authorization required")
 
@@ -102,30 +93,30 @@ class AuditExtension(Extension):
 
             decrypted_payload = None
 
-            if encrypted_payload is not None:
-                if isinstance(encrypted_payload, dict):
-                    decrypted_payload = encrypted_payload
+            if not is_public and encrypted_payload is not None:
 
-                elif isinstance(encrypted_payload, str):
-                    try:
-                        decrypted_payload = json.loads(encrypted_payload)
-                    except Exception:
-                        if context.aes_auth:
-                            try:
-                                decrypted_payload = AES.decrypt(context.aes_auth, encrypted_payload)
-                                try:
-                                    decrypted_payload = json.loads(decrypted_payload)
-                                except Exception:
-                                    pass
-                            except Exception:
-                                decrypted_payload = 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")
+
+                try:
+                    decrypted_payload = json.loads(decrypted)
+                except Exception:
+                    raise ValueError("Decrypted payload is not valid JSON")
+                        
             if decrypted_payload is not None:
-                context.decrypted_payload = decrypted_payload
+                kwargs["data"] = decrypted_payload
             
             if not is_public:
                 token = TenantPolicy.resolve(
-                    token=context._original_token,
+                    token=original_token,
                     headers=request.headers,
                     decrypted_payload=decrypted_payload,
                     operation_type=info.operation.operation.value
@@ -155,13 +146,6 @@ class AuditExtension(Extension):
         if is_root and self.result is None:
             self.result = result
 
-            if not getattr(context, "audit_plain_response", None):
-                if result.encryption_type in VALID_TYPES and result.key:
-                    result_copy = copy.deepcopy(result)
-                    result = encryptor_data(result.encryption_type, result.key, result.data)
-
-                context.audit_plain_response = result_copy
-
         return result
 
     def has_errors(self, errors, context):
@@ -174,13 +158,16 @@ class AuditExtension(Extension):
 
         query = self.request_payload.get("query", "")
 
-        if "__schema" in query or "__type" in query:
+        if self._should_skip({"query": query}):
+            return
+        
+        if self.result is None:
             return
 
-        final_result = context.audit_plain_response or self.result
+        decrypted_key = context.aes_auth
 
-        if final_result is None:
-            return
+        if isinstance(self.result, Response):
+            decrypted_key = self.result.key or decrypted_key
 
         dispatcher = context.request.app.state.audit_dispatcher
 
@@ -188,8 +175,11 @@ class AuditExtension(Extension):
             dispatcher.dispatch(
                 request=self.request,
                 request_payload=self.request_payload,
-                result=final_result,
+                result=self.result,
+                metadata={
+                    "decrypted_key": decrypted_key
+                },
                 audit_type=Constant.MESSAGE_LOG_INTERNAL
             )
         except Exception as e:
-            logger(f"[AUDIT ERROR]: {str(e)}")
+            logger.warning(f"[AUDIT ERROR]: {str(e)}")

{encryptors-2.42 → encryptors-2.44}/src/Osdental/Graphql/_Helpers/_AuditHelper.py

@@ -14,7 +14,7 @@ class AuditHelper:
 
         user_ip = request.headers.get("X-Forwarded-For")
         if user_ip:
-            user_ip = user_ip.split(',')[0]
+            user_ip = user_ip.split(",")[0]
         else:
             user_ip = getattr(request.client, "host", "*")
 

{encryptors-2.42 → encryptors-2.44}/src/Osdental/Helpers/AuditDispatcher.py

@@ -40,6 +40,7 @@ class AuditDispatcher:
         request: Request, 
         request_payload: Dict[str, Any], 
         result: Response,
+        metadata: Dict[str, Any],
         audit_type: str = None
     ):
         try:
@@ -47,6 +48,7 @@ class AuditDispatcher:
                 "request": request,
                 "request_payload": request_payload,
                 "result": result,
+                "metadata": metadata,
                 "audit_type": audit_type
             }
 
@@ -77,6 +79,7 @@ class AuditDispatcher:
         request_payload = payload["request_payload"]
         result: Response = payload["result"]
         audit_type = payload["audit_type"]
+        metadata = payload["metadata"]
 
         operation_name = request_payload.get("operation_name")
         if operation_name == 'UnknownOperation':
@@ -100,9 +103,8 @@ class AuditDispatcher:
 
         # Obtencion de campos adicionales cuando es otro tipo de encriptacion o clave
         encryption_type = result.encryption_type
-        key = result.key
+        decrypted_key = metadata.get("decrypted_key")
 
-        
         if audit_type == Constant.MESSAGE_LOG_INTERNAL:
 
             ERROR_PREFIXES = ("DB_ERROR", "DB_WARNING")
@@ -116,7 +118,6 @@ class AuditDispatcher:
             except ValueError:
                 is_error = True
     
-
         if is_error:
             payload = AuditHelper.build_final_payload(
                 _type="ERROR",
@@ -127,8 +128,8 @@ class AuditDispatcher:
             audit_message = request_audit_payload | payload
 
         else:
-            if encryption_type in VALID_TYPES and key:
-                data = decryptor_data(encryption_type, key, data)
+            if encryption_type in VALID_TYPES and decrypted_key:
+                data = decryptor_data(encryption_type, decrypted_key, data)
 
             payload = AuditHelper.build_final_payload(
                 _type="RESPONSE",

encryptors-2.42/src/Osdental/Decorators/SecureResolver.py

@@ -1,56 +0,0 @@
-import inspect
-import copy
-from functools import wraps
-from typing import Callable, Dict, Any
-from Osdental.Models.Token import AuthToken
-from Osdental.Models.Response import Response
-from Osdental.Shared.Enums.Profile import Profile
-from Osdental.Exception.ControlledException import OSDException, AccessDeniedException
-from Osdental.Encryptor.Aes import AES
-from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Shared.Logger import logger
-
-def secure_resolver(action = None):
-    def decorator(func: Callable):
-
-        signature = inspect.signature(func)
-        params = signature.parameters
-
-        @wraps(func)
-        async def wrapper(obj: Any, context: BaseGraphQLContext, **kwargs: Dict[str, Any]):
-            try:
-                token: AuthToken = context.token
-                payload = getattr(context, "decrypted_payload", None)
-                aes_auth = getattr(context, "aes_auth", None)
-
-                if action:
-                    if Profile(token.abbreviation) not in action.allowed_roles:
-                        raise AccessDeniedException(error="The user's profile is not allowed to perform this action.")
-
-                if "token" in params:
-                    kwargs["token"] = token
-
-                if "data" in params:
-                    kwargs["data"] = payload
-
-                result: Response = await func(obj, **kwargs)
-
-                context.audit_plain_response = copy.deepcopy(result)
-
-                if result.data is not None and result.encryption_type == "AES" and result.key is None:
-                    result.data = AES.encrypt(aes_auth, result.data)
-
-                return result.send()
-
-            except (Exception, OSDException) as e:
-                logger.exception(f"An error has occurred: {str(e)}")
-                result = Response(
-                    status=getattr(e, "status_code", "DB_ERROR_UNEXPECTED"),
-                    message=getattr(e, "message", "Could not process request."),
-                    error=f"{type(e).__name__}: {str(e)}"
-                )
-                context.audit_plain_response = result
-                return result.send()
-
-        return wrapper
-    return decorator