Patched code sample

import re

# A custom exception to be raised on security violations.
class SecurityError(Exception):
    """Raised when a potential security violation is detected."""
    pass

# Regular expression for what is considered a safe, public attribute.
# It must be a valid Python identifier and cannot start with an underscore.
SAFE_ATTRIBUTE_REGEX = re.compile(r"^[a-zA-Z][a-zA-Z0-9_]*$")

class MethodNode:
    """
    Represents a method call on a nested object structure.

    This class securely resolves a path (e.g., 'attr1.attr2.method') on a
    given object, preventing access to private or dunder attributes that
    could lead to arbitrary code execution.
    """
    def __init__(self, path: str):
        if not isinstance(path, str):
            raise TypeError(f"Path must be a string, but got {type(path)}")

        self.parts = path.split('.')
        # Pre-validate all parts of the path during initialization.
        for part in self.parts:
            if not SAFE_ATTRIBUTE_REGEX.match(part):
                raise SecurityError(
                    f"Insecure or invalid attribute '{part}' in path '{path}'. "
                    "Access to attributes starting with an underscore is not permitted."
                )
        self.path = path

    def resolve(self, instance: object):
        """
        Safely resolves the attribute path on the given instance.

        Each part of the path is validated again during resolution to ensure
        it does not access private or special (dunder) attributes.
        """
        target = instance
        for part in self.parts:
            # The check is performed here again as a defense-in-depth measure,
            # though it's already validated in __init__. This is the core of the fix.
            if not SAFE_ATTRIBUTE_REGEX.match(part):
                # This block prevents traversal through attributes like `__class__`,
                # `__subclasses__`, `__globals__`, or `_private_attr`, which is
                # the vector for the vulnerability.
                raise SecurityError(
                    f"Attempted to access a non-public or special attribute '{part}'."
                )
            
            try:
                target = getattr(target, part)
            except AttributeError:
                raise AttributeError(
                    f"'{type(target).__name__}' object has no attribute '{part}' "
                    f"while resolving path '{self.path}'."
                )
        return target

# Example Usage Demonstration (for context, not part of the core fix)

if __name__ == '__main__':
    class SafeObject:
        def __init__(self):
            self.public_attribute = "hello"
            self._private_attribute = "secret"

        def public_method(self):
            return "This is a safe method."

    class NestedObject:
        def __init__(self):
            self.child = SafeObject()

    obj = NestedObject()

    # --- Secure Use Case ---
    try:
        # This path is safe and will be resolved correctly.
        safe_path = "child.public_method"
        node = MethodNode(safe_path)
        resolved_method = node.resolve(obj)
        print(f"Successfully resolved '{safe_path}': {resolved_method()}")
    except (SecurityError, AttributeError) as e:
        print(f"Error resolving '{safe_path}': {e}")


    # --- Insecure Use Case (Blocked by the fix) ---
    # This path attempts to access a private attribute.
    insecure_path_private = "child._private_attribute"
    try:
        node = MethodNode(insecure_path_private)
        # The line above will already raise a SecurityError.
        node.resolve(obj) 
    except SecurityError as e:
        print(f"Correctly blocked insecure path '{insecure_path_private}': {e}")

    # --- Insecure Use Case (Blocked by the fix) ---
    # This path attempts to use a dunder method to start an exploit chain.
    insecure_path_dunder = "child.__class__"
    try:
        node = MethodNode(insecure_path_dunder)
        # The line above will already raise a SecurityError.
        node.resolve(obj)
    except SecurityError as e:
        print(f"Correctly blocked insecure path '{insecure_path_dunder}': {e}")

    # --- Insecure Use Case (Blocked by the fix) ---
    # A more complex, malicious path.
    malicious_path = "child.__class__.__mro__"
    try:
        node = MethodNode(malicious_path)
    except SecurityError as e:
        print(f"Correctly blocked malicious path '{malicious_path}': {e}")