A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(api/sso): link SSO identities and sync group roles
Hampus2e0e79eed97b
diff --git a/fluxer_api/src/api/auth/services/SsoIdentityLinks.ts b/fluxer_api/src/api/auth/services/SsoIdentityLinks.tsnew file mode 100644index 000000000..2af580303--- /dev/null+++ b/fluxer_api/src/api/auth/services/SsoIdentityLinks.ts@@ -0,0 +1,112 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {createHash} from 'node:crypto';+import {SsoIdentityRepository} from '@app/api/auth/services/SsoIdentityRepository';+import type {UserSsoIdentityRow} from '@app/api/database/types/AuthTypes';+import type {InstanceSsoConfig} from '@app/api/instance/InstanceConfigRepository';+import type {User} from '@app/api/models/User';+import type {UserRepository} from '@app/api/user/repositories/UserRepository';+import {UserTraits} from '@app/api/user/UserTraits';+import {UserFlags} from '@fluxer/constants/src/UserConstants';+import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';+import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';++const SSO_IDENTITY_TRAIT_PREFIXES = ['sso:', 'sso_provider:', 'sso_identity:'];++export function ssoProviderIdOf(config: Pick<InstanceSsoConfig, 'issuer' | 'authorizationUrl'>): string {+ return config.issuer || config.authorizationUrl || 'sso';+}++export function ssoIdentityTrait(providerId: string, sub: string): string {+ const digest = createHash('sha256').update(providerId).update('\0').update(sub).digest('hex');+ return `sso_identity:${digest}`;+}++export function ssoIdentityTraits(providerId: string, sub: string): Array<string> {+ const providerDigest = createHash('sha256').update(providerId).digest('hex').slice(0, 32);+ return [UserTraits.SSO, `sso:${providerId}`, `sso_provider:${providerDigest}`, ssoIdentityTrait(providerId, sub)];+}++function withoutSsoIdentityTraits(traits: Iterable<string>): Set<string> {+ return new Set(+ Array.from(traits).filter(+ (trait) => trait !== UserTraits.SSO && !SSO_IDENTITY_TRAIT_PREFIXES.some((prefix) => trait.startsWith(prefix)),+ ),+ );+}++function isLiveAccount(user: User | null): user is User {+ return user !== null && (user.flags & UserFlags.DELETED) === 0n;+}++export class SsoIdentityLinkService {+ private readonly identities = new SsoIdentityRepository();++ constructor(private readonly users: UserRepository) {}++ async unlink(user: User, providerId: string): Promise<Array<UserSsoIdentityRow>> {+ await this.releaseAll(user, providerId);+ await this.users.patchUpsert(user.id, {traits: withoutSsoIdentityTraits(user.traits)}, user.toRow());+ return this.identities.listForUser(user.id);+ }++ async link(user: User, providerId: string, subject: string): Promise<Array<UserSsoIdentityRow>> {+ const holder = await this.identities.findIdentity(providerId, subject);+ if (holder && holder.user_id !== user.id) {+ if (isLiveAccount(await this.users.findUnique(holder.user_id))) {+ throw InputValidationError.fromCode('subject', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);+ }+ await this.identities.releaseIdentity(providerId, subject);+ }+ await this.releaseAll(user, providerId);+ await this.identities.tryClaimIdentity({providerId, subject, userId: user.id, claimedAt: new Date()});+ const traits = withoutSsoIdentityTraits(user.traits);+ for (const trait of ssoIdentityTraits(providerId, subject)) {+ traits.add(trait);+ }+ await this.users.patchUpsert(user.id, {traits}, user.toRow());+ return this.identities.listForUser(user.id);+ }++ async migrate(fromProviderId: string, toProviderId: string): Promise<{moved: number; skipped: number}> {+ let moved = 0;+ let skipped = 0;+ for (const identity of await this.identities.listForProvider(fromProviderId)) {+ const user = await this.users.findUnique(identity.user_id);+ if (!user || !(await this.claimFor(toProviderId, identity))) {+ skipped += 1;+ continue;+ }+ await this.identities.releaseIdentity(fromProviderId, identity.subject);+ const traits = new Set(user.traits);+ for (const trait of ssoIdentityTraits(fromProviderId, identity.subject)) {+ traits.delete(trait);+ }+ for (const trait of ssoIdentityTraits(toProviderId, identity.subject)) {+ traits.add(trait);+ }+ await this.users.patchUpsert(user.id, {traits}, user.toRow());+ moved += 1;+ }+ return {moved, skipped};+ }++ private async releaseAll(user: User, providerId: string): Promise<void> {+ if ((await this.identities.releaseIdentitiesForUser(user.id)) > 0) return;+ for (const identity of await this.identities.listForProvider(providerId)) {+ if (identity.user_id === user.id) {+ await this.identities.releaseIdentity(identity.provider_id, identity.subject);+ }+ }+ }++ private async claimFor(providerId: string, identity: UserSsoIdentityRow): Promise<boolean> {+ const claimed = await this.identities.tryClaimIdentity({+ providerId,+ subject: identity.subject,+ userId: identity.user_id,+ claimedAt: identity.claimed_at,+ });+ return claimed || (await this.identities.findUserId(providerId, identity.subject)) === identity.user_id;+ }+}diff --git a/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts b/fluxer_api/src/api/auth/services/SsoIdentityRepository.tsindex 6288ac3a7..47fcf510e 100644--- a/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts+++ b/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts@@ -1,9 +1,9 @@// SPDX-License-Identifier: AGPL-3.0-or-laterimport type {UserID} from '@app/api/BrandedTypes';-import {deleteOneOrMany, executeQuery, fetchOne} from '@app/api/database/CassandraQueryExecution';+import {deleteOneOrMany, executeQuery, fetchMany, fetchOne, upsertOne} from '@app/api/database/CassandraQueryExecution';import type {UserSsoIdentityRow} from '@app/api/database/types/AuthTypes';-import {UserSsoIdentities} from '@app/api/Tables';+import {UserSsoIdentities, UserSsoIdentitiesByUser} from '@app/api/Tables';interface ConditionalInsertResult {'[applied]': boolean;@@ -14,12 +14,21 @@ const FIND_SSO_IDENTITY_QUERY = UserSsoIdentities.select({limit: 1,});+const LIST_PROVIDER_IDENTITIES_QUERY = UserSsoIdentities.select({+ where: UserSsoIdentities.where.eq('provider_id'),+});++const LIST_USER_IDENTITIES_QUERY = UserSsoIdentitiesByUser.select({+ where: UserSsoIdentitiesByUser.where.eq('user_id'),+});+export class SsoIdentityRepository {+ async findIdentity(providerId: string, subject: string): Promise<UserSsoIdentityRow | null> {+ return fetchOne<UserSsoIdentityRow>(FIND_SSO_IDENTITY_QUERY.bind({provider_id: providerId, subject}));+ }+async findUserId(providerId: string, subject: string): Promise<UserID | null> {- const row = await fetchOne<Pick<UserSsoIdentityRow, 'user_id'>>(- FIND_SSO_IDENTITY_QUERY.bind({provider_id: providerId, subject}),- );- return row?.user_id ?? null;+ return (await this.findIdentity(providerId, subject))?.user_id ?? null;}async tryClaimIdentity(params: {@@ -28,21 +37,73 @@ export class SsoIdentityRepository {userId: UserID;claimedAt: Date;}): Promise<boolean> {- const [result] = await executeQuery<ConditionalInsertResult>(- UserSsoIdentities.insertIfNotExists({- provider_id: params.providerId,- subject: params.subject,- user_id: params.userId,- claimed_at: params.claimedAt,- }),- );+ const row: UserSsoIdentityRow = {+ provider_id: params.providerId,+ subject: params.subject,+ user_id: params.userId,+ claimed_at: params.claimedAt,+ };+ const [result] = await executeQuery<ConditionalInsertResult>(UserSsoIdentities.insertIfNotExists(row));if (!result || typeof result['[applied]'] !== 'boolean') {throw new Error('Unexpected database response for SSO identity claim');}+ if (result['[applied]']) {+ await this.indexIdentity(row);+ }return result['[applied]'];}+ async indexIdentity(row: UserSsoIdentityRow): Promise<void> {+ await upsertOne(UserSsoIdentitiesByUser.insert(row));+ }+async releaseIdentity(providerId: string, subject: string): Promise<void> {+ const identity = await this.findIdentity(providerId, subject);await deleteOneOrMany(UserSsoIdentities.deleteByPk({provider_id: providerId, subject}));+ if (identity) {+ await this.unindexIdentity(identity);+ }+ }++ async listForUser(userId: UserID): Promise<Array<UserSsoIdentityRow>> {+ const indexed = await fetchMany<UserSsoIdentityRow>(LIST_USER_IDENTITIES_QUERY.bind({user_id: userId}));+ const identities: Array<UserSsoIdentityRow> = [];+ for (const entry of indexed) {+ const identity = await this.findIdentity(entry.provider_id, entry.subject);+ if (identity?.user_id === userId) {+ identities.push(identity);+ }+ }+ return identities;+ }++ async listForProvider(providerId: string): Promise<Array<UserSsoIdentityRow>> {+ return fetchMany<UserSsoIdentityRow>(LIST_PROVIDER_IDENTITIES_QUERY.bind({provider_id: providerId}));+ }++ async releaseIdentitiesForUser(userId: UserID): Promise<number> {+ const indexed = await fetchMany<UserSsoIdentityRow>(LIST_USER_IDENTITIES_QUERY.bind({user_id: userId}));+ let released = 0;+ for (const entry of indexed) {+ const identity = await this.findIdentity(entry.provider_id, entry.subject);+ if (identity?.user_id === userId) {+ await deleteOneOrMany(+ UserSsoIdentities.deleteByPk({provider_id: identity.provider_id, subject: identity.subject}),+ );+ released += 1;+ }+ await this.unindexIdentity({...entry, user_id: userId});+ }+ return released;+ }++ private async unindexIdentity(identity: UserSsoIdentityRow): Promise<void> {+ await deleteOneOrMany(+ UserSsoIdentitiesByUser.deleteByPk({+ user_id: identity.user_id,+ provider_id: identity.provider_id,+ subject: identity.subject,+ }),+ );}}diff --git a/fluxer_api/src/api/auth/services/SsoService.ts b/fluxer_api/src/api/auth/services/SsoService.tsindex 330f62422..6376ee24b 100644--- a/fluxer_api/src/api/auth/services/SsoService.ts+++ b/fluxer_api/src/api/auth/services/SsoService.ts@@ -2,28 +2,34 @@import {createHash, randomBytes} from 'node:crypto';import type {ApiContext} from '@app/api/ApiContext';-import {maybeAutoJoinInvite} from '@app/api/auth/AuthRegistration';+import {createMfaTicketResponse, type LoginMfaResult} from '@app/api/auth/AuthLogin';+import * as AuthMfa from '@app/api/auth/AuthMfa';+import {assertAccountCreationPastSetup, maybeAutoJoinInvite} from '@app/api/auth/AuthRegistration';import * as AuthSession from '@app/api/auth/AuthSession';import * as AuthUtility from '@app/api/auth/AuthUtility';-import {assertEmailNotBlocklisted} from '@app/api/auth/EmailBlocklist';+import {assertEmailNotBlocklisted, isEmailBlocklisted} from '@app/api/auth/EmailBlocklist';+import {ssoIdentityTrait, ssoIdentityTraits, ssoProviderIdOf} from '@app/api/auth/services/SsoIdentityLinks';import {SsoIdentityRepository} from '@app/api/auth/services/SsoIdentityRepository';import {parseTokenEndpointResponse,sanitizeSsoRedirectTo,tryDiscoverOidcProviderMetadata,} from '@app/api/auth/services/SsoUtils';-import type {UserID} from '@app/api/BrandedTypes';+import {userHasMfa} from '@app/api/auth/services/SudoMethods';+import {resolveWebAuthnSecondFactor} from '@app/api/auth/services/WebAuthnSecondFactor';+import {createRoleID, type UserID} from '@app/api/BrandedTypes';import {EMPTY_USER_ROW, type UserRow} from '@app/api/database/types/UserTypes';+import type {GuildMemberService} from '@app/api/guild/services/GuildMemberService';import {emitActivity} from '@app/api/infrastructure/activity/ActivityEvents';import type {DiscriminatorService} from '@app/api/infrastructure/DiscriminatorService';import type {KVActivityTracker} from '@app/api/infrastructure/KVActivityTracker';-import {usesUsernameSignIn} from '@app/api/instance/AccountIdentityModeCache';+import {instanceCollectsDateOfBirth} from '@app/api/instance/DateOfBirthCollectionCache';import {type InstanceConfigRepository,type InstanceSsoConfig,REGISTRATION_PENDING_APPROVAL_TRAIT,} from '@app/api/instance/InstanceConfigRepository';-import type {SingleCommunityService} from '@app/api/instance/SingleCommunityService';+import {canJoinSingleCommunity, type SingleCommunityService} from '@app/api/instance/SingleCommunityService';import {deriveSsoRedirectUri,getSsoRequestUrlPolicy,@@ -33,11 +39,15 @@ import {import type {InviteService} from '@app/api/invite/InviteService';import {Logger} from '@app/api/Logger';import {profileSubstringBlocklistCache} from '@app/api/middleware/ProfileSubstringBlocklistCache';-import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';+import {createRequestCache, type RequestCache} from '@app/api/middleware/RequestCacheMiddleware';import type {User} from '@app/api/models/User';import {UserSettings} from '@app/api/models/UserSettings';+import {enqueueStripeCustomerEmailSync} from '@app/api/stripe/StripeCustomer';import {deriveAvailableUsername, reserveUsername, type UsernameReservation} from '@app/api/user/UniqueUsernames';+import {isEnforcementDeletion} from '@app/api/user/UserHelpers';+import {dispatchUserUpdate} from '@app/api/user/UserMappers';import {USERNAME_MODE_DISCRIMINATOR} from '@app/api/user/UserTag';+import {DOB_DEFERRED_TRAIT} from '@app/api/user/UserTraits';import {EXTERNAL_RESPONSE_LIMITS} from '@app/api/utils/ExternalResponseLimits';import * as FetchUtils from '@app/api/utils/FetchUtils';import {isJsonRecord, parseJsonRecord, parseJsonWithGuard} from '@app/api/utils/JsonBoundaryUtils';@@ -46,11 +56,10 @@ import {generateRandomUsername} from '@app/api/utils/UsernameGenerator';import {deriveUsernameFromDisplayName} from '@app/api/utils/UsernameSuggestionUtils';import {AccountIdentityModes, TagStyles} from '@fluxer/constants/src/AccountIdentityConstants';import {SSO_MOBILE_CALLBACK_URI, SSO_MOBILE_STATE_PREFIX} from '@fluxer/constants/src/SsoConstants';-import {ProfileFieldPrivacyFlags} from '@fluxer/constants/src/UserConstants';+import {ProfileFieldPrivacyFlags, UserFlags} from '@fluxer/constants/src/UserConstants';import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';-import {RegistrationClosedError} from '@fluxer/errors/src/domains/auth/RegistrationClosedError';import {RegistrationPendingApprovalError} from '@fluxer/errors/src/domains/auth/RegistrationPendingApprovalError';-import {SsoRequiredError} from '@fluxer/errors/src/domains/auth/SsoRequiredError';+import {SsoRequiredError, SsoRequiredReasons} from '@fluxer/errors/src/domains/auth/SsoRequiredError';import {ContentBlockedError} from '@fluxer/errors/src/domains/content/ContentBlockedError';import {FeatureTemporarilyDisabledError} from '@fluxer/errors/src/domains/core/FeatureTemporarilyDisabledError';import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';@@ -78,10 +87,26 @@ interface SsoStatePayload {createdAt: number;}+interface PendingSsoLink {+ userId: string;+ providerId: string;+ subject: string;+ groups: Array<string> | null;+}++interface SsoSignIn {+ token: string;+ user_id: string;+ redirect_to: string;+}++type SsoCompletion = SsoSignIn | (LoginMfaResult & {redirect_to: string});+interface PublicSsoStatus {enabled: boolean;enforced: boolean;display_name: string | null;+ button_label: string | null;redirect_uri: string;}@@ -95,10 +120,12 @@ interface ResolvedSsoConfig extends InstanceSsoConfig {}interface ResolvedSsoClaims {- email: string;+ email: string | null;emailVerified: boolean;- name?: string | null;+ preferredUsername: string | null;+ name: string | null;sub: string;+ groups: Array<string> | null;}interface RemoteJwkSetResolver {@@ -138,7 +165,11 @@ function buildStateCacheKey(state: string): string {return `sso:state:${state}`;}-function buildDiscoveryCacheKey(issuer: string): string {+function pendingSsoLinkKey(ticket: string): string {+ return `sso:pending-link:${ticket}`;+}++export function ssoDiscoveryCacheKey(issuer: string): string {const key = createHash('sha256').update(issuer).digest('hex').slice(0, 32);return `sso:oidc-discovery:${key}`;}@@ -169,16 +200,6 @@ function validateEmailAgainstAllowlist(email: string, domains: Array<string>): v}}-function buildSsoProviderTrait(providerId: string): string {- const digest = createHash('sha256').update(providerId).digest('hex').slice(0, 32);- return `sso_provider:${digest}`;-}--function buildSsoIdentityTrait(providerId: string, sub: string): string {- const digest = createHash('sha256').update(providerId).update('\0').update(sub).digest('hex');- return `sso_identity:${digest}`;-}-function normalizeSsoEmail(rawEmail: string): string {const email = rawEmail.trim().toLowerCase();if (!EmailType.safeParse(email).success) {@@ -202,17 +223,84 @@ function readStringClaim(return typeof value === 'string' ? value : undefined;}-function parseTestProviderClaims(rawPayload: string): ResolvedSsoClaims {+function readTrimmedClaim(record: Record<string, unknown> | JWTPayload | null | undefined, key: string): string | null {+ return readStringClaim(record, key)?.trim() || null;+}++function readDisplayName(record: Record<string, unknown> | JWTPayload | null | undefined): string | null {+ const name = readTrimmedClaim(record, 'name');+ if (name) return name;+ const parts = [readTrimmedClaim(record, 'given_name'), readTrimmedClaim(record, 'family_name')];+ return parts.filter((part): part is string => part !== null).join(' ') || null;+}++const DEFAULT_GROUPS_CLAIM = 'groups';++function readGroupsClaim(+ record: Record<string, unknown> | JWTPayload | null | undefined,+ key: string,+): Array<string> | null {+ const value = record?.[key];+ if (typeof value === 'string') return [value];+ if (!Array.isArray(value)) return null;+ return value.filter((group): group is string => typeof group === 'string');+}++function parseTestProviderClaims(rawPayload: string, groupsClaim: string): ResolvedSsoClaims {const parsed = rawPayload.trim().startsWith('{') ? parseJsonRecord(rawPayload) : null;- const rawEmail = parsed ? readStringClaim(parsed, 'email') : rawPayload;- if (!rawEmail) {+ if (!parsed) {+ const email = normalizeSsoEmail(rawPayload);+ return {+ email,+ emailVerified: true,+ preferredUsername: null,+ name: 'Test SSO User',+ sub: normalizeSsoSubject(email),+ groups: null,+ };+ }+ const rawEmail = readStringClaim(parsed, 'email');+ const email = rawEmail ? normalizeSsoEmail(rawEmail) : null;+ const sub = readStringClaim(parsed, 'sub') ?? email;+ if (!sub) {throw InputValidationError.fromCode('code', ValidationErrorCodes.SSO_TEST_CODE_MISSING_EMAIL);}- const email = normalizeSsoEmail(rawEmail);- const sub = normalizeSsoSubject(parsed ? (readStringClaim(parsed, 'sub') ?? email) : email);- const emailVerified = parsed ? (coerceEmailVerified(parsed['email_verified']) ?? true) : true;- const name = parsed ? (readStringClaim(parsed, 'name') ?? 'Test SSO User') : 'Test SSO User';- return {email, emailVerified, name, sub};+ return {+ email,+ emailVerified: email !== null && (coerceEmailVerified(parsed['email_verified']) ?? true),+ preferredUsername: readTrimmedClaim(parsed, 'preferred_username'),+ name: readDisplayName(parsed),+ sub: normalizeSsoSubject(sub),+ groups: readGroupsClaim(parsed, groupsClaim),+ };+}++function deriveSsoUsernameBase(claims: ResolvedSsoClaims): string | null {+ const preferredUsername = claims.preferredUsername?.split('@')[0];+ for (const candidate of [preferredUsername, claims.name, claims.email?.split('@')[0]]) {+ const username = candidate ? deriveUsernameFromDisplayName(candidate) : null;+ if (username) return username;+ }+ return null;+}++function resolveUsableSsoEmail(+ claims: ResolvedSsoClaims,+ allowedEmailDomains: Array<string>,+ usernameMode: boolean,+): string | null {+ const emailRequired = !usernameMode || allowedEmailDomains.length > 0;+ if (!emailRequired) {+ return claims.emailVerified ? claims.email : null;+ }+ if (!claims.email) {+ throw InputValidationError.fromCode('email', ValidationErrorCodes.SSO_PROVIDER_DID_NOT_RETURN_EMAIL);+ }+ if (!claims.emailVerified) {+ throw InputValidationError.fromCode('email_verified', ValidationErrorCodes.SSO_EMAIL_NOT_VERIFIED);+ }+ validateEmailAgainstAllowlist(claims.email, allowedEmailDomains);+ return claims.email;}function readMatchingEmailVerified(@@ -269,6 +357,7 @@ export class SsoService {private readonly kvActivityTracker: KVActivityTracker,private readonly singleCommunityService: SingleCommunityService,private readonly inviteService: InviteService,+ private readonly guildMemberService: GuildMemberService,) {}async getPublicStatus(): Promise<PublicSsoStatus> {@@ -278,6 +367,7 @@ export class SsoService {enabled,enforced: enabled && config.enforced,display_name: config.displayName ?? null,+ button_label: config.buttonLabel,redirect_uri: config.redirectUri,};}@@ -340,16 +430,14 @@ export class SsoService {state,request,requestCache,+ clientIp,}: {code: string;state: string;request: Request;requestCache: RequestCache;- }): Promise<{- token: string;- user_id: string;- redirect_to: string;- }> {+ clientIp: string;+ }): Promise<SsoCompletion> {const config = await this.requireReadyConfig();const {cache} = this.apiContext.services;const statePayload = await cache.getAndDelete<SsoStatePayload>(buildStateCacheKey(state));@@ -363,56 +451,131 @@ export class SsoService {config,});const claims = await this.resolveClaims(tokenResponse, config, statePayload.nonce);- const user = await this.resolveUserFromClaims(claims, config, requestCache);+ const redirectTo = statePayload.redirectTo ?? '';+ const resolved = await this.resolveUserFromClaims(claims, config, requestCache, clientIp);+ if (resolved.secondFactorRequired) {+ return {...(await this.challengeSecondFactor(resolved.user, claims, config)), redirect_to: redirectTo};+ }+ const {user} = resolved;+ await this.joinCommunityAndSyncRoles(user, claims.groups, config, requestCache);const [token] = await AuthSession.createAuthSession(this.apiContext, {user,origin: AuthSession.resolveSessionOrigin(this.apiContext, request),});- return {token, user_id: user.id.toString(), redirect_to: statePayload.redirectTo ?? ''};+ if (config.enforced && claims.email && claims.emailVerified) {+ await this.syncEnforcedEmail(user, claims.email);+ }+ return {token, user_id: user.id.toString(), redirect_to: redirectTo};}- private async resolveUserFromClaims(+ async isPendingLinkTicket(ticket: string): Promise<boolean> {+ return this.apiContext.services.cache.exists(pendingSsoLinkKey(ticket));+ }++ async completePendingLink(user: User, ticket: string): Promise<User> {+ const {cache} = this.apiContext.services;+ const pending = await cache.getAndDelete<PendingSsoLink>(pendingSsoLinkKey(ticket));+ if (!pending) {+ return user;+ }+ try {+ const config = await this.requireReadyConfig();+ if (pending.userId !== user.id.toString() || pending.providerId !== config.providerId) {+ throw InputValidationError.fromCode('ticket', ValidationErrorCodes.SESSION_TIMEOUT);+ }+ const linkedUser = await this.bindSsoIdentity(user, pending.subject, config);+ await this.joinCommunityAndSyncRoles(linkedUser, pending.groups, config, createRequestCache());+ return linkedUser;+ } catch (error) {+ await cache.delete(`mfa-ticket:${ticket}`);+ throw error;+ }+ }++ private async challengeSecondFactor(+ user: User,claims: ResolvedSsoClaims,config: ResolvedSsoConfig,+ ): Promise<LoginMfaResult> {+ AuthUtility.assertMfaTicketAllowed(this.apiContext, user);+ const challenge = await createMfaTicketResponse(+ this.apiContext,+ user,+ await resolveWebAuthnSecondFactor(this.apiContext, user),+ );+ const pending: PendingSsoLink = {+ userId: user.id.toString(),+ providerId: config.providerId,+ subject: claims.sub,+ groups: claims.groups,+ };+ await this.apiContext.services.cache.set(pendingSsoLinkKey(challenge.ticket), pending, seconds('5 minutes'));+ return challenge;+ }++ private async hasSecondFactor(user: User): Promise<boolean> {+ return (+ userHasMfa(user) ||+ (await resolveWebAuthnSecondFactor(this.apiContext, user)) ||+ (await AuthMfa.hasUnconsumedBackupCodes(this.apiContext, user.id))+ );+ }++ private async joinCommunityAndSyncRoles(+ user: User,+ groups: Array<string> | null,+ config: ResolvedSsoConfig,requestCache: RequestCache,- ): Promise<User> {- if (!claims.emailVerified) {- throw InputValidationError.fromCode('email_verified', ValidationErrorCodes.INVALID_SSO_TOKEN);+ ): Promise<void> {+ if (canJoinSingleCommunity(user)) {+ await this.singleCommunityService.joinStockCommunity(user.id, requestCache);}- const emailLower = claims.email.toLowerCase();- getLogger().info(- usesUsernameSignIn() ? {has_sub: true} : {email: emailLower, has_sub: true},- 'SSO login with sub claim',- );- const identityUserId = await this.ssoIdentityRepository.findUserId(config.providerId, claims.sub);- if (identityUserId) {- const user = await this.apiContext.services.users.findUnique(identityUserId);- if (!user) {- getLogger().error(- {user_id: identityUserId.toString()},- 'SSO identity mapping points at a missing user; refusing reassignment',- );- throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);- }- return this.bindSsoIdentity(user, claims.sub, config);+ await this.syncGroupRoles(user, groups, config, requestCache);+ }++ private async resolveUserFromClaims(+ claims: ResolvedSsoClaims,+ config: ResolvedSsoConfig,+ requestCache: RequestCache,+ clientIp: string,+ ): Promise<{user: User; secondFactorRequired: boolean}> {+ const accountIdentity = await this.instanceConfigRepository.getAccountIdentity();+ const usernameMode = accountIdentity.mode === AccountIdentityModes.USERNAME;+ const email = resolveUsableSsoEmail(claims, config.allowedEmailDomains, usernameMode);+ getLogger().info(usernameMode ? {has_sub: true} : {email, has_sub: true}, 'SSO login with sub claim');+ const mappedUser = await this.findMappedUser(claims.sub, config, usernameMode ? null : email);+ if (mappedUser) {+ return {user: await this.bindSsoIdentity(mappedUser, claims.sub, config), secondFactorRequired: false};}const {users} = this.apiContext.services;- const existingUser = await users.findByEmail(emailLower);+ const existingUser = email ? await users.findByEmail(email) : null;if (existingUser) {- return this.bindSsoIdentity(existingUser, claims.sub, config);+ this.assertLinkable(existingUser, claims.sub, config);+ if (+ !existingUser.traits.has(ssoIdentityTrait(config.providerId, claims.sub)) &&+ (await this.hasSecondFactor(existingUser))+ ) {+ return {user: existingUser, secondFactorRequired: true};+ }+ return {user: await this.bindSsoIdentity(existingUser, claims.sub, config), secondFactorRequired: false};}AuthUtility.assertNetworkAllowed(this.apiContext);if (!config.autoProvision) {- throw new SsoRequiredError();+ throw new SsoRequiredError(SsoRequiredReasons.NO_ACCOUNT);}+ await assertAccountCreationPastSetup(this.apiContext, this.instanceConfigRepository, clientIp);const registrationConfig = await this.instanceConfigRepository.getRegistrationConfig();- if (registrationConfig.mode === 'closed') {- throw new RegistrationClosedError();+ if (email) {+ await assertEmailNotBlocklisted(email, 'email');}- await assertEmailNotBlocklisted(emailLower, 'email');const pendingApproval = registrationConfig.mode === 'approval';const autoJoinInviteCode = this.apiContext.services.config.instance.autoJoinInviteCode?.trim() || null;- const user = await this.provisionUserFromClaims(claims, config, {pendingApproval, autoJoinInviteCode});+ const user = await this.provisionUserFromClaims({...claims, email}, config, {+ usernameMode,+ uniqueUsernames: accountIdentity.tagStyle === TagStyles.NONE,+ pendingApproval,+ autoJoinInviteCode,+ });if (pendingApproval) {throw new RegistrationPendingApprovalError();}@@ -421,8 +584,84 @@ export class SsoService {inviteCode: autoJoinInviteCode,requestCache,});- await this.singleCommunityService.joinStockCommunity(user.id, requestCache);- return user;+ return {user, secondFactorRequired: false};+ }++ private async syncGroupRoles(+ user: User,+ groups: Array<string> | null,+ config: ResolvedSsoConfig,+ requestCache: RequestCache,+ ): Promise<void> {+ if (groups === null || config.groupRoleMappings.length === 0) return;+ const guildId = await this.singleCommunityService.getStockCommunityId();+ if (guildId === null) return;+ const memberOf = new Set(groups);+ try {+ await this.guildMemberService.systemSyncManagedRoles({+ targetId: user.id,+ guildId,+ managedRoleIds: new Set(config.groupRoleMappings.map(({roleId}) => createRoleID(BigInt(roleId)))),+ grantedRoleIds: new Set(+ config.groupRoleMappings+ .filter(({group}) => memberOf.has(group))+ .map(({roleId}) => createRoleID(BigInt(roleId))),+ ),+ requestCache,+ });+ } catch (error) {+ getLogger().error({error, user_id: user.id.toString()}, 'Failed to sync community roles from SSO groups');+ }+ }++ private async findMappedUser(sub: string, config: ResolvedSsoConfig, email: string | null): Promise<User | null> {+ const identityUserId = await this.ssoIdentityRepository.findUserId(config.providerId, sub);+ if (!identityUserId) {+ return null;+ }+ const user = await this.apiContext.services.users.findUnique(identityUserId);+ if (!user) {+ getLogger().error(+ {user_id: identityUserId.toString()},+ 'SSO identity mapping points at a missing user; refusing reassignment',+ );+ throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);+ }+ if ((user.flags & UserFlags.DELETED) === 0n) {+ return user;+ }+ if (isEnforcementDeletion(user) && (email === null || (await isEmailBlocklisted(email)))) {+ return user;+ }+ await this.ssoIdentityRepository.releaseIdentity(config.providerId, sub);+ getLogger().info({user_id: user.id.toString()}, 'Released SSO identity of a deleted account');+ return null;+ }++ private async syncEnforcedEmail(user: User, email: string): Promise<void> {+ if (user.email?.toLowerCase() === email) {+ return;+ }+ const accountIdentity = await this.instanceConfigRepository.getAccountIdentity();+ if (accountIdentity.mode === AccountIdentityModes.USERNAME) {+ return;+ }+ const {users, gateway, worker} = this.apiContext.services;+ const holder = await users.findByEmail(email);+ if (holder) {+ getLogger().warn(+ {user_id: user.id.toString(), holder_user_id: holder.id.toString()},+ 'SSO provider email belongs to another account; keeping the current email',+ );+ return;+ }+ const updatedUser = await users.patchUpsert(+ user.id,+ {email, email_verified: true, email_bounced: false},+ user.toRow(),+ );+ await enqueueStripeCustomerEmailSync(worker, user, updatedUser);+ await dispatchUserUpdate(gateway, updatedUser);}private async claimSsoIdentity(userId: UserID, sub: string, config: ResolvedSsoConfig): Promise<void> {@@ -435,33 +674,38 @@ export class SsoService {if (claimed) {return;}- const ownerId = await this.ssoIdentityRepository.findUserId(config.providerId, sub);- if (ownerId?.toString() === userId.toString()) {+ const owned = await this.ssoIdentityRepository.findIdentity(config.providerId, sub);+ if (owned?.user_id === userId) {+ await this.ssoIdentityRepository.indexIdentity(owned);return;}getLogger().error(- {user_id: userId.toString(), owner_user_id: ownerId?.toString() ?? null},+ {user_id: userId.toString(), owner_user_id: owned?.user_id.toString() ?? null},'SSO identity is already linked to another account',);- throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);+ throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);}- private async bindSsoIdentity(user: User, sub: string, config: ResolvedSsoConfig): Promise<User> {- const identityTrait = buildSsoIdentityTrait(config.providerId, sub);- const traits = user.traits;- const existingIdentities = Array.from(traits).filter((trait) => trait.startsWith('sso_identity:'));- if (existingIdentities.length > 0 && !traits.has(identityTrait)) {+ private assertLinkable(user: User, sub: string, config: ResolvedSsoConfig): void {+ const identityTrait = ssoIdentityTrait(config.providerId, sub);+ const existingIdentities = Array.from(user.traits).filter((trait) => trait.startsWith('sso_identity:'));+ if (existingIdentities.length > 0 && !user.traits.has(identityTrait)) {getLogger().error({user_id: user.id.toString()}, 'SSO identity claim did not match linked account');- throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);+ throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_ACCOUNT_LINKED_TO_ANOTHER_IDENTITY);}+ }++ private async bindSsoIdentity(user: User, sub: string, config: ResolvedSsoConfig): Promise<User> {+ const identityTrait = ssoIdentityTrait(config.providerId, sub);+ const traits = user.traits;+ this.assertLinkable(user, sub, config);await this.claimSsoIdentity(user.id, sub, config);if (traits.has(identityTrait)) {return user;}- traits.add('sso');- traits.add(`sso:${config.providerId}`);- traits.add(buildSsoProviderTrait(config.providerId));- traits.add(identityTrait);+ for (const trait of ssoIdentityTraits(config.providerId, sub)) {+ traits.add(trait);+ }const {users} = this.apiContext.services;return users.patchUpsert(user.id, {traits}, user.toRow());}@@ -477,30 +721,27 @@ export class SsoService {private async provisionUserFromClaims(claims: ResolvedSsoClaims,config: ResolvedSsoConfig,- options?: {- pendingApproval?: boolean;- autoJoinInviteCode?: string | null;+ options: {+ usernameMode: boolean;+ uniqueUsernames: boolean;+ pendingApproval: boolean;+ autoJoinInviteCode: string | null;},): Promise<User> {const {users, snowflake, cache} = this.apiContext.services;- const accountIdentity = await this.instanceConfigRepository.getAccountIdentity();- const usernameMode = accountIdentity.mode === AccountIdentityModes.USERNAME;- const uniqueUsernames = accountIdentity.tagStyle === TagStyles.NONE;+ const {usernameMode, uniqueUsernames} = options;const userId = (await snowflake.generate()) as UserID;- const baseName = claims.name?.trim() || claims.email.split('@')[0] || generateRandomUsername();- const derivedUsername = deriveUsernameFromDisplayName(baseName) ?? generateRandomUsername();+ const derivedUsername = deriveSsoUsernameBase(claims) ?? generateRandomUsername();const username = uniqueUsernames ? await deriveAvailableUsername(users, derivedUsername) : derivedUsername;const discriminator = uniqueUsernames ? USERNAME_MODE_DISCRIMINATOR : await this.allocateDiscriminator(username);const now = new Date();- const traits = new Set<string>([- 'sso',- `sso:${config.providerId}`,- buildSsoProviderTrait(config.providerId),- buildSsoIdentityTrait(config.providerId, claims.sub),- ]);- if (options?.pendingApproval) {+ const traits = new Set<string>(ssoIdentityTraits(config.providerId, claims.sub));+ if (options.pendingApproval) {traits.add(REGISTRATION_PENDING_APPROVAL_TRAIT);}+ if (instanceCollectsDateOfBirth()) {+ traits.add(DOB_DEFERRED_TRAIT);+ }const globalName = claims.name?.substring(0, 256) ?? username;if (profileSubstringBlocklistCache.containsBannedSubstring('username', username) ||@@ -516,28 +757,27 @@ export class SsoService {global_name: globalName,bot: false,system: false,- email: usernameMode ? null : claims.email.toLowerCase(),- email_verified: claims.emailVerified,+ email: usernameMode ? null : claims.email,+ email_verified: claims.email !== null && claims.emailVerified,email_bounced: false,timezone_privacy_flags: ProfileFieldPrivacyFlags.EVERYONE,flags: 0n,has_ever_purchased: false,- terms_agreed_at: now,- privacy_agreed_at: now,+ terms_agreed_at: null,+ privacy_agreed_at: null,last_active_at: now,acls: new Set<string>(),traits,version: 1,};await this.claimSsoIdentity(userId, claims.sub, config);- let createAttempted = false;- let userCreated = false;+ let creationStage: 'unattempted' | 'attempted' | 'created' = 'unattempted';let usernameReservation: UsernameReservation | null = null;try {if (uniqueUsernames) {usernameReservation = await reserveUsername({users, cache}, username);}- if (options?.pendingApproval) {+ if (options.pendingApproval) {await this.instanceConfigRepository.addPendingRegistration({user_id: userId.toString(),username,@@ -547,17 +787,17 @@ export class SsoService {requested_at: now.toISOString(),registration_url_id: null,client_ip: null,- invite_code: options.autoJoinInviteCode ?? null,+ invite_code: options.autoJoinInviteCode,});}- createAttempted = true;+ creationStage = 'attempted';const user = await users.create(userRow);- userCreated = true;+ creationStage = 'created';await users.upsertSettings(UserSettings.getDefaultUserSettings({userId,locale: 'en-US',- isAdult: true,+ isAdult: !instanceCollectsDateOfBirth(),}),);void this.kvActivityTracker.updateActivity(user.id, now).catch((error: unknown) => {@@ -569,6 +809,7 @@ export class SsoService {{user_id: user.id.toString(),method: 'oauth',+ source: 'app',email: user.email,username: user.username,username_user_chosen: false,@@ -584,11 +825,11 @@ export class SsoService {);return user;} catch (error) {- if (!userCreated) {+ if (creationStage !== 'created') {await this.ssoIdentityRepository.releaseIdentity(config.providerId, claims.sub).catch((releaseError) => {getLogger().error({releaseError}, 'Failed to release SSO identity after user provisioning failed');});- if (options?.pendingApproval && !createAttempted) {+ if (options.pendingApproval && creationStage === 'unattempted') {await this.instanceConfigRepository.removePendingRegistration(userId.toString()).catch((removeError: unknown) => {@@ -618,9 +859,7 @@ export class SsoService {if (!rawEmail) {throw InputValidationError.fromCode('code', ValidationErrorCodes.SSO_TEST_CODE_MISSING_EMAIL);}- const testClaims = parseTestProviderClaims(rawEmail);- validateEmailAgainstAllowlist(testClaims.email, config.allowedEmailDomains);- return testClaims;+ return parseTestProviderClaims(rawEmail, config.groupsClaim ?? DEFAULT_GROUPS_CLAIM);}let claims: JWTPayload | null = null;if (tokenResponse.id_token) {@@ -658,27 +897,27 @@ export class SsoService {getLogger().error('SSO email mismatch between id_token and userinfo');throw InputValidationError.fromCode('email', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);}- const email =- normalizedIdTokenEmail ??- normalizedUserInfoEmail ??- (() => {- throw InputValidationError.fromCode('email', ValidationErrorCodes.SSO_PROVIDER_DID_NOT_RETURN_EMAIL);- })();- const primaryClaims = normalizedIdTokenEmail ? claims : userInfo;- const emailVerified = resolveEmailVerified({- claims,- userInfo,- idTokenEmail: normalizedIdTokenEmail,- userInfoEmail: normalizedUserInfoEmail,+ const email = normalizedIdTokenEmail ?? normalizedUserInfoEmail ?? null;+ const emailVerified =+ email !== null &&+ resolveEmailVerified({+ claims,+ userInfo,+ idTokenEmail: normalizedIdTokenEmail,+ userInfoEmail: normalizedUserInfoEmail,+ email,+ });+ return {email,- });- if (!emailVerified) {- throw InputValidationError.fromCode('email_verified', ValidationErrorCodes.INVALID_SSO_TOKEN);- }- const name = readStringClaim(primaryClaims, 'name') ?? null;- validateEmailAgainstAllowlist(email, config.allowedEmailDomains);- const resolvedClaims: ResolvedSsoClaims = {email, emailVerified, name, sub};- return resolvedClaims;+ emailVerified,+ preferredUsername:+ readTrimmedClaim(claims, 'preferred_username') ?? readTrimmedClaim(userInfo, 'preferred_username'),+ name: readDisplayName(claims) ?? readDisplayName(userInfo),+ sub,+ groups:+ readGroupsClaim(claims, config.groupsClaim ?? DEFAULT_GROUPS_CLAIM) ??+ readGroupsClaim(userInfo, config.groupsClaim ?? DEFAULT_GROUPS_CLAIM),+ };}private async verifyIdToken(idToken: string, config: ResolvedSsoConfig, expectedNonce: string): Promise<JWTPayload> {@@ -906,7 +1145,7 @@ export class SsoService {const stored = await this.instanceConfigRepository.getSsoConfig({includeSecret: true});const redirectUri = deriveSsoRedirectUri(config.endpoints.webApp);const scope = stored.scope?.trim() || 'openid email profile';- const providerId = stored.issuer || stored.authorizationUrl || 'sso';+ const providerId = ssoProviderIdOf(stored);let authorizationUrl = stored.authorizationUrl;let tokenUrl = stored.tokenUrl;let userInfoUrl = stored.userInfoUrl;@@ -924,7 +1163,7 @@ export class SsoService {? await this.validateOptionalPublicOutboundUrl(stored.issuer, 'issuer'): stored.issuer;if (validatedIssuer) {- const cacheKey = buildDiscoveryCacheKey(validatedIssuer);+ const cacheKey = ssoDiscoveryCacheKey(validatedIssuer);const {cache} = this.apiContext.services;let discovered = await cache.get<{issuer: string;diff --git a/fluxer_api/src/api/guild/services/GuildMemberService.ts b/fluxer_api/src/api/guild/services/GuildMemberService.tsindex 9d69f895e..cea77ab64 100644--- a/fluxer_api/src/api/guild/services/GuildMemberService.ts+++ b/fluxer_api/src/api/guild/services/GuildMemberService.ts@@ -18,6 +18,7 @@ import type {LimitConfigService} from '@app/api/limits/LimitConfigService';import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';import type {Guild} from '@app/api/models/Guild';import type {GuildMember} from '@app/api/models/GuildMember';+import type {TierContext} from '@app/api/user/AccountTier';import type {UserRepository} from '@app/api/user/repositories/UserRepository';import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';import type {JoinSourceType} from '@fluxer/constants/src/GuildConstants';@@ -215,6 +216,58 @@ export class GuildMemberService {});}+ async systemSyncManagedRoles(params: {+ targetId: UserID;+ guildId: GuildID;+ managedRoleIds: ReadonlySet<RoleID>;+ grantedRoleIds: ReadonlySet<RoleID>;+ requestCache: RequestCache;+ }): Promise<void> {+ const {targetId, guildId, managedRoleIds, grantedRoleIds, requestCache} = params;+ const member = await this.guildRepository.getMember(guildId, targetId);+ if (!member) return;+ const existingRoleIds = new Set((await this.guildRepository.listRoles(guildId)).map((role) => role.id));+ const nextRoleIds = new Set([...member.roleIds].filter((roleId) => !managedRoleIds.has(roleId)));+ for (const roleId of grantedRoleIds) {+ if (managedRoleIds.has(roleId) && existingRoleIds.has(roleId)) nextRoleIds.add(roleId);+ }+ if (nextRoleIds.size === member.roleIds.size && [...nextRoleIds].every((roleId) => member.roleIds.has(roleId))) {+ return;+ }+ const previousSnapshot = this.auditService.serializeMemberForAudit(member);+ await this.guildRepository.upsertMember({...member.toRow(), role_ids: nextRoleIds});+ const updatedMember = await this.guildRepository.getMember(guildId, targetId);+ if (!updatedMember) return;+ await this.eventService.dispatchGuildMemberUpdate({guildId, member: updatedMember, requestCache});+ await this.refreshMemberSearchIndex(updatedMember);+ await this.guildAuditLogService.record({+ guildId,+ userId: SYSTEM_USER_ID,+ action: AuditLogActionType.MEMBER_ROLE_UPDATE,+ targetId,+ auditLogReason: null,+ changes: this.guildAuditLogService.computeChanges(+ previousSnapshot,+ this.auditService.serializeMemberForAudit(updatedMember),+ ),+ });+ }++ async systemRemoveMemberRole(params: {+ targetId: UserID;+ guildId: GuildID;+ roleId: RoleID;+ initiatorId: UserID;+ requestCache: RequestCache;+ }): Promise<void> {+ await this.applyRoleChange({+ ...params,+ actorId: params.initiatorId,+ auditLogReason: null,+ mutate: () => this.roleService.systemRemoveMemberRole(params),+ });+ }+async removeMemberRole(params: {userId: UserID;@@ -286,6 +339,7 @@ export class GuildMemberService {inviterId?: UserID;requestCache: RequestCache;initiatorId?: UserID;+ tierContext?: TierContext;}): Promise<GuildMember> {return this.operationsService.addUserToGuild(params, this.eventService);}diff --git a/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts b/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.tsindex 874642790..2f371fb5d 100644--- a/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts+++ b/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts@@ -44,6 +44,16 @@ export class GuildMemberRoleService {await this.applyAddMemberRole(targetMember, guildId, targetId, roleId);}+ async systemRemoveMemberRole(params: {targetId: UserID; guildId: GuildID; roleId: RoleID}): Promise<void> {+ const {targetId, guildId, roleId} = params;+ const targetMember = await this.guildRepository.getMember(guildId, targetId);+ if (!targetMember) throw new UnknownGuildMemberError();+ if (!targetMember.roleIds.has(roleId)) return;+ const updatedRoleIds = new Set(targetMember.roleIds);+ updatedRoleIds.delete(roleId);+ await this.guildRepository.upsertMember({...targetMember.toRow(), role_ids: updatedRoleIds});+ }+async addMemberRole(params: {userId: UserID; targetId: UserID; guildId: GuildID; roleId: RoleID}): Promise<void> {const {userId, targetId, guildId, roleId} = params;const {guildData, hasPermission, canManageRoles} = await getGuildAuth(this.gatewayService, this.userRepository, {