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.
254 lines
9.0 KiB
Go
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)
|
|
}
|