orionis 0.546.0__tar.gz → 0.547.0__tar.gz

orionis-0.547.0/MANIFEST.in

@@ -0,0 +1,20 @@
+include README.md
+include LICENSE
+
+recursive-include orionis *.py *.html
+
+exclude app/*
+exclude bootstrap/*
+exclude config/*
+exclude database/*
+exclude routes/*
+exclude storage/*
+exclude tests/*
+
+recursive-exclude app *
+recursive-exclude bootstrap *
+recursive-exclude config *
+recursive-exclude database *
+recursive-exclude routes *
+recursive-exclude storage *
+recursive-exclude tests *

{orionis-0.546.0/orionis.egg-info → orionis-0.547.0}/PKG-INFO

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

{orionis-0.546.0 → orionis-0.547.0}/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-0.546.0 → orionis-0.547.0}/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-0.546.0 → orionis-0.547.0}/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-0.547.0/orionis/foundation/config/app/enums/ciphers.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+class Cipher(Enum):
+    """
+    Enumeration of supported AES cipher modes.
+
+    This enum defines various Advanced Encryption Standard (AES) cipher modes and key sizes
+    commonly used for encryption and decryption operations.
+
+    Members:
+        - 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_256_CBC = "AES-256-CBC"
+    AES_128_GCM = "AES-128-GCM"
+    AES_256_GCM = "AES-256-GCM"

{orionis-0.546.0 → orionis-0.547.0}/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-0.546.0 → orionis-0.547.0}/orionis/metadata/framework.py

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

orionis-0.547.0/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-0.546.0 → orionis-0.547.0}/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-0.547.0/orionis/services/environment/key/key_generator.py

@@ -0,0 +1,47 @@
+import os
+import base64
+
+class SecureKeyGenerator:
+    """
+    Utility class for generating Laravel-compatible APP_KEY values.
+
+    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(cipher: str = "AES-256-CBC") -> str:
+        """
+        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 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)
+
+        # Encode in Base64 and prepend 'base64:'
+        return "base64:" + base64.b64encode(key).decode("utf-8")

{orionis-0.546.0 → orionis-0.547.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.546.0 → orionis-0.547.0}/orionis.egg-info/SOURCES.txt

@@ -260,6 +260,7 @@ orionis/services/asynchrony/contracts/__init__.py
 orionis/services/asynchrony/contracts/coroutines.py
 orionis/services/asynchrony/exceptions/__init__.py
 orionis/services/asynchrony/exceptions/exception.py
+orionis/services/encrypter/encrypter.py
 orionis/services/environment/__init__.py
 orionis/services/environment/env.py
 orionis/services/environment/contracts/__init__.py
@@ -441,149 +442,4 @@ orionis/test/validators/verbosity.py
 orionis/test/validators/web_report.py
 orionis/test/validators/workers.py
 orionis/test/view/__init__.py
-orionis/test/view/render.py
-tests/container/__init__.py
-tests/container/context/__init__.py
-tests/container/context/test_manager.py
-tests/container/context/test_scope.py
-tests/container/core/__init__.py
-tests/container/core/test_advanced_async.py
-tests/container/core/test_async_optimizations.py
-tests/container/core/test_container.py
-tests/container/core/test_singleton.py
-tests/container/core/test_thread_safety.py
-tests/container/entities/__init__.py
-tests/container/entities/test_binding.py
-tests/container/enums/__init__.py
-tests/container/enums/test_lifetimes.py
-tests/container/facades/__init__.py
-tests/container/facades/test_facade.py
-tests/container/mocks/__init__.py
-tests/container/mocks/mock_advanced_async.py
-tests/container/mocks/mock_async_optimizations.py
-tests/container/mocks/mock_auto_resolution.py
-tests/container/mocks/mock_complex_classes.py
-tests/container/mocks/mock_simple_classes.py
-tests/container/providers/__init__.py
-tests/container/providers/test_providers.py
-tests/container/validators/__init__.py
-tests/container/validators/test_implements.py
-tests/container/validators/test_is_abstract_class.py
-tests/container/validators/test_is_callable.py
-tests/container/validators/test_is_concrete_class.py
-tests/container/validators/test_is_instance.py
-tests/container/validators/test_is_not_subclass.py
-tests/container/validators/test_is_subclass.py
-tests/container/validators/test_is_valid_alias.py
-tests/container/validators/test_lifetime.py
-tests/example/__init__.py
-tests/example/test_example.py
-tests/foundation/__init__.py
-tests/foundation/config/__init__.py
-tests/foundation/config/app/__init__.py
-tests/foundation/config/app/test_foundation_config_app.py
-tests/foundation/config/auth/__init__.py
-tests/foundation/config/auth/test_foundation_config_auth.py
-tests/foundation/config/cache/__init__.py
-tests/foundation/config/cache/test_foundation_config_cache.py
-tests/foundation/config/cache/test_foundation_config_cache_file.py
-tests/foundation/config/cache/test_foundation_config_cache_stores.py
-tests/foundation/config/cors/__init__.py
-tests/foundation/config/cors/test_foundation_config_cors.py
-tests/foundation/config/database/__init__.py
-tests/foundation/config/database/test_foundation_config_database.py
-tests/foundation/config/database/test_foundation_config_database_connections.py
-tests/foundation/config/database/test_foundation_config_database_mysql.py
-tests/foundation/config/database/test_foundation_config_database_oracle.py
-tests/foundation/config/database/test_foundation_config_database_pgsql.py
-tests/foundation/config/database/test_foundation_config_database_sqlite.py
-tests/foundation/config/filesystems/__init__.py
-tests/foundation/config/filesystems/test_foundation_config_filesystems.py
-tests/foundation/config/filesystems/test_foundation_config_filesystems_aws.py
-tests/foundation/config/filesystems/test_foundation_config_filesystems_disks.py
-tests/foundation/config/filesystems/test_foundation_config_filesystems_local.py
-tests/foundation/config/filesystems/test_foundation_config_filesystems_public.py
-tests/foundation/config/logging/__init__.py
-tests/foundation/config/logging/test_foundation_config_logging.py
-tests/foundation/config/logging/test_foundation_config_logging_channels.py
-tests/foundation/config/logging/test_foundation_config_logging_chunked.py
-tests/foundation/config/logging/test_foundation_config_logging_daily.py
-tests/foundation/config/logging/test_foundation_config_logging_hourly.py
-tests/foundation/config/logging/test_foundation_config_logging_monthly.py
-tests/foundation/config/logging/test_foundation_config_logging_stack.py
-tests/foundation/config/logging/test_foundation_config_logging_weekly.py
-tests/foundation/config/mail/__init__.py
-tests/foundation/config/mail/test_foundation_config_mail.py
-tests/foundation/config/mail/test_foundation_config_mail_file.py
-tests/foundation/config/mail/test_foundation_config_mail_mailers.py
-tests/foundation/config/mail/test_foundation_config_mail_smtp.py
-tests/foundation/config/queue/__init__.py
-tests/foundation/config/queue/test_foundation_config_queue.py
-tests/foundation/config/queue/test_foundation_config_queue_brokers.py
-tests/foundation/config/queue/test_foundation_config_queue_database.py
-tests/foundation/config/root/__init__.py
-tests/foundation/config/root/test_foundation_config_root_paths.py
-tests/foundation/config/session/__init__.py
-tests/foundation/config/session/test_foundation_config_session.py
-tests/foundation/config/startup/__init__.py
-tests/foundation/config/startup/test_foundation_config_startup.py
-tests/foundation/config/testing/__init__.py
-tests/foundation/config/testing/test_foundation_config_testing.py
-tests/metadata/__init__.py
-tests/metadata/test_metadata_framework.py
-tests/metadata/test_metadata_package.py
-tests/services/__init__.py
-tests/services/asynchrony/__init__.py
-tests/services/asynchrony/test_services_asynchrony_coroutine.py
-tests/services/environment/__init__.py
-tests/services/environment/test_services_environment.py
-tests/services/introspection/__init__.py
-tests/services/introspection/test_reflection.py
-tests/services/introspection/dependencies/__init__.py
-tests/services/introspection/dependencies/test_reflect_dependencies.py
-tests/services/introspection/dependencies/mocks/__init__.py
-tests/services/introspection/dependencies/mocks/mock_user.py
-tests/services/introspection/dependencies/mocks/mock_user_controller.py
-tests/services/introspection/dependencies/mocks/mock_users_permissions.py
-tests/services/introspection/reflection/__init__.py
-tests/services/introspection/reflection/test_reflection_abstract.py
-tests/services/introspection/reflection/test_reflection_callable.py
-tests/services/introspection/reflection/test_reflection_concrete.py
-tests/services/introspection/reflection/test_reflection_instance.py
-tests/services/introspection/reflection/test_reflection_module.py
-tests/services/introspection/reflection/mock/__init__.py
-tests/services/introspection/reflection/mock/fake_reflect_instance.py
-tests/services/log/__init__.py
-tests/services/log/test_log.py
-tests/services/system/__init__.py
-tests/services/system/test_services_system_imports.py
-tests/services/system/test_services_system_workers.py
-tests/support/__init__.py
-tests/support/entities/__init__.py
-tests/support/entities/mock_dataclass.py
-tests/support/entities/test_base.py
-tests/support/patterns/__init__.py
-tests/support/patterns/singleton/__init__.py
-tests/support/patterns/singleton/test_patterns_singleton.py
-tests/support/standard/__init__.py
-tests/support/standard/test_services_std.py
-tests/support/wrapper/__init__.py
-tests/support/wrapper/test_services_wrapper_docdict.py
-tests/testing/__init__.py
-tests/testing/test_testing_unit.py
-tests/testing/cases/__init__.py
-tests/testing/cases/test_testing_asynchronous.py
-tests/testing/cases/test_testing_synchronous.py
-tests/testing/entities/__init__.py
-tests/testing/entities/test_testing_result.py
-tests/testing/enums/__init__.py
-tests/testing/enums/test_testing_status.py
-tests/testing/output/__init__.py
-tests/testing/output/test_testing_dumper.py
-tests/testing/output/test_testing_printer.py
-tests/testing/records/__init__.py
-tests/testing/records/test_testing_records.py
-tests/testing/validators/__init__.py
-tests/testing/validators/test_testing_validators.py
-tests/testing/view/__init__.py
-tests/testing/view/test_render.py
+orionis/test/view/render.py

{orionis-0.546.0 → orionis-0.547.0}/orionis.egg-info/top_level.txt

@@ -1,2 +1 @@
 orionis
-tests

{orionis-0.546.0 → orionis-0.547.0}/setup.py

@@ -54,13 +54,13 @@ setup(
     license='MIT',
     packages=find_packages(
         exclude=[
-            'app',
-            'bootstrap',
-            'config',
-            'database'
-            'routes',
-            'storage',
-            'tests'
+            'app', 'app.*',
+            'bootstrap', 'bootstrap.*',
+            'config', 'config.*',
+            'database', 'database.*',
+            'routes', 'routes.*',
+            'storage', 'storage.*',
+            'tests', 'tests.*'
         ]
     ),
     include_package_data=True,

orionis-0.546.0/MANIFEST.in

@@ -1,3 +0,0 @@
-include README.md
-include LICENSE
-recursive-include orionis *.py *.html

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

@@ -1,34 +0,0 @@
-from enum import Enum
-
-class Cipher(Enum):
-    """
-    Enumeration of supported AES cipher modes.
-
-    This enum defines various Advanced Encryption Standard (AES) cipher modes and key sizes
-    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-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"

orionis-0.546.0/orionis/services/environment/key/key_generator.py

@@ -1,26 +0,0 @@
-import os
-
-class SecureKeyGenerator:
-    """
-    Static utility class for generating cryptographically secure random keys.
-
-    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.
-    """
-
-    @staticmethod
-    def generate() -> str:
-        """
-        Generate a cryptographically secure random key encoded in hexadecimal.
-
-        Returns
-        -------
-        str
-            A 64-character hexadecimal string representing a 32-byte
-            cryptographically secure random key.
-        """
-
-        # Generate 32 random bytes using a cryptographically secure RNG
-        # Encode the bytes as a hexadecimal string and return
-        return os.urandom(32).hex()