Files
Anya Tokugawa b90aef79d0
Build and publish container images / images (push) Successful in 11m37s
Release container images / release (push) Successful in 22s
feat: add browser upload queue and trusted sessions with bounded projections
2026-11-08 20:27:04 +09:00

249 lines
9.0 KiB
Go

package server
import (
"context"
"crypto/tls"
"crypto/x509"
"database/sql"
"encoding/base64"
"errors"
"fmt"
"log"
"net"
"net/http"
"net/url"
"strings"
"time"
"unicode/utf8"
ldap "github.com/go-ldap/ldap/v3"
"pageswiki/internal/store"
)
type ldapDirectory interface {
Bind(string, string) error
Search(*ldap.SearchRequest) (*ldap.SearchResult, error)
Close() error
}
type ldapDialFunc func(context.Context, store.AuthProviderConfig) (ldapDirectory, error)
type ldapIdentity struct {
Subject, Username, Email, DisplayName, DN string
}
func ldapTLSConfig(config store.AuthProviderConfig) (*tls.Config, error) {
parsed, err := url.Parse(config.LDAPURL)
if err != nil {
return nil, err
}
tlsConfig := &tls.Config{ // #nosec G402 -- opt-out is an explicit administrator setting.
MinVersion: tls.VersionTLS12,
ServerName: parsed.Hostname(),
InsecureSkipVerify: config.LDAPSkipTLSVerify,
}
if config.LDAPCAPEM != "" {
pool, poolErr := x509.SystemCertPool()
if poolErr != nil || pool == nil {
pool = x509.NewCertPool()
}
if !pool.AppendCertsFromPEM([]byte(config.LDAPCAPEM)) {
return nil, errors.New("LDAP CA PEM contains no certificate")
}
tlsConfig.RootCAs = pool
}
return tlsConfig, nil
}
func dialLDAPDirectory(_ context.Context, config store.AuthProviderConfig) (ldapDirectory, error) {
if err := store.ValidateLDAPProviderConfig(config); err != nil {
return nil, err
}
tlsConfig, err := ldapTLSConfig(config)
if err != nil {
return nil, err
}
conn, err := ldap.DialURL(config.LDAPURL,
ldap.DialWithDialer(&net.Dialer{Timeout: 5 * time.Second, KeepAlive: 30 * time.Second}),
ldap.DialWithTLSConfig(tlsConfig),
)
if err != nil {
return nil, err
}
conn.SetTimeout(8 * time.Second)
if config.LDAPStartTLS {
if err = conn.StartTLS(tlsConfig); err != nil {
conn.Close()
return nil, err
}
}
return conn, nil
}
func ldapStableSubject(raw []byte) (string, error) {
if len(raw) == 0 || len(raw) > 4096 {
return "", errors.New("LDAP immutable UID is missing or too large")
}
return "attr:" + base64.RawURLEncoding.EncodeToString(raw), nil
}
func (s *Server) authenticateLDAPDirectory(ctx context.Context, config store.AuthProviderConfig, login, password string) (ldapIdentity, error) {
login = strings.TrimSpace(login)
if login == "" || len(login) > 512 || password == "" || len(password) > 4096 || config.UUID == "" {
return ldapIdentity{}, store.ErrAccessDenied
}
if err := store.ValidateLDAPProviderConfig(config); err != nil || !config.Enabled {
return ldapIdentity{}, store.ErrAccessDenied
}
dial := s.ldapDial
if dial == nil {
dial = dialLDAPDirectory
}
directory, err := dial(ctx, config)
if err != nil {
return ldapIdentity{}, err
}
defer func() { _ = directory.Close() }()
if config.LDAPBindDN != "" {
if config.LDAPBindPassword == "" {
return ldapIdentity{}, errors.New("LDAP service bind password is unavailable")
}
if err = directory.Bind(config.LDAPBindDN, config.LDAPBindPassword); err != nil {
return ldapIdentity{}, fmt.Errorf("LDAP service bind: %w", err)
}
}
attributes := []string{config.LDAPUIDAttribute, config.LDAPUsernameAttribute, config.LDAPEmailAttribute, config.LDAPDisplayAttribute}
unique := make([]string, 0, len(attributes))
seen := map[string]bool{}
for _, attribute := range attributes {
key := strings.ToLower(attribute)
if !seen[key] {
seen[key] = true
unique = append(unique, attribute)
}
}
filter := strings.ReplaceAll(config.LDAPSearchFilter, "{{username}}", ldap.EscapeFilter(login))
request := ldap.NewSearchRequest(config.LDAPSearchBase, ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 2, 6, false, filter, unique, nil)
result, err := directory.Search(request)
if err != nil {
return ldapIdentity{}, fmt.Errorf("LDAP user search: %w", err)
}
if len(result.Entries) != 1 || result.Entries[0].DN == "" {
return ldapIdentity{}, store.ErrAccessDenied
}
entry := result.Entries[0]
subject, err := ldapStableSubject(entry.GetEqualFoldRawAttributeValue(config.LDAPUIDAttribute))
if err != nil {
return ldapIdentity{}, err
}
identity := ldapIdentity{
Subject: subject, DN: entry.DN,
Username: strings.ToLower(strings.TrimSpace(entry.GetEqualFoldAttributeValue(config.LDAPUsernameAttribute))),
Email: strings.ToLower(strings.TrimSpace(entry.GetEqualFoldAttributeValue(config.LDAPEmailAttribute))),
DisplayName: strings.TrimSpace(entry.GetEqualFoldAttributeValue(config.LDAPDisplayAttribute)),
}
if identity.Username == "" || !utf8.ValidString(identity.Username) || !utf8.ValidString(identity.DisplayName) || !utf8.ValidString(identity.Email) {
return ldapIdentity{}, errors.New("LDAP identity attributes are invalid")
}
// The successful user bind is the password proof. Never retain or log the
// supplied password, and do not accept a search result alone as login.
if err = directory.Bind(entry.DN, password); err != nil {
return ldapIdentity{}, store.ErrAccessDenied
}
return identity, nil
}
func (s *Server) authenticateLDAPPrincipal(ctx context.Context, domainUUID, login, password string) (*store.Principal, error) {
config, err := s.store.AuthProviderConfig(domainUUID, "ldap")
if err != nil || !config.Enabled {
return nil, store.ErrAccessDenied
}
identity, err := s.authenticateLDAPDirectory(ctx, config, login, password)
if err != nil {
return nil, err
}
attributes := map[string]string{"dn": identity.DN, "username": identity.Username, "email": identity.Email, "display_name": identity.DisplayName}
principal, err := s.store.PrincipalByExternalIdentity(domainUUID, "ldap", config.UUID, "", identity.Subject)
if err == nil {
if bindErr := s.store.BindExternalIdentity(principal.UUID, "ldap", config.UUID, "", identity.Subject, attributes); bindErr != nil {
return nil, bindErr
}
return principal, nil
}
if !errors.Is(err, sql.ErrNoRows) {
return nil, err
}
switch config.LDAPMatchBy {
case "email":
principal, err = s.store.PrincipalByVerifiedEmail(domainUUID, identity.Email)
default:
principal, err = s.store.PrincipalByExternalUsername(domainUUID, identity.Username)
}
if err == nil {
if err = s.store.BindExternalIdentityIfProviderUnbound(domainUUID, principal.UUID, "ldap", config.UUID, "", identity.Subject, attributes); err != nil {
return nil, err
}
return principal, nil
}
if !errors.Is(err, store.ErrAccessDenied) || !config.LDAPAutoProvision {
return nil, store.ErrAccessDenied
}
return s.store.ProvisionExternalAccount(domainUUID, identity.Username, identity.DisplayName, identity.Email, "ldap", config.UUID, "", identity.Subject, attributes)
}
func (s *Server) handleLDAPLogin(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
w.Header().Set("Allow", http.MethodPost)
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("Cache-Control", "no-store")
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
}
returnPath := safeReturnPath(r.FormValue("return"))
select {
case s.ldapSlots <- struct{}{}:
defer func() { <-s.ldapSlots }()
default:
http.Error(w, "directory authentication is busy", http.StatusServiceUnavailable)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 12*time.Second)
defer cancel()
domainUUID := s.domainUUIDForRequest(r)
principal, err := s.authenticateLDAPPrincipal(ctx, domainUUID, r.FormValue("username"), r.FormValue("password"))
if err != nil {
log.Printf("LDAP login failed domain=%s error=%v", domainUUID, err)
s.renderAuthPage(w, r, map[string]any{"Error": translate(s.getLocale(domainUUID), "auth.invalid_credentials"), "Return": returnPath})
return
}
if s.store.HasTOTP(principal.UUID) {
challenge, challengeErr := s.store.CreateTOTPLoginChallengeForLogin(domainUUID, principal.UUID, r.PostForm.Get("remember") == "1")
if challengeErr != nil {
http.Error(w, "authentication unavailable", http.StatusServiceUnavailable)
return
}
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
}
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": returnPath})
return
}
token, lifetime, err := s.store.CreateLoginSession(domainUUID, principal.UUID, 0, !strings.Contains(r.Header.Get("Accept"), "application/json"), r.PostForm.Get("remember") == "1")
if err != nil {
http.Error(w, "authentication unavailable", http.StatusServiceUnavailable)
return
}
if strings.Contains(r.Header.Get("Accept"), "application/json") {
writeEventJSON(w, http.StatusOK, map[string]any{"access_token": token, "token_type": "Bearer", "expires_in": int(lifetime.Seconds())})
return
}
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, returnPath, http.StatusSeeOther)
}