feat: refuse unrecoverable shell commands

Add internal/tools/command: an always-on floor under the shell tool,
enforced in the provider adapter so the lifted tau files stay diffable.

This is not a security boundary and does not pretend to be one. Anything
with a shell has countless ways past a rule list. What it buys is that
the failures with no recovery -- where you cannot intervene afterwards
because the machine, the filesystem, or the gateway itself is gone --
are not reachable by an ordinary mistake.

Rules: recursive delete of / and system directories, mkfs, raw block
device writes, fork bombs, kill -1, shutdown/reboot/init/systemctl
power, and sudo -S with no SUDO_PASSWORD configured. Two more are
archie's own: an agent must not stop the daemon that hosts /stop
(pkill/systemctl/docker), nor start a second one outside the supervisor.

The parsing is the actual work. Patterns are anchored to command
position, so `git commit -m "revert the rm -rf / change"` and
`echo "rm -rf /"` are ordinary commands, while `echo x; rm -rf /` and
`$(rm -rf /)` are not. Quoting, separators, ${VAR} braces, environment
assignments and privilege wrappers are all parsed rather than matched.

Probing the first version found two bypasses that made every rule
optional, both of which a model writes unprompted rather than only an
attacker: `bash -c "rm -rf /"` and `xargs rm -rf /` hide the command in
an argument. Segments are now followed into shell -c payloads, eval, and
command wrappers (xargs, timeout, nice, env, nohup, ...), bounded by a
nesting limit. Tests cover both directions -- the refusals and, at equal
length, the ordinary commands that must not trip them.
This commit is contained in:
sam committed 2026-07-29 18:45:43 +10:00
1 parent 9784cc6b3e
commit bb7b779b35
5 files changed
+1011

No files matched your search

