orionis 0.546.0__py3-none-any.whl → 0.548.0__py3-none-any.whl

orionis/console/base/scheduler_event_listener.py

@@ -44,23 +44,6 @@ class BaseScheduleEventListener(IScheduleEventListener):
         """
         pass  # Placeholder for post-job execution logic
 
-    async def onSuccess(self, event: EventJob, schedule):
-        """
-        Called when a job is successfully executed.
-
-        Parameters
-        ----------
-        event : EventJob
-            The successful job execution event containing details about the job.
-        schedule : ISchedule
-            The associated schedule instance managing the job.
-
-        Returns
-        -------
-        None
-        """
-        pass  # Placeholder for logic to handle successful job execution
-
     async def onFailure(self, event: EventJob, schedule):
         """
         Called when a job execution fails.

orionis/console/contracts/schedule_event_listener.py

@@ -43,24 +43,6 @@ class IScheduleEventListener(ABC):
         """
         pass
 
-    @abstractmethod
-    async def onSuccess(self, event: EventJob, schedule):
-        """
-        Called when a job is successfully executed.
-
-        Parameters
-        ----------
-        event : EventJob
-            The successful job execution event containing details about the job.
-        schedule : ISchedule
-            The associated schedule instance managing the job.
-
-        Returns
-        -------
-        None
-        """
-        pass
-
     @abstractmethod
     async def onFailure(self, event: EventJob, schedule):
         """

orionis/foundation/config/app/entities/app.py

@@ -237,8 +237,9 @@ class App(BaseEntity):
         # Validate `key` attribute
         if self.key is None:
             self.key = SecureKeyGenerator.generate()
-        if not isinstance(self.key, str):
-            raise OrionisIntegrityException("The 'key' attribute must be a string.")
+            Env.set('APP_KEY', self.key)
+        if not isinstance(self.key, (bytes, str)) or not self.key.strip():
+            raise OrionisIntegrityException("The 'key' attribute must be a non-empty string.")
 
         # Validate `maintenance` attribute
         if not isinstance(self.maintenance, str) or not self.name.strip() or not self.maintenance.startswith('/'):

orionis/foundation/config/app/enums/ciphers.py

@@ -8,27 +8,13 @@ class Cipher(Enum):
     commonly used for encryption and decryption operations.
 
     Members:
