Files
2026-11-15 05:47:14 +09:00

325 lines
13 KiB
Go

package server
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"errors"
"log"
"net/http"
"net/url"
"strings"
"time"
)
type oidcChallenge struct {
Verifier, Nonce, Return, Issuer, ClientID, BrowserHash, CLIRequest string
Remember bool
}
func logOIDCFailure(stage, domainUUID, issuer string, err error) {
host := "invalid"
if parsed, parseErr := url.Parse(issuer); parseErr == nil && parsed.Hostname() != "" {
host = parsed.Hostname()
}
cause := err
for errors.Unwrap(cause) != nil {
cause = errors.Unwrap(cause)
}
log.Printf("OIDC %s failed domain=%s issuer_host=%s cause=%T: %v", stage, domainUUID, host, cause, cause)
}
func randomURLToken(size int) string {
raw := make([]byte, size)
_, _ = rand.Read(raw)
return base64.RawURLEncoding.EncodeToString(raw)
}
func externalURL(r *http.Request, path string) string {
scheme := "http"
if requestIsHTTPS(r) {
scheme = "https"
}
return scheme + "://" + r.Host + path
}
func (s *Server) beginOIDC(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.Header().Set("Allow", http.MethodGet)
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
domainUUID := s.domainUUIDForRequest(r)
config, err := s.store.AuthProviderConfig(domainUUID, "oidc")
if err != nil || !config.Enabled {
http.NotFound(w, r)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
defer cancel()
cliRequest := r.URL.Query().Get("cli")
remember := r.URL.Query().Get("remember") == "1"
returnPath := safeReturnPath(r.URL.Query().Get("return"))
if cliRequest != "" {
if !cliSecureTransport(r) || !cliProofPattern.MatchString(cliRequest) {
http.Error(w, "invalid CLI request", 400)
return
}
if err := s.store.BeginCLIAuth(ctx, domainUUID, cliOrigin(r), cliRequest); err != nil {
http.Error(w, "invalid CLI request", 400)
return
}
returnPath = cliVerifyPath(cliRequest)
grant, err := s.store.CLIAuthRequest(ctx, domainUUID, cliOrigin(r), cliRequest)
if err != nil {
http.Error(w, "invalid CLI request", 400)
return
}
remember = grant.Remember
}
metadata, err := fetchOIDCMetadata(ctx, config.Issuer)
if err != nil {
logOIDCFailure("discovery", domainUUID, config.Issuer, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
verifier, nonce, browser := randomURLToken(32), randomURLToken(24), randomURLToken(32)
browserDigest := sha256.Sum256([]byte(browser))
state, err := s.store.CreateAuthChallenge(domainUUID, "", "oidc", oidcChallenge{Verifier: verifier, Nonce: nonce, Return: returnPath, Issuer: config.Issuer, ClientID: config.ClientID, BrowserHash: base64.RawURLEncoding.EncodeToString(browserDigest[:]), CLIRequest: cliRequest, Remember: remember}, 5*time.Minute)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
digest := sha256.Sum256([]byte(verifier))
query := url.Values{"response_type": {"code"}, "client_id": {config.ClientID}, "redirect_uri": {externalURL(r, "/_/auth/callback/oidc")}, "scope": {"openid email profile"}, "state": {state}, "nonce": {nonce}, "code_challenge_method": {"S256"}, "code_challenge": {base64.RawURLEncoding.EncodeToString(digest[:])}}
authorizationURL, _ := url.Parse(metadata.AuthorizationEndpoint)
parameters := authorizationURL.Query()
for key, value := range query {
parameters[key] = value
}
authorizationURL.RawQuery = parameters.Encode()
setOIDCBrowserCookie(w, r, browser, 300)
w.Header().Set("Cache-Control", "no-store")
http.Redirect(w, r, authorizationURL.String(), http.StatusFound)
}
func (s *Server) completeOIDC(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.Header().Set("Allow", http.MethodGet)
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("Cache-Control", "no-store")
domainUUID := s.domainUUIDForRequest(r)
var challenge oidcChallenge
if _, err := s.store.ConsumeAuthChallenge(domainUUID, "oidc", r.URL.Query().Get("state"), &challenge); err != nil {
http.Error(w, "invalid OIDC state", http.StatusBadRequest)
return
}
if !validOIDCBrowserChallenge(oidcBrowserCookie(r), challenge.BrowserHash) {
http.Error(w, "OIDC state belongs to a different browser", http.StatusBadRequest)
return
}
setOIDCBrowserCookie(w, r, "", -1)
config, err := s.store.AuthProviderConfig(domainUUID, "oidc")
if err != nil || !config.Enabled {
http.Error(w, "OIDC is disabled", http.StatusBadRequest)
return
}
if config.Issuer != challenge.Issuer || config.ClientID != challenge.ClientID || r.URL.Query().Get("code") == "" || r.URL.Query().Get("error") != "" {
http.Error(w, "OIDC login must be restarted", http.StatusBadRequest)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
defer cancel()
metadata, err := fetchOIDCMetadata(ctx, config.Issuer)
if err != nil {
logOIDCFailure("callback discovery", domainUUID, config.Issuer, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
form := url.Values{"grant_type": {"authorization_code"}, "code": {r.URL.Query().Get("code")}, "redirect_uri": {externalURL(r, "/_/auth/callback/oidc")}, "client_id": {config.ClientID}, "client_secret": {config.ClientSecret}, "code_verifier": {challenge.Verifier}}
var tokens struct {
AccessToken string `json:"access_token"`
IDToken string `json:"id_token"`
TokenType string `json:"token_type"`
}
if tokenErr := oidcVerifier.requestJSON(ctx, http.MethodPost, metadata.TokenEndpoint, form, "", &tokens); tokenErr != nil {
logOIDCFailure("token exchange", domainUUID, config.Issuer, tokenErr)
http.Error(w, "OIDC token exchange failed", http.StatusBadGateway)
return
}
if tokens.AccessToken == "" || len(tokens.AccessToken) > 16<<10 || !strings.EqualFold(tokens.TokenType, "Bearer") {
http.Error(w, "OIDC token exchange failed", http.StatusBadGateway)
return
}
idClaims, err := oidcVerifier.verify(ctx, metadata, tokens.IDToken, config.ClientID, challenge.Nonce, tokens.AccessToken)
if err != nil {
logOIDCFailure("ID-token verification", domainUUID, config.Issuer, err)
http.Error(w, "OIDC ID-token verification failed", http.StatusBadRequest)
return
}
var claims struct {
Sub, Email string
Name string `json:"name"`
DisplayName string `json:"display_name"`
PreferredName string `json:"preferred_username"`
EmailVerified bool `json:"email_verified"`
}
if userinfoErr := oidcVerifier.requestJSON(ctx, http.MethodGet, metadata.UserinfoEndpoint, nil, tokens.AccessToken, &claims); userinfoErr != nil {
logOIDCFailure("UserInfo", domainUUID, config.Issuer, userinfoErr)
http.Error(w, "OIDC identity is not a verified account", http.StatusForbidden)
return
}
if claims.Sub == "" {
http.Error(w, "OIDC identity is not a verified account", http.StatusForbidden)
return
}
if claims.Sub != idClaims.Sub {
http.Error(w, "OIDC subject mismatch", http.StatusForbidden)
return
}
principal, err := s.store.PrincipalByExternalIdentity(domainUUID, "oidc", "oidc", config.Issuer, claims.Sub)
if err != nil {
switch config.OIDCMatchBy {
case "preferred_username":
principal, err = s.store.PrincipalByExternalUsername(domainUUID, claims.PreferredName)
if err != nil {
log.Printf("OIDC local account match failed domain=%s mode=preferred_username present=%t", domainUUID, strings.TrimSpace(claims.PreferredName) != "")
}
case "display_name":
displayName := strings.TrimSpace(claims.Name)
claimSource := "name"
if displayName == "" {
displayName = strings.TrimSpace(claims.DisplayName)
claimSource = "display_name"
}
principal, err = s.store.PrincipalByDisplayName(domainUUID, displayName)
if err != nil {
log.Printf("OIDC local account match failed domain=%s mode=display_name claim=%s present=%t", domainUUID, claimSource, displayName != "")
}
default:
if claims.Email == "" || !claims.EmailVerified {
http.Error(w, "OIDC identity is not a verified account", http.StatusForbidden)
return
}
principal, err = s.store.PrincipalByVerifiedEmail(domainUUID, claims.Email)
}
if err == nil {
err = s.store.BindExternalIdentity(principal.UUID, "oidc", "oidc", config.Issuer, claims.Sub, claims)
}
}
if err != nil {
http.Error(w, "No local account matches the configured OIDC identity field", http.StatusForbidden)
return
}
token, lifetime, err := s.store.CreateLoginSession(domainUUID, principal.UUID, 0, true, challenge.Remember)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if challenge.CLIRequest != "" {
if err := s.store.BindCLIAuth(r.Context(), domainUUID, cliOrigin(r), challenge.CLIRequest, token); err != nil {
_ = s.store.RevokeAuthSession(token)
http.Error(w, "CLI request expired or already used; restart login", 400)
return
}
}
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, challenge.Return, http.StatusSeeOther)
}
func (s *Server) requestMagicLink(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
w.Header().Set("Allow", "POST")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("Cache-Control", "no-store")
domainUUID := s.domainUUIDForRequest(r)
r.Body = http.MaxBytesReader(w, r.Body, 64<<10)
if err := r.ParseForm(); err != nil {
http.Error(w, "invalid sign-in request", http.StatusBadRequest)
return
}
config, configErr := s.store.AuthProviderConfig(domainUUID, "smtp")
requested, mailboxErr := smtpMailbox(r.FormValue("email"))
if configErr == nil && config.Enabled && mailboxErr == nil {
principal, principalErr := s.store.PrincipalByVerifiedEmail(domainUUID, requested.Address)
if principalErr == nil {
_, _, _, _, principalErr = smtpMessage(config, principal.Email, externalURL(r, "/_/auth/magic-link/verify"))
}
if principalErr == nil {
select {
case s.smtpSlots <- struct{}{}:
token, err := s.store.CreateAuthChallenge(domainUUID, principal.UUID, "magic-link", magicLinkChallenge{Return: safeReturnPath(r.FormValue("return")), Email: principal.Email, Remember: r.PostForm.Get("remember") == "1"}, 15*time.Minute)
if err != nil {
<-s.smtpSlots
break
}
link := externalURL(r, "/_/auth/magic-link/verify?token="+url.QueryEscape(token))
go func() {
defer func() { <-s.smtpSlots }()
_ = sendMagicLinkSMTP(context.Background(), config, principal.Email, link)
}()
default:
}
}
}
s.renderAuthPage(w, r, map[string]any{"MagicSent": true, "Return": safeReturnPath(r.FormValue("return"))})
}
func (s *Server) verifyMagicLink(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.Header().Set("Allow", "GET")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("Cache-Control", "no-store")
domainUUID := s.domainUUIDForRequest(r)
var payload magicLinkChallenge
principalUUID, err := s.store.ConsumeAuthChallenge(domainUUID, "magic-link", r.URL.Query().Get("token"), &payload)
if err != nil {
http.Error(w, "This sign-in link is invalid or expired", http.StatusBadRequest)
return
}
config, configErr := s.store.AuthProviderConfig(domainUUID, "smtp")
valid, stateErr := s.store.ValidateMagicLinkIdentity(r.Context(), domainUUID, principalUUID, payload.Email)
if configErr != nil || !config.Enabled || stateErr != nil || !valid || payload.Email == "" {
http.Error(w, "This sign-in link is invalid or expired", http.StatusBadRequest)
return
}
token, lifetime, err := s.store.CreateLoginSession(domainUUID, principalUUID, 0, true, payload.Remember)
if err != nil {
http.Error(w, "This sign-in link is invalid or expired", http.StatusBadRequest)
return
}
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, safeReturnPath(payload.Return), http.StatusSeeOther)
}
func (s *Server) renderAuthPage(w http.ResponseWriter, r *http.Request, data map[string]any) {
domainUUID := s.domainUUIDForRequest(r)
if data == nil {
data = map[string]any{}
}
if config, err := s.store.AuthProviderConfig(domainUUID, "oidc"); err == nil {
data["OIDCEnabled"] = config.Enabled
}
if config, err := s.store.AuthProviderConfig(domainUUID, "smtp"); err == nil {
data["MagicEnabled"] = config.Enabled
}
if config, err := s.store.AuthProviderConfig(domainUUID, "ldap"); err == nil {
data["LDAPEnabled"] = config.Enabled
}
data["Locale"] = s.getLocale(domainUUID)
data["TrustedSessionDays"] = s.store.TrustedSessionDays(domainUUID)
data["RememberRequested"] = r.PostForm.Get("remember") == "1"
transparency := s.homeGlassTransparency(domainUUID)
data["HomeGlassTransparency"] = transparency
data["HomeGlassOpacity"] = 100 - transparency
// Login has no wallpaper: private home images must not become public.
s.renderWithContext(w, r, "auth.gohtml", data)
}