Skip to content

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

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

import type {ApiContext} from '@app/api/ApiContext';
import {
	assertEmailSendAllowed,
	budgetEnvFor,
	recordAccountCodeFailure,
	recordEmailSend,
} from '@app/api/auth/AccountBudgets';
import {generateCode, generateOpaqueToken, hashCode, normalizeEmailKey, sha256Hex} from '@app/api/auth/AccountCodes';
import {checkEmailCode, storeEmailCode} from '@app/api/auth/EmailCodeStore';
import {getCachedAccountIdentityMode} from '@app/api/instance/AccountIdentityModeCache';
import {getEmailDeliveryState} from '@app/api/instance/AccountsConfigCache';
import type {User} from '@app/api/models/User';
import {EmailCodeAvailability} from '@fluxer/constants/src/AccountConfigConstants';
import {resolveEmailCodeAvailability} from '@fluxer/constants/src/AccountTierRules';
import {InvalidSignInCodeError} from '@fluxer/errors/src/domains/auth/InvalidSignInCodeError';
import {SignInCodeExpiredError} from '@fluxer/errors/src/domains/auth/SignInCodeExpiredError';
import {UnknownSignInTicketError} from '@fluxer/errors/src/domains/auth/UnknownSignInTicketError';
import {requireClientIp} from '@fluxer/ip_utils/src/ClientIp';
import {ms, seconds} from 'itty-time';

const SUDO_CODE_TTL_SECONDS = seconds('10 minutes');
const CODE_SCOPE = 'sudo';

interface SudoCodeRecord {
	user_id: string;
	code_hash: string;
}

function recordKey(ticket: string): string {
	return `sudo:email_code:${sha256Hex(ticket)}`;
}

type EmailCodeUser = Pick<User, 'email' | 'emailVerified'>;

export function getEmailCodeAvailability(user: EmailCodeUser): EmailCodeAvailability {
	return resolveEmailCodeAvailability({
		identityMode: getCachedAccountIdentityMode(),
		deliveryState: getEmailDeliveryState(),
		hasEmail: user.email !== null,
		emailVerified: user.emailVerified,
	});
}

export function emailCodesCanBeSent(availability: EmailCodeAvailability): boolean {
	return availability === EmailCodeAvailability.AVAILABLE || availability === EmailCodeAvailability.NO_OWNED_EMAIL;
}

export function hasOwnedEmail(user: EmailCodeUser): boolean {
	return getEmailCodeAvailability(user) === EmailCodeAvailability.AVAILABLE;
}

export async function sendSudoEmailCode(
	ctx: ApiContext,
	params: {user: User; request: Request},
): Promise<{ticket: string; code_expires_at: string; resend_available_at: string}> {
	const {user, request} = params;
	const email = user.email!;
	const env = budgetEnvFor(ctx.services, request);
	const clientIp = requireClientIp(request, {
		trustClientIpHeader: ctx.services.config.proxy.trust_client_ip_header,
		clientIpHeaderName: ctx.services.config.proxy.client_ip_header,
	});
	const emailKey = normalizeEmailKey(email);
	await assertEmailSendAllowed(env, {emailKey, requester: 'known', clientIp, userId: user.id.toString()});
	const ticket = generateOpaqueToken();
	const code = generateCode();
	const now = Date.now();
	const expiresAt = new Date(now + SUDO_CODE_TTL_SECONDS * 1000);
	await storeEmailCode<SudoCodeRecord>(ctx, {
		key: recordKey(ticket),
		record: {user_id: user.id.toString(), code_hash: hashCode(code, CODE_SCOPE)},
		ttlSeconds: SUDO_CODE_TTL_SECONDS,
	});
	await recordEmailSend(env, {emailKey, requester: 'known'});
	await ctx.services.email.send('reauth_code', email, {code, expiresAt}, user.locale);
	return {
		ticket,
		code_expires_at: expiresAt.toISOString(),
		resend_available_at: new Date(now + ms('30 seconds')).toISOString(),
	};
}

export async function verifySudoEmailCode(
	ctx: ApiContext,
	params: {user: User; ticket: string | undefined; code: string | undefined; request: Request},
): Promise<void> {
	const {user, ticket, code} = params;
	if (!ticket) throw new UnknownSignInTicketError();
	const check = await checkEmailCode<SudoCodeRecord>(ctx, {
		key: recordKey(ticket),
		code,
		scope: CODE_SCOPE,
		ttlSeconds: SUDO_CODE_TTL_SECONDS,
		accepts: (record) => record.user_id === user.id.toString(),
	});
	if (check.kind === 'missing') throw new UnknownSignInTicketError();
	if (check.kind === 'exhausted') throw new SignInCodeExpiredError();
	if (check.kind === 'wrong') {
		await recordAccountCodeFailure(budgetEnvFor(ctx.services, params.request), user.id.toString());
		throw new InvalidSignInCodeError();
	}
}