Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
10.2 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import type {ApiContext} from '@app/api/ApiContext';
import {
	assertEmailSendAllowed,
	budgetEnvFor,
	chargeAddressLookup,
	recordAddressCodeFailure,
	recordEmailSend,
	requesterNetworkKey,
} from '@app/api/auth/AccountBudgets';
import {generateCode, hashCode, normalizeEmailKey} from '@app/api/auth/AccountCodes';
import {emitCodeSent} from '@app/api/auth/AuthIdentify';
import * as AuthPassword from '@app/api/auth/AuthPassword';
import {assertInstanceAcceptsEmailDomain, assertRegistrationEmailDeliverable} from '@app/api/auth/AuthRegistration';
import {checkEmailCode, storeEmailCode} from '@app/api/auth/EmailCodeStore';
import {confirmEmailOwnership} from '@app/api/auth/EmailOwnership';
import {emailCodesCanBeSent, getEmailCodeAvailability} from '@app/api/auth/services/SudoEmailCode';
import type {UserRow} from '@app/api/database/types/UserTypes';
import {emitActivity} from '@app/api/infrastructure/activity/ActivityEvents';
import {getCachedAccountIdentityMode} from '@app/api/instance/AccountIdentityModeCache';
import {getEffectiveVerificationBasis, getEmailDeliveryState} from '@app/api/instance/AccountsConfigCache';
import type {User} from '@app/api/models/User';
import {getAccountTier, getLocalCredential} from '@app/api/user/AccountTier';
import {mapUserToPrivateResponse} from '@app/api/user/UserMappers';
import {hashPassword} from '@app/api/utils/PasswordUtils';
import {
	ClaimAccountNextSteps,
	type EmailDeliveryState,
	EmailDeliveryStates,
	VerificationBases,
} from '@fluxer/constants/src/AccountConfigConstants';
import {type AccountIdentityMode, AccountIdentityModes} from '@fluxer/constants/src/AccountIdentityConstants';
import {AccountTiers, LocalCredentialKinds} from '@fluxer/constants/src/AccountTierConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {AccountAlreadyClaimedError} from '@fluxer/errors/src/domains/auth/AccountAlreadyClaimedError';
import {EmailCodesUnavailableError} from '@fluxer/errors/src/domains/auth/EmailCodesUnavailableError';
import {InvalidSignInCodeError} from '@fluxer/errors/src/domains/auth/InvalidSignInCodeError';
import {
	PasswordRequiredToClaimError,
	type PasswordRequiredToClaimReason,
	PasswordRequiredToClaimReasons,
} from '@fluxer/errors/src/domains/auth/PasswordRequiredToClaimError';
import {SignInCodeExpiredError} from '@fluxer/errors/src/domains/auth/SignInCodeExpiredError';
import {UseClaimRouteError} from '@fluxer/errors/src/domains/auth/UseClaimRouteError';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import type {ClaimAccountResponse, EmailVerificationCodeResponse} from '@fluxer/schema/src/domains/user/AccountSchemas';
import type {UserPrivateResponse} from '@fluxer/schema/src/domains/user/UserResponseSchemas';
import {seconds} from 'itty-time';

const CODE_TTL_SECONDS = seconds('10 minutes');
const RESEND_COOLDOWN_MS = 30_000;
const CODE_SCOPE = 'email_verification';

interface VerificationCodeRecord {
	email: string;
	code_hash: string;
	network: string;
}

function verificationKey(user: User): string {
	return `user:email_verification:${user.id}`;
}

async function dispatchUserUpdate(ctx: ApiContext, user: User): Promise<void> {
	await ctx.services.gateway.dispatchPresence({
		userId: user.id,
		event: 'USER_UPDATE',
		data: mapUserToPrivateResponse(user),
	});
}

