Patched code sample

import ast

class PluginSecurity:
    """
    A mock representation of the fixed PluginSecurity class.
    The vulnerability was an incomplete blocklist. The fix involves
    adding checks for bypass techniques.
    """

    # In a real scenario, this would be more exhaustive.
    # The vulnerability was that this list was incomplete.
    BLOCKED_NODE_TYPES = (
        ast.Import,
        ast.ImportFrom,
    )

    # THE FIX: The vulnerable version was missing a check for dangerous
    # function calls, which allowed bypasses. This new blocklist is added.
    BLOCKED_CALL_NAMES = {
        '__import__',
        'eval',
        'exec',
        'open',
        'compile',
        'execfile',
        'input',
    }

    def validate_plugin_code(self, code_string: str):
        """
        Validates plugin code using an AST traversal.

        This 'fixed' version now checks for specific dangerous function calls
        in addition to blocking import statements.
        """
        try:
            tree = ast.parse(code_string, filename="<plugin>")
        except SyntaxError as e:
            raise ValueError(f"Plugin code is not valid Python: {e}")

        for node in ast.walk(tree):
            # Original check: Block 'import' and 'from ... import'
            if isinstance(node, self.BLOCKED_NODE_TYPES):
                raise ValueError(
                    f"Disallowed construct '{type(node).__name__}' found on line {getattr(node, 'lineno', '?')}."
                )

            # THE FIX: Add a new check for dangerous function calls.
            # This prevents bypasses like `__import__('os').system('rm -rf /')`
            # which would not be caught by the node type check alone.
            if isinstance(node, ast.Call):
                # Check for calls by simple name, e.g., `eval(...)`
                if isinstance(node.func, ast.Name) and node.func.id in self.BLOCKED_CALL_NAMES:
                    raise ValueError(
                        f"Disallowed call to function '{node.func.id}' found on line {node.lineno}."
                    )
                # Check for calls on an attribute, e.g., `os.system(...)`
                # A robust check would require tracking variable assignments.
                # For this example, we block common dangerous attributes.
                if isinstance(node.func, ast.Attribute) and node.func.attr in ('system', 'popen', 'spawn', 'run'):
                    raise ValueError(
                        f"Disallowed attribute call '{node.func.attr}' found on line {node.lineno}."
                    )
        return True