-        AES_128_CBC: AES with 128-bit key in Cipher Block Chaining (CBC) mode.
-        AES_192_CBC: AES with 192-bit key in CBC mode.
-        AES_256_CBC: AES with 256-bit key in CBC mode.
-        AES_128_GCM: AES with 128-bit key in Galois/Counter Mode (GCM).
-        AES_256_GCM: AES with 256-bit key in GCM.
-        AES_CTR: AES in Counter (CTR) mode.
-        AES_CFB: AES in Cipher Feedback (CFB) mode.
-        AES_CFB8: AES in CFB mode with 8-bit feedback.
-        AES_CFB128: AES in CFB mode with 128-bit feedback.
-        AES_OFB: AES in Output Feedback (OFB) mode.
-        AES_ECB: AES in Electronic Codebook (ECB) mode.
+        - AES_128_CBC: AES with a 128-bit key in Cipher Block Chaining (CBC) mode.
+        - AES_256_CBC: AES with a 256-bit key in Cipher Block Chaining (CBC) mode.
+        - AES_128_GCM: AES with a 128-bit key in Galois/Counter Mode (GCM).
+        - AES_256_GCM: AES with a 256-bit key in Galois/Counter Mode (GCM).
     """
 
     AES_128_CBC = "AES-128-CBC"
-    AES_192_CBC = "AES-192-CBC"
     AES_256_CBC = "AES-256-CBC"
     AES_128_GCM = "AES-128-GCM"
-    AES_256_GCM = "AES-256-GCM"
-    AES_CTR = "AES-CTR"
-    AES_CFB = "AES-CFB"
-    AES_CFB8 = "AES-CFB8"
-    AES_CFB128 = "AES-CFB128"
-    AES_OFB = "AES-OFB"
-    AES_ECB = "AES-ECB"
+    AES_256_GCM = "AES-256-GCM"

orionis/foundation/config/session/entities/session.py

@@ -94,8 +94,8 @@ class Session(BaseEntity):
         # Validate secret_key
         if self.secret_key is None:
             self.secret_key = SecretKey.random()
-        if not isinstance(self.secret_key, str) or not self.secret_key.strip():
-            raise OrionisIntegrityException("Session secret_key must be a non-empty string")
+        if not isinstance(self.secret_key, (bytes, str)) or not self.secret_key.strip():
+            raise OrionisIntegrityException("secret_key must be a non-empty string")
 
         # Validate session_cookie
         if not isinstance(self.session_cookie, str) or not self.session_cookie.strip():

orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.546.0"
+VERSION = "0.548.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/services/encrypter/encrypter.py

@@ -0,0 +1,115 @@
+import base64
+import json
+import os
+from typing import Optional
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+
+class Encrypter:
+
+    SUPPORTED_CIPHERS = ["AES-128-CBC", "AES-256-CBC", "AES-128-GCM", "AES-256-GCM"]
+
+    def __init__(self, app_key: str, cipher: str = "AES-256-CBC"):
+        # Decodificar APP_KEY de Laravel
+        if app_key.startswith("base64:"):
+            key_bytes = base64.b64decode(app_key[7:])
+        else:
+            key_bytes = app_key.encode()
+
+        self.key = key_bytes
+        self.cipher = cipher
+
+        # Validar cipher
+        if cipher not in self.SUPPORTED_CIPHERS:
+            raise ValueError(f"Cipher '{cipher}' no soportado. Usa uno de: {self.SUPPORTED_CIPHERS}")
+
+        # Validar longitud de clave según el cipher
+        key_len = len(self.key)
+        if cipher.startswith("AES-128") and key_len != 16:
+            raise ValueError("La clave debe ser de 16 bytes para AES-128")
+        if cipher.startswith("AES-256") and key_len != 32:
+            raise ValueError("La clave debe ser de 32 bytes para AES-256")
+
+    def encrypt(self, plaintext: str) -> str:
+        data = plaintext.encode()
+
+        if "GCM" in self.cipher:
+            return self._encrypt_gcm(data)
+        else:
+            return self._encrypt_cbc(data)
+
+    def decrypt(self, payload: str) -> str:
+        # Decodificar base64 -> JSON
+        decoded = base64.b64decode(payload).decode()
+        data = json.loads(decoded)
+
+        cipher = data.get("cipher")
+        iv = base64.b64decode(data["iv"])
+        value = base64.b64decode(data["value"])
+        tag = base64.b64decode(data["tag"]) if data.get("tag") else None
+
+        if cipher != self.cipher:
+            raise ValueError(f"El cipher del payload '{cipher}' no coincide con el configurado '{self.cipher}'")
+
+        if "GCM" in cipher:
+            return self._decrypt_gcm(value, iv, tag).decode()
+        else:
+            return self._decrypt_cbc(value, iv).decode()
+
+    # -------------------
+    # Métodos privados CBC
+    # -------------------
+    def _encrypt_cbc(self, data: bytes) -> str:
+        iv = os.urandom(16)
+        cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv), backend=default_backend())
+        encryptor = cipher.encryptor()
+
+        # PKCS7 padding
+        pad_len = 16 - (len(data) % 16)
+        data += bytes([pad_len]) * pad_len
+
+        ct = encryptor.update(data) + encryptor.finalize()
+
+        payload = {
+            "iv": base64.b64encode(iv).decode(),
+            "value": base64.b64encode(ct).decode(),
+            "tag": None,
+            "cipher": self.cipher,
+        }
+
+        return base64.b64encode(json.dumps(payload).encode()).decode()
+
+    def _decrypt_cbc(self, ct: bytes, iv: bytes) -> bytes:
+        cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv), backend=default_backend())
+        decryptor = cipher.decryptor()
+        data = decryptor.update(ct) + decryptor.finalize()
+
+        # Unpad PKCS7
+        pad_len = data[-1]
+        return data[:-pad_len]
+
+    # -------------------
+    # Métodos privados GCM
+    # -------------------
+    def _encrypt_gcm(self, data: bytes) -> str:
+        iv = os.urandom(12)
+        aesgcm = AESGCM(self.key)
+        ct = aesgcm.encrypt(iv, data, None)
+
+        # separar ciphertext y tag (últimos 16 bytes)
+        value, tag = ct[:-16], ct[-16:]
+
+        payload = {
+            "iv": base64.b64encode(iv).decode(),
+            "value": base64.b64encode(value).decode(),
+            "tag": base64.b64encode(tag).decode(),
+            "cipher": self.cipher,
+        }
+
+        return base64.b64encode(json.dumps(payload).encode()).decode()
+
+    def _decrypt_gcm(self, value: bytes, iv: bytes, tag: Optional[bytes]) -> bytes:
+        aesgcm = AESGCM(self.key)
+        return aesgcm.decrypt(iv, value + tag, None)

orionis/services/environment/dynamic/caster.py

@@ -255,64 +255,72 @@ class EnvironmentCaster(IEnvironmentCaster):
         """
         Convert the internal value to a Base64 encoded string with the type hint prefix.
 
+        - If the value is already valid base64, leave it as-is.
+        - Otherwise, encode it to base64.
+
         Returns
         -------
         str
