Files
pages/internal/server/auth_handler.go
T
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts.

Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation.

Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
2026-11-01 15:23:31 +09:00

407 lines
14 KiB
Go

package server
import (
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"database/sql"
"encoding/base64"
"errors"
"log"
"net/http"
"net/url"
"strings"
"pageswiki/internal/store"
)
const authCookieName = "pageswiki_session"
const mfaChallengeCookieName = "pageswiki_mfa"
func (s *Server) ensureBootstrapToken(domainUUID string) error {
if value, _ := s.store.GetConfigInDomain(domainUUID, "auth_bootstrap_token_hash"); value != "" {
return nil
}
raw := make([]byte, 24)
if _, err := rand.Read(raw); err != nil {
return err
}
token := base64.RawURLEncoding.EncodeToString(raw)
sum := sha256.Sum256([]byte(token))
if err := s.store.SetConfigInDomain(domainUUID, "auth_bootstrap_token_hash", base64.RawURLEncoding.EncodeToString(sum[:])); err != nil {
return err
}
log.Printf("AUTH BOOTSTRAP TOKEN domain=%s token=%s (one-time; create the owner at /_/auth/login)", domainUUID, token)
return nil
}
func (s *Server) validBootstrapToken(domainUUID, token string) bool {
want, err := s.store.GetConfigInDomain(domainUUID, "auth_bootstrap_token_hash")
if err != nil || want == "" {
return false
}
sum := sha256.Sum256([]byte(strings.TrimSpace(token)))
got := base64.RawURLEncoding.EncodeToString(sum[:])
return subtle.ConstantTimeCompare([]byte(want), []byte(got)) == 1
}
func safeReturnPath(value string) string {
value = strings.TrimSpace(value)
parsed, err := url.Parse(value)
if err != nil || !strings.HasPrefix(parsed.Path, "/") || strings.HasPrefix(parsed.Path, "//") || strings.ContainsAny(parsed.Path, "\\\r\n\x00") || parsed.IsAbs() || parsed.Host != "" {
return "/"
}
return parsed.RequestURI()
}
func requestIsHTTPS(r *http.Request) bool {
if r.TLS != nil {
return true
}
return strings.EqualFold(strings.TrimSpace(strings.Split(r.Header.Get("X-Forwarded-Proto"), ",")[0]), "https")
}
func (s *Server) setAuthCookie(w http.ResponseWriter, r *http.Request, token string) {
http.SetCookie(w, &http.Cookie{Name: authCookieName, Value: token, Path: "/", HttpOnly: true, Secure: requestIsHTTPS(r), SameSite: http.SameSiteLaxMode, MaxAge: s.store.AuthSessionLifetimeMinutes(s.domainUUIDForRequest(r)) * 60})
}
func (s *Server) authTokenFromRequest(r *http.Request) string {
if headers := r.Header.Values("Authorization"); len(headers) != 0 {
// An explicitly supplied but invalid credential must never fall back to
// an ambient browser session (including unknown credential schemes).
if len(headers) != 1 {
return ""
}
parts := strings.Fields(headers[0])
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") || len(parts[1]) > 4096 || strings.Contains(parts[1], ",") {
return ""
}
if strings.HasPrefix(parts[1], "pw_browser_") {
return ""
}
return parts[1]
}
var token string
count := 0
for _, cookie := range r.Cookies() {
if cookie.Name == authCookieName {
token = cookie.Value
count++
}
}
if count == 1 {
if strings.HasPrefix(token, "pw_api_") {
return ""
}
return token
}
return ""
}
func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
action := strings.Trim(strings.TrimPrefix(r.URL.Path, "/_/auth"), "/")
domainUUID := s.domainUUIDForRequest(r)
switch action {
case "wallpaper":
s.handleAuthWallpaper(w, r)
return
case "oidc":
s.beginOIDC(w, r)
return
case "ldap":
s.handleLDAPLogin(w, r)
return
case "callback/oidc":
s.completeOIDC(w, r)
return
case "magic-link":
if r.Method == http.MethodPost {
s.requestMagicLink(w, r)
return
}
case "magic-link/verify":
s.verifyMagicLink(w, r)
return
}
if action == "logout" {
s.handleLogout(w, r)
return
}
if action != "login" && action != "setup" && action != "totp" {
http.NotFound(w, r)
return
}
if r.Method != http.MethodGet && r.Method != http.MethodHead && r.Method != http.MethodPost {
w.Header().Set("Allow", "GET, HEAD, POST")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
count, err := s.store.PrincipalCount()
if err != nil {
http.Error(w, err.Error(), 500)
return
}
setup := count == 0
if setup {
if err := s.ensureBootstrapToken(domainUUID); err != nil {
http.Error(w, err.Error(), 500)
return
}
}
if r.Method == http.MethodPost {
r.Body = http.MaxBytesReader(w, r.Body, 64<<10)
if err := r.ParseForm(); err != nil {
http.Error(w, err.Error(), 400)
return
}
var principal *store.Principal
mfaLevel := 0
if action == "setup" && setup && s.validBootstrapToken(domainUUID, r.FormValue("bootstrap_token")) {
principal, err = s.store.BootstrapOwner(domainUUID, r.FormValue("username"), r.FormValue("password"), r.FormValue("display_name"), r.FormValue("email"))
if err == nil {
err = s.store.SetConfigInDomain(domainUUID, "authorization_mode", "enforcing")
if err == nil {
_ = s.store.SetConfigInDomain(domainUUID, "auth_bootstrap_token_hash", "")
}
}
} else if action == "login" && !setup {
principal, err = s.store.AuthenticatePassword(r.FormValue("username"), r.FormValue("password"))
if err == nil && s.store.HasTOTP(principal.UUID) {
challenge, challengeErr := s.store.CreateTOTPLoginChallenge(domainUUID, principal.UUID)
if challengeErr != nil {
err = challengeErr
} else if strings.Contains(r.Header.Get("Accept"), "application/json") {
writeEventJSON(w, http.StatusUnauthorized, map[string]any{"mfa_required": true, "challenge_token": challenge, "method": "totp"})
return
} else {
http.SetCookie(w, &http.Cookie{Name: mfaChallengeCookieName, Value: challenge, Path: "/_/auth/", HttpOnly: true, Secure: requestIsHTTPS(r), SameSite: http.SameSiteStrictMode, MaxAge: 300})
s.renderAuthPage(w, r, map[string]any{"MFA": true, "Return": safeReturnPath(r.FormValue("return"))})
return
}
}
} else if action == "totp" && !setup {
challenge := r.FormValue("challenge_token")
if challenge == "" {
if cookie, cookieErr := r.Cookie(mfaChallengeCookieName); cookieErr == nil {
challenge = cookie.Value
}
}
var principalUUID string
principalUUID, err = s.store.CompleteTOTPLoginChallenge(domainUUID, challenge, r.FormValue("code"))
if err == nil {
principal = &store.Principal{UUID: principalUUID}
mfaLevel = 1
http.SetCookie(w, &http.Cookie{Name: mfaChallengeCookieName, Path: "/_/auth/", MaxAge: -1, HttpOnly: true, Secure: requestIsHTTPS(r), SameSite: http.SameSiteStrictMode})
}
} else {
err = store.ErrAccessDenied
}
if err == nil {
var token string
if strings.Contains(r.Header.Get("Accept"), "application/json") {
token, err = s.store.CreateAuthSessionWithMFA(domainUUID, principal.UUID, mfaLevel)
} else {
token, err = s.store.CreateBrowserAuthSession(domainUUID, principal.UUID, mfaLevel)
}
if err == nil {
if strings.Contains(r.Header.Get("Accept"), "application/json") {
writeEventJSON(w, http.StatusOK, map[string]any{"access_token": token, "token_type": "Bearer", "expires_in": s.store.AuthSessionLifetimeMinutes(domainUUID) * 60})
return
}
s.setAuthCookie(w, r, token)
http.Redirect(w, r, safeReturnPath(r.FormValue("return")), http.StatusSeeOther)
return
}
}
if action == "totp" {
s.renderAuthPage(w, r, map[string]any{"MFA": true, "Error": translate(s.getLocale(domainUUID), "auth.totp_invalid"), "Return": safeReturnPath(r.FormValue("return"))})
return
}
s.renderAuthPage(w, r, map[string]any{"Setup": setup, "Error": translate(s.getLocale(domainUUID), "auth.invalid_credentials"), "Return": safeReturnPath(r.FormValue("return"))})
return
}
s.renderAuthPage(w, r, map[string]any{"Setup": setup, "Return": safeReturnPath(r.URL.Query().Get("return"))})
}
func authorizationTargetForRequest(r *http.Request, domainUUID string) (string, string) {
policy := policyForRequest(r)
if policy.Target == targetDomain {
return string(targetDomain), domainUUID
}
path := r.URL.Path
if strings.HasPrefix(path, "/e/") {
return "path", semanticEditorPath(path)
}
return string(targetPath), path
}
func (s *Server) authorizePathRequest(r *http.Request, capability, path string) error {
domainUUID := s.domainUUIDForRequest(r)
mode, err := s.store.GetConfigInDomain(domainUUID, "authorization_mode")
if err != nil {
return err
}
if mode != "enforcing" {
return nil
}
principal, err := s.store.PrincipalForSession(domainUUID, s.authTokenFromRequest(r))
if err != nil {
return err
}
return s.store.Authorize(store.AuthorizationRequest{DomainUUID: domainUUID, PrincipalUUID: principal.UUID, Capability: capability, TargetType: "path", TargetID: path})
}
func ownUserEditorPath(path, username string) bool {
for _, prefix := range []string{"/e/-/u/", "/e/u/"} {
if strings.HasPrefix(path, prefix) {
owner := strings.Split(strings.TrimPrefix(path, prefix), "/")[0]
return owner == username
}
}
return false
}
func (s *Server) withAuthorization(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// HTML and dynamic listings contain per-principal data. They must not
// enter shared caches even in legacy mode; immutable projections can
// choose a more specific private cache policy in their own handlers.
if r.URL.Path != "/health" && !strings.HasPrefix(r.URL.Path, "/static/") && !strings.HasPrefix(r.URL.Path, "/o/path:/system/static/") {
w.Header().Set("Cache-Control", "private, no-store")
w.Header().Add("Vary", "Cookie, Authorization")
}
// Runs before handler-owned auth and legacy-mode bypasses, protecting
// login, groups, configuration and upload forms as well as JSON APIs.
if !validBrowserMutationOrigin(r) {
rejectBrowserMutation(w, r)
return
}
// No process-wide principal/policy cache: revocation is observed by the
// next request. Read snapshots never authorize mutating store operations.
r = cacheRequestDomain(withReadPolicyContext(r))
if r.URL.Path == "/g" || strings.HasPrefix(r.URL.Path, "/g/") {
next.ServeHTTP(w, r)
return
}
if strings.HasPrefix(r.URL.Path, "/_/auth/") || r.URL.Path == "/health" || strings.HasPrefix(r.URL.Path, "/static/") || strings.HasPrefix(r.URL.Path, adapterGatewayPrefix+"/") || strings.HasPrefix(r.URL.Path, "/_/api/v1/adapter/session/") || r.URL.Path == "/_/api/v1/federation/enroll" {
next.ServeHTTP(w, r)
return
}
policy := policyForRequest(r)
// Calendar handlers enforce per-calendar ACLs, including public reads,
// regardless of the domain's legacy/enforcing switch.
if taskRoute(r.URL.Path) || calendarRoute(r.URL.Path) {
next.ServeHTTP(w, r)
return
}
// Compatibility URL for public application assets, not document objects.
// Serve from a confined static FileServer, never from object resolution.
if (r.Method == http.MethodGet || r.Method == http.MethodHead) && strings.HasPrefix(r.URL.Path, "/o/path:/system/static/") {
http.StripPrefix("/o/path:/system/static/", http.FileServer(http.Dir("./static"))).ServeHTTP(w, r)
return
}
if policy.Capability == "deny" {
http.Error(w, "forbidden: endpoint authorization policy is not defined", http.StatusForbidden)
return
}
domainUUID := s.domainUUIDForRequest(r)
mode, configErr := s.store.GetConfigInDomain(domainUUID, "authorization_mode")
if configErr != nil {
http.Error(w, "authorization policy unavailable", http.StatusServiceUnavailable)
return
}
userSpacePath := ""
if store.IsUserSpacePath(r.URL.Path) {
userSpacePath = r.URL.Path
} else if strings.HasPrefix(r.URL.Path, "/v/raw/path:/u/") {
userSpacePath = strings.TrimPrefix(r.URL.Path, "/v/raw/path:")
} else if username := publicUserNavigationUsername(r); username != "" {
if r.URL.Path == "/v/children" {
userSpacePath = r.URL.Query().Get("path")
} else {
userSpacePath = "/u/" + username
}
}
if mode != "enforcing" && userSpacePath == "" {
next.ServeHTTP(w, r)
return
}
token := s.authTokenFromRequest(r)
if token == "" {
if s.tryAnonymousProjection(w, r) {
return
}
s.authRequired(w, r)
return
}
principal, err := s.store.PrincipalForSession(domainUUID, token)
if err != nil {
s.authRequired(w, r)
return
}
if userSpacePath != "" {
allowed, audienceErr := s.store.UserSpaceCanReadAuthenticated(r.Context(), domainUUID, principal.UUID, userSpacePath)
if audienceErr != nil || !allowed {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
}
if mode != "enforcing" {
next.ServeHTTP(w, r)
return
}
if strings.HasPrefix(r.URL.Path, "/-/sys/config") {
domain := s.domainForRequest(r)
if s.store.IsBuiltinGroupAdmin(domainUUID, principal.UUID, "domain_admin") || (domain != nil && s.store.IsCampusAdmin(domain.CampusUUID, principal.UUID)) {
next.ServeHTTP(w, r)
return
}
}
if strings.HasPrefix(r.URL.Path, "/_/api/v1/city/") && r.Method != http.MethodGet && r.Method != http.MethodHead && s.store.IsBuiltinGroupAdmin(domainUUID, principal.UUID, "domain_admin") {
next.ServeHTTP(w, r)
return
}
capability := policy.Capability
if capability == "write" && principal.State == "active" && ownUserEditorPath(r.URL.Path, principal.Username) && s.store.CheckLocalityAccessCaps(domainUUID, principal.UUID, "write", semanticEditorPath(r.URL.Path)) == nil {
next.ServeHTTP(w, r)
return
}
if handled, resolvedErr := s.authorizeResolvedEndpoint(r, principal, policy); handled {
if resolvedErr != nil {
if errors.Is(resolvedErr, store.ErrAccessDenied) {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
http.Error(w, resolvedErr.Error(), http.StatusInternalServerError)
return
}
next.ServeHTTP(w, r)
return
}
targetType, targetID := authorizationTargetForRequest(r, domainUUID)
if capability == "write" && targetType == "path" {
if _, resolveErr := s.store.ResolvePathInDomain(domainUUID, targetID); errors.Is(resolveErr, sql.ErrNoRows) {
capability = "create"
}
}
err = s.store.Authorize(store.AuthorizationRequest{DomainUUID: domainUUID, PrincipalUUID: principal.UUID, Capability: capability, TargetType: targetType, TargetID: targetID})
if err != nil {
if errors.Is(err, store.ErrAccessDenied) {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
http.Error(w, err.Error(), 500)
return
}
next.ServeHTTP(w, r)
})
}
func (s *Server) authRequired(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.URL.Path, "/_/api/") {
writeEventJSON(w, http.StatusUnauthorized, map[string]string{"error": "authentication required"})
return
}
http.Redirect(w, r, "/_/auth/login?return="+url.QueryEscape(r.URL.RequestURI()), http.StatusSeeOther)
}