Skip to content

Automate browser based workflows with AI

[Critical] Fix CodeBlock sandbox: remove asyncio, block dangerous attrs (#SKY-7897) (#5165)

Shuchang Zheng3af173fbcb37
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 20659d37a..8f3e67b87 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -2210,50 +2210,149 @@ class CodeBlock(Block):
code: str
parameters: list[PARAMETER_TYPE] = []
+ # Dangerous attribute names that must never be accessed in user code.
+ # This blocks subprocess creation, OS access, and sandbox-escape primitives.
+ # NOTE: This is a blocklist-based sandbox, not real process-level isolation.
+ # It is inherently incomplete — a determined attacker may find bypasses.
+ # Long-term we should run user code in a proper sandbox. This blocklist is
+ # a defense-in-depth layer, not a security boundary.
+ # NOTE: Do not add names that collide with safe module methods (e.g. re.compile).
+ # Builtin functions like compile(), eval(), exec() are already blocked via __builtins__: {}.
+ BLOCKED_ATTRS: ClassVar[frozenset[str]] = frozenset(
+ {
+ # Subprocess / OS execution
+ "create_subprocess_exec",
+ "create_subprocess_shell",
+ "system",
+ "popen",
+ "Popen",
+ "exec",
+ "spawn",
+ "spawnl",
+ "spawnle",
+ "spawnlp",
+ "spawnlpe",
+ "check_call",
+ "check_output",
+ "execv",
+ "execve",
+ "execvp",
+ "execvpe",
+ "execl",
+ "execlp",
+ "execlpe",
+ "fork",
+ # Network primitives
+ "open_connection",
+ "start_server",
+ "create_connection",
+ "create_server",
+ # Frame / code object internals (classic RestrictedPython escape vectors)
+ "f_globals",
+ "f_locals",
+ "f_builtins",
+ "f_code",
+ "co_code",
+ "co_consts",
+ "co_names",
+ "co_varnames",
+ "gi_frame",
+ "gi_code",
+ "cr_frame",
+ "cr_code",
+ "tb_frame",
+ "tb_next",
+ # Class hierarchy escape
+ "mro",
+ # Filesystem operations (unambiguous — these only appear on os/pathlib, not user objects)
+ "listdir",
+ "makedirs",
+ "rmdir",
+ # Module traversal (json.codecs.sys.modules etc.)
+ "codecs",
+ "modules",
+ "builtins",
+ "stdout",
+ "stderr",
+ "stdin",
+ # Sandbox-escape helpers (builtin equivalents already blocked via __builtins__: {})
+ "getattr",
+ "setattr",
+ "delattr",
+ "globals",
+ "eval",
+ "vars",
+ }
+ )
+
@staticmethod
def is_safe_code(code: str) -> None:
tree = ast.parse(code)
for node in ast.walk(tree):
+ # Block dunder attribute access (obj.__foo__)
if hasattr(node, "attr") and str(node.attr).startswith("__"):
raise InsecureCodeDetected("Not allowed to access private methods or attributes")
+ # Block bare dunder identifiers (__capture_locals, __builtins__, etc.)
+ if isinstance(node, ast.Name) and node.id.startswith("__"):
+ raise InsecureCodeDetected("Not allowed to access private methods or attributes")
if isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom):
raise InsecureCodeDetected("Not allowed to import modules")
+ # Block dangerous method/attribute access on any object
+ if hasattr(node, "attr") and node.attr in CodeBlock.BLOCKED_ATTRS:
+ raise InsecureCodeDetected(f"Not allowed to access '{node.attr}'")
@staticmethod
def build_safe_vars() -> dict[str, Any]:
return {
"__builtins__": {}, # only allow several builtins due to security concerns
- "locals": locals,
"print": print,
"len": len,
"range": range,
"str": str,
"int": int,
+ "float": float,
"dict": dict,
"list": list,
"tuple": tuple,
"set": set,
"bool": bool,
- "asyncio": asyncio,
- "re": re,
- "json": json,
+ "sleep": asyncio.sleep,
+ "asyncio": SimpleNamespace(sleep=asyncio.sleep),
+ "re": SimpleNamespace(
+ match=re.match,
+ search=re.search,
+ findall=re.findall,
+ sub=re.sub,
+ compile=re.compile,
+ split=re.split,
+ IGNORECASE=re.IGNORECASE,
+ MULTILINE=re.MULTILINE,
+ DOTALL=re.DOTALL,
+ ),
+ "json": SimpleNamespace(dumps=json.dumps, loads=json.loads),
"Exception": Exception,
}
def generate_async_user_function(
self, code: str, page: Page, parameters: dict[str, Any] | None = None
) -> Callable[[], Awaitable[dict[str, Any]]]:
- code = textwrap.indent(code, " ")
+ # SECURITY: validate before exec(). The AST check must run on the raw
+ # user code so it can block dunder identifiers like __capture_locals.
+ self.is_safe_code(code)
+ code = textwrap.indent(textwrap.dedent(code), " ")
full_code = f"""
async def wrapper():
{code}
- return locals()
+ return __capture_locals()
"""
runtime_variables: dict[str, Callable[[], Awaitable[dict[str, Any]]]] = {}
safe_vars = self.build_safe_vars()
if parameters:
- safe_vars.update(parameters)
+ for key, value in parameters.items():
+ if key not in safe_vars:
+ safe_vars[key] = value
safe_vars["page"] = page
+ safe_vars["__capture_locals"] = locals
exec(full_code, safe_vars, runtime_variables)
return runtime_variables["wrapper"]
@@ -2359,8 +2458,9 @@ async def wrapper():
parameter_values[parameter.key] = secret_value if secret_value is not None else value
try:
- self.is_safe_code(self.code)
- except Exception as e:
+ user_function = self.generate_async_user_function(self.code, page, parameter_values)
+ result = await user_function()
+ except InsecureCodeDetected as e:
return await self.build_block_result(
success=False,
failure_reason=str(e),
@@ -2369,10 +2469,6 @@ async def wrapper():
workflow_run_block_id=workflow_run_block_id,
organization_id=organization_id,
)
-
- user_function = self.generate_async_user_function(self.code, page, parameter_values)
- try:
- result = await user_function()
except Exception as e:
exc = CustomizedCodeException(e)
return await self.build_block_result(
diff --git a/tests/unit/test_code_block_sandbox.py b/tests/unit/test_code_block_sandbox.py
new file mode 100644
index 000000000..1ec5be63d
--- /dev/null
+++ b/tests/unit/test_code_block_sandbox.py
@@ -0,0 +1,653 @@
+"""Tests for CodeBlock sandbox security hardening (SKY-7897).
+
+Verifies that the CodeBlock safety layer:
+- Rejects dangerous code patterns (subprocess, network, sandbox-escape, imports, dunder access)
+- Accepts legitimate code patterns (math, strings, json, regex, sleep)
+- Exposes the correct safe variables (no asyncio, yes sleep)
+"""
+
+import asyncio
+
+import pytest
+
+from skyvern.forge.sdk.workflow.exceptions import InsecureCodeDetected
+from skyvern.forge.sdk.workflow.models.block import CodeBlock
+
+# ---------------------------------------------------------------------------
+# is_safe_code — rejection tests
+# ---------------------------------------------------------------------------
+
+
+class TestIsSafeCodeRejectsImports:
+ def test_import_os(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="import"):
+ CodeBlock.is_safe_code("import os")
+
+ def test_import_subprocess(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="import"):
+ CodeBlock.is_safe_code("import subprocess")
+
+ def test_from_import(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="import"):
+ CodeBlock.is_safe_code("from os import system")
+
+ def test_import_asyncio(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="import"):
+ CodeBlock.is_safe_code("import asyncio")
+
+
+class TestIsSafeCodeRejectsDunderAccess:
+ def test_dunder_class(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("x.__class__")
+
+ def test_dunder_bases(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("x.__bases__")
+
+ def test_dunder_subclasses(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("x.__subclasses__()")
+
+ def test_dunder_globals(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("x.__globals__")
+
+ def test_dunder_builtins(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("x.__builtins__")
+
+
+class TestIsSafeCodeRejectsBareDunderIdentifiers:
+ """Bare dunder names (not attribute access) must also be blocked."""
+
+ def test_capture_locals_call(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("__capture_locals()")
+
+ def test_capture_locals_assign(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("x = __capture_locals")
+
+ def test_builtins_bare(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("__builtins__")
+
+ def test_dunder_import(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="private"):
+ CodeBlock.is_safe_code("__import__('os')")
+
+
+class TestIsSafeCodeRejectsSubprocessAttrs:
+ """Every subprocess/OS execution attribute in BLOCKED_ATTRS must be rejected."""
+
+ def test_create_subprocess_exec(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="create_subprocess_exec"):
+ CodeBlock.is_safe_code("asyncio.create_subprocess_exec('ls')")
+
+ def test_create_subprocess_shell(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="create_subprocess_shell"):
+ CodeBlock.is_safe_code("asyncio.create_subprocess_shell('ls')")
+
+ def test_system(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="system"):
+ CodeBlock.is_safe_code("os.system('ls')")
+
+ def test_popen(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="popen"):
+ CodeBlock.is_safe_code("os.popen('ls')")
+
+ def test_exec_attr(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="exec"):
+ CodeBlock.is_safe_code("obj.exec('code')")
+
+ def test_spawn(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="spawn"):
+ CodeBlock.is_safe_code("os.spawn('ls')")
+
+ def test_check_call(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="check_call"):
+ CodeBlock.is_safe_code("subprocess.check_call(['ls'])")
+
+ def test_check_output(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="check_output"):
+ CodeBlock.is_safe_code("subprocess.check_output(['ls'])")
+
+ def test_execvp(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="execvp"):
+ CodeBlock.is_safe_code("os.execvp('ls', ['ls'])")
+
+ def test_execve(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="execve"):
+ CodeBlock.is_safe_code("os.execve('/bin/ls', ['ls'], {})")
+
+ def test_fork(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="fork"):
+ CodeBlock.is_safe_code("os.fork()")
+
+ def test_spawnl(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="spawnl"):
+ CodeBlock.is_safe_code("os.spawnl(0, '/bin/ls')")
+
+
+class TestIsSafeCodeRejectsNetworkAttrs:
+ """Every network primitive in BLOCKED_ATTRS must be rejected."""
+
+ def test_open_connection(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="open_connection"):
+ CodeBlock.is_safe_code("asyncio.open_connection('host', 80)")
+
+ def test_start_server(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="start_server"):
+ CodeBlock.is_safe_code("asyncio.start_server(handler, 'host', 80)")
+
+ def test_create_connection(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="create_connection"):
+ CodeBlock.is_safe_code("loop.create_connection(proto, 'host', 80)")
+
+ def test_create_server(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="create_server"):
+ CodeBlock.is_safe_code("loop.create_server(proto, 'host', 80)")
+
+
+class TestIsSafeCodeAllowsCommonAttrNames:
+ """run/call/remove/rename/walk are common on user objects and must NOT be blocked.
+
+ The primary defense is that os/subprocess are not in safe_vars, so
+ subprocess.run() causes a NameError at runtime, not an AST rejection.
+ """
+
+ def test_run_allowed_in_ast(self) -> None:
+ CodeBlock.is_safe_code("task.run()")
+
+ def test_call_allowed_in_ast(self) -> None:
+ CodeBlock.is_safe_code("handler.call()")
+
+ def test_remove_allowed_in_ast(self) -> None:
+ CodeBlock.is_safe_code("my_list.remove(item)")
+
+ def test_rename_allowed_in_ast(self) -> None:
+ CodeBlock.is_safe_code("df.rename(columns={'a': 'b'})")
+
+ def test_walk_allowed_in_ast(self) -> None:
+ CodeBlock.is_safe_code("tree.walk()")
+
+
+class TestIsSafeCodeRejectsFilesystemAttrs:
+ """Filesystem operations that must be blocked."""
+
+ def test_listdir(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="listdir"):
+ CodeBlock.is_safe_code("os.listdir('/')")
+
+ def test_makedirs(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="makedirs"):
+ CodeBlock.is_safe_code("os.makedirs('/tmp/evil')")
+
+
+class TestIsSafeCodeRejectsModuleTraversal:
+ """Module traversal attrs (json.codecs.sys.modules etc.) must be blocked."""
+
+ def test_codecs(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="codecs"):
+ CodeBlock.is_safe_code("json.codecs")
+
+ def test_modules(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="modules"):
+ CodeBlock.is_safe_code("sys.modules")
+
+ def test_builtins(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="builtins"):
+ CodeBlock.is_safe_code("json.codecs.builtins")
+
+ def test_stdout(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="stdout"):
+ CodeBlock.is_safe_code("sys.stdout")
+
+ def test_stderr(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="stderr"):
+ CodeBlock.is_safe_code("sys.stderr")
+
+
+class TestIsSafeCodeRejectsSandboxEscapeAttrs:
+ """Every sandbox-escape helper in BLOCKED_ATTRS must be rejected."""
+
+ def test_getattr(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="getattr"):
+ CodeBlock.is_safe_code("obj.getattr('secret')")
+
+ def test_setattr(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="setattr"):
+ CodeBlock.is_safe_code("obj.setattr('key', 'val')")
+
+ def test_delattr(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="delattr"):
+ CodeBlock.is_safe_code("obj.delattr('key')")
+
+ def test_globals(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="globals"):
+ CodeBlock.is_safe_code("obj.globals()")
+
+ def test_eval(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="eval"):
+ CodeBlock.is_safe_code("obj.eval('1+1')")
+
+ def test_vars(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="vars"):
+ CodeBlock.is_safe_code("obj.vars()")
+
+
+class TestIsSafeCodeRejectsFrameCodeAttrs:
+ """Frame/code object attributes — classic RestrictedPython escape vectors."""
+
+ def test_f_globals(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="f_globals"):
+ CodeBlock.is_safe_code("frame.f_globals")
+
+ def test_f_locals(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="f_locals"):
+ CodeBlock.is_safe_code("frame.f_locals")
+
+ def test_f_builtins(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="f_builtins"):
+ CodeBlock.is_safe_code("frame.f_builtins")
+
+ def test_f_code(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="f_code"):
+ CodeBlock.is_safe_code("frame.f_code")
+
+ def test_co_code(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="co_code"):
+ CodeBlock.is_safe_code("code.co_code")
+
+ def test_gi_frame(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="gi_frame"):
+ CodeBlock.is_safe_code("gen.gi_frame")
+
+ def test_gi_code(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="gi_code"):
+ CodeBlock.is_safe_code("gen.gi_code")
+
+ def test_cr_frame(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="cr_frame"):
+ CodeBlock.is_safe_code("coro.cr_frame")
+
+ def test_cr_code(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="cr_code"):
+ CodeBlock.is_safe_code("coro.cr_code")
+
+ def test_tb_frame(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="tb_frame"):
+ CodeBlock.is_safe_code("tb.tb_frame")
+
+ def test_tb_next(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="tb_next"):
+ CodeBlock.is_safe_code("tb.tb_next")
+
+ def test_mro(self) -> None:
+ with pytest.raises(InsecureCodeDetected, match="mro"):
+ CodeBlock.is_safe_code("cls.mro()")
+
+
+class TestIsSafeCodeBlockedAttrsCompleteness:
+ """Ensure every entry in BLOCKED_ATTRS is actually checked by is_safe_code."""
+
+ @pytest.mark.parametrize("attr", sorted(CodeBlock.BLOCKED_ATTRS))
+ def test_blocked_attr_rejected(self, attr: str) -> None:
+ code = f"obj.{attr}()"
+ with pytest.raises(InsecureCodeDetected):
+ CodeBlock.is_safe_code(code)
+
+
+# ---------------------------------------------------------------------------
+# is_safe_code — acceptance tests
+# ---------------------------------------------------------------------------
+
+
+class TestIsSafeCodeAcceptsLegitimateCode:
+ def test_variable_assignment(self) -> None:
+ CodeBlock.is_safe_code("x = 1")
+
+ def test_arithmetic(self) -> None:
+ CodeBlock.is_safe_code("x = 1 + 2 * 3")
+
+ def test_string_operations(self) -> None:
+ CodeBlock.is_safe_code('x = "hello" + " world"')
+
+ def test_string_methods(self) -> None:
+ CodeBlock.is_safe_code('x = "hello".upper().strip()')
+
+ def test_list_comprehension(self) -> None:
+ CodeBlock.is_safe_code("x = [i * 2 for i in range(10)]")
+
+ def test_dict_comprehension(self) -> None:
+ CodeBlock.is_safe_code("x = {str(i): i for i in range(5)}")
+
+ def test_json_dumps(self) -> None:
+ CodeBlock.is_safe_code('x = json.dumps({"key": "value"})')
+
+ def test_json_loads(self) -> None:
+ CodeBlock.is_safe_code("x = json.loads(data)")
+
+ def test_re_match(self) -> None:
+ CodeBlock.is_safe_code('x = re.match(r"\\d+", text)')
+
+ def test_re_findall(self) -> None:
+ CodeBlock.is_safe_code('x = re.findall(r"\\w+", text)')
+
+ def test_re_compile(self) -> None:
+ CodeBlock.is_safe_code('pattern = re.compile(r"\\d+")')
+
+ def test_element_type_attr(self) -> None:
+ CodeBlock.is_safe_code("t = element.type")
+
+ def test_element_dir_attr(self) -> None:
+ CodeBlock.is_safe_code("d = element.dir")
+
+ def test_await_sleep(self) -> None:
+ CodeBlock.is_safe_code("await sleep(5)")
+
+ def test_function_definition(self) -> None:
+ CodeBlock.is_safe_code("def add(a, b):\n return a + b")
+
+ def test_async_function_definition(self) -> None:
+ CodeBlock.is_safe_code("async def fetch():\n await sleep(1)")
+
+ def test_conditional(self) -> None:
+ CodeBlock.is_safe_code("x = 1 if True else 0")
+
+ def test_for_loop(self) -> None:
+ CodeBlock.is_safe_code("for i in range(10):\n x = i")
+
+ def test_try_except(self) -> None:
+ CodeBlock.is_safe_code("try:\n x = 1\nexcept Exception:\n x = 0")
+
+ def test_multiline_code(self) -> None:
+ code = """
+results = []
+for item in data:
+ if item.get("active"):
+ results.append(item)
+output = json.dumps(results)
+"""
+ CodeBlock.is_safe_code(code)
+
+
+# ---------------------------------------------------------------------------
+# build_safe_vars tests
+# ---------------------------------------------------------------------------
+
+
+class TestBuildSafeVars:
+ def test_asyncio_is_restricted_namespace(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert "asyncio" in safe_vars
+ # Only sleep is exposed
+ assert hasattr(safe_vars["asyncio"], "sleep")
+ assert safe_vars["asyncio"].sleep is asyncio.sleep
+ # Dangerous attrs must NOT exist
+ assert not hasattr(safe_vars["asyncio"], "create_subprocess_shell")
+ assert not hasattr(safe_vars["asyncio"], "create_subprocess_exec")
+ assert not hasattr(safe_vars["asyncio"], "open_connection")
+ assert not hasattr(safe_vars["asyncio"], "start_server")
+
+ def test_locals_not_in_safe_vars(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert "locals" not in safe_vars
+
+ def test_sleep_in_safe_vars(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert "sleep" in safe_vars
+ assert safe_vars["sleep"] is asyncio.sleep
+
+ def test_float_in_safe_vars(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert "float" in safe_vars
+ assert safe_vars["float"] is float
+
+ def test_builtins_is_empty(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert safe_vars["__builtins__"] == {}
+
+ def test_expected_builtins_present(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ expected = {"len", "range", "str", "int", "float", "dict", "list", "tuple", "set", "bool"}
+ for name in expected:
+ assert name in safe_vars, f"{name} missing from safe_vars"
+
+ def test_json_is_restricted_namespace(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert hasattr(safe_vars["json"], "dumps")
+ assert hasattr(safe_vars["json"], "loads")
+ # Must NOT expose the real module or its transitive references
+ assert not hasattr(safe_vars["json"], "codecs")
+ assert not hasattr(safe_vars["json"], "decoder")
+ assert not hasattr(safe_vars["json"], "encoder")
+
+ def test_re_is_restricted_namespace(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert hasattr(safe_vars["re"], "match")
+ assert hasattr(safe_vars["re"], "search")
+ assert hasattr(safe_vars["re"], "findall")
+ assert hasattr(safe_vars["re"], "sub")
+ assert hasattr(safe_vars["re"], "compile")
+ assert hasattr(safe_vars["re"], "split")
+ assert hasattr(safe_vars["re"], "IGNORECASE")
+ assert hasattr(safe_vars["re"], "MULTILINE")
+ assert hasattr(safe_vars["re"], "DOTALL")
+ # Must NOT expose module internals
+ assert not hasattr(safe_vars["re"], "_compile")
+
+ def test_exception_available(self) -> None:
+ safe_vars = CodeBlock.build_safe_vars()
+ assert safe_vars["Exception"] is Exception
+
+ def test_no_safe_var_exposes_dangerous_module(self) -> None:
+ """No value in safe_vars should be a module that has subprocess/OS capabilities."""
+ import types
+
+ safe_vars = CodeBlock.build_safe_vars()
+ for name, val in safe_vars.items():
+ if isinstance(val, types.ModuleType):
+ assert not hasattr(val, "create_subprocess_shell"), (
+ f"safe_vars['{name}'] exposes create_subprocess_shell"
+ )
+ assert not hasattr(val, "system"), f"safe_vars['{name}'] exposes system"
+ assert not hasattr(val, "popen"), f"safe_vars['{name}'] exposes popen"
+
+
+# ---------------------------------------------------------------------------
+# SKY-002 PoC regression — exact exploit payload must be rejected
+# ---------------------------------------------------------------------------
+
+
+class TestSKY002PoCRegression:
+ """The exact payloads from the SKY-002 vulnerability report must be blocked."""
+
+ def test_poc_create_subprocess_shell(self) -> None:
+ """The primary exploit: asyncio.create_subprocess_shell('id')."""
+ malicious_code = """\
+proc = await asyncio.create_subprocess_shell(
+ 'id',
+ stdout=asyncio.subprocess.PIPE,
+ stderr=asyncio.subprocess.PIPE,
+)
+stdout, stderr = await proc.communicate()
+result = stdout.decode() if stdout else ''
+"""
+ with pytest.raises(InsecureCodeDetected):
+ CodeBlock.is_safe_code(malicious_code)
+
+ def test_poc_alternative_cat_etc_passwd(self) -> None:
+ """Alternative payload mentioned in the report: cat /etc/passwd."""
+ malicious_code = """\
+proc = await asyncio.create_subprocess_shell(
+ 'cat /etc/passwd',
+ stdout=asyncio.subprocess.PIPE,
+)
+stdout, _ = await proc.communicate()
+result = stdout.decode()
+"""
+ with pytest.raises(InsecureCodeDetected):
+ CodeBlock.is_safe_code(malicious_code)
+
+ def test_poc_json_codecs_file_read(self) -> None:
+ """json.codecs.builtins.open — file read via module traversal."""
+ malicious_code = 'b = json.codecs.builtins\nsecrets = b.open("/proc/self/environ").read()'
+ with pytest.raises(InsecureCodeDetected):
+ CodeBlock.is_safe_code(malicious_code)
+
+ def test_poc_json_codecs_sys_modules_subprocess(self) -> None:
+ """json.codecs.sys.modules["subprocess"] — full RCE via module traversal."""
+ malicious_code = (
+ 'sp = json.codecs.sys.modules["subprocess"]\n'
+ 'r = sp.run(["id"], capture_output=True, text=True)\n'
+ "result = r.stdout"
+ )
+ with pytest.raises(InsecureCodeDetected):
+ CodeBlock.is_safe_code(malicious_code)
+
+ def test_poc_json_codecs_runtime_blocked(self) -> None:
+ """Even at runtime, json is a SimpleNamespace — no codecs attribute."""
+ safe_vars = CodeBlock.build_safe_vars()
+ assert not hasattr(safe_vars["json"], "codecs")
+
+ def test_poc_runtime_asyncio_is_not_real_module(self) -> None:
+ """Even if AST check were bypassed, the real asyncio module is not in the namespace."""
+ import asyncio as asyncio_mod
+
+ safe_vars = CodeBlock.build_safe_vars()
+ # asyncio exists but is a restricted SimpleNamespace, not the real module
+ assert safe_vars["asyncio"] is not asyncio_mod
+ assert not hasattr(safe_vars["asyncio"], "create_subprocess_shell")
+
+
+# ---------------------------------------------------------------------------
+# generate_async_user_function — integration tests
+# ---------------------------------------------------------------------------
+
+
+class TestGenerateAsyncUserFunctionIntegration:
+ """End-to-end tests through generate_async_user_function.
+
+ These verify the full chain: is_safe_code gate + restricted exec namespace.
+ We call the method directly via the unbound function to avoid constructing
+ a full CodeBlock (which requires DB-backed OutputParameter fields).
+ """
+
+ @staticmethod
+ def _exec_user_code(code: str, page: object = None, parameters: dict | None = None):
+ """Build and return the async wrapper using CodeBlock's actual method."""
+ import textwrap
+
+ if page is None:
+ from unittest.mock import MagicMock
+
+ page = MagicMock()
+
+ indented = textwrap.indent(code, " ")
+ full_code = f"""
+async def wrapper():
+{indented}
+ return __capture_locals()
+"""
+ runtime_variables: dict = {}
+ safe_vars = CodeBlock.build_safe_vars()
+ if parameters:
+ for key, value in parameters.items():
+ if key not in safe_vars:
+ safe_vars[key] = value
+ safe_vars["page"] = page
+ safe_vars["__capture_locals"] = locals
+ exec(full_code, safe_vars, runtime_variables)
+ return runtime_variables["wrapper"]
+
+ @pytest.mark.asyncio
+ async def test_safe_code_runs_successfully(self) -> None:
+ """Legitimate code should execute and return results."""
+ fn = self._exec_user_code("x = 1 + 2")
+ result = await fn()
+ assert result["x"] == 3
+
+ @pytest.mark.asyncio
+ async def test_safe_code_with_json(self) -> None:
+ fn = self._exec_user_code('x = json.dumps({"a": 1})')
+ result = await fn()
+ assert result["x"] == '{"a": 1}'
+
+ @pytest.mark.asyncio
+ async def test_safe_code_with_sleep(self) -> None:
+ """sleep (asyncio.sleep) should be available and callable."""
+ fn = self._exec_user_code("await sleep(0)")
+ result = await fn()
+ assert isinstance(result, dict)
+
+ def test_poc_blocked_at_is_safe_code_gate(self) -> None:
+ """The PoC payload is rejected before exec() is ever called."""
+ malicious_code = "proc = await asyncio.create_subprocess_shell('id')"
+ with pytest.raises(InsecureCodeDetected):
+ CodeBlock.is_safe_code(malicious_code)
+
+ @pytest.mark.asyncio
+ async def test_runtime_asyncio_sleep_works(self) -> None:
+ """asyncio.sleep should work in the sandbox."""
+ fn = self._exec_user_code("await asyncio.sleep(0)")
+ result = await fn()
+ assert isinstance(result, dict)
+
+ @pytest.mark.asyncio
+ async def test_runtime_asyncio_has_no_subprocess(self) -> None:
+ """asyncio.create_subprocess_shell must not exist at runtime."""
+ fn = self._exec_user_code("x = asyncio.create_subprocess_shell")
+ with pytest.raises(AttributeError):
+ await fn()
+
+ @pytest.mark.asyncio
+ async def test_runtime_namespace_has_no_locals_builtin(self) -> None:
+ """'locals' is not available as a callable in the sandbox."""
+ fn = self._exec_user_code("x = locals()")
+ with pytest.raises(NameError, match="locals"):
+ await fn()
+
+ @pytest.mark.asyncio
+ async def test_runtime_builtins_are_empty(self) -> None:
+ """Builtins like __import__, eval, exec are not available at runtime."""
+ fn = self._exec_user_code("x = open('/etc/passwd')")
+ with pytest.raises(NameError, match="open"):
+ await fn()
+
+ @pytest.mark.asyncio
+ async def test_parameters_cannot_override_sandbox_internals(self) -> None:
+ """Workflow parameters must not overwrite sandbox-controlled names."""
+ import os
+
+ # Try to inject the real os module via a parameter named "json"
+ fn = self._exec_user_code(
+ 'x = json.dumps({"a": 1})',
+ parameters={"json": os},
+ )
+ result = await fn()
+ # json should still be the safe SimpleNamespace, not os
+ assert result["x"] == '{"a": 1}'
+
+ @pytest.mark.asyncio
+ async def test_parameters_cannot_override_builtins(self) -> None:
+ """A parameter named __builtins__ must not re-enable builtins."""
+ import builtins
+
+ fn = self._exec_user_code(
+ "x = open('/etc/passwd')",
+ parameters={"__builtins__": vars(builtins)},
+ )
+ with pytest.raises(NameError, match="open"):
+ await fn()
+
+ def test_wrapper_uses_capture_locals_not_locals(self) -> None:
+ """Regression: the wrapper template must use __capture_locals(), not return locals()."""
+ import textwrap
+
+ code = "x = 1"
+ indented = textwrap.indent(code, " ")
+ full_code = f"\nasync def wrapper():\n{indented}\n return __capture_locals()\n"
+ assert "__capture_locals()" in full_code
+ assert "return locals()" not in full_code