Patched code sample

import importlib

# Define a list of trusted modules/packages that can be deserialized.
# This acts as an allowlist, preventing the loading of arbitrary modules.
ALLOWED_MODULES = (
    'laboneq.dsl.experiment',
    'laboneq.dsl.parameter',
    # Assume other safe, non-system-interacting modules from the project
    # would be listed here.
)

def import_cls(fully_qualified_name: str):
    """
    FIXED version of the class importer.

    It dynamically imports a class, but only after validating that it belongs
    to a module within an approved (allowlisted) package.
    """
    try:
        module_name, class_name = fully_qualified_name.rsplit('.', 1)
    except ValueError:
        raise ImportError(f"Invalid fully-qualified name: '{fully_qualified_name}'")

    # --- THE FIX ---
    # Validate that the module is in the allowlist.
    # The `startswith` check allows entire packages (e.g., 'laboneq.dsl') to be
    # trusted, without having to list every single submodule. This prevents
    # loading classes from dangerous modules like 'os', 'subprocess', etc.
    if not any(module_name.startswith(allowed) for allowed in ALLOWED_MODULES):
        raise ImportError(
            f"Deserialization of class '{fully_qualified_name}' is disallowed "
            "because its module is not on the allowlist."
        )
    # --- END OF FIX ---

    # If validation passes, proceed with the import.
    try:
        module = importlib.import_module(module_name)
        cls = getattr(module, class_name)
        return cls
    except (ImportError, AttributeError) as e:
        raise ImportError(f"Could not import class '{fully_qualified_name}'.") from e

# Example usage within a hypothetical deserializer:
def deserialize_safe(data: dict):
    """
    Example deserializer that uses the secured import_cls function.
    """
    class_fqn = data.pop('__type__')

    # This call is now safe. It will raise an ImportError for malicious input.
    cls_to_instantiate = import_cls(class_fqn)

    # The class is now guaranteed to be from a trusted source before instantiation.
    return cls_to_instantiate(**data)

# --- DEMONSTRATION ---

# Define some dummy classes to simulate the environment
class MockSafeExperiment:
    def __init__(self, name):
        self.name = name
        print(f"Safely deserialized Experiment: {self.name}")

# To make this runnable, we need to place the class where the loader expects it.
# We'll use a trick with __main__ to simulate a valid module path.
import sys
# Mock the 'laboneq.dsl.experiment' module
sys.modules['laboneq.dsl.experiment'] = sys.modules[__name__]
# Assign the class to the mocked module's namespace
laboneq.dsl.experiment.SafeExperiment = MockSafeExperiment

# 1. Example of a legitimate, safe payload
safe_payload = {
    '__type__': 'laboneq.dsl.experiment.SafeExperiment',
    'name': 'My Safe Test'
}

# 2. Example of a malicious payload trying to execute code
# This would fail because the 'os' module is not in ALLOWED_MODULES.
malicious_payload = {
    '__type__': 'os.system',
    'command': 'echo "This command should NOT be executed"'
}

print("--- Attempting to deserialize a safe payload ---")
try:
    obj = deserialize_safe(safe_payload)
except ImportError as e:
    print(f"Error: {e}")

print("\n--- Attempting to deserialize a malicious payload ---")
try:
    obj = deserialize_safe(malicious_payload)
except ImportError as e:
    print(f"Successfully blocked malicious payload. Error: {e}")