Files
pages/internal/server/auth_ldap.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

254 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.CreateTOTPLoginChallenge(domainUUID, principal.UUID)
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
}
var token string
if strings.Contains(r.Header.Get("Accept"), "application/json") {
token, err = s.store.CreateAuthSession(domainUUID, principal.UUID)
} else {
token, err = s.store.CreateBrowserAuthSession(domainUUID, principal.UUID, 0)
}
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": s.store.AuthSessionLifetimeMinutes(domainUUID) * 60})
return
}
s.setAuthCookie(w, r, token)
http.Redirect(w, r, returnPath, http.StatusSeeOther)
}