Encryptors 2.40__tar.gz → 2.42__tar.gz

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

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

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

@@ -1,8 +1,8 @@
 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.40",
+    version="2.42",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

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

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

{encryptors-2.40 → encryptors-2.42}/src/Encryptors.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ src/Osdental/Graphql/_Helpers/_TokenService.py
 src/Osdental/Graphql/_Helpers/__init__.py
 src/Osdental/Helpers/AuditDispatcher.py
 src/Osdental/Helpers/KeyVaultService.py
+src/Osdental/Helpers/ResponseDecryptor.py
 src/Osdental/Helpers/__init__.py
 src/Osdental/Http/APIClient.py
 src/Osdental/Http/_Exceptions.py
@@ -77,6 +78,7 @@ src/Osdental/Shared/Utils/HashValidator.py
 src/Osdental/Shared/Utils/Mapper.py
 src/Osdental/Shared/Utils/PasswordGenerator.py
 src/Osdental/Shared/Utils/QueryGenerator.py
+src/Osdental/Shared/Utils/RsaUtils.py
 src/Osdental/Shared/Utils/TextProcessor.py
 src/Osdental/Shared/Utils/__init__.py
 src/Osdental/Storage/AzureBlobStorage.py

{encryptors-2.40 → encryptors-2.42}/src/Osdental/Decorators/SecureResolver.py

@@ -37,7 +37,7 @@ def secure_resolver(action = None):
 
                 context.audit_plain_response = copy.deepcopy(result)
 
-                if result.data is not None:
+                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()

{encryptors-2.40 → encryptors-2.42}/src/Osdental/Encryptor/Jwt.py

@@ -1,5 +1,5 @@
 import jwt
-from typing import Dict
+from typing import Dict, Any
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.backends import default_backend
 from Osdental.Exception.ControlledException import JWTokenException
@@ -11,7 +11,7 @@ class JWT:
 
     @staticmethod
     def generate_token(
-        payload: Dict[str, str], jwt_secret_key: str, algorithm="HS256"
+        payload: Dict[str, Any], jwt_secret_key: str, algorithm="HS256"
     ) -> str:
         try:
             token = jwt.encode(payload, jwt_secret_key, algorithm=algorithm)
@@ -22,7 +22,7 @@ class JWT:
             raise JWTokenException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e))
 
     @staticmethod
-    def extract_payload(jwt_token: str, jwt_secret_key: str) -> Dict[str, str]:
+    def extract_payload(jwt_token: str, jwt_secret_key: str) -> Dict[str, Any]:
         try:
             payload = jwt.decode(jwt_token, jwt_secret_key, algorithms=["HS256"])
             return payload

{encryptors-2.40 → encryptors-2.42}/src/Osdental/Encryptor/Rsa.py

@@ -1,6 +1,6 @@
 import json
 from base64 import b64decode, b64encode
-from typing import Dict
+from typing import Dict, Any
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import padding
 from cryptography.hazmat.primitives import hashes
@@ -12,7 +12,7 @@ from Osdental.Shared.Enums.Constant import Constant
 class RSAEncryptor:
 
     @staticmethod
-    def encrypt(data:str | Dict[str,str], public_key_rsa:str) -> str:
+    def encrypt(data: str | Dict[str, Any], public_key_rsa: str) -> str:
         try:
             if isinstance(data, dict):
                 data = json.dumps(data)
@@ -36,7 +36,7 @@ class RSAEncryptor:
 
 
     @staticmethod
-    def decrypt(data:str, private_key_rsa:str, silent:bool = False) -> str:
+    def decrypt(data: str, private_key_rsa: str, silent: bool = False) -> str:
         try:
             encrypted_bytes = b64decode(data)
             private_key = serialization.load_pem_private_key(private_key_rsa.encode(Constant.DEFAULT_ENCODING), password=None)

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

@@ -1,4 +1,5 @@
 import json
