Files
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

185 lines
7.2 KiB
Go

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")
}
}