async function sendCode(
	ctx: ApiContext,
	params: {user: User; email: string; request: Request; clientIp: string},
): Promise<EmailVerificationCodeResponse> {
	const {user, email, request} = params;
	const network = requesterNetworkKey(params.clientIp);
	const env = budgetEnvFor(ctx.services, request);
	const emailKey = normalizeEmailKey(email);
	const now = Date.now();
	const expiresAt = new Date(now + CODE_TTL_SECONDS * 1000);
	const code = generateCode();
	await storeEmailCode<VerificationCodeRecord>(ctx, {
		key: verificationKey(user),
		record: {email: email.toLowerCase(), code_hash: hashCode(code, CODE_SCOPE), network},
		ttlSeconds: CODE_TTL_SECONDS,
	});
	await ctx.services.email.send('email_verification_code', email, {code, expiresAt}, user.locale);
	await recordEmailSend(env, {emailKey, requester: 'unknown'});
	return codeTimes(now);
}

function codeTimes(now: number): EmailVerificationCodeResponse {
	return {
		code_expires_at: new Date(now + CODE_TTL_SECONDS * 1000).toISOString(),
		resend_available_at: new Date(now + RESEND_COOLDOWN_MS).toISOString(),
	};
}

async function assertCodeSendAllowed(
	ctx: ApiContext,
	params: {email: string; request: Request; clientIp: string},
): Promise<void> {
	await assertEmailSendAllowed(budgetEnvFor(ctx.services, params.request), {
		emailKey: normalizeEmailKey(params.email),
		requester: 'unknown',
		clientIp: params.clientIp,
	});
}

function claimCredentialReason(
	identityMode: AccountIdentityMode,
	deliveryState: EmailDeliveryState,
): PasswordRequiredToClaimReason | null {
	if (identityMode === AccountIdentityModes.USERNAME) return PasswordRequiredToClaimReasons.USERNAME_IDENTITY;
	if (deliveryState !== EmailDeliveryStates.ON) return PasswordRequiredToClaimReasons.EMAIL_DELIVERY_OFF;
	return getEffectiveVerificationBasis() === VerificationBases.LOCAL_CREDENTIAL
		? PasswordRequiredToClaimReasons.LOCAL_CREDENTIAL_BASIS
		: null;
}

export async function claimAccount(
	ctx: ApiContext,
	params: {user: User; email: string | undefined; password: string | undefined; request: Request; clientIp: string},
): Promise<ClaimAccountResponse> {
	const {user, password, request, clientIp} = params;
	if (getAccountTier(user) !== AccountTiers.UNCLAIMED) throw new AccountAlreadyClaimedError();
	const identityMode = getCachedAccountIdentityMode();
	const deliveryState = getEmailDeliveryState();
	if (!password && getLocalCredential(user) === LocalCredentialKinds.NONE) {
		const reason = claimCredentialReason(identityMode, deliveryState);
		if (reason !== null) throw new PasswordRequiredToClaimError(reason);
	}
	if (password && (await AuthPassword.isPasswordPwned(ctx, password))) {
		throw InputValidationError.fromCode('password', ValidationErrorCodes.PASSWORD_IS_TOO_COMMON);
	}
	const passwordPatch = password
		? {password_hash: await hashPassword(password), password_last_changed_at: new Date()}
		: {};
	if (identityMode === AccountIdentityModes.USERNAME) {
		return await completeClaim(ctx, {user, patch: passwordPatch, withPassword: password !== undefined});
	}
	const email = params.email;
	if (!email) throw InputValidationError.fromCode('email', ValidationErrorCodes.EMAIL_IS_REQUIRED);
	await assertInstanceAcceptsEmailDomain(email, 'email');
	await assertRegistrationEmailDeliverable(email, ctx.services.emailDnsValidation);
	await assertAddressFree(ctx, {user, email, clientIp, request});
	if (deliveryState !== EmailDeliveryStates.ON) {
		return await completeClaim(ctx, {
			user,
			patch: {email, email_verified: true, email_bounced: false, ...passwordPatch},
			withPassword: password !== undefined,
		});
	}
	await assertCodeSendAllowed(ctx, {email, request, clientIp});
	const updated = await ctx.services.users.patchUpsert(
		user.id,
		{email, email_verified: false, email_bounced: false, ...passwordPatch},
		user.toRow(),
	);
	const delivery = await sendCode(ctx, {user: updated, email, request, clientIp});
	await dispatchUserUpdate(ctx, updated);
	emitClaimed(updated, password !== undefined);
	emitCodeSent(updated.id.toString(), 'claim', email);
	return {next_step: ClaimAccountNextSteps.CONFIRM_EMAIL, user: mapUserToPrivateResponse(updated), ...delivery};
}