+import copy
 from graphql.pyutils import is_awaitable
 from ariadne.types import Extension
 from Osdental.Shared.Logger import logger
@@ -9,6 +10,7 @@ from Osdental.Rest.Context.RequestContext import (
     RequestContext
 )
 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):
@@ -29,37 +31,36 @@ class AuditExtension(Extension):
 
     def _should_skip(self, body) -> bool:
         query = body.get("query", "") or ""
-        return "__schema" in query or "__type" in query
+        return "__schema" in query or "__type(" in query
 
     async def resolve(self, next_, root, info, **kwargs):
 
         context: BaseGraphQLContext = info.context
         request = context.request
 
-        # 🔹 cache body
+        # cache body
         if not hasattr(context, "_cached_body"):
             context._cached_body = await request.json()
 
         body = context._cached_body
 
-        # 🔹 skip introspection
+        # skip introspection
         if self._should_skip(body):
             result = next_(root, info, **kwargs)
             if is_awaitable(result):
                 result = await result
             return result
 
-        # 🔥 CLAVE
         is_root = root is None
 
-        # 🔥 SOLO ROOT → TODO TU SISTEMA
+        # SOLO ROOT
         if is_root:
 
-            # 🔹 identificar resolver público
+            # identificar resolver público
             resolver_fn = getattr(next_, "__wrapped__", next_)
             is_public = getattr(resolver_fn, "_is_public", False)
 
-            # 🔹 inicializar auth UNA SOLA VEZ
+            # inicializar auth UNA SOLA VEZ
             if not hasattr(context, "_auth_initialized"):
                 context._auth_initialized = True
 
@@ -85,13 +86,13 @@ class AuditExtension(Extension):
                 context.token = original_token
                 context.aes_auth = aes_auth
 
-            # 🔐 VALIDACIÓN SOLO ROOT
+            # VALIDACIÓN SOLO ROOT
             original_token = getattr(context, "_original_token", None)
 
             if not is_public and not original_token:
                 raise ValueError("Authorization required")
 
-            # 🔹 payload
+            # payload
             variables = body.get("variables") or {}
 
             encrypted_payload = (
@@ -131,7 +132,7 @@ class AuditExtension(Extension):
                 )
                 context.token = token
 
-            # 🔹 auditoría request
+            # auditoría request payload
             if not self.request_payload:
                 token = context.token
 
@@ -144,18 +145,22 @@ class AuditExtension(Extension):
                     "user": token.user_full_name if token else "Public"
                 }
 
-        # 🔥 SIEMPRE ejecutar resolver (root + fields)
+        # SIEMPRE ejecutar resolver (root + fields)
         result = next_(root, info, **kwargs)
 
         if is_awaitable(result):
             result = await result
 
-        # 🔹 SOLO ROOT captura resultado final
+        # SOLO ROOT captura resultado final
         if is_root and self.result is None:
             self.result = result
 
             if not getattr(context, "audit_plain_response", None):
-                context.audit_plain_response = result
+                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
 

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

@@ -4,6 +4,7 @@ from fastapi import Request
 from Osdental.Models.AuditConfig import AuditConfig
 from Osdental.Messaging import IMessageQueue
 from Osdental.Graphql._Helpers._AuditHelper import AuditHelper
+from Osdental.Helpers.ResponseDecryptor import decryptor_data, VALID_TYPES
 from Osdental.Models._Audit import Audit
 from Osdental.Models.Response import Response
 from Osdental.Shared.Enums.Constant import Constant
@@ -74,7 +75,7 @@ class AuditDispatcher:
     async def _process(self, payload: Dict[str, Any]):
         request = payload["request"]
         request_payload = payload["request_payload"]
-        result = payload["result"]
+        result: Response = payload["result"]
         audit_type = payload["audit_type"]
 
         operation_name = request_payload.get("operation_name")
@@ -96,6 +97,11 @@ class AuditDispatcher:
         message = result.message
         data = result.data
         error = result.error if result.error else message
