package store import ( "crypto/sha256" "database/sql" "encoding/base64" "encoding/json" "errors" "net/url" "regexp" "strings" "time" ldap "github.com/go-ldap/ldap/v3" "github.com/google/uuid" ) type AuthProviderConfig struct { UUID string `json:"-"` Kind string `json:"kind"` Enabled bool `json:"enabled"` Issuer string `json:"issuer,omitempty"` ClientID string `json:"client_id,omitempty"` ClientSecret string `json:"client_secret,omitempty"` OIDCMatchBy string `json:"oidc_match_by,omitempty"` SMTPAddress string `json:"smtp_address,omitempty"` SMTPUsername string `json:"smtp_username,omitempty"` SMTPPassword string `json:"smtp_password,omitempty"` SMTPFrom string `json:"smtp_from,omitempty"` LDAPURL string `json:"ldap_url,omitempty"` LDAPBindDN string `json:"ldap_bind_dn,omitempty"` LDAPBindPassword string `json:"ldap_bind_password,omitempty"` LDAPSearchBase string `json:"ldap_search_base,omitempty"` LDAPSearchFilter string `json:"ldap_search_filter,omitempty"` LDAPStartTLS bool `json:"ldap_start_tls,omitempty"` LDAPSkipTLSVerify bool `json:"ldap_skip_tls_verify,omitempty"` LDAPCAPEM string `json:"ldap_ca_pem,omitempty"` LDAPUIDAttribute string `json:"ldap_uid_attribute,omitempty"` LDAPUsernameAttribute string `json:"ldap_username_attribute,omitempty"` LDAPEmailAttribute string `json:"ldap_email_attribute,omitempty"` LDAPDisplayAttribute string `json:"ldap_display_attribute,omitempty"` LDAPMatchBy string `json:"ldap_match_by,omitempty"` LDAPAutoProvision bool `json:"ldap_auto_provision,omitempty"` } var ldapAttributePattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9.-]*(;[A-Za-z0-9-]+)*$`) func normalizeLDAPProviderConfig(config *AuthProviderConfig) { config.LDAPURL = strings.TrimSpace(config.LDAPURL) config.LDAPBindDN = strings.TrimSpace(config.LDAPBindDN) config.LDAPSearchBase = strings.TrimSpace(config.LDAPSearchBase) config.LDAPSearchFilter = strings.TrimSpace(config.LDAPSearchFilter) if config.LDAPSearchFilter == "" { config.LDAPSearchFilter = "(uid={{username}})" } defaults := map[*string]string{ &config.LDAPUIDAttribute: "uid", &config.LDAPUsernameAttribute: "uid", &config.LDAPEmailAttribute: "mail", &config.LDAPDisplayAttribute: "displayName", } for target, fallback := range defaults { *target = strings.TrimSpace(*target) if *target == "" { *target = fallback } } config.LDAPMatchBy = strings.ToLower(strings.TrimSpace(config.LDAPMatchBy)) if config.LDAPMatchBy == "" { config.LDAPMatchBy = "username" } config.LDAPCAPEM = strings.TrimSpace(config.LDAPCAPEM) } // ValidateLDAPProviderConfig checks only administrator-controlled connection // metadata. It never opens the configured network endpoint. func ValidateLDAPProviderConfig(config AuthProviderConfig) error { normalizeLDAPProviderConfig(&config) if !config.Enabled && config.LDAPURL == "" { return nil } if len(config.LDAPURL) > 2048 || len(config.LDAPBindDN) > 2048 || len(config.LDAPSearchBase) > 2048 || len(config.LDAPSearchFilter) > 2048 || len(config.LDAPCAPEM) > 64<<10 { return errors.New("LDAP setting exceeds its size limit") } parsed, err := url.Parse(config.LDAPURL) if err != nil || (parsed.Scheme != "ldap" && parsed.Scheme != "ldaps") || parsed.Hostname() == "" || parsed.User != nil || (parsed.Path != "" && parsed.Path != "/") || parsed.RawQuery != "" || parsed.Fragment != "" { return errors.New("LDAP URL must be ldap://host[:port] or ldaps://host[:port]") } if parsed.Scheme == "ldaps" && config.LDAPStartTLS { return errors.New("StartTLS cannot be combined with an ldaps URL") } if config.LDAPSearchBase == "" || strings.Count(config.LDAPSearchFilter, "{{username}}") == 0 { return errors.New("LDAP search base and a filter containing {{username}} are required") } if _, err := ldap.ParseDN(config.LDAPSearchBase); err != nil { return errors.New("invalid LDAP search base DN") } if config.LDAPBindDN != "" { if _, err := ldap.ParseDN(config.LDAPBindDN); err != nil { return errors.New("invalid LDAP service bind DN") } } if _, err := ldap.CompileFilter(strings.ReplaceAll(config.LDAPSearchFilter, "{{username}}", "validation-user")); err != nil { return errors.New("invalid LDAP search filter") } for _, attribute := range []string{config.LDAPUIDAttribute, config.LDAPUsernameAttribute, config.LDAPEmailAttribute, config.LDAPDisplayAttribute} { if !ldapAttributePattern.MatchString(attribute) || len(attribute) > 128 { return errors.New("invalid LDAP attribute mapping") } } if config.LDAPMatchBy != "username" && config.LDAPMatchBy != "email" { return errors.New("unsupported LDAP account matching field") } return nil } func externalIdentityPayload(attributes any) (string, error) { payload, err := json.Marshal(attributes) if err != nil || len(payload) > 64<<10 { if err == nil { err = errors.New("external identity attributes exceed 64 KiB") } return "", err } return string(payload), nil } // BindExternalIdentityIfProviderUnbound performs the first-login bootstrap // without allowing a recreated external account with the same mutable username // or email to replace an identity already bound from this provider. func (s *Store) BindExternalIdentityIfProviderUnbound(domainUUID, principalUUID, providerType, providerUUID, issuer, subject string, attributes any) error { if domainUUID == "" || principalUUID == "" || providerType == "" || providerUUID == "" || strings.TrimSpace(subject) == "" { return ErrAccessDenied } payload, err := externalIdentityPayload(attributes) if err != nil { return err } tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() if _, err = tx.Exec(`UPDATE principals SET updated_at_ms=updated_at_ms WHERE uuid=?`, principalUUID); err != nil { return err } var eligible, alreadyBound bool if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE p.uuid=? AND p.state IN ('active','readonly'))`, domainUUID, principalUUID).Scan(&eligible); err != nil || !eligible { return ErrAccessDenied } if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=? AND provider_type=? AND provider_uuid=?)`, principalUUID, providerType, providerUUID).Scan(&alreadyBound); err != nil || alreadyBound { return ErrAccessDenied } if _, err = tx.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, payload, time.Now().UnixMilli()); err != nil { return ErrAccessDenied } return tx.Commit() } // ProvisionExternalAccount creates a normal Domain member with a local // username identity but no local password credential, and binds the immutable // directory identity in the same transaction. func (s *Store) ProvisionExternalAccount(domainUUID, username, displayName, email, providerType, providerUUID, issuer, subject string, attributes any) (*Principal, error) { username = strings.ToLower(strings.TrimSpace(username)) if !authUsernamePattern.MatchString(username) || domainUUID == "" || providerType == "" || providerUUID == "" || strings.TrimSpace(subject) == "" { return nil, ErrAccessDenied } payload, err := externalIdentityPayload(attributes) if err != nil { return nil, err } now := time.Now().UnixMilli() p := &Principal{UUID: uuid.NewString(), Username: username, DisplayName: strings.TrimSpace(displayName), Email: strings.TrimSpace(email), State: "active"} if p.DisplayName == "" { p.DisplayName = username } tx, err := s.DB.Begin() if err != nil { return nil, err } defer tx.Rollback() roleID := "" err = tx.QueryRow(`SELECT uuid FROM auth_roles WHERE domain_uuid=? AND name='member'`, domainUUID).Scan(&roleID) if errors.Is(err, sql.ErrNoRows) { roleID = uuid.NewString() if _, err = tx.Exec(`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, roleID, domainUUID, "member", "Domain member", now); err != nil { return nil, err } if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil { return nil, err } } else if err != nil { return nil, err } membershipID := uuid.NewString() for _, item := range []struct { query string args []any }{ {`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}}, {`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, now}}, {`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, providerType, providerUUID, issuer, subject, payload, now}}, {`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, p.UUID, "active", now}}, {`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}}, } { if _, err = tx.Exec(item.query, item.args...); err != nil { return nil, ErrAccessDenied } } if err = tx.Commit(); err != nil { return nil, err } return p, nil } func (s *Store) SetAuthProviderConfig(domainUUID string, config AuthProviderConfig) error { config.Kind = strings.ToLower(strings.TrimSpace(config.Kind)) if config.Kind != "oidc" && config.Kind != "smtp" && config.Kind != "ldap" { return errors.New("unsupported authentication provider") } if config.Kind == "oidc" { config.OIDCMatchBy = strings.ToLower(strings.TrimSpace(config.OIDCMatchBy)) if config.OIDCMatchBy == "" { config.OIDCMatchBy = "email" } if config.OIDCMatchBy != "email" && config.OIDCMatchBy != "display_name" && config.OIDCMatchBy != "preferred_username" { return errors.New("unsupported OIDC account matching field") } } if config.Kind == "ldap" { normalizeLDAPProviderConfig(&config) if err := ValidateLDAPProviderConfig(config); err != nil { return err } } secret := config.ClientSecret if config.Kind == "smtp" { secret = config.SMTPPassword } else if config.Kind == "ldap" { secret = config.LDAPBindPassword } config.ClientSecret, config.SMTPPassword, config.LDAPBindPassword = "", "", "" payload, err := json.Marshal(config) if err != nil { return err } encrypted := "" if secret != "" { encrypted, err = s.encryptAuthSecret([]byte(secret)) if err != nil { return err } } else { _ = s.DB.QueryRow(`SELECT secret_encrypted FROM auth_providers WHERE domain_uuid=? AND kind=?`, domainUUID, config.Kind).Scan(&encrypted) } _, err = s.DB.Exec(`INSERT INTO auth_providers(uuid,domain_uuid,kind,config_json,secret_encrypted,enabled,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET config_json=excluded.config_json,secret_encrypted=excluded.secret_encrypted,enabled=excluded.enabled,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), domainUUID, config.Kind, string(payload), encrypted, config.Enabled, time.Now().UnixMilli(), time.Now().UnixMilli()) return err } func (s *Store) AuthProviderConfig(domainUUID, kind string) (AuthProviderConfig, error) { var config AuthProviderConfig var payload, encrypted string var enabled bool err := s.DB.QueryRow(`SELECT uuid,config_json,secret_encrypted,enabled FROM auth_providers WHERE domain_uuid=? AND kind=?`, domainUUID, kind).Scan(&config.UUID, &payload, &encrypted, &enabled) if err != nil { return config, err } if err := json.Unmarshal([]byte(payload), &config); err != nil { return config, err } config.Enabled = enabled if kind == "oidc" { config.OIDCMatchBy = strings.ToLower(strings.TrimSpace(config.OIDCMatchBy)) if config.OIDCMatchBy != "display_name" && config.OIDCMatchBy != "preferred_username" { // Missing legacy values and unrecognized values both fail back to the // stricter verified-email bootstrap policy. config.OIDCMatchBy = "email" } } if kind == "ldap" { normalizeLDAPProviderConfig(&config) } if encrypted != "" { secret, err := s.decryptAuthSecret(encrypted) if err != nil { return config, err } if kind == "oidc" { config.ClientSecret = string(secret) } else if kind == "smtp" { config.SMTPPassword = string(secret) } else if kind == "ldap" { config.LDAPBindPassword = string(secret) } } return config, nil } // PrincipalByExternalUsername resolves the OIDC preferred_username claim to // the local password username while enforcing the same account and Domain // membership state checks as the other external-login bootstrap strategies. func (s *Store) PrincipalByExternalUsername(domainUUID, username string) (*Principal, error) { username = strings.ToLower(strings.TrimSpace(username)) if username == "" || domainUUID == "" { return nil, ErrAccessDenied } rows, err := s.DB.Query(`SELECT p.uuid,i.subject,p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE i.provider_type='password' AND i.subject=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, username) if err != nil { return nil, err } defer rows.Close() var found *Principal for rows.Next() { if found != nil { return nil, ErrAccessDenied } var principal Principal if err := rows.Scan(&principal.UUID, &principal.Username, &principal.DisplayName, &principal.Email, &principal.State, &principal.HasAvatar); err != nil { return nil, err } found = &principal } if err := rows.Err(); err != nil { return nil, err } if found == nil { return nil, ErrAccessDenied } return found, nil } func (s *Store) PrincipalByVerifiedEmail(domainUUID, email string) (*Principal, error) { email = strings.ToLower(strings.TrimSpace(email)) if email == "" || domainUUID == "" { return nil, ErrAccessDenied } rows, err := s.DB.Query(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE lower(p.email)=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, email) if err != nil { return nil, err } defer rows.Close() var found *Principal for rows.Next() { if found != nil { return nil, ErrAccessDenied } var p Principal if err := rows.Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar); err != nil { return nil, err } found = &p } if err := rows.Err(); err != nil { return nil, err } if found == nil { return nil, ErrAccessDenied } return found, nil } // PrincipalByDisplayName deliberately requires an exact, unique match inside // the active Domain membership. Display names are mutable and not identifiers; // this is only a first-login bootstrap before the provider issuer+sub binding // becomes authoritative. func (s *Store) PrincipalByDisplayName(domainUUID, displayName string) (*Principal, error) { displayName = strings.TrimSpace(displayName) if displayName == "" || domainUUID == "" { return nil, ErrAccessDenied } rows, err := s.DB.Query(`SELECT p.uuid, COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid), p.display_name,p.email,p.state,length(p.avatar)>0 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE p.display_name=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, displayName) if err != nil { return nil, err } defer rows.Close() var found *Principal for rows.Next() { if found != nil { return nil, ErrAccessDenied } var principal Principal if err := rows.Scan(&principal.UUID, &principal.Username, &principal.DisplayName, &principal.Email, &principal.State, &principal.HasAvatar); err != nil { return nil, err } found = &principal } if err := rows.Err(); err != nil { return nil, err } if found == nil { return nil, ErrAccessDenied } return found, nil } func (s *Store) BindExternalIdentity(principalUUID, providerType, providerUUID, issuer, subject string, attributes any) error { if strings.TrimSpace(subject) == "" || strings.TrimSpace(principalUUID) == "" { return ErrAccessDenied } payload, err := json.Marshal(attributes) if err != nil { return err } now := time.Now().UnixMilli() result, err := s.DB.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(provider_type,provider_uuid,issuer,subject) DO UPDATE SET attributes_json=excluded.attributes_json WHERE principal_identities.principal_uuid=excluded.principal_uuid`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, string(payload), now) if err != nil { return err } changed, err := result.RowsAffected() if err != nil { return err } if changed != 1 { return ErrAccessDenied } return nil } func (s *Store) PrincipalByExternalIdentity(domainUUID, providerType, providerUUID, issuer, subject string) (*Principal, error) { var p Principal err := s.DB.QueryRow(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities x WHERE x.principal_uuid=p.uuid AND x.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE i.provider_type=? AND i.provider_uuid=? AND i.issuer=? AND i.subject=? AND p.state IN ('active','readonly')`, domainUUID, providerType, providerUUID, issuer, subject).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar) return &p, err } func (s *Store) CreateAuthChallenge(domainUUID, principalUUID, kind string, payload any, lifetime time.Duration) (string, error) { token, hash, err := authToken() if err != nil { return "", err } encoded, _ := json.Marshal(payload) now := time.Now().UnixMilli() _, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), domainUUID, principalUUID, kind, hash, string(encoded), now+lifetime.Milliseconds(), now) return token, err } func (s *Store) ConsumeAuthChallenge(domainUUID, kind, token string, payload any) (string, error) { hash := hashAuthToken(token) var id, principalUUID, encoded string var expires int64 err := s.DB.QueryRow(`SELECT uuid,principal_uuid,payload_json,expires_at_ms FROM auth_challenges WHERE domain_uuid=? AND kind=? AND token_hash=? AND consumed_at_ms=0`, domainUUID, kind, hash).Scan(&id, &principalUUID, &encoded, &expires) if err != nil || expires < time.Now().UnixMilli() { return "", ErrAccessDenied } result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=? WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), id) if err != nil { return "", err } changed, _ := result.RowsAffected() if changed != 1 { return "", ErrAccessDenied } if payload != nil && json.Unmarshal([]byte(encoded), payload) != nil { return "", ErrAccessDenied } return principalUUID, nil } func hashAuthToken(token string) string { sum := sha256.Sum256([]byte(token)) return base64.RawURLEncoding.EncodeToString(sum[:]) }