The workspace app proxy stripped Coder cookies before forwarding a request to the app, but not the `Coder-Session-Token` header or the `coder_session_token` query parameter. App auth accepts both, so a client that authenticated that way (the CLI and codersdk, or an IDE extension pointed at a path app URL) passed its API key through to whatever runs behind the app. That matters most for shared apps and ports, where the caller's token reached a workspace owned by someone else. This strips both before proxying. The query parameter is removed from the raw query string, so everything else in the query reaches the app byte-for-byte. `Authorization` and `access_token` are still forwarded since apps can use them for their own auth. Stripping those safely needs to know which credential Coder actually used, so that's tracked in [CORE-817](https://linear.app/codercom/issue/CORE-817/strip-authorization-and-access-token-from-app-proxy-requests-when). This is marked breaking because an app that relied on the caller's Coder token arriving through that header or query param won't get it anymore. Cookie-authenticated requests were already covered, so this only affects callers that send the token in that header or query param. Nothing in this repo depends on it. Apps that need to call the Coder API as the visitor should use the OAuth2 provider instead. Covered by the shared app proxy tests, which run against coderd and wsproxy, for both the owner on a path app and another user on a shared subdomain app, plus unit tests for the query filtering. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
269 lines
9.4 KiB
Go
269 lines
9.4 KiB
Go
package workspaceapps
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"cdr.dev/slog/v3"
|
|
"cdr.dev/slog/v3/sloggers/slogjson"
|
|
"github.com/coder/coder/v2/coderd/httpapi"
|
|
"github.com/coder/coder/v2/coderd/tracing"
|
|
"github.com/coder/coder/v2/coderd/workspaceapps/appurl"
|
|
"github.com/coder/coder/v2/codersdk/workspacesdk"
|
|
"github.com/coder/coder/v2/testutil"
|
|
"github.com/coder/quartz"
|
|
"github.com/coder/websocket"
|
|
)
|
|
|
|
// Test_originLocalURL checks that originLocalURL produces a redirect target that
|
|
// stays on the current origin.
|
|
func Test_originLocalURL(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("RejectsOffOrigin", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Each path models an already-percent-decoded r.URL.Path that tries to
|
|
// smuggle a separate host into the redirect.
|
|
cases := []struct {
|
|
name string
|
|
path string
|
|
}{
|
|
{name: "DoubleSlash", path: "//evil.com/phish"},
|
|
{name: "TripleSlash", path: "///evil.com/phish"},
|
|
{name: "SlashBackslash", path: "/\\evil.com/phish"},
|
|
{name: "SlashBackslashSlash", path: "/\\/evil.com/phish"},
|
|
{name: "DoubleBackslash", path: "\\\\evil.com/phish"},
|
|
{name: "SlashTab", path: "/\t/evil.com/phish"},
|
|
{name: "SlashTabBackslash", path: "/\t\\evil.com/phish"},
|
|
{name: "SlashNewline", path: "/\n/evil.com/phish"},
|
|
{name: "SlashCarriageReturn", path: "/\r/evil.com/phish"},
|
|
{name: "SlashTabDoubleSlash", path: "/\t//evil.com/phish"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
loc := originLocalURL(tc.path).String()
|
|
|
|
// The Location must parse as a relative, same-origin reference.
|
|
require.Falsef(t, strings.HasPrefix(loc, "//"),
|
|
"path %q produced scheme-relative Location %q", tc.path, loc)
|
|
parsed, err := url.Parse(loc)
|
|
require.NoErrorf(t, err, "path %q produced unparseable Location %q", tc.path, loc)
|
|
require.Emptyf(t, parsed.Scheme, "path %q produced Location %q with a scheme", tc.path, loc)
|
|
require.Emptyf(t, parsed.Host, "path %q produced Location %q with a host", tc.path, loc)
|
|
|
|
// It must also be free of raw bytes a browser would normalize back
|
|
// into an authority before resolving (a backslash becomes "/", and
|
|
// tab/newline/CR are stripped, either of which could re-form
|
|
// "//host"). url.URL.String() guarantees this by percent-encoding
|
|
// them; we assert it here rather than reproducing browser
|
|
// normalization in the code.
|
|
for _, raw := range []string{`\`, "\t", "\n", "\r"} {
|
|
require.NotContainsf(t, loc, raw,
|
|
"path %q produced Location %q containing a raw %q", tc.path, loc, raw)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("EscapesControlCharacters", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// A redirect built from a path containing a raw control character is an
|
|
// open redirect: http.Redirect emits it verbatim (url.Parse rejects the
|
|
// control byte and skips cleaning) and browsers strip tab/newline/CR
|
|
// before resolving, re-forming "//evil.com". originLocalURL percent-encodes
|
|
// each one. Assert every class is escaped so a future change that breaks
|
|
// encoding for only one class is caught.
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "Tab", in: "/\t/evil.com", want: "/%09/evil.com"},
|
|
{name: "Newline", in: "/\n/evil.com", want: "/%0A/evil.com"},
|
|
{name: "CarriageReturn", in: "/\r/evil.com", want: "/%0D/evil.com"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.Equalf(t, tc.want, originLocalURL(tc.in).String(),
|
|
"originLocalURL(%q) must percent-encode the control character", tc.in)
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("PreservesLegitPaths", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "Empty", in: "", want: "/"},
|
|
{name: "Root", in: "/", want: "/"},
|
|
{name: "Simple", in: "/test", want: "/test"},
|
|
{name: "Nested", in: "/app/sub/page", want: "/app/sub/page"},
|
|
{name: "PathApp", in: "/@user/ws/apps/app", want: "/@user/ws/apps/app"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.Equalf(t, tc.want, originLocalURL(tc.in).String(), "originLocalURL(%q)", tc.in)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
// fakeTokenProvider returns the same token for every request.
|
|
type fakeTokenProvider struct {
|
|
token *SignedToken
|
|
}
|
|
|
|
func (p fakeTokenProvider) FromRequest(*http.Request) (*SignedToken, bool) {
|
|
return p.token, true
|
|
}
|
|
|
|
func (fakeTokenProvider) Issue(context.Context, http.ResponseWriter, *http.Request, IssueTokenRequest) (*SignedToken, string, bool) {
|
|
panic("unexpected Issue call")
|
|
}
|
|
|
|
// unreachableAgentProvider fails every AgentConn with AgentUnreachableError.
|
|
type unreachableAgentProvider struct {
|
|
fields []slog.Field
|
|
}
|
|
|
|
func (unreachableAgentProvider) ReverseProxy(*url.URL, *url.URL, uuid.UUID, appurl.ApplicationURL, string) *httputil.ReverseProxy {
|
|
panic("unexpected ReverseProxy call")
|
|
}
|
|
|
|
func (p unreachableAgentProvider) AgentConn(context.Context, uuid.UUID) (workspacesdk.AgentConn, func(), error) {
|
|
return nil, nil, &AgentUnreachableError{Fields: p.fields}
|
|
}
|
|
|
|
func (unreachableAgentProvider) ServeHTTPDebug(http.ResponseWriter, *http.Request) {}
|
|
|
|
func (unreachableAgentProvider) Close() error { return nil }
|
|
|
|
func TestWorkspaceAgentPTY_AgentUnreachable(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
|
|
logs := testutil.NewWaitBuffer()
|
|
logger := slog.Make(slogjson.Sink(logs)).Leveled(slog.LevelDebug)
|
|
|
|
agentID := uuid.New()
|
|
basePath := fmt.Sprintf("/api/v2/workspaceagents/%s/pty", agentID)
|
|
accessURL, err := url.Parse("http://coder.test")
|
|
require.NoError(t, err)
|
|
|
|
s := NewServer(ServerOptions{
|
|
Logger: logger,
|
|
DashboardURL: accessURL,
|
|
AccessURL: accessURL,
|
|
SignedTokenProvider: fakeTokenProvider{token: &SignedToken{
|
|
Request: Request{
|
|
AccessMethod: AccessMethodTerminal,
|
|
BasePath: basePath,
|
|
AgentNameOrID: agentID.String(),
|
|
},
|
|
AgentID: agentID,
|
|
}},
|
|
AgentProvider: unreachableAgentProvider{fields: []slog.Field{
|
|
slog.F("agent_id", agentID),
|
|
slog.F("reason", "no_node"),
|
|
}},
|
|
WSWatcher: httpapi.NewWSWatcher(quartz.NewReal(), nil),
|
|
})
|
|
r := chi.NewRouter()
|
|
r.Use(tracing.StatusWriterMiddleware, tracing.Middleware(nil, tracing.DefaultRoutePatterns, "coderd"))
|
|
r.Get("/api/v2/workspaceagents/{workspaceagent}/pty", s.workspaceAgentPTY)
|
|
srv := httptest.NewServer(r)
|
|
t.Cleanup(srv.Close)
|
|
|
|
wsURL := "ws" + strings.TrimPrefix(srv.URL, "http") + basePath + "?reconnect=" + uuid.NewString()
|
|
conn, _, err := websocket.Dial(ctx, wsURL, nil) //nolint:bodyclose // The response body is nil after a successful upgrade.
|
|
require.NoError(t, err)
|
|
defer conn.Close(websocket.StatusNormalClosure, "")
|
|
|
|
// The handler closes the socket once the dial fails.
|
|
_, _, err = conn.Read(ctx)
|
|
var closeErr websocket.CloseError
|
|
require.ErrorAs(t, err, &closeErr)
|
|
require.Equal(t, websocket.StatusInternalError, closeErr.Code)
|
|
require.Contains(t, closeErr.Reason, "agent is unreachable")
|
|
|
|
var found bool
|
|
for _, line := range strings.Split(strings.TrimSpace(logs.String()), "\n") {
|
|
var entry struct {
|
|
Level string `json:"level"`
|
|
Msg string `json:"msg"`
|
|
Fields map[string]any `json:"fields"`
|
|
}
|
|
require.NoError(t, json.Unmarshal([]byte(line), &entry), line)
|
|
if entry.Msg != "agent is unreachable" {
|
|
continue
|
|
}
|
|
found = true
|
|
require.Equal(t, "WARN", entry.Level)
|
|
require.Equal(t, agentID.String(), entry.Fields["agent_id"])
|
|
require.Equal(t, "no_node", entry.Fields["reason"])
|
|
}
|
|
require.True(t, found, "no agent is unreachable log line")
|
|
}
|
|
|
|
func Test_stripQueryParam(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const key = "coder_session_token"
|
|
cases := []struct {
|
|
name string
|
|
rawQuery string
|
|
want string
|
|
wantRemoved bool
|
|
}{
|
|
{name: "Empty", rawQuery: "", want: ""},
|
|
{name: "NoMatch", rawQuery: "b=2&a=1&c=%2C", want: "b=2&a=1&c=%2C"},
|
|
{name: "First", rawQuery: "coder_session_token=K&b=2&a=1", want: "b=2&a=1", wantRemoved: true},
|
|
{name: "Middle", rawQuery: "b=2&coder_session_token=K&a=1", want: "b=2&a=1", wantRemoved: true},
|
|
{name: "Last", rawQuery: "b=2&a=1&coder_session_token=K", want: "b=2&a=1", wantRemoved: true},
|
|
{name: "Only", rawQuery: "coder_session_token=K", want: "", wantRemoved: true},
|
|
{name: "Duplicates", rawQuery: "coder_session_token=K1&b=2&coder_session_token=K2&a=1", want: "b=2&a=1", wantRemoved: true},
|
|
{name: "PercentEncodedKey", rawQuery: "a=1&coder%5Fsession%5Ftoken=K", want: "a=1", wantRemoved: true},
|
|
{name: "ValueWithSemicolon", rawQuery: "coder_session_token=K;&view=1", want: "view=1", wantRemoved: true},
|
|
{name: "KeyWithoutEquals", rawQuery: "a=1&coder_session_token&b=2", want: "a=1&b=2", wantRemoved: true},
|
|
{name: "UnparseableFieldsKept", rawQuery: "filter=a;b&coder_session_token=K&bad=%zz&%zz=1", want: "filter=a;b&bad=%zz&%zz=1", wantRemoved: true},
|
|
{name: "EmptyFieldsKept", rawQuery: "a=1&&b=2&coder_session_token=K&", want: "a=1&&b=2&", wantRemoved: true},
|
|
{name: "SimilarKeysKept", rawQuery: "xcoder_session_token=1&coder_session_token_extra=1", want: "xcoder_session_token=1&coder_session_token_extra=1"},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, removed := stripQueryParam(tc.rawQuery, key)
|
|
require.Equal(t, tc.want, got)
|
|
require.Equal(t, tc.wantRemoved, removed)
|
|
})
|
|
}
|
|
}
|