+
+        # Obtencion de campos adicionales cuando es otro tipo de encriptacion o clave
+        encryption_type = result.encryption_type
+        key = result.key
+
         
         if audit_type == Constant.MESSAGE_LOG_INTERNAL:
 
@@ -121,6 +127,9 @@ class AuditDispatcher:
             audit_message = request_audit_payload | payload
 
         else:
+            if encryption_type in VALID_TYPES and key:
+                data = decryptor_data(encryption_type, key, data)
+
             payload = AuditHelper.build_final_payload(
                 _type="RESPONSE",
                 status_code=status_code,

encryptors-2.42/src/Osdental/Helpers/ResponseDecryptor.py

@@ -0,0 +1,33 @@
+from typing import Dict, Any
+from Osdental.Encryptor.Aes import AES
+from Osdental.Encryptor.Rsa import RSAEncryptor
+from Osdental.Shared.Logger import logger
+
+VALID_TYPES = {"RSA", "AES"}
+
+def encryptor_data(encryption_type: str, key: str, data: Dict[str, Any] | str) -> Any:
+    match encryption_type:
+
+        case "AES":
+            return AES.encrypt(key, data)
+
+        case "RSA":
+            return RSAEncryptor.encrypt(data, key)
+        
+        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:
+    
+    match encryption_type:
+
+        case "AES":
+            return AES.decrypt(key, data)
+
+        case "RSA":
+            return RSAEncryptor.decrypt(data, key)
+        
+        case _:
+            logger.warning(f"Encryption type '{encryption_type}' not supported.")
+            return data

{encryptors-2.40 → encryptors-2.42}/src/Osdental/Models/Response.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field, asdict
-from typing import Optional, Any
+from typing import Optional, Any, Literal
 from Osdental.Shared.Enums.Code import Code
 from Osdental.Shared.Enums.Message import Message
 
@@ -9,6 +9,8 @@ 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"
+    key: Optional[str] = None
 
     def send(self):
         response = asdict(self)
@@ -16,4 +18,10 @@ class Response:
         if response["error"] is None:
             response.pop("error")
 
+        if response["encryption_type"]:
+            response.pop("encryption_type")
+
+        if response["key"]:
+            response.pop("key")
+
         return response

encryptors-2.42/src/Osdental/Shared/Utils/RsaUtils.py

@@ -0,0 +1,30 @@
+
+def normalize_rsa_keys(key_str: str, is_private: bool = True) -> str:
+    """
+    Normaliza una llave RSA (privada o pública) para que sea compatible con cryptography.
+    Si is_private=True, normaliza la llave privada; si False, normaliza la llave pública.
+    """
+
+    # Determinar encabezados correctos
+    if is_private:
+        header = "-----BEGIN RSA PRIVATE KEY-----"
+        footer = "-----END RSA PRIVATE KEY-----"
+        invalid_texts = ["-----BEGINRSAPRIVATEKEY-----", "-----ENDRSAPRIVATEKEY-----",
+                        "-----BEGIN RSA PRIVATE KEY-----", "-----END RSA PRIVATE KEY-----"]
+    else:
+        header = "-----BEGIN PUBLIC KEY-----"
+        footer = "-----END PUBLIC KEY-----"
+        invalid_texts = ["-----BEGINPUBLICKEY-----", "-----ENDPUBLICKEY-----",
+                        "-----BEGIN PUBLIC KEY-----", "-----END PUBLIC KEY-----"]
+
+    # Limpiar encabezados inválidos y espacios
+    for text in invalid_texts:
+        key_str = key_str.replace(text, "")
+    key_str = key_str.replace("\r", "").replace(" ", "").replace("\n", "")
+
+    # Dividir en líneas de 64 caracteres
+    lines = [key_str[i:i+64] for i in range(0, len(key_str), 64)]
+
+    # Reconstruir PEM válido
+    pem = f"{header}\n" + "\n".join(lines) + f"\n{footer}\n"
+    return pem