-            A string in the format "<type_hint>:<base64_value>", where <base64_value> is the Base64
-            encoded representation of the internal value.
-
-        Raises
-        ------
-        OrionisEnvironmentValueError
-            If the internal value is not a string or bytes.
+            A string in the format "<type_hint>:<base64_value>".
         """
-
-        # Import the base64 module for encoding
         import base64
 
-        # Ensure the internal value is a string or bytes before encoding
         if not isinstance(self.__value_raw, (str, bytes)):
             raise OrionisEnvironmentValueError(
                 f"Value must be a string or bytes to convert to Base64, got {type(self.__value_raw).__name__} instead."
             )
 
-        # Encode the value in Base64
-        encoded_value = base64.b64encode(str(self.__value_raw).encode()).decode()
+        # Normalizar a str
+        if isinstance(self.__value_raw, bytes):
+            candidate = self.__value_raw.decode("utf-8", errors="ignore")
+        else:
+            candidate = self.__value_raw
+
+        try:
+            # Validar si ya es base64 válido
+            base64.b64decode(candidate, validate=True)
+            encoded_value = candidate
+        except Exception:
+            # No era base64, entonces convertirlo
+            raw_bytes = (
+                self.__value_raw.encode() if isinstance(self.__value_raw, str) else self.__value_raw
+            )
+            encoded_value = base64.b64encode(raw_bytes).decode("utf-8")
 
-        # Return the formatted string with type hint and Base64 encoded value
         return f"{self.__type_hint}:{encoded_value}"
 
-    def __parseBase64(self) -> str:
+    def __parseBase64(self) -> bytes:
         """
         Decode the internal raw value from Base64 encoding.
 
-        Decodes the Base64-encoded string stored in the internal raw value and returns the decoded result as a string.
-        If decoding fails, raises an OrionisEnvironmentValueException.
-
         Returns
         -------
-        str
-            The decoded string from the Base64-encoded internal value.
+        bytes
+            The decoded raw bytes from the Base64-encoded internal value.
 
         Raises
         ------
         OrionisEnvironmentValueException
             If the internal value cannot be decoded from Base64.
         """
-
-        # Import the base64 module for decoding
         import base64
 
         try:
+            raw_value = self.__value_raw
+            if isinstance(raw_value, bytes):
+                raw_value = raw_value.decode("utf-8", errors="ignore")
 
-            # Decode the Base64 encoded value and return as string
-            decoded_value = base64.b64decode(self.__value_raw).decode()
-            return decoded_value
+            decoded = base64.b64decode(raw_value, validate=True)
 
-        except Exception as e:
+            try:
+                return decoded.decode("utf-8")
+            except UnicodeDecodeError:
+                return decoded
 
-            # Raise a custom exception if decoding fails
-            raise OrionisEnvironmentValueException(f"Cannot decode Base64 value '{self.__value_raw}': {str(e)}")
+        except Exception as e:
+            raise OrionisEnvironmentValueException(
+                f"Cannot decode Base64 value '{self.__value_raw}': {str(e)}"
+            )
 
     def __parsePath(self):
         """

orionis/services/environment/key/key_generator.py

@@ -1,26 +1,47 @@
 import os
+import base64
 
 class SecureKeyGenerator:
     """
-    Static utility class for generating cryptographically secure random keys.
+    Utility class for generating Laravel-compatible APP_KEY values.
 
-    This class provides a static method to generate a secure random key,
-    encoded as a hexadecimal string, suitable for use in security-sensitive
-    applications such as cryptographic secrets or tokens.
+    Laravel expects keys in Base64 format, prefixed with 'base64:'.
+    Supported ciphers: AES-128-CBC, AES-256-CBC, AES-128-GCM, AES-256-GCM.
     """
 
+    KEY_SIZES = {
+        "AES-128-CBC": 16,
+        "AES-256-CBC": 32,
+        "AES-128-GCM": 16,
+        "AES-256-GCM": 32,
+    }
+
     @staticmethod
-    def generate() -> str:
+    def generate(cipher: str = "AES-256-CBC") -> str:
         """
-        Generate a cryptographically secure random key encoded in hexadecimal.
+        Generate a Laravel-compatible APP_KEY.
+
+        Parameters
+        ----------
+        cipher : str
+            The cipher algorithm. Options: AES-128-CBC, AES-256-CBC,
+            AES-128-GCM, AES-256-GCM. Default is AES-256-CBC.
 
         Returns
         -------
         str
-            A 64-character hexadecimal string representing a 32-byte
-            cryptographically secure random key.
+            A string formatted like Laravel's APP_KEY (e.g., base64:xxxx).
         """
+        if cipher not in SecureKeyGenerator.KEY_SIZES:
+            raise ValueError(
+                f"Cipher '{cipher}' no soportado. "
+                f"Opciones: {', '.join(SecureKeyGenerator.KEY_SIZES.keys())}"
+            )
+
+        key_length = SecureKeyGenerator.KEY_SIZES[cipher]
+
+        # Generate secure random bytes
+        key = os.urandom(key_length)
 
-        # Generate 32 random bytes using a cryptographically secure RNG
-        # Encode the bytes as a hexadecimal string and return
-        return os.urandom(32).hex()
+        # Encode in Base64 and prepend 'base64:'
+        return "base64:" + base64.b64encode(key).decode("utf-8")

{orionis-0.546.0.dist-info → orionis-0.548.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.546.0
+Version: 0.548.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro