A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
test(api/auth): cover identifier-first sign-in
Hampuscda554d32486
diff --git a/fluxer_api/src/api/auth/tests/IdentifierFirstSignIn.test.ts b/fluxer_api/src/api/auth/tests/IdentifierFirstSignIn.test.tsnew file mode 100644index 000000000..470f30cfa--- /dev/null+++ b/fluxer_api/src/api/auth/tests/IdentifierFirstSignIn.test.ts@@ -0,0 +1,733 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {+ ACCOUNT_CODE_FAILURES_DAILY_CAP,+ ADDRESS_CODE_FAILURES_DAILY_CAP,+ ADDRESS_CODE_FAILURES_PER_STEP,+ CODE_FAILURES_DAILY_CAP,+ enforceLookupHardLimits,+ GLOBAL_CODE_FAILURES_THRESHOLD,+ recordAccountCodeFailure,+ recordAddressCodeFailure,+ requesterNetworkKey,+} from '@app/api/auth/AccountBudgets';+import {normalizeEmailKey} from '@app/api/auth/AccountCodes';+import {+ clearTestEmails,+ createTestAccount,+ createTotpSecret,+ createUniqueEmail,+ findLastTestEmail,+ generateTotpCode,+ listTestEmails,+} from '@app/api/auth/tests/AuthTestUtils';+import {createUserID} from '@app/api/BrandedTypes';+import {getContentMessage} from '@app/api/content_i18n/ContentI18n';+import {getKVClient} from '@app/api/middleware/ServiceRegistry';+import {+ getInstanceConfigRepository,+ getRateLimitService,+ getUserRepository,+} from '@app/api/middleware/ServiceSingletons';+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';+import {+ CAPTCHA_TEST_HEADER,+ type CaptchaErrorBody,+ solveCaptchaChallenge,+ useCheapCaptcha,+} from '@app/api/test/CaptchaTestUtils';+import {HTTP_STATUS} from '@app/api/test/TestConstants';+import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';+import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from 'vitest';++interface IdentifyBody {+ ticket: string;+ account: 'existing' | 'new';+ sign_in_method: 'password' | 'code' | null;+ registration: {mode: string; consent_required: boolean; requires_password: boolean} | null;+}++interface SignInBody {+ token?: string;+ user_id?: string;+ device_proof?: string;+ mfa?: boolean;+ ticket?: string;+}++const STRANGER_IP = '203.0.113.9';+const ENABLE_RATE_LIMITS = 'x-fluxer-test-enable-rate-limits';++describe('Identifier-first sign-in', () => {+ let harness: ApiTestHarness;+ beforeAll(async () => {+ harness = await createApiTestHarness();+ });+ beforeEach(async () => {+ await harness.reset();+ await getInstanceConfigRepository().updateAuthConfig({identifier_first: true});+ await clearTestEmails(harness);+ });+ afterAll(async () => {+ await harness?.shutdown();+ });++ async function identify(email: string, ip = STRANGER_IP): Promise<IdentifyBody> {+ return await createBuilderWithoutAuth<IdentifyBody>(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', ip)+ .body({email})+ .execute();+ }++ async function sendCode(ticket: string, ip = STRANGER_IP): Promise<{purpose: string}> {+ return await createBuilderWithoutAuth<{purpose: string}>(harness)+ .post('/auth/email-code/send')+ .header('x-forwarded-for', ip)+ .body({ticket})+ .execute();+ }++ async function dropPassword(account: {userId: string}): Promise<void> {+ const user = await getUserRepository().findUniqueAssert(createUserID(BigInt(account.userId)));+ await getUserRepository().patchUpsert(user.id, {password_hash: null}, user.toRow());+ }++ function lastCode(email: string, type: string, emails: Awaited<ReturnType<typeof listTestEmails>>): string {+ const record = findLastTestEmail(+ emails.filter((entry) => entry.to.toLowerCase() === email.toLowerCase()),+ type,+ );+ expect(record).not.toBeNull();+ return record!.metadata['code']!;+ }++ it('refuses the lookup while the instance keeps the older sign-in', async () => {+ await getInstanceConfigRepository().updateAuthConfig({identifier_first: false});+ await createBuilderWithoutAuth(harness)+ .post('/auth/identify')+ .body({email: createUniqueEmail('off')})+ .expect(HTTP_STATUS.FORBIDDEN, APIErrorCodes.FEATURE_TEMPORARILY_DISABLED)+ .execute();+ });++ it('answers existing and new with the same keys and no sign-in methods', async () => {+ const account = await createTestAccount(harness);+ const existing = await identify(account.email);+ const fresh = await identify(createUniqueEmail('fresh'));+ expect(existing.account).toBe('existing');+ expect(existing.registration).toBeNull();+ expect(fresh.account).toBe('new');+ expect(fresh.registration).toEqual({+ mode: 'open',+ consent_required: true,+ requires_password: false,+ instant_account_availability: 'available',+ });+ expect(Object.keys(existing).sort()).toEqual(Object.keys(fresh).sort());+ expect(existing.ticket).toHaveLength(43);+ });++ it('signs in with an emailed code, authorizes the IP and returns a device proof', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const {ticket} = await identify(account.email);+ expect((await sendCode(ticket)).purpose).toBe('sign_in');+ const emails = await listTestEmails(harness, {recipient: account.email});+ const code = lastCode(account.email, 'sign_in_code', emails);+ const signedIn = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', STRANGER_IP)+ .body({ticket, code})+ .execute();+ expect(signedIn.user_id).toBe(account.userId);+ expect(signedIn.token).toBeTruthy();+ expect(signedIn.device_proof).toBeTruthy();+ expect(await getUserRepository().checkIpAuthorized(createUserID(BigInt(account.userId)), STRANGER_IP)).toBe(true);+ });++ it('refuses a wrong code, kills a code after five tries and replaces an older code', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const {ticket} = await identify(account.email);+ await sendCode(ticket);+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const wrong = code === '000000' ? '111111' : '000000';+ for (let attempt = 0; attempt < 5; attempt++) {+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code: wrong})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.INVALID_SIGN_IN_CODE)+ .execute();+ }+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.SIGN_IN_CODE_EXPIRED)+ .execute();+ });++ it('asks to wait before another code for the same ticket', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const {ticket} = await identify(account.email);+ await sendCode(ticket);+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/send')+ .body({ticket})+ .expect(429, APIErrorCodes.EMAIL_CODE_RESEND_COOLDOWN)+ .execute();+ });++ it('rejects an unknown ticket', async () => {+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/send')+ .body({ticket: 'a'.repeat(43)})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.UNKNOWN_SIGN_IN_TICKET)+ .execute();+ });++ it('creates the account only after the sign-up code with the terms accepted, with a confirmed email', async () => {+ const email = createUniqueEmail('signup');+ const {ticket, account} = await identify(email);+ expect(account).toBe('new');+ expect((await sendCode(ticket)).purpose).toBe('sign_up');+ const code = lastCode(email, 'sign_up_code', await listTestEmails(harness, {recipient: email}));+ for (const consent of [undefined, false]) {+ const refused = await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/verify')+ .body(consent === undefined ? {ticket, code} : {ticket, code, consent})+ .expect(HTTP_STATUS.BAD_REQUEST, 'INVALID_FORM_BODY')+ .executeWithResponse();+ expect(JSON.stringify(refused.json)).toContain('MUST_AGREE_TO_TOS_AND_PRIVACY_POLICY');+ }+ expect((await identify(email)).account).toBe('new');+ const created = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code, consent: true})+ .execute();+ const me = await createBuilder<{+ email: string;+ verified: boolean;+ claimed: boolean;+ has_password: boolean;+ date_of_birth_required: boolean;+ global_name: string | null;+ }>(harness, created.token!)+ .get('/users/@me')+ .execute();+ expect(me).toMatchObject({+ email,+ verified: true,+ claimed: true,+ has_password: false,+ date_of_birth_required: true,+ global_name: null,+ });+ const user = await getUserRepository().findUniqueAssert(createUserID(BigInt(created.user_id!)));+ expect(user.termsAgreedAt).not.toBeNull();+ expect(user.privacyAgreedAt).not.toBeNull();+ expect((await identify(email)).account).toBe('existing');+ });++ it('writes the sign-up code email in the language the client asked for', async () => {+ const swedish = getContentMessage('auth.unknown_location', 'sv-SE');+ expect(swedish).not.toBe(getContentMessage('auth.unknown_location', 'en-US'));+ for (const header of ['sv', 'sv-SE,sv;q=0.9,en;q=0.8']) {+ const email = createUniqueEmail('locale');+ const {ticket} = await identify(email);+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/send')+ .header('x-forwarded-for', STRANGER_IP)+ .header('accept-language', header)+ .body({ticket})+ .execute();+ const sent = findLastTestEmail(await listTestEmails(harness, {recipient: email}), 'sign_up_code');+ expect(sent?.metadata['location']).toBe(swedish);+ }+ });++ it('hands MFA accounts a second-factor ticket after the code', async () => {+ const account = await createTestAccount(harness);+ const secret = createTotpSecret();+ await createBuilder(harness, account.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: generateTotpCode(secret), password: account.password})+ .execute();+ await dropPassword(account);+ const {ticket} = await identify(account.email);+ await sendCode(ticket);+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const result = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .execute();+ expect(result.mfa).toBe(true);+ expect(result.token).toBeUndefined();+ });++ it('signs the inbox owner into the account whose claim holds the address, and confirms it', async () => {+ const email = createUniqueEmail('claimed-address');+ const squatter = await createBuilderWithoutAuth<{token: string; user_id: string}>(harness)+ .post('/auth/register')+ .body({username: 'squatter', consent: true, date_of_birth: '2000-01-01'})+ .execute();+ await createBuilder(harness, squatter.token).post('/users/@me/claim').body({email}).execute();+ const {ticket, account} = await identify(email);+ expect(account).toBe('existing');+ expect((await sendCode(ticket)).purpose).toBe('sign_in');+ const code = lastCode(email, 'sign_in_code', await listTestEmails(harness, {recipient: email}));+ const signedIn = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .execute();+ expect(signedIn.user_id).toBe(squatter.user_id);+ const me = await createBuilder<{email: string; verified: boolean}>(harness, signedIn.token!)+ .get('/users/@me')+ .execute();+ expect(me).toMatchObject({email, verified: true});+ });++ it('sends a password account to its password and never signs it in by code', async () => {+ const account = await createTestAccount(harness);+ const {ticket, sign_in_method} = await identify(account.email);+ expect(sign_in_method).toBe('password');+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/send')+ .header('x-forwarded-for', STRANGER_IP)+ .body({ticket})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.PASSWORD_SIGN_IN_REQUIRED)+ .execute();+ expect(findLastTestEmail(await listTestEmails(harness, {recipient: account.email}), 'sign_in_code')).toBeNull();+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', STRANGER_IP)+ .body({ticket, code: '000000'})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.PASSWORD_SIGN_IN_REQUIRED)+ .execute();+ });++ it('refuses a code sent before the account set a password', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const {ticket, sign_in_method} = await identify(account.email);+ expect(sign_in_method).toBe('code');+ await sendCode(ticket);+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const user = await getUserRepository().findUniqueAssert(createUserID(BigInt(account.userId)));+ await getUserRepository().patchUpsert(user.id, {password_hash: 'set-later'}, user.toRow());+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.PASSWORD_SIGN_IN_REQUIRED)+ .execute();+ });++ it('signs out other sessions and forgets networks when a code confirms an address', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ await createBuilder(harness, '')+ .post(`/test/users/${account.userId}/security-flags`)+ .body({email_verified: false})+ .execute();+ const repository = getUserRepository();+ const {ticket} = await identify(account.email);+ await sendCode(ticket);+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const signedIn = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', STRANGER_IP)+ .body({ticket, code})+ .execute();+ await createBuilder(harness, account.token).get('/users/@me').expect(HTTP_STATUS.UNAUTHORIZED).execute();+ const me = await createBuilder<{verified: boolean}>(harness, signedIn.token!).get('/users/@me').execute();+ expect(me.verified).toBe(true);+ const user = await repository.findUniqueAssert(createUserID(BigInt(account.userId)));+ expect((await repository.getAuthorizedIps(user.id)).map((entry) => entry.ip)).toEqual([STRANGER_IP]);+ });++ it('leaves a passwordless squatter no session or window to enroll a factor after the owner proves the inbox', async () => {+ const email = createUniqueEmail('squatted');+ const squatter = await createBuilderWithoutAuth<{token: string; user_id: string}>(harness)+ .post('/auth/register')+ .body({username: 'squatter', consent: true, date_of_birth: '2000-01-01'})+ .execute();+ await createBuilder(harness, squatter.token).post('/users/@me/claim').body({email}).execute();+ const {ticket, sign_in_method} = await identify(email);+ expect(sign_in_method).toBe('code');+ await sendCode(ticket);+ const code = lastCode(email, 'sign_in_code', await listTestEmails(harness, {recipient: email}));+ const signedIn = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .execute();+ expect(signedIn.user_id).toBe(squatter.user_id);+ await createBuilder(harness, squatter.token).get('/users/@me').expect(HTTP_STATUS.UNAUTHORIZED).execute();+ const secret = createTotpSecret();+ await createBuilder(harness, squatter.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: generateTotpCode(secret)})+ .expect(HTTP_STATUS.UNAUTHORIZED)+ .execute();+ await createBuilder(harness, squatter.token)+ .post('/users/@me/mfa/webauthn/credentials/registration-options')+ .body({})+ .expect(HTTP_STATUS.UNAUTHORIZED)+ .execute();+ });++ it('lets the inbox owner take back an address a squatter set a password on through a reset', async () => {+ const email = createUniqueEmail('squatted-password');+ const squatterPassword = 'a-strong-squatter-password-3';+ const squatter = await createBuilderWithoutAuth<{token: string; user_id: string}>(harness)+ .post('/auth/register')+ .body({username: 'squatter', consent: true, date_of_birth: '2000-01-01'})+ .execute();+ await createBuilder(harness, squatter.token)+ .post('/users/@me/claim')+ .body({email, password: squatterPassword})+ .execute();+ await createBuilderWithoutAuth(harness)+ .post('/auth/login')+ .header('x-forwarded-for', '192.0.2.77')+ .body({email, password: squatterPassword})+ .expect(HTTP_STATUS.FORBIDDEN)+ .execute();+ const approval = findLastTestEmail(await listTestEmails(harness, {recipient: email}), 'ip_authorization');+ const {sign_in_method} = await identify(email);+ expect(sign_in_method).toBe('password');+ await createBuilderWithoutAuth(harness).post('/auth/forgot').body({email}).expect(HTTP_STATUS.NO_CONTENT).execute();+ const token = findLastTestEmail(await listTestEmails(harness, {recipient: email}), 'password_reset')!.metadata[+ 'token'+ ];+ const ownerPassword = 'the-real-owner-password-4';+ const reset = await createBuilderWithoutAuth<{user_id: string; token: string}>(harness)+ .post('/auth/reset')+ .body({token, password: ownerPassword})+ .execute();+ expect(reset.user_id).toBe(squatter.user_id);+ await createBuilder(harness, squatter.token).get('/users/@me').expect(HTTP_STATUS.UNAUTHORIZED).execute();+ await createBuilderWithoutAuth(harness)+ .post('/auth/authorize-ip')+ .header('x-forwarded-for', '192.0.2.77')+ .body({token: approval!.metadata['token']})+ .expect(HTTP_STATUS.BAD_REQUEST)+ .execute();+ await createBuilderWithoutAuth(harness)+ .post('/auth/login')+ .header('x-forwarded-for', '127.0.0.1')+ .body({email, password: squatterPassword})+ .expect(HTTP_STATUS.BAD_REQUEST)+ .execute();+ });++ it('authorizes the network that passes the factor after a code', async () => {+ const account = await createTestAccount(harness);+ const secret = createTotpSecret();+ await createBuilder(harness, account.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: generateTotpCode(secret), password: account.password})+ .execute();+ await dropPassword(account);+ const ip = '198.51.100.88';+ const {ticket} = await identify(account.email, ip);+ await sendCode(ticket, ip);+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const challenge = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', ip)+ .body({ticket, code})+ .execute();+ const user = await getUserRepository().findUniqueAssert(createUserID(BigInt(account.userId)));+ expect(await getUserRepository().checkIpAuthorized(user.id, ip)).toBe(false);+ await createBuilderWithoutAuth(harness)+ .post('/auth/login/mfa/totp')+ .header('x-forwarded-for', ip)+ .body({ticket: challenge.ticket, code: generateTotpCode(secret)})+ .execute();+ expect(await getUserRepository().checkIpAuthorized(user.id, ip)).toBe(true);+ });++ it('asks an unconfirmed owner with a second factor for it after the code', async () => {+ const account = await createTestAccount(harness);+ const secret = createTotpSecret();+ await createBuilder(harness, account.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: generateTotpCode(secret), password: account.password})+ .execute();+ await dropPassword(account);+ await createBuilder(harness, '')+ .post(`/test/users/${account.userId}/security-flags`)+ .body({email_verified: false})+ .execute();+ const {ticket, account: state} = await identify(account.email);+ expect(state).toBe('existing');+ expect((await sendCode(ticket)).purpose).toBe('sign_in');+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const challenge = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .execute();+ expect(challenge.mfa).toBe(true);+ expect(challenge.token).toBeUndefined();+ const pending = await getUserRepository().findUniqueAssert(createUserID(BigInt(account.userId)));+ expect(pending).toMatchObject({email: account.email, emailVerified: false, totpSecret: secret});+ await createBuilder(harness, account.token).get('/users/@me').expect(HTTP_STATUS.OK).execute();+ const signedIn = await createBuilderWithoutAuth<{token: string}>(harness)+ .post('/auth/login/mfa/totp')+ .body({ticket: challenge.ticket, code: generateTotpCode(secret)})+ .execute();+ const me = await createBuilder<{email: string; mfa_enabled: boolean}>(harness, signedIn.token)+ .get('/users/@me')+ .execute();+ expect(me).toMatchObject({email: account.email, mfa_enabled: true});+ });++ it('leaves the email unconfirmed when the second factor never passes after the code', async () => {+ const account = await createTestAccount(harness);+ const secret = createTotpSecret();+ await createBuilder(harness, account.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: generateTotpCode(secret), password: account.password})+ .execute();+ await dropPassword(account);+ await createBuilder(harness, '')+ .post(`/test/users/${account.userId}/security-flags`)+ .body({email_verified: false})+ .execute();+ const {ticket} = await identify(account.email);+ await sendCode(ticket);+ const code = lastCode(account.email, 'sign_in_code', await listTestEmails(harness, {recipient: account.email}));+ const challenge = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .body({ticket, code})+ .execute();+ await createBuilderWithoutAuth(harness)+ .post('/auth/login/mfa/totp')+ .body({ticket: challenge.ticket, code: '000000'})+ .expect(HTTP_STATUS.BAD_REQUEST)+ .execute();+ const user = await getUserRepository().findUniqueAssert(createUserID(BigInt(account.userId)));+ expect(user).toMatchObject({email: account.email, emailVerified: false, totpSecret: secret});+ expect(await getUserRepository().checkIpAuthorized(user.id, STRANGER_IP)).toBe(false);+ });++ it('asks a stranger for a captcha once one network looks up too many addresses', async () => {+ await useCheapCaptcha();+ const lookups = async (count: number) => {+ for (let index = 0; index < count; index++) {+ await createBuilderWithoutAuth(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', STRANGER_IP)+ .header('x-fluxer-test-enable-rate-limits', 'true')+ .header(CAPTCHA_TEST_HEADER, 'true')+ .body({email: createUniqueEmail(`spray-${index}`)})+ .execute();+ }+ };+ await lookups(10);+ const {json} = await createBuilderWithoutAuth<CaptchaErrorBody>(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', STRANGER_IP)+ .header('x-fluxer-test-enable-rate-limits', 'true')+ .header(CAPTCHA_TEST_HEADER, 'true')+ .body({email: createUniqueEmail('spray-captcha')})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.CAPTCHA_REQUIRED)+ .executeWithResponse();+ const token = await solveCaptchaChallenge(json);+ await createBuilderWithoutAuth(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', STRANGER_IP)+ .header('x-fluxer-test-enable-rate-limits', 'true')+ .header(CAPTCHA_TEST_HEADER, 'true')+ .header('x-captcha-token', token)+ .body({email: createUniqueEmail('spray-captcha')})+ .expect(HTTP_STATUS.OK)+ .execute();+ });++ it('keeps sending codes to the owner through a separate allowance while strangers spray the address', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const sprayFrom = async (ip: string, expectedStatus: number) => {+ const {ticket} = await createBuilderWithoutAuth<IdentifyBody>(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', ip)+ .header('x-fluxer-test-enable-rate-limits', 'true')+ .body({email: account.email})+ .execute();+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/send')+ .header('x-forwarded-for', ip)+ .header('x-fluxer-test-enable-rate-limits', 'true')+ .body({ticket})+ .expect(expectedStatus)+ .execute();+ };+ for (let index = 0; index < 5; index++) {+ await sprayFrom(`198.51.100.${index + 1}`, HTTP_STATUS.OK);+ }+ await sprayFrom('198.51.100.50', 429);+ await sprayFrom('127.0.0.1', HTTP_STATUS.OK);+ });++ function budgetEnv() {+ return {kv: getKVClient(), rateLimit: getRateLimitService(), enforce: true};+ }++ async function limitedIdentify(email: string, ip: string): Promise<IdentifyBody> {+ return await createBuilderWithoutAuth<IdentifyBody>(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', ip)+ .header(ENABLE_RATE_LIMITS, 'true')+ .body({email})+ .execute();+ }++ async function limitedSend(ticket: string, ip: string, status: number, code?: string): Promise<void> {+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/send')+ .header('x-forwarded-for', ip)+ .header(ENABLE_RATE_LIMITS, 'true')+ .body({ticket})+ .expect(status, code)+ .execute();+ }++ async function guessWrong(email: string, ticket: string, ip: string): Promise<void> {+ const code = lastCode(email, 'sign_in_code', await listTestEmails(harness, {recipient: email}));+ await createBuilderWithoutAuth(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', ip)+ .body({ticket, code: ((Number(code) + 1) % 1_000_000).toString().padStart(6, '0')})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.INVALID_SIGN_IN_CODE)+ .execute();+ }++ it('stops codes to an account once its own devices reach the wrong-code cap', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ for (let failure = 1; failure < ACCOUNT_CODE_FAILURES_DAILY_CAP; failure++) {+ await recordAccountCodeFailure(budgetEnv(), account.userId);+ }+ const first = await limitedIdentify(account.email, '127.0.0.1');+ await limitedSend(first.ticket, '127.0.0.1', HTTP_STATUS.OK);+ await guessWrong(account.email, first.ticket, '127.0.0.1');+ for (const ip of ['127.0.0.1', STRANGER_IP]) {+ const {ticket} = await limitedIdentify(account.email, ip);+ await limitedSend(ticket, ip, 429, APIErrorCodes.EMAIL_CODE_RESEND_COOLDOWN);+ }+ });++ async function nearCodeFailureCap(email: string, ip: string): Promise<void> {+ const emailKey = normalizeEmailKey(email);+ for (let failure = 1; failure < CODE_FAILURES_DAILY_CAP; failure++) {+ await recordAddressCodeFailure(budgetEnv(), {emailKey, network: requesterNetworkKey(ip)});+ }+ }++ it('keeps a stranger network that guesses wrong codes from blocking the address for other networks', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ await nearCodeFailureCap(account.email, STRANGER_IP);+ const first = await limitedIdentify(account.email, STRANGER_IP);+ await limitedSend(first.ticket, STRANGER_IP, HTTP_STATUS.OK);+ await guessWrong(account.email, first.ticket, STRANGER_IP);+ const sameNetwork = await limitedIdentify(account.email, '203.0.113.200');+ await limitedSend(sameNetwork.ticket, '203.0.113.200', 429, APIErrorCodes.EMAIL_CODE_RESEND_COOLDOWN);+ const otherNetwork = await limitedIdentify(account.email, '192.0.2.5');+ await limitedSend(otherNetwork.ticket, '192.0.2.5', HTTP_STATUS.OK);+ });++ it('counts a wrong code against the network that asked for it, wherever the guess comes from', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ await nearCodeFailureCap(account.email, STRANGER_IP);+ const first = await limitedIdentify(account.email, STRANGER_IP);+ await limitedSend(first.ticket, STRANGER_IP, HTTP_STATUS.OK);+ await guessWrong(account.email, first.ticket, '198.51.100.7');+ const sameNetwork = await limitedIdentify(account.email, '203.0.113.200');+ await limitedSend(sameNetwork.ticket, '203.0.113.200', 429, APIErrorCodes.EMAIL_CODE_RESEND_COOLDOWN);+ const guessingNetwork = await limitedIdentify(account.email, '198.51.100.7');+ await limitedSend(guessingNetwork.ticket, '198.51.100.7', HTTP_STATUS.OK);+ });++ it('stops codes to strangers once wrong codes for the address add up across networks', async () => {+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const emailKey = normalizeEmailKey(account.email);+ for (let failure = 1; failure < ADDRESS_CODE_FAILURES_DAILY_CAP; failure++) {+ await recordAddressCodeFailure(budgetEnv(), {emailKey, network: `10.${failure}.0.0/24`});+ }+ const first = await limitedIdentify(account.email, STRANGER_IP);+ await limitedSend(first.ticket, STRANGER_IP, HTTP_STATUS.OK);+ await guessWrong(account.email, first.ticket, STRANGER_IP);+ const fresh = await limitedIdentify(account.email, '192.0.2.5');+ await limitedSend(fresh.ticket, '192.0.2.5', 429, APIErrorCodes.EMAIL_CODE_RESEND_COOLDOWN);+ const owner = await limitedIdentify(account.email, '127.0.0.1');+ await limitedSend(owner.ticket, '127.0.0.1', HTTP_STATUS.OK);+ });++ async function verifyNeedsCaptcha(email: string, ticket: string, ip: string): Promise<number> {+ const code = lastCode(email, 'sign_in_code', await listTestEmails(harness, {recipient: email}));+ const {json} = await createBuilderWithoutAuth<CaptchaErrorBody>(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', ip)+ .header(ENABLE_RATE_LIMITS, 'true')+ .header(CAPTCHA_TEST_HEADER, 'true')+ .body({ticket, code})+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.CAPTCHA_REQUIRED)+ .executeWithResponse();+ const token = await solveCaptchaChallenge(json);+ const signedIn = await createBuilderWithoutAuth<SignInBody>(harness)+ .post('/auth/email-code/verify')+ .header('x-forwarded-for', ip)+ .header(ENABLE_RATE_LIMITS, 'true')+ .header(CAPTCHA_TEST_HEADER, 'true')+ .header('x-captcha-token', token)+ .body({ticket, code})+ .execute();+ expect(signedIn.token).toBeDefined();+ return (json.altcha_challenge!.parameters as {cost: number}).cost;+ }++ it('asks for a captcha before checking a code once wrong codes for the address add up across networks', async () => {+ await useCheapCaptcha();+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const emailKey = normalizeEmailKey(account.email);+ for (let failure = 0; failure < ADDRESS_CODE_FAILURES_PER_STEP; failure++) {+ await recordAddressCodeFailure(budgetEnv(), {emailKey, network: `10.${failure}.0.0/24`});+ }+ const {ticket} = await limitedIdentify(account.email, STRANGER_IP);+ await limitedSend(ticket, STRANGER_IP, HTTP_STATUS.OK);+ await verifyNeedsCaptcha(account.email, ticket, STRANGER_IP);+ });++ it('asks every sign-in for one fixed captcha step once wrong codes pile up across the instance', async () => {+ await useCheapCaptcha();+ for (let failure = 0; failure < GLOBAL_CODE_FAILURES_THRESHOLD * 3; failure++) {+ await recordAccountCodeFailure(budgetEnv(), `${failure + 1}`);+ }+ const account = await createTestAccount(harness);+ await dropPassword(account);+ const {ticket} = await limitedIdentify(account.email, '127.0.0.1');+ await limitedSend(ticket, '127.0.0.1', HTTP_STATUS.OK);+ expect(await verifyNeedsCaptcha(account.email, ticket, '127.0.0.1')).toBe(2000);+ });++ it('refuses lookups past the hard limits while the captcha is off, and not while it is on', async () => {+ for (let lookup = 0; lookup < 30; lookup++) await enforceLookupHardLimits(budgetEnv(), STRANGER_IP);+ await getInstanceConfigRepository().updateCaptchaConfig({enabled: false});+ await createBuilderWithoutAuth(harness)+ .post('/auth/identify')+ .header('x-forwarded-for', STRANGER_IP)+ .header(ENABLE_RATE_LIMITS, 'true')+ .body({email: createUniqueEmail('hard-limit')})+ .expect(429, APIErrorCodes.RATE_LIMITED)+ .execute();+ await getInstanceConfigRepository().updateCaptchaConfig({enabled: true});+ await limitedIdentify(createUniqueEmail('hard-limit'), STRANGER_IP);+ });+});