mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-20 15:11:01 +08:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7cd9faf1f9 |
+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)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user