Compare commits

..
Author SHA1 Message Date
BaaRai 02a67bf9c5 fix(intercept): deny always-allow for git, cmake, ctest and cpack
The argv allow denylist is the only gate that stops an always-allow rule
from naming a program whose flags can run arbitrary commands. git (aliases,
hooks, -c), cmake (-P), ctest and cpack run commands from user-controlled
files, so an allow prefix for them is never safe. Also key the arity table
by the normalised program name so a path-qualified binary derives the same
prefix length as the bare name.
2026-11-20 01:23:45 +01:00
8 changed files with 64 additions and 243 deletions
+4 -4
View File
@@ -15,12 +15,12 @@ import (
func TestArgvAllowKeepsDenyAndTargetGate(t *testing.T) {
ic := intercept.New(nil)
ic.SetRulesForTest([]db.InterceptRule{
{ID: 1, Name: "no force push", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "string",
{ID: 1, Name: "no force flag", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "string",
Pattern: "--force", Action: "deny", Message: "force push is forbidden"},
{ID: 2, Name: "argv allow curl", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["curl"]`, Action: "allow"},
{ID: 3, Name: "argv allow git push", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["git","push"]`, Action: "allow"},
{ID: 3, Name: "argv allow nmap", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["nmap"]`, Action: "allow"},
})
g := NewWithInterceptor(ic)
gate := &fakeGate{t: t, check: unpinnedOnce, request: func(int, []intercept.TargetRequest, *intercept.Decision) intercept.TargetResult {
@@ -29,7 +29,7 @@ func TestArgvAllowKeepsDenyAndTargetGate(t *testing.T) {
g.gate = gate
ctx := gateOn(context.Background(), "7", time.Minute)
if block, msg := pre(g, ctx, "Bash", `{"command":"git push --force origin"}`); !block || !strings.Contains(msg, "force push is forbidden") {
if block, msg := pre(g, ctx, "Bash", `{"command":"nmap --force 10.0.0.1"}`); !block || !strings.Contains(msg, "force push is forbidden") {
t.Fatalf("deny over argv allow: block=%v msg=%q", block, msg)
}
if gate.checks != 0 {
+2
View File
@@ -27,6 +27,8 @@ var alwaysAllowDenylist = func() map[string]bool {
// package managers and build tools: run package scripts and hooks
"npm npx pnpm yarn bunx corepack pip pipx uv uvx poetry conda composer gem bundle bundler rake cargo go " +
"mvn gradle dotnet apt apt-get dpkg dnf yum rpm pacman apk brew snap flatpak",
// version control and build generators: run hooks, aliases and script files
"git cmake ctest cpack",
// orchestration: run images, playbooks and plans
"docker docker-compose podman nerdctl kubectl helm ansible ansible-playbook terraform pulumi vagrant",
// destructive
+27 -7
View File
@@ -13,12 +13,13 @@ func TestArgvAllowDenylist(t *testing.T) {
"python", "python3", "python3.11", "/usr/bin/python3.11", "php8.2", "ruby3.2", "perl5", "pip3",
"env", "/usr/bin/env", "bash", "/bin/sh", "find", "rm", "mkfs", "mkfs.ext4", "/sbin/mkfs.xfs",
"docker", "kubectl", "npm", "sudo", "xargs", "Rscript", ".",
"git", "/usr/bin/git", "cmake", "cmake3", "/usr/bin/cmake", "ctest", "cpack",
} {
if !ArgvAllowDenied(prog) {
t.Errorf("%q is not denied", prog)
}
}
for _, prog := range []string{"nmap", "git", "/usr/bin/git", "curl", "ls", "gh", "x", "7z", "pythonic"} {
for _, prog := range []string{"nmap", "curl", "ls", "gh", "x", "7z", "pythonic"} {
if ArgvAllowDenied(prog) {
t.Errorf("%q is denied, want allowable", prog)
}
@@ -30,8 +31,8 @@ func TestAlwaysAllowPrefix(t *testing.T) {
b, _ := json.Marshal(map[string]string{"command": cmd})
return b
}
if got, err := AlwaysAllowPrefix("Bash", bash("git push --force origin main")); err != nil || !slices.Equal(got, []string{"git", "push"}) {
t.Fatalf("git push: %q %v", got, err)
if got, err := AlwaysAllowPrefix("Bash", bash("gh pr list --limit 5")); err != nil || !slices.Equal(got, []string{"gh", "pr", "list"}) {
t.Fatalf("gh pr list: %q %v", got, err)
}
if got, err := AlwaysAllowPrefix("Bash", bash("nmap -p 80 10.0.0.1")); err != nil || !slices.Equal(got, []string{"nmap"}) {
t.Fatalf("nmap: %q %v", got, err)
@@ -40,10 +41,10 @@ func TestAlwaysAllowPrefix(t *testing.T) {
tool string
input []byte
}{
"not Bash": {"shell_open", bash("git push")},
"compound": {"Bash", bash("git push; id")},
"substitution": {"Bash", bash("git push $(id)")},
"redirection": {"Bash", bash("git push > out")},
"not Bash": {"shell_open", bash("gh pr list")},
"compound": {"Bash", bash("gh pr list; id")},
"substitution": {"Bash", bash("gh pr list $(id)")},
"redirection": {"Bash", bash("gh pr list > out")},
"empty": {"Bash", bash("")},
"no command": {"Bash", []byte(`{}`)},
"not json": {"Bash", []byte(`not json`)},
@@ -52,6 +53,11 @@ func TestAlwaysAllowPrefix(t *testing.T) {
"find": {"Bash", bash("find . -exec sh -c id ;")},
"rm": {"Bash", bash("rm -rf /")},
"docker": {"Bash", bash("docker run --privileged x")},
"git": {"Bash", bash("git status")},
"path to git": {"Bash", bash("/usr/bin/git status")},
"git config": {"Bash", bash("git config user.name x")},
"cmake": {"Bash", bash("cmake --version")},
"ctest": {"Bash", bash("ctest -N")},
} {
if got, err := AlwaysAllowPrefix(c.tool, c.input); err == nil {
t.Errorf("%s: prefix %q, want a refusal", name, got)
@@ -59,6 +65,20 @@ func TestAlwaysAllowPrefix(t *testing.T) {
}
}
// The arity table is keyed by program name, so a path-qualified binary derives
// the same prefix length as the bare name.
func TestArgvPrefixLenUsesBasename(t *testing.T) {
if got := argvPrefixLen([]string{"/usr/bin/gh", "pr", "list"}); got != 3 {
t.Errorf("path-qualified gh prefix length = %d, want 3", got)
}
if got := argvPrefixLen([]string{"/usr/bin/git", "status"}); got != 2 {
t.Errorf("path-qualified git prefix length = %d, want 2", got)
}
if got, err := ArgvPrefix("/usr/bin/gh pr list"); err != nil || !slices.Equal(got, []string{"/usr/bin/gh", "pr", "list"}) {
t.Errorf("path-qualified gh prefix = %q, %v", got, err)
}
}
// The denylist neutralises argv allow rules at matching time (a rule created
// before the denylist, or written straight into the database), and only them:
// an argv deny or ask rule for the same program still matches.
+9 -1
View File
@@ -25,9 +25,17 @@ var argvArity = map[string]int{
}
// argvPrefixLen returns the number of leading tokens that form the prefix.
// The arity table is keyed by program name, so a path-qualified binary
// (/usr/bin/git) uses the same arity as the bare name.
func argvPrefixLen(tokens []string) int {
if len(tokens) == 0 {
return 0
}
key := make([]string, len(tokens))
copy(key, tokens)
key[0] = argvProgramName(tokens[0])
for n := len(tokens); n > 0; n-- {
if a, ok := argvArity[strings.Join(tokens[:n], " ")]; ok {
if a, ok := argvArity[strings.Join(key[:n], " ")]; ok {
return min(a, len(tokens))
}
}
+8 -8
View File
@@ -214,20 +214,20 @@ func TestParseArgvPattern(t *testing.T) {
func TestArgvAllowBelowDeny(t *testing.T) {
ic := New(nil)
ic.SetRulesForTest([]db.InterceptRule{
{ID: 1, Name: "no force push", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "regex",
{ID: 1, Name: "no force flag", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "regex",
Pattern: `--force`, Action: "deny"},
{ID: 2, Name: "argv allow git push", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["git","push"]`, Action: "allow"},
{ID: 2, Name: "argv allow nmap", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["nmap"]`, Action: "allow"},
})
dec, ok := ic.Match("Bash", []byte(`{"command":"git push --force"}`))
dec, ok := ic.Match("Bash", []byte(`{"command":"nmap --force 10.0.0.1"}`))
if !ok || dec.Action != "deny" || dec.RuleID != 1 {
t.Fatalf("force push: %+v %v, want the deny rule", dec, ok)
t.Fatalf("force flag: %+v %v, want the deny rule", dec, ok)
}
dec, ok = ic.Match("Bash", []byte(`{"command":"git push origin"}`))
dec, ok = ic.Match("Bash", []byte(`{"command":"nmap 10.0.0.1"}`))
if !ok || dec.Action != "allow" || dec.RuleID != 2 {
t.Fatalf("push: %+v %v, want the argv allow", dec, ok)
t.Fatalf("nmap: %+v %v, want the argv allow", dec, ok)
}
if _, ok := ic.Match("Bash", []byte(`{"command":"git push; id"}`)); ok {
if _, ok := ic.Match("Bash", []byte(`{"command":"nmap 10.0.0.1; id"}`)); ok {
t.Fatal("a compound command matched the argv rule")
}
if _, ok := compileRule(db.InterceptRule{MatchType: "argv", Pattern: `["-x"]`}); ok {
+10 -86
View File
@@ -17,7 +17,6 @@ import (
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"strings"
@@ -102,66 +101,6 @@ func normalizeHeaders(headers map[string]string) (map[string]string, error) {
return out, nil
}
// originKey returns the scheme, host and effective port of u, in a form two
// URLs can be compared with. Empty means u is not an absolute http(s) URL with
// a host.
func originKey(u *url.URL) string {
if u == nil {
return ""
}
scheme := strings.ToLower(u.Scheme)
var port string
switch scheme {
case "http":
port = "80"
case "https":
port = "443"
default:
return ""
}
host := strings.ToLower(u.Hostname())
if host == "" {
return ""
}
if p := u.Port(); p != "" {
port = p
}
return scheme + "://" + net.JoinHostPort(host, port)
}
// sameOrigin reports whether u has the same scheme, host and effective port as
// base.
func sameOrigin(base, u *url.URL) bool {
key := originKey(base)
return key != "" && key == originKey(u)
}
// redirectPolicy refuses a redirect that leaves the origin of the configured
// endpoint, so a remote MCP server cannot retarget authenticated requests.
func redirectPolicy(base *url.URL) func(*http.Request, []*http.Request) error {
return func(req *http.Request, via []*http.Request) error {
if len(via) >= 10 {
return errors.New("mcp: stopped after 10 redirects")
}
if !sameOrigin(base, req.URL) {
return fmt.Errorf("mcp: refusing a redirect to another origin: %s", req.URL.Redacted())
}
return nil
}
}
// parseMCPURL parses and validates a configured MCP endpoint URL.
func parseMCPURL(raw string) (*url.URL, error) {
u, err := url.Parse(raw)
if err != nil {
return nil, fmt.Errorf("mcp url: %w", err)
}
if originKey(u) == "" {
return nil, fmt.Errorf("mcp url must be an absolute http or https URL with a host: %q", raw)
}
return u, nil
}
// New connects to a remote MCP endpoint and performs the initialize handshake.
// headers are sent on every request (Authorization, custom API keys, …).
// When insecure is true, TLS certificate verification is skipped so servers that
@@ -178,11 +117,7 @@ func New(ctx context.Context, server, url string, headers map[string]string, ins
if timeoutSeconds > 0 {
timeout = time.Duration(timeoutSeconds) * time.Second
}
base, err := parseMCPURL(url)
if err != nil {
return nil, err
}
hc := &http.Client{Timeout: timeout, CheckRedirect: redirectPolicy(base)}
hc := &http.Client{Timeout: timeout}
if insecure {
hc.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
}
@@ -207,11 +142,7 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
if err != nil {
return nil, err
}
base, err := parseMCPURL(sseURL)
if err != nil {
return nil, err
}
hc := &http.Client{CheckRedirect: redirectPolicy(base)} // the SSE stream is intentionally long-lived.
hc := &http.Client{} // the SSE stream is intentionally long-lived.
if insecure {
hc.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
}
@@ -236,7 +167,7 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
return nil, fmt.Errorf("mcp sse http %d: %s", resp.StatusCode, readSnippet(resp.Body))
}
reader := bufio.NewReader(resp.Body)
endpoint, err := readSSEEndpoint(reader, base)
endpoint, err := readSSEEndpoint(reader, sseURL)
if err != nil {
resp.Body.Close()
cancel()
@@ -264,11 +195,7 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
return c, nil
}
// readSSEEndpoint reads the message endpoint announced by the SSE stream. The
// endpoint must stay on the origin of the configured SSE URL: the POSTs that
// follow carry the operator's headers, and a remote server must not be able to
// retarget them.
func readSSEEndpoint(r *bufio.Reader, base *url.URL) (string, error) {
func readSSEEndpoint(r *bufio.Reader, base string) (string, error) {
for {
line, err := r.ReadString('\n')
if err != nil {
@@ -286,17 +213,14 @@ func readSSEEndpoint(r *bufio.Reader, base *url.URL) (string, error) {
if err != nil {
return "", fmt.Errorf("mcp sse endpoint URL: %w", err)
}
if u.User != nil {
return "", errors.New("mcp sse endpoint must not carry userinfo")
}
abs := u
if !u.IsAbs() {
abs = base.ResolveReference(u)
b, err := url.Parse(base)
if err != nil {
return "", err
}
candidate = b.ResolveReference(u).String()
}
if !sameOrigin(base, abs) {
return "", fmt.Errorf("mcp sse endpoint %q is not on the configured origin", abs.Redacted())
}
return abs.String(), nil
return candidate, nil
}
}
-133
View File
@@ -1,13 +1,11 @@
package mcphttp
import (
"bufio"
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"testing"
@@ -107,134 +105,3 @@ func TestLegacySSEClientDiscoverAndCall(t *testing.T) {
t.Fatalf("Call() = %q, %v", got, err)
}
}
func TestReadSSEEndpointSameOrigin(t *testing.T) {
base, err := url.Parse("https://mcp.example.com:8443/sse")
if err != nil {
t.Fatal(err)
}
read := func(line string) (string, error) {
stream := "event: endpoint\ndata: " + line + "\n\n"
return readSSEEndpoint(bufio.NewReader(strings.NewReader(stream)), base)
}
for _, line := range []string{
"/message?sessionId=1",
"https://mcp.example.com:8443/message",
"HTTPS://MCP.EXAMPLE.COM:8443/message",
"//mcp.example.com:8443/message",
} {
got, err := read(line)
if err != nil {
t.Errorf("%q: %v", line, err)
continue
}
u, err := url.Parse(got)
if err != nil || !sameOrigin(base, u) {
t.Errorf("%q: resolved to %q, not the configured origin", line, got)
}
}
for _, line := range []string{
"https://evil.example/message",
"http://mcp.example.com:8443/message",
"https://mcp.example.com:444/message",
"//evil.example/message",
"http://user:pass@mcp.example.com:8443/message",
"ftp://mcp.example.com/message",
} {
if got, err := read(line); err == nil {
t.Errorf("%q: accepted as %q, want a refusal", line, got)
}
}
}
func TestReadSSEEndpointDefaultPort(t *testing.T) {
base, err := url.Parse("https://mcp.example.com/sse")
if err != nil {
t.Fatal(err)
}
stream := "data: https://mcp.example.com:443/message\n\n"
if _, err := readSSEEndpoint(bufio.NewReader(strings.NewReader(stream)), base); err != nil {
t.Fatalf("explicit default port refused: %v", err)
}
}
func TestParseMCPURL(t *testing.T) {
for _, raw := range []string{"ftp://x/y", "not-a-url", "http:///nohost", ""} {
if _, err := parseMCPURL(raw); err == nil {
t.Errorf("%q accepted, want a refusal", raw)
}
}
for _, raw := range []string{"http://x/y", "https://x:8443/y"} {
if _, err := parseMCPURL(raw); err != nil {
t.Errorf("%q refused: %v", raw, err)
}
}
}
func TestLegacySSERefusesCrossOriginEndpoint(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
fmt.Fprint(w, "event: endpoint\ndata: http://evil.invalid/message\n\n")
w.(http.Flusher).Flush()
<-r.Context().Done()
}))
defer srv.Close()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if _, err := NewSSE(ctx, "test", srv.URL+"/sse", nil, false); err == nil {
t.Fatal("cross-origin SSE endpoint accepted")
}
}
func TestMCPClientRefusesCrossOriginRedirect(t *testing.T) {
var hits int
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hits++
}))
defer target.Close()
src := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, target.URL+"/steal", http.StatusFound)
}))
defer src.Close()
base, err := url.Parse(src.URL + "/sse")
if err != nil {
t.Fatal(err)
}
hc := &http.Client{CheckRedirect: redirectPolicy(base)}
resp, err := hc.Get(src.URL + "/sse")
if err == nil {
resp.Body.Close()
t.Fatal("cross-origin redirect accepted")
}
if hits != 0 {
t.Fatalf("redirect target was reached %d times", hits)
}
}
func TestMCPClientAllowsSameOriginRedirect(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/sse", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/sse2", http.StatusFound)
})
mux.HandleFunc("/sse2", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
srv := httptest.NewServer(mux)
defer srv.Close()
base, err := url.Parse(srv.URL + "/sse")
if err != nil {
t.Fatal(err)
}
hc := &http.Client{CheckRedirect: redirectPolicy(base)}
resp, err := hc.Get(srv.URL + "/sse")
if err != nil {
t.Fatalf("same-origin redirect refused: %v", err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("status %d", resp.StatusCode)
}
}
+4 -4
View File
@@ -7,7 +7,7 @@ import (
)
func TestValidateArgvRuleReq(t *testing.T) {
base := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: `["git","push"]`, Action: "allow"}
base := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: `["nmap"]`, Action: "allow"}
if err := validateInterceptRuleReq(base); err != nil {
t.Fatalf("valid argv rule refused: %v", err)
}
@@ -15,7 +15,7 @@ func TestValidateArgvRuleReq(t *testing.T) {
"tool_name target": func(r *interceptRuleReq) { r.MatchTarget = "tool_name" },
"empty pattern": func(r *interceptRuleReq) { r.Pattern = "" },
"empty token": func(r *interceptRuleReq) { r.Pattern = `["git",""]` },
"flag token": func(r *interceptRuleReq) { r.Pattern = `["git","-C"]` },
"flag token": func(r *interceptRuleReq) { r.Pattern = `["nmap","-C"]` },
"metacharacter": func(r *interceptRuleReq) { r.Pattern = `["nmap;id"]` },
"nine tokens": func(r *interceptRuleReq) { r.Pattern = `["a","b","c","d","e","f","g","h","i"]` },
"not an array": func(r *interceptRuleReq) { r.Pattern = `git push` },
@@ -31,7 +31,7 @@ func TestValidateArgvRuleReq(t *testing.T) {
// The manual rule form refuses an argv allow rule for a denylisted program,
// with the message of the "always allow" endpoint; deny and ask stay creatable.
func TestValidateArgvAllowDenylist(t *testing.T) {
for _, pattern := range []string{`["python"]`, `["python3.11"]`, `["/usr/bin/env"]`, `["find"]`, `["docker","run"]`} {
for _, pattern := range []string{`["python"]`, `["python3.11"]`, `["/usr/bin/env"]`, `["find"]`, `["docker","run"]`, `["git","push"]`, `["cmake"]`} {
req := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: pattern, Action: "allow"}
tokens, _ := intercept.ParseArgvPattern(pattern)
want := intercept.CheckArgvAllow(tokens)
@@ -45,7 +45,7 @@ func TestValidateArgvAllowDenylist(t *testing.T) {
}
}
}
for _, pattern := range []string{`["nmap"]`, `["git","push"]`} {
for _, pattern := range []string{`["nmap"]`, `["curl"]`} {
req := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: pattern, Action: "allow"}
if err := validateInterceptRuleReq(req); err != nil {
t.Errorf("allow %s refused: %v", pattern, err)