Files
sam db346b159d fix(webui): mark cookies Secure behind a TLS proxy; run gosec in the gate (#1919)
Cookies took Secure from r.TLS, which is nil behind a proxy that terminates
TLS, so sign-in cookies went out without it. Every dashboard cookie now goes
through one builder that reads the scheme the way the origin check does.

The worktree reset and the agent worker's chown walk use os.Root, so a
symlink swapped in mid-walk can't point them outside the worktree.

gosec runs in golangci-lint, tests included. G104, G115, G204 and G304 are
excluded in config; each remaining finding is fixed or suppressed at the site
with its reason.
2026-11-13 03:16:15 +11:00

428 lines
14 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"net"
"net/http"
"strings"
"time"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/ratelimit"
)
func (s *Server) registerAccountRoutes(public, protected *http.ServeMux) {
if s.Accounts == nil {
return
}
s.accountRateLimit = ratelimit.New(time.Minute, 20)
public.HandleFunc("GET /api/auth/status", s.handleAccountStatus)
public.HandleFunc("POST /api/auth/setup", s.handleAccountSetup)
public.HandleFunc("POST /api/auth/login", s.handleAccountLogin)
public.HandleFunc("POST /api/auth/logout", s.handleAccountLogout)
public.HandleFunc("POST /api/auth/recover", s.handleAccountRecover)
protected.HandleFunc("POST /api/accounts", s.handleAccountCreate)
personal := http.NewServeMux()
personal.HandleFunc("POST /api/account/password", s.handleAccountPassword)
personal.HandleFunc("POST /api/account/recovery", s.handleAccountRecovery)
public.Handle("/api/account/", s.requireAccount(s.authorizeAccountSelf(personal)))
protected.HandleFunc("GET /api/authentication", s.handleAuthenticationSettings)
protected.HandleFunc("PUT /api/authentication", s.handleAuthenticationSettings)
s.registerPasskeyRoutes(public, personal)
}
func (s *Server) accountIdentity(r *http.Request) (identity.Identity, error) {
if c, err := r.Cookie(s.cookies().account); err == nil {
value, err := s.Accounts.ResolveAccountSession(r.Context(), c.Value)
if err != nil {
return identity.Identity{}, err
}
if err := s.verifyAccountProvider(r, value); err != nil {
return identity.Identity{}, err
}
return value, nil
}
if s.Authenticate != nil && strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
return s.Authenticate(r.Context(), strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
}
if cookie, err := r.Cookie(s.cookies().providerToken); err == nil {
return s.authenticateBrowser(r.Context(), cookie.Value)
}
return identity.Identity{}, identity.ErrNoCredential
}
func (s *Server) requireAccount(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Any active identity may authenticate: a person, or a service
// account whose bearer token carries a scoped grant. What the
// identity may then do is the policy chain's call, not the
// credential kind's; an inactive identity is refused here.
value, err := s.accountIdentity(r)
if err != nil || !value.CanAct() {
if err == nil {
err = identity.ErrCredentialRejected
}
s.writeAccountError(w, err)
return
}
h.ServeHTTP(w, r.WithContext(WithActingIdentity(r.Context(), value)))
})
}
func (s *Server) handleAccountStatus(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Cache-Control", "no-store")
required, err := s.Accounts.AccountSetupRequired(r.Context())
if err != nil {
s.writeAccountError(w, err)
return
}
var user *identity.Identity
value, err := s.accountIdentity(r)
if err == nil && value.Kind == identity.KindUser && value.CanAct() {
user = &value
} else if err != nil && !errors.Is(err, identity.ErrNoCredential) && !errors.Is(err, identity.ErrCredentialRejected) && !errors.Is(err, identity.ErrIdentityInactive) && !errors.Is(err, identity.ErrSubjectUnbound) {
s.writeAccountError(w, err)
return
}
oidcEnabled := s.Login != nil
publicURL := ""
if store, ok := s.authenticationSettings(); ok {
settings, settingsErr := store.AuthenticationSettings(r.Context())
if settingsErr != nil {
s.writeAccountError(w, settingsErr)
return
}
publicURL = settings.PublicURL
if settings.PublicURL != "" {
oidcEnabled = settings.OIDCIssuer != ""
}
}
writeJSON(w, map[string]any{"setup_required": required, "user": user, "oidc": oidcEnabled, "public_url": publicURL, "instance": s.Instance})
}
func decodeAccountRequest(w http.ResponseWriter, r *http.Request, value any) bool {
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(value); err != nil {
http.Error(w, "invalid account request", http.StatusBadRequest)
return false
}
return true
}
func (s *Server) handleAccountSetup(w http.ResponseWriter, r *http.Request) {
if !s.authorizeAuthenticationMutation(w, r) {
return
}
var request identity.AccountRegistration
if !decodeAccountRequest(w, r, &request) {
return
}
if _, err := s.Accounts.RegisterAccount(r.Context(), request, true); err != nil {
s.writeAccountError(w, err)
return
}
s.signInAccount(w, r, request.Email, request.Password)
}
func (s *Server) handleAccountLogin(w http.ResponseWriter, r *http.Request) {
if !s.authorizeAuthenticationMutation(w, r) {
return
}
var request struct {
Email string `json:"email"`
Password string `json:"password"`
}
if !decodeAccountRequest(w, r, &request) {
return
}
s.signInAccount(w, r, request.Email, request.Password)
}
func (s *Server) signInAccount(w http.ResponseWriter, r *http.Request, email, password string) {
value, err := s.Accounts.SignInAccount(r.Context(), email, password)
if err != nil {
s.logf("account sign-in refused", "peer", r.RemoteAddr)
s.writeAccountError(w, err)
return
}
if s.Log != nil {
s.Log.InfoContext(r.Context(), "account signed in", "identity", value.Identity.ID)
}
s.clearCookie(w, r, s.cookies().providerToken, "/")
s.setAccountCookie(w, r, value)
writeJSON(w, map[string]any{"user": value.Identity})
}
func (s *Server) setAccountCookie(w http.ResponseWriter, r *http.Request, value identity.AccountSession) {
s.setCookie(w, r, cookie{name: s.cookies().account, value: value.Token, maxAge: int(time.Until(value.Expires).Seconds())})
w.Header().Set("Cache-Control", "no-store")
}
func (s *Server) handleAccountLogout(w http.ResponseWriter, r *http.Request) {
if !s.authorizeAuthenticationMutation(w, r) {
return
}
if c, err := r.Cookie(s.cookies().account); err == nil {
if err = s.Accounts.SignOutAccount(r.Context(), c.Value); err != nil {
s.writeAccountError(w, err)
return
}
}
for _, name := range []string{s.cookies().account, s.cookies().providerToken} {
s.clearCookie(w, r, name, "/")
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) handleAccountCreate(w http.ResponseWriter, r *http.Request) {
if !s.authorizeAuthenticationMutation(w, r) {
return
}
if !s.requireFreshAccount(w, r) {
return
}
var request identity.AccountRegistration
if !decodeAccountRequest(w, r, &request) {
return
}
value, err := s.Accounts.RegisterAccount(r.Context(), request, false)
if err != nil {
s.writeAccountError(w, err)
return
}
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"user": value})
}
func (s *Server) handleAccountPassword(w http.ResponseWriter, r *http.Request) {
if !s.authorizeAuthenticationMutation(w, r) {
return
}
var request struct {
Current string `json:"current_password"`
New string `json:"new_password"`
}
if !decodeAccountRequest(w, r, &request) {
return
}
if err := s.Accounts.ChangeAccountPassword(r.Context(), request.Current, request.New); err != nil {
s.writeAccountError(w, err)
return
}
s.clearCookie(w, r, s.cookies().account, "/")
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) writeAccountError(w http.ResponseWriter, err error) {
switch {
case errors.Is(err, identity.ErrNoCredential), errors.Is(err, identity.ErrCredentialRejected), errors.Is(err, identity.ErrIdentityInactive), errors.Is(err, identity.ErrSubjectUnbound):
http.Error(w, "Sign-in required or credentials not accepted.", http.StatusUnauthorized)
case errors.Is(err, identity.ErrSetupComplete):
http.Error(w, identity.ErrSetupComplete.Error(), http.StatusConflict)
case errors.Is(err, identity.ErrNotFound):
http.Error(w, "Record not found.", http.StatusNotFound)
case errors.Is(err, identity.ErrConflict):
http.Error(w, "An account already uses that email.", http.StatusConflict)
case errors.Is(err, identity.ErrInvalid):
http.Error(w, "Enter a name, valid email, organisation name for setup, and an uncommon password of at least 15 characters (at most 1024 bytes).", http.StatusBadRequest)
default:
s.logf("account operation failed", "err", err)
http.Error(w, "Account service unavailable.", http.StatusServiceUnavailable)
}
}
func (s *Server) authenticationSettings() (identity.AuthenticationSettingsStore, bool) {
value, ok := s.Accounts.(identity.AuthenticationSettingsStore)
return value, ok
}
func (s *Server) handleAuthenticationSettings(w http.ResponseWriter, r *http.Request) {
if !instanceOwner(r) {
http.Error(w, "instance administrator required", http.StatusForbidden)
return
}
store, ok := s.authenticationSettings()
if !ok {
http.Error(w, "authentication settings unavailable", http.StatusServiceUnavailable)
return
}
if r.Method == http.MethodGet {
value, err := store.AuthenticationSettings(r.Context())
if err != nil {
s.writeAccountError(w, err)
return
}
writeJSON(w, value)
return
}
if !s.requireFreshAccount(w, r) {
return
}
if !s.authorizeAuthenticationMutation(w, r) {
return
}
var value identity.AuthenticationSettings
if !decodeAccountRequest(w, r, &value) {
return
}
if err := store.SaveAuthenticationSettings(r.Context(), value); err != nil {
if errors.Is(err, identity.ErrInvalid) {
http.Error(w, "Use a valid instance origin and complete OIDC settings. Remove enrolled passkeys before changing the instance URL.", http.StatusBadRequest)
return
}
s.writeAccountError(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) authorizeAccountSelf(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
acting, ok := ActingIdentity(r.Context())
if !ok || acting.Kind != identity.KindUser || !acting.CanAct() {
http.Error(w, "sign-in required", http.StatusUnauthorized)
return
}
principal, err := s.requestPrincipal(r.Context())
if err != nil {
s.writeAccountError(w, err)
return
}
h.ServeHTTP(w, r.WithContext(org.WithOrg(access.WithPrincipal(r.Context(), principal), principal.Org)))
})
}
func (s *Server) requireFreshAccount(w http.ResponseWriter, r *http.Request) bool {
store, ok := s.Accounts.(identity.AccountSecurity)
if !ok {
http.Error(w, "account security unavailable", http.StatusServiceUnavailable)
return false
}
cookie, err := r.Cookie(s.cookies().account)
if err == nil {
err = store.RequireFreshAccountSession(r.Context(), cookie.Value)
}
if err != nil {
http.Error(w, "Sign in again before changing account security.", http.StatusForbidden)
return false
}
return true
}
func (s *Server) handleAccountRecovery(w http.ResponseWriter, r *http.Request) {
if !s.authorizeTaskMutation(w, r) || !s.requireFreshAccount(w, r) {
return
}
store, ok := s.Accounts.(identity.AccountSecurity)
if !ok {
http.Error(w, "account security unavailable", http.StatusServiceUnavailable)
return
}
code, err := store.CreateAccountRecovery(r.Context())
if err != nil {
s.writeAccountError(w, err)
return
}
w.Header().Set("Cache-Control", "no-store")
writeJSON(w, map[string]string{"code": code})
}
func (s *Server) handleAccountRecover(w http.ResponseWriter, r *http.Request) {
if !s.authorizeAuthenticationMutation(w, r) {
return
}
store, ok := s.Accounts.(identity.AccountSecurity)
if !ok {
http.Error(w, "account security unavailable", http.StatusServiceUnavailable)
return
}
var request struct {
Email string `json:"email"`
Code string `json:"code"`
Password string `json:"password"`
}
if !decodeAccountRequest(w, r, &request) {
return
}
if err := store.RecoverAccount(r.Context(), request.Email, request.Code, request.Password); err != nil {
s.writeAccountError(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) authorizeAuthenticationMutation(w http.ResponseWriter, r *http.Request) bool {
if !s.authorizeTaskMutation(w, r) {
return false
}
scheme, host := s.expectedOrigin(r)
hostname := host
if name, _, err := net.SplitHostPort(host); err == nil {
hostname = name
}
local := strings.EqualFold(hostname, "localhost") || (net.ParseIP(hostname) != nil && net.ParseIP(hostname).IsLoopback())
if scheme != "https" && !local {
http.Error(w, "Account credentials require HTTPS. Use a TLS proxy, or localhost for development.", http.StatusForbidden)
return false
}
if strings.HasPrefix(r.URL.Path, "/api/auth/") && s.accountRateLimit != nil {
peer, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
peer = r.RemoteAddr
}
s.accountRateLimit.EvictStale()
if !s.accountRateLimit.Allow("authentication", peer) {
w.Header().Set("Retry-After", "60")
http.Error(w, "Too many sign-in attempts. Try again shortly.", http.StatusTooManyRequests)
return false
}
}
return true
}
func (s *Server) verifyAccountProvider(r *http.Request, value identity.Identity) error {
cookie, err := r.Cookie(s.cookies().providerToken)
if errors.Is(err, http.ErrNoCookie) {
return nil
}
if err != nil {
return err
}
providerValue, err := s.authenticateBrowser(r.Context(), cookie.Value)
if err != nil {
return err
}
if providerValue.ID != value.ID {
return identity.ErrCredentialRejected
}
return nil
}
func (s *Server) authenticateBrowser(ctx context.Context, credential string) (identity.Identity, error) {
verify := s.AuthenticateBrowser
if verify == nil {
verify = s.Authenticate
}
if verify == nil {
return identity.Identity{}, identity.ErrCredentialRejected
}
return verify(ctx, credential)
}
func (s *Server) memberIssuer(r *http.Request) string {
if store, ok := s.authenticationSettings(); ok {
value, err := store.AuthenticationSettings(r.Context())
if err != nil {
return ""
}
if value.PublicURL != "" {
return value.OIDCIssuer
}
}
return s.Issuer
}