package server import ( "encoding/json" "net/http" "net/http/httptest" "testing" ) func TestBrowserMutationOrigins(t *testing.T) { for _, tc := range []struct { name, method, origin, site, referer, authorization string cookie, allow bool }{ {"same_origin", "POST", "https://wiki.example", "same-origin", "", "", true, true}, {"legacy_same_origin", "POST", "https://wiki.example", "", "", "", true, true}, {"legacy_cross_scheme", "POST", "http://wiki.example", "", "", "", true, false}, {"legacy_cross_scheme_login", "POST", "http://wiki.example", "", "", "", false, false}, {"origin_is_not_url_path", "POST", "https://wiki.example/path", "", "", "", true, false}, {"foreign_origin", "POST", "https://evil.example", "cross-site", "", "", true, false}, {"sibling_is_not_trusted", "POST", "https://sibling.wiki.example", "same-site", "", "", true, false}, {"null_origin", "POST", "null", "", "", "", true, false}, {"no_origin_cookie", "POST", "", "", "", "", true, false}, {"same_origin_metadata", "POST", "", "same-origin", "", "", true, true}, {"old_same_origin_referrer", "POST", "", "", "https://wiki.example/form", "", true, true}, {"foreign_referrer", "POST", "", "", "https://evil.example/form", "", true, false}, {"cli_bearer", "POST", "", "", "", "Bearer explicit", false, true}, {"explicit_bearer_with_cookie", "POST", "", "", "", "Bearer explicit", true, true}, {"cross_origin_login", "POST", "https://evil.example", "cross-site", "", "", false, false}, {"machine_enrollment", "POST", "", "", "", "", false, true}, {"safe_read", "GET", "https://evil.example", "cross-site", "", "", true, true}, {"cross_origin_delete", "DELETE", "https://evil.example", "cross-site", "", "", true, false}, } { t.Run(tc.name, func(t *testing.T) { r := httptest.NewRequest(tc.method, "https://wiki.example/_/auth/login", nil) r.Header.Set("Origin", tc.origin) r.Header.Set("Sec-Fetch-Site", tc.site) r.Header.Set("Referer", tc.referer) if tc.authorization != "" { r.Header.Set("Authorization", tc.authorization) } if tc.cookie { r.AddCookie(&http.Cookie{Name: authCookieName, Value: "browser"}) } called := false w := httptest.NewRecorder() (&Server{}).withAuthorization(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { called = true })).ServeHTTP(w, r) if called != tc.allow || (!tc.allow && w.Code != http.StatusForbidden) { t.Fatalf("allowed=%v status=%d, want %v", called, w.Code, tc.allow) } }) } // Handler-owned JSON routes receive a parseable denial, before DB access. r := httptest.NewRequest("POST", "https://wiki.example/_/api/v1/assets", nil) r.Header.Set("Origin", "https://evil.example") w := httptest.NewRecorder() (&Server{}).withAuthorization(http.NotFoundHandler()).ServeHTTP(w, r) var result map[string]string if w.Code != 403 || json.Unmarshal(w.Body.Bytes(), &result) != nil || result["error"] == "" { t.Fatalf("invalid CSRF JSON: %d %s", w.Code, w.Body.String()) } } func TestExplicitCredentialNeverFallsBackToCookie(t *testing.T) { s := &Server{} for _, tc := range []struct{ header, want string }{ {"Basic secret", ""}, {"Bearer", ""}, {"Bearer a b", ""}, {"Bearer a,b", ""}, {"bearer api-token", "api-token"}, } { r := httptest.NewRequest("GET", "http://localhost/", nil) r.AddCookie(&http.Cookie{Name: authCookieName, Value: "cookie-token"}) r.Header.Set("Authorization", tc.header) if got := s.authTokenFromRequest(r); got != tc.want { t.Fatalf("header=%q got=%q want=%q", tc.header, got, tc.want) } } r := httptest.NewRequest("GET", "http://localhost/", nil) r.AddCookie(&http.Cookie{Name: authCookieName, Value: "one"}) r.AddCookie(&http.Cookie{Name: authCookieName, Value: "two"}) if s.authTokenFromRequest(r) != "" { t.Fatal("ambiguous cookies accepted") } } func TestLogoutRequiresPostAndRevokesSelectedCredential(t *testing.T) { s, token, domain := configFixture(t) s.mux.HandleFunc("/_/auth/", s.handleAuth) principal, err := s.store.PrincipalForSession(domain, token) if err != nil { t.Fatal(err) } cookieToken, err := s.store.CreateBrowserAuthSession(domain, principal.UUID, 0) if err != nil { t.Fatal(err) } request := func(method, origin, bearer string) *httptest.ResponseRecorder { r := httptest.NewRequest(method, "http://localhost/_/auth/logout", nil) r.AddCookie(&http.Cookie{Name: authCookieName, Value: cookieToken}) if origin != "" { r.Header.Set("Origin", origin) } if bearer != "" { r.Header.Set("Authorization", "Bearer "+bearer) } w := httptest.NewRecorder() s.withAuthorization(s.mux).ServeHTTP(w, r) return w } if w := request("GET", "", ""); w.Code != 200 { t.Fatalf("confirmation: %d %s", w.Code, w.Body.String()) } if _, err := s.store.PrincipalForSession(domain, cookieToken); err != nil { t.Fatal("GET revoked session") } if w := request("POST", "http://evil.example", ""); w.Code != 403 { t.Fatalf("CSRF logout accepted: %d", w.Code) } if w := request("POST", "", token); w.Code != 200 { t.Fatalf("bearer logout: %d", w.Code) } if _, err := s.store.PrincipalForSession(domain, token); err == nil { t.Fatal("Bearer token survived logout") } if _, err := s.store.PrincipalForSession(domain, cookieToken); err != nil { t.Fatal("Bearer logout revoked unrelated cookie credential") } if w := request("POST", "http://localhost", ""); w.Code != 303 { t.Fatalf("cookie logout: %d", w.Code) } if _, err := s.store.PrincipalForSession(domain, cookieToken); err == nil { t.Fatal("cookie token survived logout") } } func TestReturnPathStaysLocal(t *testing.T) { for _, value := range []string{"https://evil.example", "//evil.example", "/%2fevil.example", "/\\evil.example", "/%00bad"} { if got := safeReturnPath(value); got != "/" { t.Fatalf("unsafe return %q -> %q", value, got) } } if got := safeReturnPath("/life/home?q=1"); got != "/life/home?q=1" { t.Fatal(got) } } func TestSessionPurposeAndEditorNavigation(t *testing.T) { s, apiToken, domain := configFixture(t) principal, err := s.store.PrincipalForSession(domain, apiToken) if err != nil { t.Fatal(err) } browserToken, err := s.store.CreateBrowserAuthSession(domain, principal.UUID, 0) if err != nil { t.Fatal(err) } for _, tc := range []struct { token, transport string allowed bool }{ {apiToken, "bearer", true}, {apiToken, "cookie", false}, {browserToken, "bearer", false}, {browserToken, "cookie", true}, } { r := httptest.NewRequest("GET", "http://localhost/", nil) if tc.transport == "bearer" { r.Header.Set("Authorization", "Bearer "+tc.token) } else { r.AddCookie(&http.Cookie{Name: authCookieName, Value: tc.token}) } _, err := s.store.PrincipalForSession(domain, s.authTokenFromRequest(r)) if (err == nil) != tc.allowed { t.Fatalf("%s purpose mismatch: allowed=%v err=%v", tc.transport, tc.allowed, err) } } r := httptest.NewRequest("GET", "https://wiki.example/e/new-page", nil) r.AddCookie(&http.Cookie{Name: authCookieName, Value: browserToken}) r.Header.Set("Sec-Fetch-Site", "cross-site") if validBrowserMutationOrigin(r) { t.Fatal("legacy editor GET accepted cross-site") } r.Header.Set("Sec-Fetch-Site", "none") r.Header.Set("Sec-Fetch-Mode", "navigate") if !validBrowserMutationOrigin(r) { t.Fatal("address-bar editor navigation rejected") } }