A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
import type {ApiContext} from '@app/api/ApiContext';
import * as AuthPassword from '@app/api/auth/AuthPassword';
import * as AuthSession from '@app/api/auth/AuthSession';
import {assertEmailNotBlocklisted} from '@app/api/auth/EmailBlocklist';
import {createSudoModeRequiredError} from '@app/api/auth/services/SudoMethods';
import type {SudoVerificationResult} from '@app/api/auth/services/SudoVerificationService';
import {Config} from '@app/api/Config';
import type {UserRow} from '@app/api/database/types/UserTypes';
import type {DiscriminatorService} from '@app/api/infrastructure/DiscriminatorService';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {resolveLimitSafe} from '@app/api/limits/LimitConfigUtils';
import {createLimitMatchContext} from '@app/api/limits/LimitMatchContextBuilder';
import {profileSubstringBlocklistCache} from '@app/api/middleware/ProfileSubstringBlocklistCache';
import {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
import type {AuthSession as AuthSessionModel} from '@app/api/models/AuthSession';
import type {User} from '@app/api/models/User';
import {getAccountTier} from '@app/api/user/AccountTier';
import {enforceFluxerTagChangeRateLimit} from '@app/api/user/FluxerTagChangeRateLimit';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {assertNoDiscriminatorChange, reserveUsername, type UsernameReservation} from '@app/api/user/UniqueUsernames';
import {isProfileSubstringExempt} from '@app/api/user/UserHelpers';
import {USERNAME_MODE_DISCRIMINATOR} from '@app/api/user/UserTag';
import {hashPassword} from '@app/api/utils/PasswordUtils';
import {AccountIdentityModes, TagStyles} from '@fluxer/constants/src/AccountIdentityConstants';
import {AccountTiers} from '@fluxer/constants/src/AccountTierConstants';
import {PremiumFlags, UserPremiumTypes} from '@fluxer/constants/src/UserConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {ContentBlockedError} from '@fluxer/errors/src/domains/content/ContentBlockedError';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import type {UserUpdateRequest} from '@fluxer/schema/src/domains/user/UserRequestSchemas';
import type {IRateLimitService} from '@pkgs/rate_limit/src/IRateLimitService';
interface UserUpdateMetadata {
invalidateAuthSessions?: boolean;
usernameReservation?: UsernameReservation;
}
type UserFieldUpdates = Partial<UserRow>;
interface UserAccountSecurityServiceDeps {
apiContext: ApiContext;
userAccountRepository: UserRepository;
discriminatorService: DiscriminatorService;
rateLimitService: IRateLimitService;
limitConfigService: LimitConfigService;
}
export interface AuthSessionReplacement {
token: string;
authSessionIdHash: string;
}
export class UserAccountSecurityService {
constructor(private readonly deps: UserAccountSecurityServiceDeps) {}
async processSecurityUpdates(params: {
user: User;
data: UserUpdateRequest;
sudoContext?: SudoVerificationResult;
}): Promise<{
updates: UserFieldUpdates;
metadata: UserUpdateMetadata;
}> {
const {user, data, sudoContext} = params;
const updates: UserFieldUpdates = {
password_hash: user.passwordHash,
username: user.username,
discriminator: user.discriminator,
global_name: user.isBot ? null : user.globalName,
email: user.email,
};
const metadata: UserUpdateMetadata = {
invalidateAuthSessions: false,
};
const isUnclaimedAccount = getAccountTier(user) === AccountTiers.UNCLAIMED;
const identityVerifiedViaSudo =
sudoContext?.method === 'mfa' || sudoContext?.method === 'sudo_token' || sudoContext?.method === 'email_code';
const identityVerifiedViaPassword = sudoContext?.method === 'password';
const rawEmail = data.email?.trim();
const normalizedEmail = rawEmail?.toLowerCase();
const tagChangeRequested = data.username !== undefined || data.discriminator !== undefined;
const accountIdentity = tagChangeRequested ? await getInstanceConfigRepository().getAccountIdentity() : null;
const usernameSignIn = accountIdentity?.mode === AccountIdentityModes.USERNAME;
const uniqueUsernames = !user.isBot && accountIdentity?.tagStyle === TagStyles.NONE;
if (uniqueUsernames) {
assertNoDiscriminatorChange(data.discriminator, user.discriminator);
}
const hasPasswordRequiredChanges =
(data.username !== undefined && data.username !== user.username) ||
(data.discriminator !== undefined && data.discriminator !== user.discriminator) ||
(data.email !== undefined && normalizedEmail !== user.email?.toLowerCase()) ||
data.new_password !== undefined;
const requiresVerification = hasPasswordRequiredChanges && !isUnclaimedAccount;
if (requiresVerification && !identityVerifiedViaSudo && !identityVerifiedViaPassword) {
throw await createSudoModeRequiredError(this.deps.apiContext, user);
}
if (isUnclaimedAccount && data.new_password) {
updates.password_hash = await this.hashNewPassword(data.new_password);
updates.password_last_changed_at = new Date();
metadata.invalidateAuthSessions = false;
} else if (data.new_password) {
if (!data.password && user.passwordHash !== null) {
throw InputValidationError.fromCode('password', ValidationErrorCodes.PASSWORD_NOT_SET);
}
if (!identityVerifiedViaSudo && !identityVerifiedViaPassword) {
throw await createSudoModeRequiredError(this.deps.apiContext, user);
}
updates.password_hash = await this.hashNewPassword(data.new_password);
updates.password_last_changed_at = new Date();
metadata.invalidateAuthSessions = true;
}
if (data.username !== undefined) {
const {newUsername, newDiscriminator} = uniqueUsernames
? {newUsername: data.username, newDiscriminator: USERNAME_MODE_DISCRIMINATOR}
: await this.updateUsername({
user,
username: data.username,
requestedDiscriminator: data.discriminator,
});
if (
!isProfileSubstringExempt(user) &&
profileSubstringBlocklistCache.containsBannedSubstring('username', newUsername)
) {
throw new ContentBlockedError();
}
updates.username = newUsername;
updates.discriminator = newDiscriminator;
} else if (data.discriminator !== undefined) {
updates.discriminator = uniqueUsernames
? data.discriminator
: await this.updateDiscriminator({user, discriminator: data.discriminator});
}
await this.enforceFluxerTagChangeRateLimit({
user,
nextUsername: updates.username ?? user.username,
nextDiscriminator: updates.discriminator ?? user.discriminator,
errorPath: data.discriminator !== undefined && data.username === undefined ? 'discriminator' : 'username',
});
const usernameRealChange =
data.username !== undefined && data.username.toLowerCase() !== user.username.toLowerCase();
const discriminatorChanged = updates.discriminator !== user.discriminator;
const shouldMarkPremiumDiscriminator =
!usernameSignIn &&
(accountIdentity?.tagStyle ?? TagStyles.RANDOM) === TagStyles.RANDOM &&
(discriminatorChanged || usernameRealChange) &&
user.isPremium() &&
user.premiumType !== UserPremiumTypes.LIFETIME;
if (shouldMarkPremiumDiscriminator && (user.premiumFlags & PremiumFlags.DISCRIMINATOR) === 0) {
updates.premium_flags = user.premiumFlags | PremiumFlags.DISCRIMINATOR;
}
if (user.isBot) {
updates.global_name = null;
} else if (data.global_name !== undefined) {
if (
data.global_name &&
!isProfileSubstringExempt(user) &&
profileSubstringBlocklistCache.containsBannedSubstring('global_name', data.global_name)
) {
throw new ContentBlockedError();
}
updates.global_name = data.global_name;
}
if (rawEmail) {
if (normalizedEmail && normalizedEmail !== user.email?.toLowerCase()) {
await assertEmailNotBlocklisted(normalizedEmail, 'email');
const existing = await this.deps.userAccountRepository.findByEmail(normalizedEmail);
if (existing && existing.id !== user.id) {
throw InputValidationError.fromCode('email', ValidationErrorCodes.EMAIL_ALREADY_IN_USE);
}
}
updates.email = rawEmail;
}
if (uniqueUsernames && (usernameRealChange || discriminatorChanged)) {
metadata.usernameReservation = await reserveUsername(
{users: this.deps.apiContext.services.users, cache: this.deps.apiContext.services.cache},
updates.username!,
user.id,
);
}
return {updates, metadata};
}
async invalidateAndRecreateSessions({
user,
oldAuthSession,
request,
}: {
user: User;
oldAuthSession: AuthSessionModel;
request: Request;
}): Promise<AuthSessionReplacement> {
const replacement = await AuthSession.replaceCurrentAuthSession(this.deps.apiContext, {
user,
currentAuthSession: oldAuthSession,
request,
});
return {token: replacement.token, authSessionIdHash: replacement.newAuthSessionIdHash};
}
private async hashNewPassword(newPassword: string): Promise<string> {
if (await AuthPassword.isPasswordPwned(this.deps.apiContext, newPassword)) {
throw InputValidationError.fromCode('new_password', ValidationErrorCodes.PASSWORD_IS_TOO_COMMON);
}
return await hashPassword(newPassword);
}
private async updateUsername({
user,
username,
requestedDiscriminator,
}: {
user: User;
username: string;
requestedDiscriminator?: number;
}): Promise<{
newUsername: string;
newDiscriminator: number;
}> {
const normalizedRequestedDiscriminator =
requestedDiscriminator == null ? undefined : Number(requestedDiscriminator);
if (
user.username.toLowerCase() === username.toLowerCase() &&
(normalizedRequestedDiscriminator === undefined || normalizedRequestedDiscriminator === user.discriminator)
) {
return {
newUsername: username,
newDiscriminator: user.discriminator,
};
}
const ctx = createLimitMatchContext({user});
const hasCustomDiscriminator = resolveLimitSafe(
this.deps.limitConfigService.getConfigSnapshot(),
ctx,
'feature_custom_discriminator',
0,
);
const isCaseOnlyChange = user.username.toLowerCase() === username.toLowerCase();
if (hasCustomDiscriminator === 0) {
if (isCaseOnlyChange) {
return {
newUsername: username,
newDiscriminator: user.discriminator,
};
}
const discriminatorResult = await this.deps.discriminatorService.generateDiscriminator({
username,
requestedDiscriminator: undefined,
user: undefined,
});
if (!discriminatorResult.available || discriminatorResult.discriminator === -1) {
throw InputValidationError.fromCode(
'username',
ValidationErrorCodes.TOO_MANY_USERS_WITH_USERNAME_TRY_DIFFERENT,
);
}
return {
newUsername: username,
newDiscriminator: discriminatorResult.discriminator,
};
}
const discriminatorToUse = normalizedRequestedDiscriminator ?? user.discriminator;
if (this.requiresVisionaryForDiscriminator0000(user, discriminatorToUse)) {
throw InputValidationError.fromCode('discriminator', ValidationErrorCodes.VISIONARY_REQUIRED_FOR_DISCRIMINATOR);
}
const discriminatorResult = await this.deps.discriminatorService.generateDiscriminator({
username,
requestedDiscriminator: discriminatorToUse,
user,
});
if (!discriminatorResult.available || discriminatorResult.discriminator === -1) {
throw InputValidationError.fromCode(
'username',
discriminatorToUse !== undefined
? ValidationErrorCodes.TAG_ALREADY_TAKEN
: ValidationErrorCodes.TOO_MANY_USERS_WITH_USERNAME_TRY_DIFFERENT,
);
}
return {
newUsername: username,
newDiscriminator: discriminatorResult.discriminator,
};
}
private async updateDiscriminator({user, discriminator}: {user: User; discriminator: number}): Promise<number> {
const ctx = createLimitMatchContext({user});
const hasCustomDiscriminator = resolveLimitSafe(
this.deps.limitConfigService.getConfigSnapshot(),
ctx,
'feature_custom_discriminator',
0,
);
if (hasCustomDiscriminator === 0) {
throw InputValidationError.fromCode(
'discriminator',
ValidationErrorCodes.CHANGING_DISCRIMINATOR_REQUIRES_PREMIUM,
);
}
if (this.requiresVisionaryForDiscriminator0000(user, discriminator)) {
throw InputValidationError.fromCode('discriminator', ValidationErrorCodes.VISIONARY_REQUIRED_FOR_DISCRIMINATOR);
}
const discriminatorResult = await this.deps.discriminatorService.generateDiscriminator({
username: user.username,
requestedDiscriminator: discriminator,
user,
});
if (!discriminatorResult.available) {
throw InputValidationError.fromCode('discriminator', ValidationErrorCodes.TAG_ALREADY_TAKEN);
}
return discriminator;
}
private requiresVisionaryForDiscriminator0000(user: User, discriminator: number): boolean {
if (Config.instance.selfHosted) {
return false;
}
return discriminator === 0 && user.premiumType !== UserPremiumTypes.LIFETIME;
}
private async enforceFluxerTagChangeRateLimit(params: {
user: User;
nextUsername: string;
nextDiscriminator: number;
errorPath: 'username' | 'discriminator';
}): Promise<void> {
const {user, nextUsername, nextDiscriminator, errorPath} = params;
if (nextUsername === user.username && nextDiscriminator === user.discriminator) {
return;
}
await enforceFluxerTagChangeRateLimit({
rateLimitService: this.deps.rateLimitService,
userId: user.id,
errorPath,
});
}
}