From 2928bdb682a121f0d6b6539097adde42d4aaf7d6 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Mon, 16 Nov 2026 00:42:48 +1100 Subject: [PATCH] fix(host): confine lookups to each host's configured path roots Lookups run no guards and the helpers read as root, so an instruction injected into an event could steer the agent into listing anywhere on the host. Each host now names the roots its lookups may look under, and any other path is refused before a command is built. --- connectors/host/host.go | 25 +++++++++++++++++++++---- connectors/host/host_test.go | 16 ++++++++++------ connectors/host/target/README.md | 3 +++ 3 files changed, 34 insertions(+), 10 deletions(-) diff --git a/connectors/host/host.go b/connectors/host/host.go index 493aa6f..fffcdee 100644 --- a/connectors/host/host.go +++ b/connectors/host/host.go @@ -26,6 +26,10 @@ type Target struct { // Helpers runs the lookups that walk directories through the root-owned // helpers in target/, so they see what the account alone can't read. Helpers bool `json:"helpers"` + // Paths are the roots lookups may look under. Lookups run no guards and + // may read as root, so a path outside them is refused: an instruction + // injected into an event can't steer the agent into the rest of the host. + Paths []string `json:"paths"` key ssh.PublicKey } @@ -48,6 +52,12 @@ func newHost(cfg connector.Config) (*host, error) { return nil, fmt.Errorf("host %q: host_key: %w", t.Name, err) } t.key = key + for i, root := range t.Paths { + if !path.IsAbs(root) { + return nil, fmt.Errorf("host %q: path root %q must be absolute", t.Name, root) + } + t.Paths[i] = path.Clean(root) + } h.targets[t.Name] = t } pem, pass := cfg.Secrets["ssh.private_key"], cfg.Secrets["ssh.private_key_passphrase"] @@ -102,7 +112,7 @@ func (h *host) Lookup(ctx context.Context, name string, raw jsontext.Value) (jso if !ok { return nil, false, fmt.Errorf("host %q isn't configured", in.Host) } - p, err := checkPath(in.Path) + p, err := checkPath(in.Path, target.Paths) if err != nil { return nil, false, err } @@ -161,15 +171,22 @@ func lookupCommand(name, p string, limit int, olderThan *int, helpers bool) (str // helperDir is where target/install.sh puts the helpers, run through sudo. const helperDir = "sudo -n /usr/local/libexec/archie/" -// checkPath accepts an absolute path with no control characters, cleaned. -func checkPath(p string) (string, error) { +// checkPath accepts an absolute path with no control characters that, once +// cleaned, is one of roots or lies under one. +func checkPath(p string, roots []string) (string, error) { if !path.IsAbs(p) { return "", fmt.Errorf("path %q must be absolute", p) } if strings.ContainsFunc(p, func(r rune) bool { return r < 0x20 || r == 0x7f }) { return "", errors.New("path contains control characters") } - return path.Clean(p), nil + clean := path.Clean(p) + for _, root := range roots { + if clean == root || strings.HasPrefix(clean, strings.TrimSuffix(root, "/")+"/") { + return clean, nil + } + } + return "", fmt.Errorf("path %q is outside this host's lookup paths %v", clean, roots) } // quote makes s one single-quoted shell word. diff --git a/connectors/host/host_test.go b/connectors/host/host_test.go index 5be0028..6df2658 100644 --- a/connectors/host/host_test.go +++ b/connectors/host/host_test.go @@ -5,10 +5,11 @@ import ( "testing" ) -// TestLookupInputCannotEscapeItsArgument guards the host connector's only -// boundary with the remote shell: ssh hands commands to a shell, so a path -// from the model must reach the command as exactly one argument, whatever it -// contains, and a path that isn't absolute or carries control characters is +// TestLookupInputCannotEscapeItsArgument guards the host connector's boundary +// with the remote host: ssh hands commands to a shell, so a path from the +// model must reach the command as exactly one argument, whatever it contains. +// A path that isn't absolute, carries control characters, or lies outside the +// host's lookup roots (where an injected instruction would steer it) is // refused before any command is built. func TestLookupInputCannotEscapeItsArgument(t *testing.T) { tests := []struct { @@ -20,13 +21,16 @@ func TestLookupInputCannotEscapeItsArgument(t *testing.T) { {name: "spaces", path: "/tmp/my dir"}, {name: "single quote breakout", path: "/tmp/x'; printf INJECTED; printf '"}, {name: "command substitution", path: "/tmp/$(printf INJECTED)`printf INJECTED`"}, - {name: "option lookalike", path: "/-rf"}, + {name: "option lookalike", path: "/tmp/-rf"}, {name: "relative path", path: "tmp", refused: true}, {name: "newline", path: "/tmp\n; id", refused: true}, + {name: "outside the roots", path: "/root", refused: true}, + {name: "climbing out of a root", path: "/tmp/../etc/shadow", refused: true}, + {name: "a root's name as a prefix", path: "/tmpfoo", refused: true}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - p, err := checkPath(tt.path) + p, err := checkPath(tt.path, []string{"/tmp", "/var/tmp"}) if tt.refused { if err == nil { t.Fatalf("checkPath(%q) accepted it", tt.path) diff --git a/connectors/host/target/README.md b/connectors/host/target/README.md index 60be7be..04bf92a 100644 --- a/connectors/host/target/README.md +++ b/connectors/host/target/README.md @@ -10,3 +10,6 @@ and run fixed commands: sudo can't safely allow `du` or `find` themselves, since `find` can delete and execute. - The host's public key, as `ssh-keyscan` prints it, in the `hosts` setting. +- The roots lookups may look under, as `paths` in the `hosts` setting (for + example `["/tmp", "/var/tmp"]`). Lookups run no guards and may read as root, + so any path outside them is refused.