World's first open-source, agentic video production system. 12 production pipelines, 100+ tools, 700+ agent skill and production-knowledge files. Turn your AI coding assistant into a full video production studio.
Python agentagentic-aiaiclaudecopilotcursorelevenlabsffmpegfluximage-generationopen-sourceopenaipythonremotionstable-diffusiontext-to-speechtext-to-videovideo-generationvideo-production
fix(math_animate): gate caller-supplied scene_code execution (#219)
0xDevNinjab69ce5f9a2a8
diff --git a/tests/tools/test_math_animate_safety.py b/tests/tools/test_math_animate_safety.pynew file mode 100644index 00000000..dafc487d--- /dev/null+++ b/tests/tools/test_math_animate_safety.py@@ -0,0 +1,122 @@+"""Tests for math_animate scene_code safety scan (issue #219).++math_animate executes caller-supplied Python via Manim. The static scan blocks+the constructs an attack needs (system/network/subprocess/secret access) while+leaving genuine math-animation scenes untouched, and can be bypassed only with+an explicit allow_unsafe_code opt-out.+"""++import sys+from pathlib import Path++import pytest++PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent+sys.path.insert(0, str(PROJECT_ROOT))++from tools.graphics.math_animate import MathAnimate # noqa: E402++SAFE_SCENE = (+ "from manim import *\n"+ "import numpy as np\n"+ "import math\n"+ "class Demo(Scene):\n"+ " def construct(self):\n"+ " self.play(Create(Circle(radius=np.pi / math.tau)))\n"+)+++def test_safe_scene_passes_scan():+ assert MathAnimate._scan_scene_code(SAFE_SCENE) == []+++ "snippet, needle",+ [+ ("import os\nos.environ", "import 'os'"),+ ("import subprocess", "import 'subprocess'"),+ ("import socket", "import 'socket'"),+ ("from urllib.request import urlopen", "from 'urllib.request' import ..."),+ ("import requests", "import 'requests'"),+ ],+)+def test_blocks_dangerous_imports(snippet, needle):+ code = f"from manim import *\n{snippet}\nclass S(Scene):\n def construct(self):\n pass\n"+ violations = MathAnimate._scan_scene_code(code)+ assert needle in violations++[email protected]("call", ["eval", "exec", "compile", "open", "__import__"])+def test_blocks_dangerous_calls(call):+ code = (+ "from manim import *\n"+ "class S(Scene):\n"+ " def construct(self):\n"+ f" {call}('x')\n"+ )+ assert f"call to '{call}()'" in MathAnimate._scan_scene_code(code)+++def test_blocks_sandbox_escape_dunders():+ code = (+ "from manim import *\n"+ "class S(Scene):\n"+ " def construct(self):\n"+ " ().__class__.__bases__[0].__subclasses__()\n"+ )+ violations = MathAnimate._scan_scene_code(code)+ assert "attribute access '.__bases__'" in violations+ assert "attribute access '.__subclasses__'" in violations+++def test_syntax_error_defers_to_manim():+ # A parse failure must not mask as a safety violation; Manim reports it.+ assert MathAnimate._scan_scene_code("class S(Scene):\n def construct(self)\n") == []+++def test_execute_blocks_dangerous_code_before_running_manim(monkeypatch):+ # Pretend manim is installed so execute() reaches the safety gate rather+ # than short-circuiting on a missing binary. The scan must reject before any+ # subprocess runs.+ monkeypatch.setattr("shutil.which", lambda _: "/usr/bin/manim")++ def boom(*a, **k): # subprocess must never be reached+ raise AssertionError("subprocess.run should not be called for blocked code")++ monkeypatch.setattr("subprocess.run", boom)++ dangerous = (+ "from manim import *\n"+ "import os\n"+ "class S(Scene):\n"+ " def construct(self):\n"+ " print(os.environ)\n"+ )+ result = MathAnimate().execute({"scene_code": dangerous})+ assert result.success is False+ assert "safety scan" in result.error+ assert "allow_unsafe_code" in result.error+++def test_allow_unsafe_code_bypasses_scan(monkeypatch):+ # With the opt-out, execution proceeds past the scan to Manim (which we stub+ # to fail); the failure must NOT be the safety-scan message.+ monkeypatch.setattr("shutil.which", lambda _: "/usr/bin/manim")++ class FakeProc:+ returncode = 1+ stderr = "manim ran"+ stdout = ""++ monkeypatch.setattr("subprocess.run", lambda *a, **k: FakeProc())++ dangerous = (+ "from manim import *\n"+ "import os\n"+ "class S(Scene):\n"+ " def construct(self):\n"+ " print(os.environ)\n"+ )+ result = MathAnimate().execute({"scene_code": dangerous, "allow_unsafe_code": True})+ assert result.success is False+ assert "safety scan" not in (result.error or "")diff --git a/tools/graphics/math_animate.py b/tools/graphics/math_animate.pyindex 61c635b6..1caf808e 100644--- a/tools/graphics/math_animate.py+++ b/tools/graphics/math_animate.py@@ -6,6 +6,7 @@ using the Manim Community Edition engine. Free, local, no API key required.from __future__ import annotations+import astimport osimport shutilimport subprocess@@ -28,6 +29,31 @@ from tools.base_tool import ()+# --- Safety: caller-supplied scene_code is a local code-execution boundary ---+# math_animate runs Manim on Python supplied by the caller (often an LLM or+# prompt-influenced reference material). That is arbitrary local code execution+# (see issue #219). The static scan below is defense-in-depth: it blocks the+# constructs an attack needs — reading secrets/SSH material, opening network+# connections, spawning subprocesses — while leaving genuine math/animation+# scenes untouched. It is NOT a security sandbox: a determined attacker can+# evade a static denylist, so it is paired with an explicit `allow_unsafe_code`+# opt-out and a tool contract that names the boundary. A passing scan is not+# proof that code is safe to run.+_BLOCKED_IMPORTS = frozenset({+ "os", "sys", "subprocess", "socket", "shutil", "requests", "urllib",+ "http", "ftplib", "smtplib", "telnetlib", "ctypes", "pickle", "marshal",+ "importlib", "builtins", "multiprocessing", "threading", "pty", "glob",+ "resource", "signal", "tempfile", "webbrowser", "pathlib",+})+_BLOCKED_CALLS = frozenset({+ "eval", "exec", "compile", "__import__", "open", "input", "breakpoint",+})+_BLOCKED_ATTRS = frozenset({+ "__globals__", "__builtins__", "__subclasses__", "__bases__", "__mro__",+ "__code__",+})++# Quality presets mapping to Manim CLI flagsQUALITY_PRESETS = {"low": {"flag": "-ql", "resolution": "854x480", "fps": 15},@@ -76,7 +102,20 @@ class MathAnimate(BaseTool):"description": ("Python code defining a Manim scene. Must contain a class ""inheriting from Scene with a construct() method. "- "Import 'from manim import *' is auto-added if missing."+ "Import 'from manim import *' is auto-added if missing. "+ "SECURITY: this code is EXECUTED on the host by Manim. It is "+ "scanned for dangerous constructs (system/network/subprocess "+ "access) and rejected by default; treat scene_code as trusted "+ "input only."+ ),+ },+ "allow_unsafe_code": {+ "type": "boolean",+ "default": False,+ "description": (+ "Bypass the scene_code safety scan. Only set this for code "+ "you fully trust — it permits arbitrary local code execution "+ "(filesystem, network, subprocess). See issue #219."),},"scene_name": {@@ -117,7 +156,13 @@ class MathAnimate(BaseTool):)retry_policy = RetryPolicy(max_retries=1, retryable_errors=["timeout"])idempotency_key_fields = ["scene_code", "scene_name", "quality"]- side_effects = ["writes video/image file to output_path", "creates temp files"]+ side_effects = [+ "EXECUTES caller-supplied Python (Manim scene_code) on the host — this "+ "is a local code-execution boundary; scene_code is scanned and rejected "+ "by default unless allow_unsafe_code=true (see issue #219)",+ "writes video/image file to output_path",+ "creates temp files",+ ]user_visible_verification = ["Watch the animation for correctness and visual quality","Verify math formulas render correctly (requires LaTeX)",@@ -160,6 +205,47 @@ class MathAnimate(BaseTool):result.duration_seconds = round(time.time() - start, 2)return result+ @staticmethod+ def _scan_scene_code(code: str) -> list[str]:+ """Static safety scan of caller-supplied Manim scene code (issue #219).++ Returns a de-duplicated list of disallowed constructs (dangerous+ imports, builtins, and sandbox-escape dunders). Empty list means the+ scan found nothing to block — which is NOT a guarantee the code is safe.+ A syntax error is left for Manim to report, so it returns no violations.+ """+ try:+ tree = ast.parse(code)+ except SyntaxError:+ return []++ violations: list[str] = []+ for node in ast.walk(tree):+ if isinstance(node, ast.Import):+ for alias in node.names:+ root = alias.name.split(".")[0]+ if root in _BLOCKED_IMPORTS:+ violations.append(f"import '{alias.name}'")+ elif isinstance(node, ast.ImportFrom):+ root = (node.module or "").split(".")[0]+ if root in _BLOCKED_IMPORTS:+ violations.append(f"from '{node.module}' import ...")+ elif isinstance(node, ast.Call):+ fn = node.func+ if isinstance(fn, ast.Name) and fn.id in _BLOCKED_CALLS:+ violations.append(f"call to '{fn.id}()'")+ elif isinstance(node, ast.Attribute):+ if node.attr in _BLOCKED_ATTRS:+ violations.append(f"attribute access '.{node.attr}'")++ seen: set[str] = set()+ deduped: list[str] = []+ for v in violations:+ if v not in seen:+ seen.add(v)+ deduped.append(v)+ return deduped+def _render(self, inputs: dict[str, Any]) -> ToolResult:scene_code = inputs["scene_code"]scene_name = inputs.get("scene_name")@@ -174,6 +260,23 @@ class MathAnimate(BaseTool):if "from manim import" not in scene_code:scene_code = "from manim import *\n\n" + scene_code+ # Safety gate: scene_code is executed on the host by Manim. Reject+ # dangerous constructs unless the caller explicitly opts out. (issue #219)+ if not inputs.get("allow_unsafe_code", False):+ violations = self._scan_scene_code(scene_code)+ if violations:+ return ToolResult(+ success=False,+ error=(+ "scene_code blocked by the math_animate safety scan. This "+ "tool executes caller-supplied Python on the host; the "+ "following constructs are disallowed by default:\n - "+ + "\n - ".join(violations)+ + "\nIf you fully trust this code and require them, pass "+ "allow_unsafe_code=true. See issue #219."+ ),+ )+# Auto-detect scene name if not providedif not scene_name:scene_name = self._detect_scene_name(scene_code)