mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 05:52:10 +00:00
766 lines
27 KiB
TypeScript
766 lines
27 KiB
TypeScript
import { z } from 'zod';
|
|
import { timingSafeEqual } from 'node:crypto';
|
|
import { logger, hashToken, getRandomValues, isValidObjectIdString } from '@librechat/data-schemas';
|
|
import type { EmailChangeErrorCode, TCustomConfig } from 'librechat-data-provider';
|
|
import { getSafeErrorMetadata } from '../utils/errors';
|
|
import { isEmailDomainAllowed } from './domain';
|
|
import { isEnabled } from '../utils/common';
|
|
|
|
export type { EmailChangeErrorCode } from 'librechat-data-provider';
|
|
|
|
export const EMAIL_CHANGE_TOKEN_TYPE = 'email_change';
|
|
const PASSWORD_RESET_TOKEN_TYPE = 'password_reset';
|
|
|
|
export function isEmailChangeAllowed(
|
|
value: string | undefined = process.env.ALLOW_EMAIL_CHANGE,
|
|
): boolean {
|
|
return value === undefined || isEnabled(value);
|
|
}
|
|
|
|
/**
|
|
* yaml wins over the environment, which wins over the documented default, so a deployment
|
|
* that sets neither keeps exactly the behavior it has today.
|
|
*/
|
|
export function resolveEmailChangeSettings(
|
|
config?: TCustomConfig['emailChange'],
|
|
env: NodeJS.ProcessEnv = process.env,
|
|
): EmailChangeSettings {
|
|
return {
|
|
enabled: config?.enabled ?? isEmailChangeAllowed(env.ALLOW_EMAIL_CHANGE),
|
|
tokenTTLSeconds: config?.tokenTTLSeconds ?? DEFAULT_EMAIL_CHANGE_TOKEN_TTL_SECONDS,
|
|
};
|
|
}
|
|
|
|
export const DEFAULT_EMAIL_CHANGE_TOKEN_TTL_SECONDS: number = 15 * 60;
|
|
|
|
const SUBMITTED_ID_PATTERN = /^[a-f\d]{24}$/i;
|
|
|
|
/**
|
|
* The confirmation endpoint is unauthenticated, so its per-submission allowance is keyed on
|
|
* the address the request came from together with the account it names. The submitted id is
|
|
* untrusted: one that cannot identify an account collapses to a single bucket, so a caller
|
|
* cannot mint a fresh allowance per malformed value.
|
|
*/
|
|
export function emailChangeSubmissionKey(ip: string, submittedUserId: unknown): string {
|
|
const userId =
|
|
typeof submittedUserId === 'string' && SUBMITTED_ID_PATTERN.test(submittedUserId)
|
|
? submittedUserId.toLowerCase()
|
|
: 'invalid';
|
|
return `ip:${ip}:user:${userId}`;
|
|
}
|
|
const EMAIL_CHANGE_ERROR_MESSAGE = 'Invalid or expired email change request';
|
|
|
|
const requestSchema = z.object({
|
|
currentPassword: z.string().min(1).max(128),
|
|
newEmail: z
|
|
.string()
|
|
.trim()
|
|
.email()
|
|
.max(254)
|
|
.transform((email) => email.toLowerCase()),
|
|
});
|
|
|
|
const confirmSchema = z.object({
|
|
email: z
|
|
.string()
|
|
.trim()
|
|
.email()
|
|
.max(254)
|
|
.transform((email) => email.toLowerCase()),
|
|
token: z.string().min(1),
|
|
userId: z.string().refine(isValidObjectIdString),
|
|
});
|
|
|
|
/**
|
|
* The service speaks in plain records so a caller can implement it without Mongoose. The
|
|
* adapter that owns the database is the one that turns documents into these.
|
|
*/
|
|
export interface EmailChangeUser {
|
|
_id?: string;
|
|
id?: string;
|
|
email: string;
|
|
name?: string;
|
|
username?: string;
|
|
password?: string;
|
|
provider?: string;
|
|
role?: string;
|
|
tenantId?: string;
|
|
/** Null is a resolved answer, absent is unknown; principal resolution distinguishes them. */
|
|
idOnTheSource?: string | null;
|
|
}
|
|
|
|
/** `lean()` yields a Map for a Mongoose map field, so reads tolerate either shape. */
|
|
export type EmailChangeTokenMetadata =
|
|
| { requestIp?: string; passwordFingerprint?: string }
|
|
| Map<string, unknown>;
|
|
|
|
export interface EmailChangeToken {
|
|
userId: string;
|
|
token: string;
|
|
email?: string;
|
|
scope?: string;
|
|
identifier?: string;
|
|
expiresAt?: Date | string;
|
|
metadata?: EmailChangeTokenMetadata;
|
|
tenantId?: string;
|
|
}
|
|
|
|
/** `null` matches a stored field that is absent, which is how legacy reset tokens are found. */
|
|
export interface EmailChangeTokenQuery {
|
|
userId?: string;
|
|
email?: string | null;
|
|
identifier?: string | null;
|
|
type?: string | null;
|
|
scope?: string;
|
|
token?: string;
|
|
}
|
|
|
|
export interface EmailChangeTokenData {
|
|
userId: string;
|
|
email: string;
|
|
scope: string;
|
|
identifier: string;
|
|
type: string;
|
|
token: string;
|
|
expiresIn: number;
|
|
metadata?: EmailChangeTokenMetadata;
|
|
}
|
|
|
|
/** What an operator may set, resolved once per call from yaml, then env, then the default. */
|
|
export interface EmailChangeSettings {
|
|
enabled: boolean;
|
|
tokenTTLSeconds: number;
|
|
}
|
|
|
|
/** The effective policy for one account, read in that account's own principal scope. */
|
|
export interface EmailChangePolicy {
|
|
settings: EmailChangeSettings;
|
|
allowedDomains?: string[] | null;
|
|
}
|
|
|
|
interface EmailData {
|
|
email: string;
|
|
subject: string;
|
|
payload: Record<string, string>;
|
|
template: string;
|
|
}
|
|
|
|
export interface EmailChangeDeps {
|
|
findUserByEmail: (email: string, tenantId?: string) => Promise<EmailChangeUser | null>;
|
|
getUserById: (userId: string, tenantId?: string) => Promise<EmailChangeUser | null>;
|
|
updateUser: (
|
|
userId: string,
|
|
update: Pick<EmailChangeUser, 'email'> & { emailVerified: boolean; emailChangedAt: Date },
|
|
expectedState: Pick<EmailChangeUser, 'email' | 'password' | 'provider'>,
|
|
tenantId?: string,
|
|
) => Promise<EmailChangeUser | null>;
|
|
findToken: (query: EmailChangeTokenQuery, tenantId?: string) => Promise<EmailChangeToken | null>;
|
|
replaceTokenIfCurrent: (
|
|
scope: string,
|
|
expectedToken: string | null,
|
|
data: EmailChangeTokenData,
|
|
tenantId?: string,
|
|
) => Promise<boolean>;
|
|
deleteTokens: (
|
|
query: EmailChangeTokenQuery,
|
|
tenantId?: string,
|
|
) => Promise<{ deletedCount?: number }>;
|
|
verifyPassword: (user: EmailChangeUser, password: string) => Promise<boolean>;
|
|
/** The token owner's effective policy, so confirmation honors the scope that issued the
|
|
* link: neither an address the allowlist stopped permitting, nor a change a tenant, role,
|
|
* group, or user override has since disabled. */
|
|
resolvePolicy: (user: EmailChangeUser) => Promise<EmailChangePolicy>;
|
|
sendEmail: (data: EmailData) => Promise<void>;
|
|
/** The deployment default, which answers only for a link that resolves to no owner: a
|
|
* disabled deployment reports an unavailable endpoint rather than an invalid token. It
|
|
* never decides a link that does resolve; `resolvePolicy` owns that. */
|
|
resolveSettings: () => Promise<EmailChangeSettings>;
|
|
clientDomain: string;
|
|
appName: string;
|
|
}
|
|
|
|
export interface EmailChangeResult {
|
|
status: number;
|
|
message: string;
|
|
code?: EmailChangeErrorCode;
|
|
}
|
|
|
|
export interface RequestEmailChangeInput {
|
|
body: {
|
|
currentPassword?: string;
|
|
newEmail?: string;
|
|
};
|
|
userId: string;
|
|
tenantId?: string;
|
|
allowedDomains?: string[] | null;
|
|
emailEnabled: boolean;
|
|
/** Resolved from the effective config the request already loaded. */
|
|
settings: EmailChangeSettings;
|
|
ip?: string;
|
|
}
|
|
|
|
export interface ConfirmEmailChangeInput {
|
|
body: {
|
|
email?: string;
|
|
token?: string;
|
|
userId?: string;
|
|
};
|
|
ip?: string;
|
|
}
|
|
|
|
function result(status: number, message: string, code?: EmailChangeErrorCode): EmailChangeResult {
|
|
return { status, message, ...(code ? { code } : {}) };
|
|
}
|
|
|
|
function normalizeEmail(email: string): string {
|
|
return email.trim().toLowerCase();
|
|
}
|
|
|
|
function userIdOf(user: EmailChangeUser): string | undefined {
|
|
const userId = user._id ?? user.id;
|
|
return userId?.toString();
|
|
}
|
|
|
|
function accountMatchesRequest(
|
|
user: EmailChangeUser | null,
|
|
userId: string,
|
|
email: string,
|
|
password: string,
|
|
): boolean {
|
|
return (
|
|
!!user &&
|
|
userIdOf(user) === userId &&
|
|
user.provider === 'local' &&
|
|
user.password === password &&
|
|
normalizeEmail(user.email) === email
|
|
);
|
|
}
|
|
|
|
function displayName(user: EmailChangeUser): string {
|
|
return user.name || user.username || user.email;
|
|
}
|
|
|
|
/**
|
|
* The template promises a lifetime, so it has to be the one the token was issued with, and
|
|
* never a longer one: rounding 90 minutes up to "2 hours" would keep claiming a link is
|
|
* valid half an hour after it expired. Only a whole number of hours is said in hours.
|
|
*/
|
|
function formatLifetime(seconds: number): string {
|
|
const minutes = Math.floor(seconds / 60);
|
|
if (minutes < 60 || minutes % 60 !== 0) {
|
|
return `${minutes} minute${minutes === 1 ? '' : 's'}`;
|
|
}
|
|
const hours = minutes / 60;
|
|
return `${hours} hour${hours === 1 ? '' : 's'}`;
|
|
}
|
|
|
|
function formatTimestamp(): string {
|
|
return new Date().toISOString();
|
|
}
|
|
|
|
async function tokenMatches(candidate: string, storedHash: string): Promise<boolean> {
|
|
const candidateHash = await hashToken(candidate);
|
|
const candidateBuffer = Buffer.from(candidateHash, 'hex');
|
|
const storedBuffer = Buffer.from(storedHash, 'hex');
|
|
return (
|
|
candidateBuffer.length === storedBuffer.length && timingSafeEqual(candidateBuffer, storedBuffer)
|
|
);
|
|
}
|
|
|
|
async function sendSecurityNotification(
|
|
deps: EmailChangeDeps,
|
|
data: EmailData,
|
|
logContext: string,
|
|
): Promise<void> {
|
|
try {
|
|
await deps.sendEmail(data);
|
|
} catch (error) {
|
|
logger.error(
|
|
`[emailChange] Failed to send ${logContext} notification`,
|
|
getSafeErrorMetadata(error),
|
|
);
|
|
}
|
|
}
|
|
|
|
function verificationLink(
|
|
deps: EmailChangeDeps,
|
|
userId: string,
|
|
email: string,
|
|
token: string,
|
|
): string {
|
|
const query = new URLSearchParams({
|
|
type: 'email-change',
|
|
userId,
|
|
email,
|
|
token,
|
|
});
|
|
return `${deps.clientDomain.replace(/\/$/, '')}/verify?${query.toString()}`;
|
|
}
|
|
|
|
function emailChangeTokenScope(userId: string): string {
|
|
return `${EMAIL_CHANGE_TOKEN_TYPE}:${userId}`;
|
|
}
|
|
|
|
function isDuplicateKeyError(error: unknown): boolean {
|
|
return (
|
|
typeof error === 'object' &&
|
|
error !== null &&
|
|
'code' in error &&
|
|
(error as { code?: number }).code === 11000
|
|
);
|
|
}
|
|
|
|
function expiryOf(token: EmailChangeToken): number | null {
|
|
if (!token.expiresAt) {
|
|
return null;
|
|
}
|
|
const expiresAt = new Date(token.expiresAt).getTime();
|
|
return Number.isFinite(expiresAt) ? expiresAt : null;
|
|
}
|
|
|
|
function isTokenExpired(token: EmailChangeToken): boolean {
|
|
const expiresAt = expiryOf(token);
|
|
return expiresAt === null || expiresAt <= Date.now();
|
|
}
|
|
|
|
function remainingLifetimeSeconds(token: EmailChangeToken): number {
|
|
const expiresAt = expiryOf(token);
|
|
return expiresAt === null ? 0 : Math.floor((expiresAt - Date.now()) / 1000);
|
|
}
|
|
|
|
function tokenMetadataValue(
|
|
token: EmailChangeToken,
|
|
key: 'requestIp' | 'passwordFingerprint',
|
|
): unknown {
|
|
if (token.metadata instanceof Map) {
|
|
return token.metadata.get(key);
|
|
}
|
|
return token.metadata?.[key];
|
|
}
|
|
|
|
async function deleteTokensOrLog(
|
|
deps: EmailChangeDeps,
|
|
query: EmailChangeTokenQuery,
|
|
tenantId: string | undefined,
|
|
context: string,
|
|
): Promise<void> {
|
|
try {
|
|
await deps.deleteTokens(query, tenantId);
|
|
} catch (error) {
|
|
logger.error(`[emailChange] Failed to clean up ${context}`, getSafeErrorMetadata(error));
|
|
}
|
|
}
|
|
|
|
type TokenClaim = 'claimed' | 'superseded' | 'unavailable';
|
|
|
|
/** Consumes the pending token only while the stored hash still matches the presented link,
|
|
* so a confirmation that a newer request superseded finds nothing to claim. A failed delete
|
|
* is reported separately because it must not be read as a superseded link. */
|
|
async function claimTokenIfCurrent(
|
|
deps: EmailChangeDeps,
|
|
query: EmailChangeTokenQuery,
|
|
tenantId: string | undefined,
|
|
): Promise<TokenClaim> {
|
|
try {
|
|
const { deletedCount } = await deps.deleteTokens(query, tenantId);
|
|
return deletedCount ? 'claimed' : 'superseded';
|
|
} catch (error) {
|
|
logger.error('[emailChange] Failed to claim the pending token', getSafeErrorMetadata(error));
|
|
return 'unavailable';
|
|
}
|
|
}
|
|
|
|
/** Reinstates a claimed token so a transient commit failure leaves the link usable. The
|
|
* conditional insert is a no-op once a newer request owns the scope, and an elapsed
|
|
* lifetime is left consumed rather than revived. */
|
|
async function restoreClaimedToken(
|
|
deps: EmailChangeDeps,
|
|
token: EmailChangeToken,
|
|
scope: string,
|
|
tenantId: string | undefined,
|
|
): Promise<void> {
|
|
const expiresIn = remainingLifetimeSeconds(token);
|
|
const { email, identifier } = token;
|
|
/** A pending change always carries both; without them there is no link to reinstate. */
|
|
if (expiresIn <= 0 || !email || !identifier) {
|
|
return;
|
|
}
|
|
try {
|
|
await deps.replaceTokenIfCurrent(
|
|
scope,
|
|
null,
|
|
{
|
|
userId: token.userId,
|
|
email,
|
|
scope,
|
|
identifier,
|
|
type: EMAIL_CHANGE_TOKEN_TYPE,
|
|
token: token.token,
|
|
expiresIn,
|
|
metadata: token.metadata,
|
|
},
|
|
tenantId,
|
|
);
|
|
} catch (error) {
|
|
logger.error('[emailChange] Failed to restore the claimed token', getSafeErrorMetadata(error));
|
|
}
|
|
}
|
|
|
|
export function createEmailChangeService(deps: EmailChangeDeps): {
|
|
requestEmailChange: (input: RequestEmailChangeInput) => Promise<EmailChangeResult>;
|
|
confirmEmailChange: (input: ConfirmEmailChangeInput) => Promise<EmailChangeResult>;
|
|
} {
|
|
async function requestEmailChange(input: RequestEmailChangeInput): Promise<EmailChangeResult> {
|
|
const { settings } = input;
|
|
if (!settings.enabled) {
|
|
logger.warn(
|
|
`[emailChange] Rejected disabled request [User ID: ${input.userId}] [IP: ${input.ip ?? 'unknown'}]`,
|
|
);
|
|
return result(403, 'Email changes are disabled', 'email_change_disabled');
|
|
}
|
|
|
|
const parsed = requestSchema.safeParse(input.body);
|
|
if (!parsed.success) {
|
|
return result(400, 'A valid new email and current password are required', 'invalid_request');
|
|
}
|
|
|
|
if (!input.emailEnabled) {
|
|
return result(503, 'Email delivery is not configured', 'email_service_unavailable');
|
|
}
|
|
|
|
const user = await deps.getUserById(input.userId, input.tenantId);
|
|
const userId = user ? userIdOf(user) : undefined;
|
|
if (!user || !userId || user.provider !== 'local' || !user.password) {
|
|
logger.warn(
|
|
`[emailChange] Rejected non-local account request [User ID: ${input.userId}] [IP: ${input.ip ?? 'unknown'}]`,
|
|
);
|
|
return result(
|
|
403,
|
|
'Email changes are only available for local accounts',
|
|
'local_account_required',
|
|
);
|
|
}
|
|
|
|
const oldEmail = normalizeEmail(user.email);
|
|
const newEmail = parsed.data.newEmail;
|
|
if (newEmail === oldEmail) {
|
|
return result(400, 'New email must be different from the current email', 'same_email');
|
|
}
|
|
|
|
const ip = input.ip ?? 'unknown';
|
|
logger.info(`[emailChange] Change requested [User ID: ${userId}] [IP: ${ip}]`);
|
|
await sendSecurityNotification(
|
|
deps,
|
|
{
|
|
email: oldEmail,
|
|
subject: 'Email change requested',
|
|
payload: {
|
|
appName: deps.appName,
|
|
name: displayName(user),
|
|
newEmail,
|
|
ip,
|
|
requestedAt: formatTimestamp(),
|
|
},
|
|
template: 'emailChangeAttempt.handlebars',
|
|
},
|
|
'email change attempt',
|
|
);
|
|
|
|
const passwordMatches = await deps.verifyPassword(user, parsed.data.currentPassword);
|
|
if (!passwordMatches) {
|
|
logger.warn(`[emailChange] Incorrect password [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(403, 'Current password is incorrect', 'current_password_invalid');
|
|
}
|
|
|
|
if (!isEmailDomainAllowed(newEmail, input.allowedDomains)) {
|
|
logger.warn(`[emailChange] Domain not allowed [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(403, 'Email domain is not allowed', 'email_domain_not_allowed');
|
|
}
|
|
|
|
const tokenScope = emailChangeTokenScope(userId);
|
|
/** Nothing here depends on another's result and all three stay scoped to the requesting
|
|
* user's tenant, so issuance makes one round trip instead of three before delivery. The
|
|
* results are still validated in the order they were, and none of them is acted on until
|
|
* the check that owns it passes. */
|
|
const [existingUser, previousToken, latestUser] = await Promise.all([
|
|
deps.findUserByEmail(newEmail, user.tenantId),
|
|
deps.findToken({ scope: tokenScope }, user.tenantId),
|
|
deps.getUserById(input.userId, input.tenantId),
|
|
]);
|
|
|
|
if (existingUser && userIdOf(existingUser) !== userId) {
|
|
logger.warn(`[emailChange] Email already in use [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(409, 'Email address is already linked to another account', 'email_in_use');
|
|
}
|
|
|
|
const rawToken = await getRandomValues(32);
|
|
const tokenHash = await hashToken(rawToken);
|
|
const passwordFingerprint = await hashToken(user.password);
|
|
const tokenQuery = {
|
|
userId,
|
|
email: newEmail,
|
|
type: EMAIL_CHANGE_TOKEN_TYPE,
|
|
token: tokenHash,
|
|
};
|
|
|
|
/** The re-read above guards delivery: an account change during request validation must not
|
|
* produce a verification message whose link can never be used. */
|
|
if (!accountMatchesRequest(latestUser, userId, oldEmail, user.password)) {
|
|
logger.warn(`[emailChange] Account changed while issuing [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(409, 'Account was modified during the request', 'account_modified');
|
|
}
|
|
|
|
try {
|
|
await deps.sendEmail({
|
|
email: newEmail,
|
|
subject: 'Verify your new email address',
|
|
payload: {
|
|
appName: deps.appName,
|
|
name: displayName(user),
|
|
newEmail,
|
|
verificationLink: verificationLink(deps, userId, newEmail, rawToken),
|
|
linkLifetime: formatLifetime(settings.tokenTTLSeconds),
|
|
year: new Date().getFullYear().toString(),
|
|
},
|
|
template: 'verifyEmailChange.handlebars',
|
|
});
|
|
} catch (error) {
|
|
logger.error(
|
|
`[emailChange] Verification delivery failed [User ID: ${userId}] [IP: ${ip}]`,
|
|
getSafeErrorMetadata(error),
|
|
);
|
|
return result(500, 'Failed to send verification email', 'email_delivery_failed');
|
|
}
|
|
|
|
const replacement = {
|
|
userId,
|
|
email: newEmail,
|
|
scope: tokenScope,
|
|
identifier: oldEmail,
|
|
type: EMAIL_CHANGE_TOKEN_TYPE,
|
|
token: tokenHash,
|
|
expiresIn: settings.tokenTTLSeconds,
|
|
metadata: { requestIp: ip, passwordFingerprint },
|
|
};
|
|
let replacedToken = await deps.replaceTokenIfCurrent(
|
|
tokenScope,
|
|
previousToken?.token ?? null,
|
|
replacement,
|
|
user.tenantId,
|
|
);
|
|
/** The observed token can be swept by the expiry monitor while the message is in flight,
|
|
* and a compare-and-set against a hash that no longer exists cannot tell that apart from
|
|
* a competitor. The empty expectation answers it atomically: the scoped index admits the
|
|
* insert only while nothing holds the scope, so a real competitor still refuses it and a
|
|
* delivered link is not reported as a losing race. */
|
|
if (!replacedToken && previousToken) {
|
|
replacedToken = await deps.replaceTokenIfCurrent(
|
|
tokenScope,
|
|
null,
|
|
replacement,
|
|
user.tenantId,
|
|
);
|
|
}
|
|
if (!replacedToken) {
|
|
logger.warn(
|
|
`[emailChange] Competing request completed first [User ID: ${userId}] [IP: ${ip}]`,
|
|
);
|
|
return result(409, 'Another email change request completed first', 'request_in_progress');
|
|
}
|
|
|
|
/** Re-read after replacement: the prior token remains valid during delivery, so a
|
|
* confirmation can move the account before the new token becomes active. */
|
|
const committedUser = await deps.getUserById(input.userId, input.tenantId);
|
|
if (!accountMatchesRequest(committedUser, userId, oldEmail, user.password)) {
|
|
await deleteTokensOrLog(deps, tokenQuery, user.tenantId, 'token bound to a stale address');
|
|
logger.warn(`[emailChange] Account changed while issuing [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(409, 'Account was modified during the request', 'account_modified');
|
|
}
|
|
|
|
logger.info(`[emailChange] Verification issued [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(200, 'Verification link sent to your new email address');
|
|
}
|
|
|
|
/** A link that names no owner has no policy to consult, so the deployment answers for it:
|
|
* an operator who turned changes off gets an unavailable endpoint rather than a report
|
|
* about the token. A link that does resolve is decided by its owner's policy alone. */
|
|
async function unresolvedLink(): Promise<EmailChangeResult> {
|
|
if (!(await deps.resolveSettings()).enabled) {
|
|
return result(403, 'Email changes are disabled', 'email_change_disabled');
|
|
}
|
|
return result(400, EMAIL_CHANGE_ERROR_MESSAGE, 'invalid_token');
|
|
}
|
|
|
|
/** Issuance answers from the requesting user's effective configuration, so confirmation has
|
|
* to answer from the same scope or a tenant, role, group, or user override that enables
|
|
* changes would offer a link the deployment default then refuses. The toggle that decides a
|
|
* real link is therefore read once, below, after the link names its owner. */
|
|
async function confirmEmailChange(input: ConfirmEmailChangeInput): Promise<EmailChangeResult> {
|
|
const parsed = confirmSchema.safeParse(input.body);
|
|
if (!parsed.success) {
|
|
return unresolvedLink();
|
|
}
|
|
|
|
const { email, token, userId } = parsed.data;
|
|
const ip = input.ip ?? 'unknown';
|
|
const scope = emailChangeTokenScope(userId);
|
|
const tokenQuery = { userId, email, type: EMAIL_CHANGE_TOKEN_TYPE, scope };
|
|
const emailChangeToken = await deps.findToken(tokenQuery);
|
|
|
|
if (
|
|
!emailChangeToken ||
|
|
isTokenExpired(emailChangeToken) ||
|
|
!(await tokenMatches(token, emailChangeToken.token))
|
|
) {
|
|
logger.warn(`[emailChange] Invalid confirmation [User ID: ${userId}] [IP: ${ip}]`);
|
|
return unresolvedLink();
|
|
}
|
|
|
|
const tenantId = emailChangeToken.tenantId;
|
|
const user = await deps.getUserById(userId, tenantId);
|
|
const oldEmail = user ? normalizeEmail(user.email) : '';
|
|
const passwordFingerprint = tokenMetadataValue(emailChangeToken, 'passwordFingerprint');
|
|
if (
|
|
!user ||
|
|
userIdOf(user) !== userId ||
|
|
user.provider !== 'local' ||
|
|
!user.password ||
|
|
typeof passwordFingerprint !== 'string' ||
|
|
!(await tokenMatches(user.password, passwordFingerprint)) ||
|
|
emailChangeToken.scope !== scope ||
|
|
normalizeEmail(emailChangeToken.email ?? '') !== email ||
|
|
normalizeEmail(emailChangeToken.identifier ?? '') !== oldEmail
|
|
) {
|
|
logger.warn(`[emailChange] Stale confirmation [User ID: ${userId}] [IP: ${ip}]`);
|
|
return unresolvedLink();
|
|
}
|
|
|
|
/** The policy of the account the link names, which is the scope that issued it: a
|
|
* deployment default reaches this through the same read when nothing overrides it. */
|
|
const policy = await deps.resolvePolicy(user);
|
|
if (!policy.settings.enabled) {
|
|
logger.warn(
|
|
`[emailChange] Rejected disabled confirmation for its owner [User ID: ${userId}] [IP: ${ip}]`,
|
|
);
|
|
return result(403, 'Email changes are disabled', 'email_change_disabled');
|
|
}
|
|
|
|
if (!isEmailDomainAllowed(email, policy.allowedDomains)) {
|
|
logger.warn(`[emailChange] Domain no longer allowed [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(403, 'Email domain is not allowed', 'email_domain_not_allowed');
|
|
}
|
|
|
|
const existingUser = await deps.findUserByEmail(email, tenantId);
|
|
if (existingUser && userIdOf(existingUser) !== userId) {
|
|
return result(409, 'Email address is already linked to another account', 'email_in_use');
|
|
}
|
|
|
|
/** Claiming the exact hash that was presented binds the commit to this link: a request
|
|
* that replaced the scoped token between the lookup and here leaves nothing to claim,
|
|
* so a superseded address can no longer overwrite the one the user was last sent.
|
|
* Reset tokens stay untouched until after the commit so a failed update cannot revoke
|
|
* an unrelated password-reset link. */
|
|
const claim = await claimTokenIfCurrent(
|
|
deps,
|
|
{ ...tokenQuery, token: emailChangeToken.token },
|
|
tenantId,
|
|
);
|
|
if (claim === 'unavailable') {
|
|
logger.error(`[emailChange] Token claim failed [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(500, 'Failed to change email address');
|
|
}
|
|
if (claim === 'superseded') {
|
|
logger.warn(`[emailChange] Superseded confirmation [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(400, EMAIL_CHANGE_ERROR_MESSAGE, 'invalid_token');
|
|
}
|
|
|
|
/** The compare-and-set remains the commit point and the single-use guard: a competing
|
|
* confirmation cannot match `oldEmail` twice. The claimed token is put back when the
|
|
* update fails transiently, so the link stays replayable. Reset tokens are not touched
|
|
* here: a failed commit must leave the account's existing reset flow intact. */
|
|
try {
|
|
const updatedUser = await deps.updateUser(
|
|
userId,
|
|
{ email, emailVerified: true, emailChangedAt: new Date() },
|
|
{ email: oldEmail, password: user.password, provider: 'local' },
|
|
tenantId,
|
|
);
|
|
if (!updatedUser) {
|
|
return result(400, EMAIL_CHANGE_ERROR_MESSAGE, 'invalid_token');
|
|
}
|
|
} catch (error) {
|
|
if (isDuplicateKeyError(error)) {
|
|
return result(409, 'Email address is already linked to another account', 'email_in_use');
|
|
}
|
|
logger.error(
|
|
`[emailChange] Update failed [User ID: ${userId}] [IP: ${ip}]`,
|
|
getSafeErrorMetadata(error),
|
|
);
|
|
await restoreClaimedToken(deps, emailChangeToken, scope, tenantId);
|
|
return result(500, 'Failed to change email address');
|
|
}
|
|
|
|
/** After the commit only. Restricted to the address that moved, address-less typed
|
|
* tokens, and untyped legacy tokens, so a reset another replica issued for the
|
|
* committed address is not revoked with them. `resetPassword` also refuses those
|
|
* leftovers via the address binding and `emailChangedAt` checks. No email change
|
|
* token is swept here: the claim above already consumed the one this link
|
|
* presented, and the scope is unique per user, so anything under it now belongs
|
|
* to a request that started after the commit and still has a live link. */
|
|
await Promise.all([
|
|
deleteTokensOrLog(
|
|
deps,
|
|
{ userId, email: oldEmail, type: PASSWORD_RESET_TOKEN_TYPE },
|
|
tenantId,
|
|
'password reset tokens bound to the previous address',
|
|
),
|
|
deleteTokensOrLog(
|
|
deps,
|
|
{ userId, email: null, type: PASSWORD_RESET_TOKEN_TYPE },
|
|
tenantId,
|
|
'address-less password reset tokens issued during the change',
|
|
),
|
|
deleteTokensOrLog(
|
|
deps,
|
|
{ userId, email: null, identifier: null, type: null },
|
|
tenantId,
|
|
'untyped legacy reset tokens issued before the change',
|
|
),
|
|
]);
|
|
const confirmationPayload = {
|
|
appName: deps.appName,
|
|
name: displayName(user),
|
|
oldEmail,
|
|
newEmail: email,
|
|
ip,
|
|
changedAt: formatTimestamp(),
|
|
};
|
|
await Promise.all([
|
|
sendSecurityNotification(
|
|
deps,
|
|
{
|
|
email: oldEmail,
|
|
subject: 'Your email address was changed',
|
|
payload: confirmationPayload,
|
|
template: 'emailChanged.handlebars',
|
|
},
|
|
'old-address confirmation',
|
|
),
|
|
sendSecurityNotification(
|
|
deps,
|
|
{
|
|
email,
|
|
subject: 'Your email address was changed',
|
|
payload: confirmationPayload,
|
|
template: 'emailChanged.handlebars',
|
|
},
|
|
'new-address confirmation',
|
|
),
|
|
]);
|
|
|
|
logger.info(`[emailChange] Change completed [User ID: ${userId}] [IP: ${ip}]`);
|
|
return result(200, 'Email address changed successfully');
|
|
}
|
|
|
|
return { requestEmailChange, confirmEmailChange };
|
|
}
|