mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-22 08:00:54 +08:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7cd9faf1f9 |
+4
-4
@@ -15,12 +15,12 @@ import (
|
||||
func TestArgvAllowKeepsDenyAndTargetGate(t *testing.T) {
|
||||
ic := intercept.New(nil)
|
||||
ic.SetRulesForTest([]db.InterceptRule{
|
||||
{ID: 1, Name: "no force flag", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "string",
|
||||
{ID: 1, Name: "no force push", 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 nmap", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
|
||||
Pattern: `["nmap"]`, Action: "allow"},
|
||||
{ID: 3, Name: "argv allow git push", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
|
||||
Pattern: `["git","push"]`, 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":"nmap --force 10.0.0.1"}`); !block || !strings.Contains(msg, "force push is forbidden") {
|
||||
if block, msg := pre(g, ctx, "Bash", `{"command":"git push --force origin"}`); !block || !strings.Contains(msg, "force push is forbidden") {
|
||||
t.Fatalf("deny over argv allow: block=%v msg=%q", block, msg)
|
||||
}
|
||||
if gate.checks != 0 {
|
||||
|
||||
@@ -27,8 +27,6 @@ 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
|
||||
|
||||
@@ -13,13 +13,12 @@ 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", "curl", "ls", "gh", "x", "7z", "pythonic"} {
|
||||
for _, prog := range []string{"nmap", "git", "/usr/bin/git", "curl", "ls", "gh", "x", "7z", "pythonic"} {
|
||||
if ArgvAllowDenied(prog) {
|
||||
t.Errorf("%q is denied, want allowable", prog)
|
||||
}
|
||||
@@ -31,8 +30,8 @@ func TestAlwaysAllowPrefix(t *testing.T) {
|
||||
b, _ := json.Marshal(map[string]string{"command": cmd})
|
||||
return b
|
||||
}
|
||||
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("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("nmap -p 80 10.0.0.1")); err != nil || !slices.Equal(got, []string{"nmap"}) {
|
||||
t.Fatalf("nmap: %q %v", got, err)
|
||||
@@ -41,10 +40,10 @@ func TestAlwaysAllowPrefix(t *testing.T) {
|
||||
tool string
|
||||
input []byte
|
||||
}{
|
||||
"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")},
|
||||
"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")},
|
||||
"empty": {"Bash", bash("")},
|
||||
"no command": {"Bash", []byte(`{}`)},
|
||||
"not json": {"Bash", []byte(`not json`)},
|
||||
@@ -53,11 +52,6 @@ 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)
|
||||
@@ -65,20 +59,6 @@ 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.
|
||||
|
||||
+1
-9
@@ -25,17 +25,9 @@ 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(key[:n], " ")]; ok {
|
||||
if a, ok := argvArity[strings.Join(tokens[:n], " ")]; ok {
|
||||
return min(a, len(tokens))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 flag", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "regex",
|
||||
{ID: 1, Name: "no force push", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "regex",
|
||||
Pattern: `--force`, Action: "deny"},
|
||||
{ID: 2, Name: "argv allow nmap", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
|
||||
Pattern: `["nmap"]`, Action: "allow"},
|
||||
{ID: 2, Name: "argv allow git push", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
|
||||
Pattern: `["git","push"]`, Action: "allow"},
|
||||
})
|
||||
dec, ok := ic.Match("Bash", []byte(`{"command":"nmap --force 10.0.0.1"}`))
|
||||
dec, ok := ic.Match("Bash", []byte(`{"command":"git push --force"}`))
|
||||
if !ok || dec.Action != "deny" || dec.RuleID != 1 {
|
||||
t.Fatalf("force flag: %+v %v, want the deny rule", dec, ok)
|
||||
t.Fatalf("force push: %+v %v, want the deny rule", dec, ok)
|
||||
}
|
||||
dec, ok = ic.Match("Bash", []byte(`{"command":"nmap 10.0.0.1"}`))
|
||||
dec, ok = ic.Match("Bash", []byte(`{"command":"git push origin"}`))
|
||||
if !ok || dec.Action != "allow" || dec.RuleID != 2 {
|
||||
t.Fatalf("nmap: %+v %v, want the argv allow", dec, ok)
|
||||
t.Fatalf("push: %+v %v, want the argv allow", dec, ok)
|
||||
}
|
||||
if _, ok := ic.Match("Bash", []byte(`{"command":"nmap 10.0.0.1; id"}`)); ok {
|
||||
if _, ok := ic.Match("Bash", []byte(`{"command":"git push; id"}`)); ok {
|
||||
t.Fatal("a compound command matched the argv rule")
|
||||
}
|
||||
if _, ok := compileRule(db.InterceptRule{MatchType: "argv", Pattern: `["-x"]`}); ok {
|
||||
|
||||
+87
-11
@@ -17,6 +17,7 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
@@ -101,6 +102,66 @@ 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
|
||||
@@ -117,7 +178,11 @@ func New(ctx context.Context, server, url string, headers map[string]string, ins
|
||||
if timeoutSeconds > 0 {
|
||||
timeout = time.Duration(timeoutSeconds) * time.Second
|
||||
}
|
||||
hc := &http.Client{Timeout: timeout}
|
||||
base, err := parseMCPURL(url)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
hc := &http.Client{Timeout: timeout, CheckRedirect: redirectPolicy(base)}
|
||||
if insecure {
|
||||
hc.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
|
||||
}
|
||||
@@ -142,7 +207,11 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
hc := &http.Client{} // the SSE stream is intentionally long-lived.
|
||||
base, err := parseMCPURL(sseURL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
hc := &http.Client{CheckRedirect: redirectPolicy(base)} // the SSE stream is intentionally long-lived.
|
||||
if insecure {
|
||||
hc.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
|
||||
}
|
||||
@@ -167,7 +236,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, sseURL)
|
||||
endpoint, err := readSSEEndpoint(reader, base)
|
||||
if err != nil {
|
||||
resp.Body.Close()
|
||||
cancel()
|
||||
@@ -195,7 +264,11 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func readSSEEndpoint(r *bufio.Reader, base string) (string, error) {
|
||||
// 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) {
|
||||
for {
|
||||
line, err := r.ReadString('\n')
|
||||
if err != nil {
|
||||
@@ -213,14 +286,17 @@ func readSSEEndpoint(r *bufio.Reader, base string) (string, error) {
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("mcp sse endpoint URL: %w", err)
|
||||
}
|
||||
if !u.IsAbs() {
|
||||
b, err := url.Parse(base)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
candidate = b.ResolveReference(u).String()
|
||||
if u.User != nil {
|
||||
return "", errors.New("mcp sse endpoint must not carry userinfo")
|
||||
}
|
||||
return candidate, nil
|
||||
abs := u
|
||||
if !u.IsAbs() {
|
||||
abs = base.ResolveReference(u)
|
||||
}
|
||||
if !sameOrigin(base, abs) {
|
||||
return "", fmt.Errorf("mcp sse endpoint %q is not on the configured origin", abs.Redacted())
|
||||
}
|
||||
return abs.String(), nil
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,11 +1,13 @@
|
||||
package mcphttp
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
@@ -105,3 +107,134 @@ 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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@ import (
|
||||
)
|
||||
|
||||
func TestValidateArgvRuleReq(t *testing.T) {
|
||||
base := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: `["nmap"]`, Action: "allow"}
|
||||
base := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: `["git","push"]`, 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 = `["nmap","-C"]` },
|
||||
"flag token": func(r *interceptRuleReq) { r.Pattern = `["git","-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"]`, `["git","push"]`, `["cmake"]`} {
|
||||
for _, pattern := range []string{`["python"]`, `["python3.11"]`, `["/usr/bin/env"]`, `["find"]`, `["docker","run"]`} {
|
||||
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"]`, `["curl"]`} {
|
||||
for _, pattern := range []string{`["nmap"]`, `["git","push"]`} {
|
||||
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)
|
||||
|
||||
Reference in New Issue
Block a user