Patched code sample

import ast
from typing import Any, Dict


def eval_custom_component_code(code: str) -> Dict[str, Any]:
    """
    Evaluates the given Python code and returns the global variables
    after execution.

    This function now includes security measures to prevent arbitrary code execution
    by parsing the code into an Abstract Syntax Tree (AST) and checking for
    disallowed operations like imports or dangerous function calls.

    Args:
        code (str): The Python code to evaluate.

    Returns:
        Dict[str, Any]: A dictionary of global variables after the code has
                        been executed.

    Raises:
        ValueError: If the code contains disallowed operations.
    """
    # Disallowed keywords - we don't want to allow imports
    disallowed_keywords = ["import"]
    # Disallowed nodes - we don't want to allow imports, and we want to prevent
    # any calls to functions that could be used for remote code execution.
    disallowed_nodes = [
        ast.Import,
        ast.ImportFrom,
    ]
    # We also want to prevent calls to open, eval, exec
    # and any dunder methods.
    disallowed_function_calls = ["open", "eval", "exec"]

    # Check for disallowed keywords
    if any(keyword in code for keyword in disallowed_keywords):
        raise ValueError("Code contains disallowed keywords.")

    # Parse the code into an AST
    try:
        tree = ast.parse(code)
    except SyntaxError as e:
        raise ValueError(f"Invalid Python code: {e}") from e

    # Check for disallowed nodes in the AST
    for node in ast.walk(tree):
        if any(isinstance(node, disallowed_node) for disallowed_node in disallowed_nodes):
            raise ValueError(f"Code contains disallowed AST nodes: {type(node).__name__}")
        # Check for disallowed function calls
        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
            if node.func.id in disallowed_function_calls:
                raise ValueError(f"Code contains disallowed function call: {node.func.id}")
        # Check for dunder methods
        if isinstance(node, ast.Attribute) and node.attr.startswith("__") and node.attr.endswith("__"):
            raise ValueError(f"Code contains disallowed dunder method call: {node.attr}")

    # If the code is safe, execute it
    globals_dict: Dict[str, Any] = {}
    exec(code, globals_dict)

    return globals_dict