Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio: block sandbox bypass via command-position substitutions in terminal tool (#10860)

veriepica09f3765bace
diff --git a/studio/backend/core/inference/tools.py b/studio/backend/core/inference/tools.py
index 43dc69fc731..481bb0e28b9 100644
--- a/studio/backend/core/inference/tools.py
+++ b/studio/backend/core/inference/tools.py
@@ -1549,6 +1549,118 @@ def _find_blocked_commands(command: str) -> set[str]:
)
blocked.update(re.findall(pattern, lowered))
+ # A substitution at command position synthesizes the executed word, so `$(ls /usr/bin | grep
+ # "^reb")` never reaches the scan above; screen the body instead. A variable launders the same
+ # shapes (`c=$(...); $c`), so bindings are collected first - bodies reference them too.
+ if _BLOCKED_COMMANDS:
+ quote_states = _shell_quote_states(command)
+
+ def _site_expands(match: "re.Match") -> bool:
+ """Whether bash expands this substitution AT command position, rather than inside an
+ argument the outer command already owns."""
+ opener = match.end() - 1
+ state = quote_states[opener] if opener < len(quote_states) else ""
+ if state in ("'", "$'", _ESCAPED_CHAR_STATE):
+ return False # bash substitutes nothing here
+ if state == '"':
+ # Double quotes DO substitute, but into a word the outer command receives - unless
+ # the quote opens at the site itself (`"$(...)"`, `"`...`"`), which is a command
+ # word.
+ return match.group(0).endswith(('"$(', '"`'))
+ return True
+
+ # Name -> the literal it holds, or None when unscreenable. `$C` is not `$c`.
+ laundered: "dict[str, str | None]" = {}
+ for assign in _SUBST_ASSIGN_RE.finditer(command):
+ if assign.group(1) in laundered or not _site_expands(assign):
+ continue
+ # An enumerating body is unknowable even when a literal (the grep selector) shows.
+ opener = assign.end() - 1 # `(` of `$(`, or the backtick
+ assign_body = _command_subst_body(command, opener).lower()
+ if _SUBST_ENUMERATES_COMMANDS_RE.search(assign_body):
+ laundered[assign.group(1)] = None
+ continue
+ found = sorted(_blocked_body_words(assign_body))
+ laundered[assign.group(1)] = found[0] if found else None
+ for printf_v in _PRINTF_V_ASSIGN_RE.finditer(command):
+ laundered.setdefault(printf_v.group(1), None)
+ for literal in _ASSIGN_BLOCKED_LITERAL_RE.finditer(command):
+ name, value = literal.group(1), literal.group(2).strip("\"'")
+ first = value.split()[0] if value.split() else ""
+ base = os.path.basename(first)
+ stem, ext = os.path.splitext(base)
+ if ext.lower() in {".exe", ".com", ".bat", ".cmd"}:
+ base = stem
+ if base.lower() in _BLOCKED_COMMANDS:
+ laundered.setdefault(name, base.lower())
+ laundered_refs = "|".join(sorted({re.escape(n) for n in laundered}, key = len, reverse = True))
+ laundered_in_body_pattern = (
+ rf"\$(?:{laundered_refs}|\{{(?:{laundered_refs})\}})" if laundered_refs else None
+ )
+ sites = [
+ site
+ for site in list(_SUBST_AT_CMD_SITE_RE.finditer(command))
+ + list(_SUBST_EXEC_DIRECTIVE_RE.finditer(command))
+ + _case_arm_sites(command, quote_states)
+ if _site_expands(site)
+ ]
+ if len(sites) > _MAX_SUBST_SITES:
+ # Refuse rather than read: each site costs a span walk to end of line, so `";$(" * 10000`
+ # took over 30s on the request thread. Fail CLOSED, never open.
+ blocked.add(_BLOCKED_SYNTHESIZED_COMMAND)
+ sites = []
+ for site in sites:
+ opener = site.end() - 1 # `(` of `$(`, or the backtick
+ body = _command_subst_body(command, opener)
+ lowered_body = body.lower()
+ blocked.update(_blocked_body_words(lowered_body))
+ if _subst_is_word_fragment(command, opener):
+ # `"$(printf r)"m` concatenates into `rm`. The body alone is benign, so nothing
+ # above can name the command: only the fact that it is unknowable is reportable.
+ blocked.add(_BLOCKED_SYNTHESIZED_COMMAND)
+ elif _SUBST_ENUMERATES_COMMANDS_RE.search(lowered_body):
+ blocked.add(_BLOCKED_SYNTHESIZED_COMMAND)
+ elif laundered_in_body_pattern is not None and re.search(
+ laundered_in_body_pattern, body
+ ):
+ # `$(echo $c)`: the body runs over laundered text, so its output is unknowable.
+ blocked.add(_BLOCKED_SYNTHESIZED_COMMAND)
+ if laundered_refs:
+ # Named, not positional: a group added in front would silently renumber these.
+ var_word = (
+ r"(?P<var>\"?\$(?:(?P<bare>"
+ + laundered_refs
+ + r")|\{(?P<braced>"
+ + laundered_refs
+ + r")\})"
+ # The closing quote ends the word too, or `"$c"` - the recommended spelling -
+ # walks through the screen the bare one is caught by. Trailing word characters
+ # are part of the SAME word: bash concatenates the fragments, so `${x}m` runs
+ # `rm` when x holds `r`, and requiring the expansion to end the word let that
+ # through.
+ r"\"?[\w.\-]*)(?=\s|$|[;&|)\]}])"
+ )
+ var_hits = list(
+ re.finditer(_SUBST_CMD_SEP + r"\s*" + _SUBST_WRAPPER_RUN + var_word, command)
+ )
+ # A case arm runs a laundered variable just as readily as a substitution.
+ var_hits += _case_arm_sites(
+ command, quote_states, re.compile(r"\)\s*" + _SUBST_WRAPPER_RUN + var_word)
+ )
+ for hit in var_hits:
+ if _is_wrapper_flag_operand(command, hit.start("var")):
+ continue # `xargs -P $n`: operand of the option, not the command
+ name = hit.group("bare") or hit.group("braced")
+ precise = laundered.get(name)
+ # A precise literal only stands when the expansion IS the whole word; glued to
+ # more text it is a fragment of an unknown name (`${x}m`), not that name.
+ if precise is not None and hit.group("var").rstrip('"').endswith(
+ ("$" + name, "{" + name + "}")
+ ):
+ blocked.add(precise)
+ else:
+ blocked.add(_BLOCKED_SYNTHESIZED_COMMAND)
+
# Nested shell invocations (bash -c, cmd /c): on a -c/-/c flag, look back for a shell name (skipping flags) and
# recursively scan the nested command string.
_SHELLS = {"bash", "sh", "zsh", "dash", "ksh", "csh", "tcsh", "fish"}
@@ -4953,6 +5065,223 @@ _SHELL_C_INTERPRETERS = frozenset({"sh", "bash", "zsh", "dash", "ksh", "fish", "
_COMMAND_SUBST_AT_CMD_RE = re.compile(
r"(?:^|[;&|\n(]|&&|\|\|)\s*(?:[A-Za-z_]\w*=[^\s;&|()]*\s+)*(?:\$\(|`)"
)
+# Command-position separators for the screens below. `:` is absent on purpose: its arguments are
+# expanded but never executed.
+# `coproc [NAME] command` (bash `help coproc`) executes COMMAND asynchronously, so its operand is
+# a command position; the optional NAME is matched only here, where it cannot widen anything else.
+_SUBST_CMD_SEP = (
+ r"(?:^|[;&|\n({]|&&|\|\||\b(?:then|do|else|elif|if|while|until)\b\s*"
+ r"|\bcoproc\b\s*(?:[A-Za-z_]\w*\s+)?|!\s*)"
+)
+# Wrappers forward to their operand. Repetitions are bounded and flat: unbounded nesting caused
+# catastrophic backtracking. A wrapper's arguments are flags, `VAR=value` and bare numbers (the
+# shapes _exec_child_index steps over), NOT "any word" - its first plain word IS its command, and
+# accepting arbitrary words hard-blocked `timeout 60 python train.py --data $(ls -d data/*)`. An
+# option taking a separate value swallows it too, or `xargs -P $n` reads the `$n` as the command.
+_ALL_WRAPPER_VALUE_FLAGS = frozenset(
+ flag for flags in _WRAPPER_VALUE_FLAGS_BY_CMD.values() for flag in flags
+) | {
+ # `env -C DIR` / `--chdir DIR` (env --help) takes a separate value, so an unconsumed DIR
+ # reads as the command and the real one behind it is never reached. Added HERE rather than
+ # to _WRAPPER_VALUE_FLAGS_BY_CMD because that table also drives the high-risk classifier,
+ # where `-C /` is exactly what makes a following relative `etc/passwd` sensitive.
+ #
+ # `-S`/`--split-string` is deliberately absent: its operand is split into the argv that RUNS,
+ # so consuming it as a value loses the command (`env -S 'rm -rf /tmp/x'` went unblocked).
+ "-C",
+ "--chdir",
+}
+_WRAPPER_VALUE_FLAG_ALT = "|".join(
+ re.escape(flag) for flag in sorted(_ALL_WRAPPER_VALUE_FLAGS, key = len, reverse = True)
+)
+# A bare number covers `nice 5`; timeout's DURATION is "a floating point number with an optional
+# suffix: 's', 'm', 'h' or 'd'" (timeout --help). Floating point there means strtod, so the
+# scientific spellings are valid too and `timeout 1e1 $(...)` really runs - every form this does
+# not accept is a site that goes unscreened.
+_SUBST_WRAPPER_ARG = (
+ r"(?:(?:" + _WRAPPER_VALUE_FLAG_ALT + r")\s+[^\s;&|()]+"
+ r"|-[^\s;&|()]*|[A-Za-z_]\w*=[^\s;&|()]*"
+ r"|(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[smhd]?)"
+)
+# Both repetitions are UNBOUNDED. `env --help` documents `[OPTION]...` before COMMAND, so any cap
+# is a number of options an attacker just exceeds to make the whole site regex fail - opening, not
+# closing. Unbounded is safe here because the parts cannot overlap: a wrapper word never matches
+# _SUBST_WRAPPER_ARG (which needs `-`, `VAR=` or a digit) and every repetition must consume a
+# mandatory `\s+`, so no token can be split across two of them and there is nothing to backtrack.
+_SUBST_WRAPPER_RUN = (
+ r"(?:(?:env|command|builtin|exec|time|nohup|nice|setsid|stdbuf|timeout|ionice|chroot"
+ r"|setpriv|sudo|doas|su|xargs)\s+(?:" + _SUBST_WRAPPER_ARG + r"\s+)*)*"
+)
+# Redirections may precede the command word (`>out.log $(...)` runs the substitution's output),
+# and the token walker already treats them as leaving command position intact. Bash allows
+# whitespace between the operator and its target, so `> out.log $(...)` is the same command.
+#
+# The target and the space after it are both MANDATORY, which is what keeps `>$(ls) cmd` out: a
+# substitution that IS the redirection target names a file, it is not run, and an optional target
+# would let this prefix match nothing and read that `$(` as the command word.
+_SUBST_REDIR_PREFIX = r"(?:\d*(?:>>|<<<|<<|>&|<&|>|<)\s*[^\s;&|()]+\s+)*"
+# VAR=x prefixes are stepped over; `(?!\()` drops arithmetic, which is a number, not a command.
+# A double-quoted backtick expands exactly like `"$(...)"`, so it opens a command word too.
+_SUBST_OPENER = r"(?:\"\$\((?!\()|\$\((?!\()|\"`|`)"
+_SUBST_CMD_WORD_PREFIX = (
+ _SUBST_REDIR_PREFIX
+ + r"(?:[A-Za-z_]\w*=[^\s;&|()]*\s+)*"
+ + _SUBST_REDIR_PREFIX
+ + _SUBST_WRAPPER_RUN
+)
+_SUBST_AT_CMD_SITE_RE = re.compile(
+ _SUBST_CMD_SEP + r"\s*" + _SUBST_CMD_WORD_PREFIX + _SUBST_OPENER,
+ re.IGNORECASE,
+)
+# A `case` arm's `)` is followed directly by the commands to run, so it is a command position -
+# but only inside `case ... in ... esac`, and only for a `)` that is not closing a substitution.
+# Treating every `)` as a separator would refuse an ordinary `echo $(date) $(ls /tmp)`.
+_SUBST_CASE_ARM_RE = re.compile(
+ r"\)\s*" + _SUBST_CMD_WORD_PREFIX + _SUBST_OPENER,
+ re.IGNORECASE,
+)
+_CASE_REGION_RE = re.compile(r"\bcase\b.*?\bin\b(.*?)(?:\besac\b|$)", re.IGNORECASE | re.DOTALL)
+# The words after a find/fd -exec directive are the executed argv, so `find . -exec $(...) \;`
+# runs whatever the body prints.
+_SUBST_EXEC_DIRECTIVE_RE = re.compile(
+ r"(?:-exec(?:dir)?|--exec(?:-batch)?|-ok(?:dir)?)\s+" + _SUBST_CMD_WORD_PREFIX + _SUBST_OPENER,
+ re.IGNORECASE,
+)
+# An assignment binds wherever it appears, so these three lead on any separator OR whitespace:
+# under `(?:^|[;&|\n])` a launder behind a keyword or subshell went uncollected and ran. Widening
+# only COLLECTS; a name is reported only where it is executed at command position.
+_ASSIGN_LEAD = (
+ r"(?:^|[\s;&|\n(){])(?:(?:export|local|readonly)\s+|(?:declare|typeset)(?:\s+[-\w+]+)*\s+)?"
+)
+# The name is laundered, its content unscreenable. `(?!\()` excludes arithmetic, whose inclusion
+# hard-blocked `sec=$((60*5)); timeout $sec make test`.
+_SUBST_ASSIGN_RE = re.compile(_ASSIGN_LEAD + r"([A-Za-z_]\w*)=[\"']?(?:\$\((?!\()|`)")
+# `printf -v NAME` runs nothing, but a later `$NAME` at command position executes it.
+_PRINTF_V_ASSIGN_RE = re.compile(_ASSIGN_LEAD + r"\bprintf\s+-v\s+([A-Za-z_]\w*)\b")
+# `c=reboot` makes `$c` at command position run reboot. Only the value's first word counts, and
+# arrays never match (the value class excludes parens).
+_ASSIGN_BLOCKED_LITERAL_RE = re.compile(_ASSIGN_LEAD + r"([A-Za-z_]\w*)=([^\s;&|()]+)")
+
+
+def _command_subst_body(command: str, opener: int) -> str:
+ """The body text of the `$(...)` (``opener`` = index of ``(``) or backtick (``opener`` = index
+ of the backtick) substitution opening there. A backtick span ends at the next unescaped
+ backtick; an unterminated span of either kind runs to the end of the string."""
+ if command[opener] == "`":
+ closer = opener + 1
+ while True:
+ closer = command.find("`", closer)
+ if closer < 0:
+ return command[opener + 1 :]
+ if command[closer - 1] != "\\":
+ return command[opener + 1 : closer]
+ closer += 1
+ end = _substitution_span(command, opener - 1)
+ return command[opener + 1 : end if end >= len(command) else end - 1]
+
+
+# For an enumerated command with no literal name to report.
+_BLOCKED_SYNTHESIZED_COMMAND = "command substitution"
+# Primitives that enumerate executable names inside a substitution body. A lookup for one literal
+# binary (`$(which python)`) stays out: that name is visible in the body itself.
+_SUBST_ENUMERATES_COMMANDS_RE = re.compile(
+ r"(?:\bcompgen\b|\b(?:ls|dir|find)\b|\b(?:echo|printf)\b[^\n;&|]*[*?[])"
+)
+# Sites read before refusing instead: each costs a span walk and this function has no length cap.
+_MAX_SUBST_SITES = 64
+
+
[email protected]_cache(maxsize = 4)
+def _blocked_body_word_pattern_for(words: "frozenset[str]") -> "re.Pattern":
+ """A blocked name appearing anywhere in a command-substitution body.
+
+ Looser than the command-position scan on purpose: anything in the body may become the word
+ that runs. `.` (the synonym for `source`) cannot share that boundary, because any dot in a
+ filename then matches it - `$(cat .env)` was refused as "Blocked command(s) for safety: .".
+ Punctuation names get the strict boundary, the only place they can run anyway.
+ """
+ word_like = sorted(w for w in words if w[:1].isalnum() or w[:1] == "_")
+ punctuation = sorted(w for w in words if w not in set(word_like))
+ parts = []
+ if word_like:
+ alt = "|".join(re.escape(w) for w in word_like)
+ parts.append(rf"(?:^|[^\w./\\-])(?:[\w./\\-]*/)?({alt})(?:\.(?:exe|com|bat|cmd))?\b")
+ if punctuation:
+ alt = "|".join(re.escape(w) for w in punctuation)
+ parts.append(rf"(?:^|[;&|`\n(])\s*({alt})(?=\s)")
+ return re.compile("|".join(parts) if parts else r"(?!)")
+
+
+def _subst_is_word_fragment(command: str, opener: int) -> bool:
+ """Whether more of the command WORD follows the substitution opening at ``opener``.
+
+ Bash concatenates adjacent fragments, so `$(printf r)m` and `"$(printf r)"m` both run `rm`.
+ The body is benign in each, so a scan that only reads bodies reports nothing; what is
+ reportable is that the executed word cannot be known.
+ """
+ if command[opener] == "`":
+ closer = command.find("`", opener + 1)
+ end = len(command) if closer < 0 else closer + 1
+ else:
+ end = _substitution_span(command, opener - 1)
+ if end < len(command) and command[end] == '"':
+ end += 1 # the `"` closing a `"$(...)"` / `"`...`"` word
+ return end < len(command) and (command[end].isalnum() or command[end] in "_.-/")
+
+
+def _case_arm_sites(
+ command: str,
+ quote_states: "list[str]",
+ pattern: "re.Pattern | None" = None,
+) -> "list[re.Match]":
+ """Matches of ``pattern`` anchored on a `case` arm's `)`, which is a command position.
+
+ Only inside `case ... in ... esac`, and only for a `)` that does not close a substitution -
+ otherwise the `)` of an ordinary `echo $(date) $(ls /tmp)` would read as an arm and refuse it.
+ ``pattern`` defaults to the substitution-site one; the variable-execution scan passes its own,
+ since a laundered `$c` runs in an arm just as readily as a substitution does.
+ """
+ pattern = pattern if pattern is not None else _SUBST_CASE_ARM_RE
+ if not _CASE_REGION_RE.search(command):
+ return []
+ # Every `)` that closes an unquoted `$(`: those belong to the substitution, not to an arm.
+ closers: "set[int]" = set()
+ for opener in re.finditer(r"\$\((?!\()", command):
+ at = opener.start()
+ if at < len(quote_states) and quote_states[at] in ("'", "$'", _ESCAPED_CHAR_STATE):
+ continue
+ end = _substitution_span(command, at)
+ if end <= len(command):
+ closers.add(end - 1)
+ sites = []
+ for region in _CASE_REGION_RE.finditer(command):
+ start, stop = region.start(1), region.end(1)
+ for site in pattern.finditer(command, start, stop):
+ if site.start() not in closers:
+ sites.append(site)
+ return sites
+
+
+def _is_wrapper_flag_operand(command: str, start: int) -> bool:
+ """Whether the word at ``start`` is the VALUE of a wrapper option rather than a command.
+
+ `xargs -P $n` gives `-P` the `$n`, which is never the command the wrapper forwards to. Checked
+ here, not in the regex: a regex consuming the option and its value backtracks to the shorter
+ reading, and the atomic group that would pin it needs 3.11 while this file supports 3.9.
+ """
+ preceding = command[:start].split()
+ return bool(preceding) and preceding[-1] in _ALL_WRAPPER_VALUE_FLAGS
+
+
+def _blocked_body_words(body: str) -> "set[str]":
+ """Every blocked name the substitution body ``body`` (already lowercased) mentions."""
+ found: "set[str]" = set()
+ for groups in _blocked_body_word_pattern_for(frozenset(_BLOCKED_COMMANDS)).findall(body):
+ if isinstance(groups, str):
+ groups = (groups,)
+ found.update(g for g in groups if g)
+ return found
+
# A command substitution appearing anywhere ($(...) that is not arithmetic, or a backtick). Used to catch a
# substitution stashed in a variable (x=`...`) that a later dynamic exec runs, which never surfaces as literal text.
diff --git a/studio/backend/tests/test_sandbox_tools.py b/studio/backend/tests/test_sandbox_tools.py
index d3d950236c8..02a2d3610e2 100644
--- a/studio/backend/tests/test_sandbox_tools.py
+++ b/studio/backend/tests/test_sandbox_tools.py
@@ -832,6 +832,75 @@ class TestBashBlocklistPosition:
# Only the long spellings carry an attached command; -x belongs to too
# many other utilities to read its neighbour as one.
pytest.param("grep -x rm file.txt", id = "short_flag_neighbour_not_read_as_command"),
+ # `$(which python)` leaves the executed name visible in the body; the rest only
+ # feed text to their outer command.
+ pytest.param("$(which python) script.py", id = "which_lookup_allowed"),
+ pytest.param("env $(which python) script.py", id = "wrapper_which_lookup_allowed"),
+ pytest.param("echo $(date)", id = "arg_position_subst_allowed"),
+ pytest.param("echo $(ls /tmp)", id = "arg_position_listing_allowed"),
+ pytest.param("$(echo hello)", id = "subst_benign_literal_allowed"),
+ pytest.param("FOO=$(date) echo hi", id = "assignment_value_subst_allowed"),
+ pytest.param("echo $((1+2))", id = "arithmetic_expansion_allowed"),
+ # Same slots, benign bodies.
+ pytest.param("{ echo hi; }", id = "brace_group_benign_allowed"),
+ pytest.param("if true; then echo hi; fi", id = "branch_body_benign_allowed"),
+ pytest.param("for f in a b; do echo $f; done", id = "loop_var_benign_allowed"),
+ pytest.param("find . -name x -exec echo {} \\;", id = "find_exec_benign_allowed"),
+ pytest.param("c=hello; echo $c", id = "benign_var_arg_allowed"),
+ pytest.param("c=reboot; echo $c", id = "blocked_var_arg_allowed"),
+ pytest.param("PATH=/usr/bin; ls", id = "path_assignment_allowed"),
+ # A wrapper is spent on its first plain word, so nothing further along the line is
+ # at command position. Reading any word within reach of one refused these.
+ pytest.param(
+ "timeout 60 python train.py --data $(ls -d data/*)",
+ id = "wrapper_spent_on_its_own_command_allowed",
+ ),
+ pytest.param(
+ "stamp=$(date +%F); nohup ./run.sh $stamp &",
+ id = "laundered_var_as_wrapper_argument_allowed",
+ ),
+ pytest.param(
+ "out=$(pwd); timeout 300 ./run.sh $out", id = "laundered_var_as_operand_allowed"
+ ),
+ pytest.param(
+ "v=$(date); env FOO=1 ./run.sh $v", id = "laundered_var_after_env_assign_allowed"
+ ),
+ # `-P` takes a separate value, so the `$n` is that value, not the command.
+ pytest.param(
+ "n=$(nproc); xargs -P $n -I{} echo {}", id = "wrapper_value_flag_operand_allowed"
+ ),
+ # Arithmetic can never hold a command name, in an assignment either.
+ pytest.param(
+ "sec=$((60*5)); timeout $sec make test", id = "arithmetic_assignment_allowed"
+ ),
+ # Single quotes expand nothing; double quotes expand into an argument, not a command.
+ pytest.param(
+ 'echo "check if $(ls -1 *.py | wc -l) files"',
+ id = "subst_inside_double_quoted_argument_allowed",
+ ),
+ pytest.param("sed 's|x|$(ls)|' f", id = "subst_inside_single_quotes_allowed"),
+ # A `)` is a command position only in a case arm. Treating every one as a separator
+ # would refuse these.
+ pytest.param("echo $(date) $(ls /tmp)", id = "two_arg_position_substs_allowed"),
+ pytest.param("(cd /tmp) $(date)", id = "subshell_close_then_subst_allowed"),
+ pytest.param("case x in x) echo hi;; esac", id = "case_arm_benign_allowed"),
+ pytest.param(">out.log echo hi", id = "leading_redirection_benign_allowed"),
+ pytest.param(
+ "timeout 1s python train.py --data $(ls -d data/*)",
+ id = "suffixed_duration_wrapper_spent_allowed",
+ ),
+ pytest.param("coproc echo hi", id = "coproc_benign_allowed"),
+ pytest.param("> out.log echo hi", id = "spaced_redirection_benign_allowed"),
+ # A substitution that IS the redirection target names a file; nothing runs.
+ pytest.param("> $(date).log echo hi", id = "subst_as_redirection_target_allowed"),
+ pytest.param('echo "`date`"', id = "quoted_backtick_in_argument_allowed"),
+ pytest.param('echo "$(printf r)m"', id = "glued_subst_in_argument_allowed"),
+ pytest.param(
+ "env --chdir /tmp python train.py --data $(ls -d data/*)",
+ id = "env_long_option_value_wrapper_spent_allowed",
+ ),
+ # A laundered expansion glued into an ARGUMENT is not a command word.
+ pytest.param("v=$(date); echo ${v}Z", id = "laundered_prefix_in_argument_allowed"),
],
)
def test_bash_blocklist_finds_nothing_in_safe_commands(self, command):
@@ -864,6 +933,234 @@ class TestBashBlocklistPosition:
pytest.param(
"curl", "while true; do curl --version; break; done", id = "while_do_blocked"
),
+ # `$(echo reboot)` runs reboot without the name appearing literally.
+ pytest.param("reboot", "$(echo reboot)", id = "subst_synthesized_literal_blocked"),
+ pytest.param(
+ "shutdown",
+ '$(printf "%s" shutdown)',
+ id = "subst_printf_literal_blocked",
+ ),
+ # An enumeration through a selector gives an unknowable name: fail closed.
+ pytest.param(
+ "command substitution",
+ '$(ls /usr/bin/ | grep "^reb")',
+ id = "subst_enumerated_name_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ '$(ls /usr/bin/ | grep "^rm$") -rf ~/Downloads/can_delete',
+ id = "subst_enumerated_rm_with_args_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ '`ls /usr/bin/ | grep "^reb"`',
+ id = "backtick_enumerated_name_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "sudo $(ls /usr/bin | grep reb)",
+ id = "wrapper_prefixed_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "env $(ls /usr/bin | grep reb)",
+ id = "env_wrapper_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ '$(compgen -c | grep "^rm$")',
+ id = "subst_compgen_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "$(find /usr/bin -name 'r*')",
+ id = "subst_find_bin_dir_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "$(echo /usr/bin/r*)",
+ id = "subst_glob_expansion_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ '"$(ls /usr/bin | grep reb)"',
+ id = "quoted_subst_enumeration_blocked",
+ ),
+ # The same synthesis past separators, all of which execute it.
+ pytest.param(
+ "command substitution",
+ "{ $(ls /usr/bin|grep reb); }",
+ id = "brace_group_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "if true; then $(ls /usr/bin|grep reb); fi",
+ id = "branch_body_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "while true; do $(ls /usr/bin|grep reb); done",
+ id = "loop_body_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "find /tmp -name x -exec $(ls /usr/bin | grep reb) \\;",
+ id = "find_exec_subst_blocked",
+ ),
+ # A variable launders the synthesis, a printf -v, or a plain literal.
+ pytest.param(
+ "command substitution",
+ "c=$(ls /usr/bin|grep reb); $c",
+ id = "laundered_subst_var_blocked",
+ ),
+ pytest.param("reboot", "c=$(echo reboot); ${c}", id = "laundered_literal_precise"),
+ pytest.param("reboot", "c=reboot; $c", id = "laundered_plain_literal_blocked"),
+ pytest.param(
+ "command substitution",
+ "printf -v c reboot; $c",
+ id = "printf_v_laundered_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "export c=$(compgen -c | grep rm); $c",
+ id = "exported_laundered_subst_blocked",
+ ),
+ # An assignment binds wherever it appears. Each of these really deletes: verified
+ # against a stand-in `rm` on PATH.
+ pytest.param(
+ "command substitution",
+ "if true; then c=$(ls /usr/bin|grep rm); fi; $c",
+ id = "laundered_behind_keyword_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "(c=$(ls /usr/bin|grep rm); $c)",
+ id = "laundered_in_subshell_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "x=1 c=$(ls /usr/bin|grep rm); $c",
+ id = "laundered_behind_assignment_prefix_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "for i in 1; do c=$(ls /usr/bin|grep rm); done; $c",
+ id = "laundered_in_loop_body_blocked",
+ ),
+ # The quoted spelling is the recommended one; it cannot be the one that escapes.
+ pytest.param(
+ "command substitution",
+ 'c=$(ls /usr/bin|grep rm); "$c"',
+ id = "laundered_quoted_exec_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ 'c=$(ls /usr/bin|grep rm); "${c}"',
+ id = "laundered_quoted_brace_exec_blocked",
+ ),
+ pytest.param("reboot", 'c=reboot; "$c"', id = "laundered_literal_quoted_exec_blocked"),
+ # Thousands of unterminated `$(` openers are refused, not scanned: each costs a
+ # span walk and this screen has no length cap.
+ pytest.param(
+ "command substitution",
+ ";$(" * 200,
+ id = "substitution_flood_refused_not_scanned",
+ ),
+ # Four spellings that reach the command word by a route the site scan did not walk.
+ # Each really deletes: verified against a stand-in `rm` on PATH.
+ #
+ # timeout's DURATION is a float with an optional s/m/h/d suffix (timeout --help), not
+ # the bare integer the scan accepted.
+ pytest.param(
+ "command substitution",
+ "timeout 1s $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "suffixed_duration_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "timeout 0.5 $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "fractional_duration_subst_blocked",
+ ),
+ # `env [OPTION]...` is unbounded, so any cap on the option run is a count an attacker
+ # exceeds to make the whole site regex fail open.
+ pytest.param(
+ "command substitution",
+ "env -u A -u B -u C -u D -u E $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "many_wrapper_options_subst_blocked",
+ ),
+ # Redirections may precede the command word.
+ pytest.param(
+ "command substitution",
+ ">out.log $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "leading_redirection_subst_blocked",
+ ),
+ # A case arm's `)` is followed directly by the commands to run.
+ pytest.param(
+ "command substitution",
+ "case x in x) $(ls /usr/bin | grep '^rm$') -rf victim;; esac",
+ id = "case_arm_subst_blocked",
+ ),
+ # timeout's DURATION is a float, so strtod accepts the scientific spellings too and
+ # `timeout 1e1 true` really runs.
+ pytest.param(
+ "command substitution",
+ "timeout 1e1 $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "scientific_duration_subst_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "timeout 1.5e1s $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "scientific_suffixed_duration_subst_blocked",
+ ),
+ # `coproc [NAME] command` (help coproc) runs COMMAND asynchronously.
+ pytest.param(
+ "command substitution",
+ "coproc $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "coproc_subst_blocked",
+ ),
+ # The two laundering routes the site fixes left behind: an arm runs a variable just
+ # as readily as a substitution, and bash concatenates `${x}m` into one command word.
+ pytest.param(
+ "command substitution",
+ "c=$(ls /usr/bin|grep '^rm$'); case x in x) $c -rf victim;; esac",
+ id = "case_arm_laundered_var_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "x=$(printf r); ${x}m -rf victim",
+ id = "laundered_prefix_command_word_blocked",
+ ),
+ # Bash allows whitespace between a redirection operator and its target.
+ pytest.param(
+ "command substitution",
+ "> out.log $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "spaced_redirection_subst_blocked",
+ ),
+ # `env -C/--chdir DIR` takes a separate value (env --help); unconsumed, the DIR read
+ # as the command and the real one behind it was never reached.
+ pytest.param(
+ "command substitution",
+ "env --chdir /tmp $(ls /usr/bin | grep '^rm$') -rf victim",
+ id = "env_long_option_value_subst_blocked",
+ ),
+ # A double-quoted backtick expands exactly like `"$(...)"`.
+ pytest.param(
+ "command substitution",
+ "\"`ls /usr/bin | grep '^rm$'`\" -rf victim",
+ id = "quoted_backtick_subst_blocked",
+ ),
+ # Bash concatenates adjacent fragments, so the body being benign proves nothing about
+ # the word that runs: `$(printf r)m` is `rm`.
+ pytest.param(
+ "command substitution",
+ '"$(printf r)"m -rf victim',
+ id = "quoted_subst_glued_to_literal_blocked",
+ ),
+ pytest.param(
+ "command substitution",
+ "$(printf r)m -rf victim",
+ id = "bare_subst_glued_to_literal_blocked",
+ ),
],
)
def test_bash_blocklist_flags_the_command(self, expected, command):