Patched code sample

The actual fix for this CVE is a change in the GitHub Actions YAML workflow file (`.github/workflows/regenerate-migrations.yml`), not in a Python file. The vulnerability was that the workflow executed untrusted Python code.

A conceptual fix in Python would involve processing the untrusted file without executing it. The following code demonstrates this principle. It safely inspects a potentially malicious Python file to find Django model definitions using Python's Abstract Syntax Tree (AST) module, which parses code without running it, thus preventing the Remote Code Execution.

```python
import ast
import os

def get_class_names_safely(filepath: str) -> list:
    """
    Safely parses a Python file to find class names without executing it.

    This function represents a fix for the vulnerability pattern. Instead of
    a direct and unsafe `import` of untrusted code, it uses the `ast` module
    to build a structural representation of the code. This allows for
    inspection without triggering module-level code execution, preventing RCE.
    """
    try:
        with open(filepath, "r") as source:
            # ast.parse is the key to the fix. It reads the code as data
            # and builds a syntax tree, but does NOT execute it.
            tree = ast.parse(source.read())
        
        # Walk the tree to find all class definition nodes and extract their names.
        class_names = [node.name for node in ast.walk(tree) if isinstance(node, ast.ClassDef)]
        return class_names
    except (FileNotFoundError, SyntaxError) as e:
        print(f"Error safely parsing file {filepath}: {e}")
        return []

# --- Demonstration of the fix ---

# 1. Simulate the attacker's malicious `models.py` file from a pull request.
#    This file contains a malicious payload at the module level.
malicious_code_path = "untrusted_models.py"
with open(malicious_code_path, "w") as f:
    f.write("""
import os

# --- MALICIOUS PAYLOAD ---
# This code executes automatically if the file is imported directly.
# In the CVE, this would run in the CI environment with access to secrets.
print("!!! RCE TRIGGERED: Attempting to exfiltrate secrets... !!!")
os.system("echo 'Secret value: $GITHUB_TOKEN'")
# --- END PAYLOAD ---

# A legitimate-looking class to make the PR appear harmless.
class UserProfileModel:
    pass
""")

# 2. In a vulnerable system, `import untrusted_models` would execute the payload.
#    Here, we demonstrate the fix by using our safe function instead.
print(f"--- Securely scanning '{malicious_code_path}' ---")
found_classes = get_class_names_safely(malicious_code_path)

# 3. The output shows that the class was found, but the malicious code did not run.
print(f"\nScan complete. The malicious `print` and `os.system` calls were NOT executed.")
print(f"Safely discovered classes: {found_classes}")

# 4. Clean up the dummy file.
os.remove(malicious_code_path)