Files
pages/internal/server/auth_ldap.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +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": 86400})
return
}
s.setAuthCookie(w, r, token)
http.Redirect(w, r, returnPath, http.StatusSeeOther)
}