+481
View File
@@ -0,0 +1,481 @@
package command
import (
"fmt"
"os"
"strings"
)
// Blocked reports a command line that must not run. It carries the
// offending segment so the refusal can name what was actually objected to
// rather than the whole line.
type Blocked struct {
// Rule is a short identifier for the rule that fired.
Rule string
// Reason explains the refusal in one line, shown to the model and the
// user.
Reason string
// Segment is the offending command as it appeared.
Segment string
}
func (b *Blocked) Error() string {
if b.Segment == "" {
return fmt.Sprintf("refused (%s): %s", b.Rule, b.Reason)
}
return fmt.Sprintf("refused (%s): %s: %q", b.Rule, b.Reason, b.Segment)
}
// Hardline checks a command line against the rules that hold regardless of
// configuration, approval, or operator instruction.
//
// This is deliberately a floor and not a security boundary. Anything with a
// shell has countless ways around a pattern list, and pretending otherwise
// would be worse than not having one. What it does buy is that the failure
// modes with no recovery -- the ones where you cannot intervene afterwards
// because the machine, the filesystem, or the gateway itself is gone -- are
// not reachable by an ordinary mistake.
//
// Two rules exist specifically to keep intervention possible: an agent must
// not be able to stop the daemon that hosts /stop, nor start a second one
// outside the supervisor's control.
func Hardline(line string) error {
return hardline(line, 0)
}
// maxNesting bounds how far the rules follow a command into the commands it
// wraps. Real command lines nest once or twice; the limit only stops a
// pathological input from recursing without end.
const maxNesting = 8
func hardline(line string, depth int) error {
if line = strings.TrimSpace(line); line == "" {
return nil
}
// The fork bomb is checked against the whole line because its
// definition spans the separators everything else is split on.
if isForkBomb(line) {
return &Blocked{
Rule: "fork-bomb",
Reason: "exhausts the process table and requires a reboot to clear",
Segment: line,
}
}
for _, seg := range Split(line) {
if err := checkSegment(seg, depth); err != nil {
return err
}
}
return nil
}
// checkSegment applies every rule to one command invocation, then follows
// the segment into any command it merely wraps.
//
// Without that second step the rules are trivially defeated, and not only
// by someone trying: `bash -c "rm -rf /"` is a shape models produce
// unprompted, and `xargs rm -rf /` reads as ordinary shell. In both cases
// the dangerous command is an argument, so nothing above sees it.
func checkSegment(seg Segment, depth int) error {
for _, rule := range rules {
if reason, hit := rule.check(seg); hit {
return &Blocked{Rule: rule.name, Reason: reason, Segment: seg.Raw}
}
}
if depth >= maxNesting {
return nil
}
// A shell's -c argument is a whole command line of its own, quoting
// and separators included, so it goes back through the front door.
if payload, ok := shellPayload(seg); ok {
return hardline(payload, depth+1)
}
// A wrapper's remaining words are one command, already tokenised.
if inner, ok := unwrap(seg); ok {
return checkSegment(inner, depth+1)
}
return nil
}
// shells run a command line supplied as an argument.
var shells = map[string]bool{
"sh": true, "bash": true, "zsh": true, "dash": true,
"ksh": true, "ash": true,
}
// shellPayload returns the command line a segment asks another shell to
// run, whether via `sh -c` or `eval`.
func shellPayload(seg Segment) (string, bool) {
base := baseName(seg.Name)
if shells[base] {
for i, arg := range seg.Args {
if arg == "-c" && i+1 < len(seg.Args) {
return seg.Args[i+1], true
}
}
return "", false
}
if base == "eval" && len(seg.Args) > 0 {
return strings.Join(seg.Args, " "), true
}
return "", false
}
// wrappers run another command rather than doing the work themselves, so
// the command that matters is further along the line.
var wrappers = map[string]bool{
"xargs": true, "env": true, "nice": true, "ionice": true,
"timeout": true, "stdbuf": true, "time": true, "nohup": true,
"setsid": true, "unbuffer": true, "script": true,
}
// unwrap returns the command a wrapper invokes.
//
// Flags, environment assignments, and bare numbers are skipped, the last
// because several wrappers take a leading value -- `timeout 30 rm -rf /`
// and `nice -n 10 rm -rf /` both have to resolve to the rm.
func unwrap(seg Segment) (Segment, bool) {
if !wrappers[baseName(seg.Name)] {
return Segment{}, false
}
for i, arg := range seg.Args {
if strings.HasPrefix(arg, "-") || isAssignment(arg) || isBareNumber(arg) {
continue
}
return segmentFromWords(strings.Join(seg.Args[i:], " "), seg.Args[i:])
}
return Segment{}, false
}
// isBareNumber reports whether a word is a plain count or duration, such
// as timeout's 30 or 1m.
func isBareNumber(word string) bool {
if word == "" {
return false
}
trimmed := strings.TrimRight(word, "smhd")
if trimmed == "" {
return false
}
for _, r := range trimmed {
if (r < '0' || r > '9') && r != '.' {
return false
}
}
return true
}
type rule struct {
name string
check func(Segment) (string, bool)
}
var rules = []rule{
{"recursive-root-delete", checkRecursiveDelete},
{"filesystem-format", checkMkfs},
{"block-device-write", checkBlockDeviceWrite},
{"kill-all-processes", checkKillAll},
{"system-power", checkSystemPower},
{"sudo-stdin-password", checkSudoStdin},
{"daemon-self-termination", checkSelfTermination},
{"daemon-launch", checkDaemonLaunch},
}
// criticalPaths are the delete targets with no recovery path. Anything
// outside this set is the operator's business, including recursive deletes
// inside the workspace.
var criticalPaths = map[string]bool{
"/": true, "//": true, "/.": true, "/..": true,
"~": true, "$HOME": true, "${HOME}": true,
"/home": true, "/root": true, "/etc": true, "/usr": true,
"/var": true, "/bin": true, "/sbin": true, "/boot": true,
"/lib": true, "/lib64": true, "/opt": true, "/srv": true,
"/proc": true, "/sys": true, "/dev": true,
}
// checkRecursiveDelete refuses a recursive rm whose target is a critical
// path. A recursive delete elsewhere is ordinary work and is allowed.
func checkRecursiveDelete(seg Segment) (string, bool) {
if seg.Name != "rm" {
return "", false
}
if !hasRecursiveFlag(seg.Args) {
return "", false
}
for _, arg := range seg.Args {
if strings.HasPrefix(arg, "-") {
continue
}
if isCriticalPath(arg) {
return "recursive delete of " + arg + ", which is not recoverable", true
}
}
return "", false
}
// hasRecursiveFlag reports whether rm was asked to recurse, covering both
// the long form and bundled short flags such as -rf and -fr.
func hasRecursiveFlag(args []string) bool {
for _, arg := range args {
if arg == "--recursive" {
return true
}
if !strings.HasPrefix(arg, "-") || strings.HasPrefix(arg, "--") {
continue
}
if strings.ContainsAny(arg[1:], "rR") {
return true
}
}
return false
}
// isCriticalPath reports whether a delete target names the filesystem root,
// a home directory, or a system directory -- with or without a trailing
// slash or glob.
func isCriticalPath(arg string) bool {
trimmed := strings.TrimSuffix(arg, "*")
trimmed = strings.TrimSuffix(trimmed, "/")
if trimmed == "" {
// The argument was "/" or "/*".
return true
}
return criticalPaths[trimmed] || criticalPaths[arg]
}
// checkMkfs refuses any filesystem format. The tool name carries the type,
// so mkfs.ext4 and mkfs alike are matched on the prefix.
func checkMkfs(seg Segment) (string, bool) {
base := baseName(seg.Name)
if base == "mkfs" || strings.HasPrefix(base, "mkfs.") {
return "formats a filesystem, destroying everything on it", true
}
return "", false
}
// checkBlockDeviceWrite refuses writes straight to a block device, whether
// through dd's of= or a shell redirect. /dev/null and /dev/zero are
// excluded: writing to them is routine and harmless.
func checkBlockDeviceWrite(seg Segment) (string, bool) {
if baseName(seg.Name) == "dd" {
for _, arg := range seg.Args {
target, ok := strings.CutPrefix(arg, "of=")
if ok && isBlockDevice(target) {
return "writes raw data to " + target + ", destroying the device's contents", true
}
}
}
for i, word := range seg.Words {
if word != ">" && word != ">>" {
continue
}
if i+1 < len(seg.Words) && isBlockDevice(seg.Words[i+1]) {
return "redirects output to the block device " + seg.Words[i+1], true
}
}
return "", false
}
// isBlockDevice reports whether a path names a disk device rather than one
// of the harmless character devices.
func isBlockDevice(path string) bool {
if !strings.HasPrefix(path, "/dev/") {
return false
}
switch path {
case "/dev/null", "/dev/zero", "/dev/random", "/dev/urandom", "/dev/stdout", "/dev/stderr":
return false
}
name := strings.TrimPrefix(path, "/dev/")
for _, prefix := range []string{"sd", "nvme", "hd", "vd", "xvd", "mmcblk", "loop", "md", "dm-"} {
if strings.HasPrefix(name, prefix) {
return true
}
}
return false
}
// checkKillAll refuses signalling every process, which takes down the
// daemon and anything else on the machine.
func checkKillAll(seg Segment) (string, bool) {
if baseName(seg.Name) != "kill" {
return "", false
}
for _, arg := range seg.Args {
if arg == "-1" {
return "signals every process on the system", true
}
}
return "", false
}
// powerCommands halt or restart the machine outright.
var powerCommands = map[string]bool{
"shutdown": true, "reboot": true, "halt": true, "poweroff": true,
}
// checkSystemPower refuses anything that powers the machine down or
// restarts it. Matching is on the command position only, so a commit
// message or a log line mentioning reboot is unaffected.
func checkSystemPower(seg Segment) (string, bool) {
base := baseName(seg.Name)
if powerCommands[base] {
return "shuts down or restarts the machine", true
}
if base == "init" || base == "telinit" {
for _, arg := range seg.Args {
if arg == "0" || arg == "6" {
return "changes runlevel to shut down or reboot", true
}
}
}
if base == "systemctl" {
for _, arg := range seg.Args {
switch arg {
case "poweroff", "reboot", "halt", "kexec":
return "shuts down or restarts the machine", true
}
}
}
return "", false
}
// checkSudoStdin refuses feeding sudo a password on stdin unless one has
// been configured deliberately. Without SUDO_PASSWORD set there is nothing
// legitimate to supply, so the flag only appears when something is trying
// passwords.
func checkSudoStdin(seg Segment) (string, bool) {
if !seg.Elevated || os.Getenv("SUDO_PASSWORD") != "" {
return "", false
}
for _, flag := range seg.ElevationArgs {
if flag == "-S" || flag == "--stdin" {
return "supplies a sudo password on stdin and no SUDO_PASSWORD is configured", true
}
if strings.HasPrefix(flag, "-") && !strings.HasPrefix(flag, "--") && strings.Contains(flag[1:], "S") {
return "supplies a sudo password on stdin and no SUDO_PASSWORD is configured", true
}
}
return "", false
}
// daemonNames are the processes whose death removes the operator's ability
// to intervene.
var daemonNames = map[string]bool{"archied": true, "archie-agent": true}
// checkSelfTermination refuses killing the daemon that hosts the gateway.
//
// /stop, approvals, and every other control run inside archied. An agent
// that can stop it can put itself beyond reach, and the only remaining
// recourse is physical access to the host.
func checkSelfTermination(seg Segment) (string, bool) {
base := baseName(seg.Name)
if base == "pkill" || base == "killall" {
for _, arg := range seg.Args {
if strings.HasPrefix(arg, "-") {
continue
}
if namesDaemon(arg) {
return "kills the archie daemon, which is what /stop runs in", true
}
}
}
if base == "systemctl" || base == "service" {
if hasAny(seg.Args, "stop", "kill", "disable", "mask", "restart") && anyNamesDaemon(seg.Args) {
return "stops the archie daemon, which is what /stop runs in", true
}
}
// The docker socket is mounted, so the container is reachable from
// inside itself.
if base == "docker" || base == "podman" {
if hasAny(seg.Args, "stop", "kill", "rm", "restart", "down") && anyNamesDaemon(seg.Args) {
return "stops the archie daemon's container, which is what /stop runs in", true
}
}
return "", false
}
// checkDaemonLaunch refuses starting another daemon.
//
// A second archied outside the supervisor competes for the same Telegram
// updates and the same queues, and nothing is tracking it -- so it cannot
// be restarted, reconfigured, or stopped through any of the usual paths.
func checkDaemonLaunch(seg Segment) (string, bool) {
name := baseName(seg.Name)
if name == "nohup" || name == "setsid" {
if len(seg.Args) > 0 && namesDaemon(baseName(seg.Args[0])) {
return "starts a second archie daemon detached from the supervisor", true
}
return "", false
}
if daemonNames[name] {
return "starts a second archie daemon outside the supervisor", true
}
return "", false
}
// namesDaemon reports whether an argument refers to an archie process or
// container. Container names carry a compose prefix and suffix, so this is
// a substring test rather than an exact one.
func namesDaemon(arg string) bool {
if daemonNames[arg] {
return true
}
return strings.Contains(arg, "archied") || strings.Contains(arg, "archie-agent")
}
func anyNamesDaemon(args []string) bool {
for _, arg := range args {
if namesDaemon(arg) {
return true
}
}
return false
}
func hasAny(args []string, wanted ...string) bool {
for _, arg := range args {
for _, w := range wanted {
if arg == w {
return true
}
}
}
return false
}
// baseName strips any directory from a command, so that /sbin/reboot and
// reboot are judged the same.
func baseName(name string) string {
if i := strings.LastIndexAny(name, "/\\"); i >= 0 {
return name[i+1:]
}
return name
}
// isForkBomb reports whether the line defines and invokes a
// self-replicating function. Whitespace is removed first because it is
// optional throughout the construct.
func isForkBomb(line string) bool {
compact := strings.Map(func(r rune) rune {
if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
return -1
}
return r
}, line)
return strings.Contains(compact, ":(){:|:&};:") ||
strings.Contains(compact, ":(){:|:&};:&")
}
+188
View File
@@ -0,0 +1,188 @@
package command_test
import (
"errors"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/tools/command"
)
// TestHardlineBlocks covers the commands that must never run.
func TestHardlineBlocks(t *testing.T) {
t.Parallel()
cases := []struct {
name string
line string
rule string
}{
{"root delete", "rm -rf /", "recursive-root-delete"},
{"root delete glob", "rm -rf /*", "recursive-root-delete"},
{"root delete dot", "rm -rf /.", "recursive-root-delete"},
{"root delete long flag", "rm --recursive --force /", "recursive-root-delete"},
{"root delete bundled reverse", "rm -fr /", "recursive-root-delete"},
{"home delete", "rm -rf ~", "recursive-root-delete"},
{"home var delete", "rm -rf $HOME", "recursive-root-delete"},
{"home brace delete", "rm -rf ${HOME}/", "recursive-root-delete"},
{"etc delete", "rm -rf /etc", "recursive-root-delete"},
{"usr glob delete", "rm -rf /usr/*", "recursive-root-delete"},
{"quoted root delete", `rm -rf "/"`, "recursive-root-delete"},
{"env prefixed delete", "FOO=bar rm -rf /", "recursive-root-delete"},
{"sudo delete", "sudo rm -rf /", "recursive-root-delete"},
{"mkfs", "mkfs.ext4 /dev/sda1", "filesystem-format"},
{"bare mkfs", "mkfs /dev/sdb", "filesystem-format"},
{"dd to disk", "dd if=/dev/zero of=/dev/sda bs=1M", "block-device-write"},
{"dd to nvme", "dd if=x.img of=/dev/nvme0n1", "block-device-write"},
{"redirect to disk", "echo x > /dev/sda", "block-device-write"},
{"fork bomb", ":(){ :|:& };:", "fork-bomb"},
{"fork bomb compact", ":(){:|:&};:", "fork-bomb"},
{"kill all", "kill -9 -1", "kill-all-processes"},
{"shutdown", "shutdown -h now", "system-power"},
{"reboot", "reboot", "system-power"},
{"poweroff path", "/sbin/poweroff", "system-power"},
{"init 0", "init 0", "system-power"},
{"telinit 6", "telinit 6", "system-power"},
{"systemctl reboot", "systemctl reboot", "system-power"},
{"sudo stdin", "sudo -S ls", "sudo-stdin-password"},
{"pkill daemon", "pkill archied", "daemon-self-termination"},
{"killall daemon", "killall -9 archied", "daemon-self-termination"},
{"systemctl stop daemon", "systemctl stop archied", "daemon-self-termination"},
{"docker stop daemon", "docker stop archie-core-archied-1", "daemon-self-termination"},
{"docker rm daemon", "docker rm -f archie-core-archied-1", "daemon-self-termination"},
{"launch daemon", "archied -config /etc/archie/config.toml", "daemon-launch"},
{"nohup daemon", "nohup archied &", "daemon-launch"},
{"hidden after separator", "echo hello; rm -rf /", "recursive-root-delete"},
{"hidden after and", "cd /tmp && rm -rf /", "recursive-root-delete"},
{"hidden after pipe", "cat x | rm -rf /", "recursive-root-delete"},
{"hidden in substitution", "echo $(rm -rf /)", "recursive-root-delete"},
{"hidden in backticks", "echo `rm -rf /`", "recursive-root-delete"},
{"hidden in subshell", "(rm -rf /)", "recursive-root-delete"},
{"hidden after newline", "echo hi\nrm -rf /", "recursive-root-delete"},
// Wrapped forms. These are not exotic: `bash -c` is a shape
// models produce unprompted, and without unwrapping every rule
// above is one quotation mark away from being bypassed.
{"bash -c", `bash -c "rm -rf /"`, "recursive-root-delete"},
{"sh -c single quoted", `sh -c 'rm -rf /'`, "recursive-root-delete"},
{"eval", `eval "rm -rf /"`, "recursive-root-delete"},
{"nested shells", `bash -c "sh -c 'rm -rf /'"`, "recursive-root-delete"},
{"xargs", "xargs rm -rf /", "recursive-root-delete"},
{"timeout with duration", "timeout 30 rm -rf /", "recursive-root-delete"},
{"nice with flag value", "nice -n 10 rm -rf /", "recursive-root-delete"},
{"env assignment", "env FOO=bar rm -rf /", "recursive-root-delete"},
{"nohup wrapping delete", "nohup rm -rf / &", "recursive-root-delete"},
{"wrapped power command", `bash -c "reboot"`, "system-power"},
{"wrapped daemon kill", `sh -c "pkill archied"`, "daemon-self-termination"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
err := command.Hardline(tc.line)
if err == nil {
t.Fatalf("Hardline(%q) allowed the command", tc.line)
}
var blocked *command.Blocked
if !errors.As(err, &blocked) {
t.Fatalf("error type = %T, want *command.Blocked", err)
}
if blocked.Rule != tc.rule {
t.Errorf("rule = %q, want %q (reason: %s)", blocked.Rule, tc.rule, blocked.Reason)
}
if blocked.Reason == "" {
t.Error("refusal carries no reason, so the model cannot tell why")
}
})
}
}
// TestHardlineAllows is the half that decides whether this is usable. A
// blocklist that fires on commit messages and ordinary work would be
// turned off within a day, so the quoting and command-position analysis
// matters as much as the patterns.
func TestHardlineAllows(t *testing.T) {
t.Parallel()
cases := []struct {
name string
line string
}{
{"echoing the string", `echo "rm -rf /"`},
{"commit message", `git commit -m "revert the rm -rf / change"`},
{"commit message single quotes", `git commit -m 'stop using rm -rf / in scripts'`},
{"pr title", `gh pr create --title "guard against rm -rf /"`},
{"grep for the pattern", `grep -r "rm -rf /" .`},
{"writing a doc that mentions reboot", `echo "reboot the machine" > notes.txt`},
{"ordinary recursive delete", "rm -rf ./build"},
{"recursive delete in workspace", "rm -rf /workspace/tmp"},
{"recursive delete of subdir", "rm -rf /var/lib/archie/work/tmp"},
{"non-recursive root file", "rm /tmp/x"},
{"dd to a file", "dd if=/dev/zero of=disk.img bs=1M count=10"},
{"redirect to null", "echo x > /dev/null"},
{"redirect to a file", "go test ./... > out.txt"},
{"killing a pid", "kill -9 12345"},
{"pkill something else", "pkill node"},
{"systemctl status", "systemctl status archied"},
{"systemctl restart something else", "systemctl restart nginx"},
{"docker ps", "docker ps -a"},
{"docker stop another container", "docker stop nats"},
{"sudo without stdin", "sudo apt-get update"},
{"ordinary build", "go build ./..."},
{"chained ordinary commands", "cd /workspace && go test ./... && git status"},
{"empty", ""},
{"whitespace", " "},
// The unwrapping must not turn ordinary wrapped commands into
// refusals.
{"bash -c ordinary", `bash -c "go test ./..."`},
{"bash -c mentioning the string", `bash -c 'echo "rm -rf /"'`},
{"xargs ordinary", "find . -name '*.tmp' | xargs rm -f"},
{"timeout ordinary", "timeout 30 go test ./..."},
{"env ordinary", "env GOFLAGS=-mod=mod go build ./..."},
{"nohup ordinary", "nohup ./long-running-job &"},
{"deeply nested ordinary", `bash -c "sh -c 'echo hello'"`},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
if err := command.Hardline(tc.line); err != nil {
t.Errorf("Hardline(%q) blocked an ordinary command: %v", tc.line, err)
}
})
}
}
// TestBlockedErrorNamesTheSegment keeps the refusal actionable: the model
// has to be able to tell which part of a chained command was objected to.
func TestBlockedErrorNamesTheSegment(t *testing.T) {
t.Parallel()
err := command.Hardline("go build ./... && rm -rf /etc")
if err == nil {
t.Fatal("Hardline allowed a recursive delete of /etc")
}
msg := err.Error()
if !strings.Contains(msg, "rm -rf /etc") {
t.Errorf("error %q does not name the offending segment", msg)
}
if strings.Contains(msg, "go build") {
t.Errorf("error %q blames the wrong segment", msg)
}
}
+270
View File
@@ -0,0 +1,270 @@
// Package command inspects shell command lines before they are executed.
//
// It exists because a substring search over a command line is wrong in both
// directions. `git commit -m "revert the rm -rf change"` is harmless and
// would be blocked; `echo x; rm -rf /` is not and, with a naive anchor on
// the start of the line, would be allowed. Deciding either way requires
// knowing where a command actually begins, which means parsing quoting and
// separators rather than pattern-matching the raw text.
//
// Tool execution owns command constraints (see docs/architecture/policy.md).
// When internal/policy's evaluation API lands, [Hardline] becomes an
// evaluator registered there; the rules themselves stay here.
package command
import "strings"
// Segment is one command invocation found within a command line, already
// split from its neighbours and stripped of quoting.
type Segment struct {
// Raw is the segment's original text, for reporting.
Raw string
// Words are the segment's tokens with quoting removed, including any
// privilege wrapper such as sudo.
Words []string
// Name is the command being invoked: the first word after leading
// environment assignments and privilege wrappers have been skipped.
// Empty when the segment invokes nothing.
Name string
// Args are the words following Name.
Args []string
// Elevated reports whether the segment runs through sudo or doas.
Elevated bool
// ElevationArgs are the flags given to that privilege wrapper.
ElevationArgs []string
}
// Split breaks a command line into the individual commands within it.
//
// Separators are only honoured outside quotes, which is what keeps a
// quoted argument from being read as a new command: in
// `echo "a; rm -rf /"` the semicolon is data, so the whole line is one
// segment whose command is echo. Command substitutions and subshells do
// start new commands, so `$(rm -rf /)` and `(rm -rf /)` are seen.
func Split(line string) []Segment {
var (
segments []Segment
current strings.Builder
quote rune
escaped bool
prev rune
// varBraces counts open ${...} expansions. Their braces are part
// of a word, unlike the braces of a { cmd; } group, so they must
// not split the line -- otherwise ${HOME} parses as the separate
// pieces "$", "HOME" and the rest.
varBraces int
)
flush := func() {
if seg, ok := newSegment(current.String()); ok {
segments = append(segments, seg)
}
current.Reset()
}
runes := []rune(line)
for i := 0; i < len(runes); i++ {
r := runes[i]
if escaped {
current.WriteRune(r)
escaped = false
prev = r
continue
}
// Inside single quotes a backslash is literal, so escaping only
// applies elsewhere.
if r == '\\' && quote != '\'' {
current.WriteRune(r)
escaped = true
prev = r
continue
}
if quote != 0 {
current.WriteRune(r)
if r == quote {
quote = 0
}
prev = r
continue
}
if r == '\'' || r == '"' {
current.WriteRune(r)
quote = r
prev = r
continue
}
// ${...} is one word, not a brace group.
if r == '{' && prev == '$' {
varBraces++
current.WriteRune(r)
prev = r
continue
}
if r == '}' && varBraces > 0 {
varBraces--
current.WriteRune(r)
prev = r
continue
}
// Unquoted from here: these end the current command and begin
// another. Backtick and the bracket forms are included because a
// substitution, subshell, or brace group contains commands of its
// own -- `echo $(rm -rf /)` must be seen as an rm.
if strings.ContainsRune(";&|\n()`{}", r) {
flush()
prev = r
continue
}
current.WriteRune(r)
prev = r
}
flush()
return segments
}
// newSegment tokenises one segment, reporting false when it invokes
// nothing.
func newSegment(raw string) (Segment, bool) {
return segmentFromWords(strings.TrimSpace(raw), tokenise(raw))
}
// segmentFromWords builds a segment from already-tokenised words. It is
// shared with wrapper unwrapping, where the inner command is a slice of an
// outer segment's words and re-parsing text would lose the original
// quoting.
func segmentFromWords(raw string, words []string) (Segment, bool) {
if len(words) == 0 {
return Segment{}, false
}
seg := Segment{Raw: raw, Words: words}
// Leading NAME=value pairs set the environment for the command that
// follows rather than being the command, so `FOO=bar rm -rf /` is an
// rm invocation.
i := 0
for i < len(words) && isAssignment(words[i]) {
i++
}
// A privilege wrapper likewise fronts the real command. Its own flags
// are kept, because some of them are the thing worth refusing.
if i < len(words) && (words[i] == "sudo" || words[i] == "doas") {
seg.Elevated = true
i++
for i < len(words) && strings.HasPrefix(words[i], "-") {
seg.ElevationArgs = append(seg.ElevationArgs, words[i])
i++
}
// sudo VAR=value cmd is accepted by sudo too.
for i < len(words) && isAssignment(words[i]) {
i++
}
}
if i >= len(words) {
// Nothing but assignments or a bare sudo: no command to judge,
// but the elevation flags may still matter.
return seg, seg.Elevated
}
seg.Name = words[i]
seg.Args = words[i+1:]
return seg, true
}
// tokenise splits a segment into words, removing quotes and treating
// redirection operators as words of their own so that a redirect target
// can be examined.
func tokenise(raw string) []string {
var (
words []string
current strings.Builder
quote rune
escaped bool
filled bool
)
end := func() {
if filled {
words = append(words, current.String())
current.Reset()
filled = false
}
}
for _, r := range raw {
if escaped {
current.WriteRune(r)
filled = true
escaped = false
continue
}
if r == '\\' && quote != '\'' {
escaped = true
continue
}
if consumed := consumeQuote(r, &quote, &current, &filled); consumed {
continue
}
switch r {
case ' ', '\t', '\r':
end()
case '>', '<':
end()
words = append(words, string(r))
default:
current.WriteRune(r)
filled = true
}
}
end()
return words
}
// consumeQuote handles one rune's interaction with quoting, reporting
// whether it was consumed. Quote characters themselves are dropped: the
// caller wants an argument's value, so that "/" and / compare equal.
func consumeQuote(r rune, quote *rune, current *strings.Builder, filled *bool) bool {
if *quote != 0 {
if r == *quote {
*quote = 0
return true
}
current.WriteRune(r)
*filled = true
return true
}
if r == '\'' || r == '"' {
*quote = r
// An empty quoted string is still a word.
*filled = true
return true
}
return false
}
// isAssignment reports whether a word is a NAME=value environment
// assignment rather than a command.
func isAssignment(word string) bool {
eq := strings.Index(word, "=")
if eq <= 0 {
return false
}
for i, r := range word[:eq] {
isLetter := (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || r == '_'
isDigit := r >= '0' && r <= '9'
if !isLetter && (!isDigit || i == 0) {
return false
}
}
return true
}
@@ -17,6 +17,7 @@ import (
"github.com/samcharles93/archie-core/internal/plugin"
"github.com/samcharles93/archie-core/internal/tools"
toolsbuiltin "github.com/samcharles93/archie-core/internal/tools/builtin"
"github.com/samcharles93/archie-core/internal/tools/command"
)
// toolset groups these tools for progressive disclosure and guardrails.
@@ -137,6 +138,10 @@ func toEntry(tool toolsbuiltin.Tool) (tools.ToolEntry, error) {
// and the guardrail engine both see it.
func handlerFor(tool toolsbuiltin.Tool) tools.Handler {
return func(ctx context.Context, input map[string]any) (any, error) {
if err := screen(tool.Schema.Name, input); err != nil {
return nil, err
}
params := json.RawMessage("{}")
if len(input) > 0 {
encoded, err := json.Marshal(input)
@@ -163,6 +168,24 @@ func handlerFor(tool toolsbuiltin.Tool) tools.Handler {
}
}
// screen applies the always-on command rules before a tool runs.
//
// This lives in the adapter rather than in the lifted shell tool so that
// the copied files stay diffable against tau, and so the rules are archie's
// to change. It is a floor, not a sandbox: anything with a shell has ways
// around a rule list, and the point is only that the failures with no
// recovery are not reachable by an ordinary mistake.
func screen(name string, input map[string]any) error {
if name != "shell" {
return nil
}
line, _ := input["command"].(string)
if err := command.Hardline(line); err != nil {
return fmt.Errorf("tool shell: %w", err)
}
return nil
}
// classify tags each tool so the guardrail engine and budget enforcement
// can reason about it. This is categorisation, not a jail: it describes
// what a tool does and does not gate whether it may run.
@@ -101,6 +101,55 @@ func TestHandlerSurfacesToolFailureAsError(t *testing.T) {
t.Fatal("no read tool discovered")
}
// TestShellHandlerEnforcesHardlineRules checks the rules are actually
// wired into the executing handler. The rules are tested in
// internal/tools/command; what matters here is that a call cannot reach
// tau's executor without passing through them.
func TestShellHandlerEnforcesHardlineRules(t *testing.T) {
t.Parallel()
shell := shellHandler(t, t.TempDir())
if _, err := shell(context.Background(), map[string]any{"command": "rm -rf /"}); err == nil {
t.Error("the shell tool accepted a recursive delete of /")
} else if !strings.Contains(err.Error(), "refused") {
t.Errorf("error = %v, want a refusal naming the rule", err)
}
}
// TestShellHandlerAllowsOrdinaryCommands guards the other direction: the
// screen must not stand between the model and normal work.
func TestShellHandlerAllowsOrdinaryCommands(t *testing.T) {
t.Parallel()
dir := t.TempDir()
out, err := shellHandler(t, dir)(context.Background(), map[string]any{
"command": `echo "rm -rf / is only mentioned here"`,
})
if err != nil {
t.Fatalf("an ordinary echo was refused: %v", err)
}
if text, ok := out.(string); !ok || !strings.Contains(text, "only mentioned here") {
t.Errorf("shell returned %#v, want the echoed text", out)
}
}
func shellHandler(t *testing.T, workspace string) func(context.Context, map[string]any) (any, error) {
t.Helper()
entries, err := startedProvider(t, workspace).Discover(context.Background())
if err != nil {
t.Fatalf("Discover: %v", err)
}
for _, e := range entries {
if e.Name == "shell" {
return e.Handler
}
}
t.Fatal("no shell tool discovered")
return nil
}
// TestUnconfiguredWorkspaceIsRejected keeps the tools from silently rooting
// at the daemon's own working directory, which in the container is /.
func TestUnconfiguredWorkspaceIsRejected(t *testing.T) {