async function assertAddressFree(
	ctx: ApiContext,
	params: {user: User; email: string; clientIp: string; request: Request},
): Promise<void> {
	const owner = await ctx.services.users.findByEmail(params.email);
	if (owner === null || owner.id === params.user.id) return;
	await chargeAddressLookup(budgetEnvFor(ctx.services, params.request), {
		clientIp: params.clientIp,
		emailKey: normalizeEmailKey(params.email),
		requester: 'unknown',
	});
	throw InputValidationError.fromCode('email', ValidationErrorCodes.EMAIL_ALREADY_IN_USE);
}

async function completeClaim(
	ctx: ApiContext,
	params: {user: User; patch: Partial<UserRow>; withPassword: boolean},
): Promise<ClaimAccountResponse> {
	const updated = await ctx.services.users.patchUpsert(params.user.id, params.patch, params.user.toRow());
	await dispatchUserUpdate(ctx, updated);
	emitClaimed(updated, params.withPassword);
	return {next_step: ClaimAccountNextSteps.NONE, user: mapUserToPrivateResponse(updated)};
}

function emitClaimed(user: User, withPassword: boolean): void {
	void emitActivity('account_claimed', user.id.toString(), {user_id: user.id.toString(), with_password: withPassword});
}

export async function sendEmailVerificationCode(
	ctx: ApiContext,
	params: {user: User; request: Request; clientIp: string},
): Promise<EmailVerificationCodeResponse> {
	const {user} = params;
	const tier = getAccountTier(user);
	if (tier === AccountTiers.UNCLAIMED || user.email === null) throw new UseClaimRouteError();
	if (!emailCodesCanBeSent(getEmailCodeAvailability(user))) throw new EmailCodesUnavailableError();
	if (tier === AccountTiers.VERIFIED) {
		throw user.emailVerified ? new AccountAlreadyClaimedError() : new EmailCodesUnavailableError();
	}
	await assertCodeSendAllowed(ctx, {email: user.email, request: params.request, clientIp: params.clientIp});
	const result = await sendCode(ctx, {
		user,
		email: user.email,
		request: params.request,
		clientIp: params.clientIp,
	});
	emitCodeSent(user.id.toString(), 'verify', user.email);
	return result;
}

export async function confirmEmailVerification(
	ctx: ApiContext,
	params: {user: User; code: string; request: Request},
): Promise<UserPrivateResponse> {
	const {user, code, request} = params;
	const email = user.email?.toLowerCase() ?? null;
	const check = await checkEmailCode<VerificationCodeRecord>(ctx, {
		key: verificationKey(user),
		code,
		scope: CODE_SCOPE,
		ttlSeconds: CODE_TTL_SECONDS,
		accepts: (record) => email !== null && record.email === email,
	});
	if (check.kind === 'wrong') {
		await recordAddressCodeFailure(budgetEnvFor(ctx.services, request), {
			emailKey: normalizeEmailKey(email!),
			network: check.record.network,
		});
		throw new InvalidSignInCodeError();
	}
	if (check.kind !== 'ok') throw new SignInCodeExpiredError();
	return mapUserToPrivateResponse(await confirmEmailOwnership(ctx, user));
}