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.
428 lines
14 KiB
Go
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
|
|
}
|