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 {
createAuthHarness,
createTestAccount,
createTotpSecret,
loginUser,
loginWithTotp,
type TestAccount,
totpCodeNow,
} from '@app/api/auth/tests/AuthTestUtils';
import type {ApiTestHarness} from '@app/api/test/ApiTestHarness';
import {HTTP_STATUS} from '@app/api/test/TestConstants';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
const SUDO_MODE_HEADER = 'X-Fluxer-Sudo-Mode-JWT';
interface ErrorResponse {
code: string;
message: string;
}
interface BackupCodesResponse {
backup_codes: Array<{
code: string;
consumed: boolean;
}>;
}
async function enableTotpForAccount(harness: ApiTestHarness, account: TestAccount, secret: string): Promise<void> {
const code = totpCodeNow(secret);
await createBuilder(harness, account.token)
.post('/users/@me/mfa/totp/enable')
.body({
secret,
code,
password: account.password,
})
.execute();
}
async function getSudoTokenViaMfa(harness: ApiTestHarness, token: string, secret: string): Promise<string> {
const {response} = await createBuilder<BackupCodesResponse>(harness, token)
.post('/users/@me/mfa/backup-codes')
.body({
mfa_method: 'totp',
mfa_code: totpCodeNow(secret),
regenerate: false,
})
.executeWithResponse();
const sudoToken = response.headers.get(SUDO_MODE_HEADER);
if (!sudoToken) {
throw new Error('No sudo token returned');
}
return sudoToken;
}
describe('Sudo mode negative cases', () => {
let harness: ApiTestHarness;
beforeAll(async () => {
harness = await createAuthHarness();
});
beforeEach(async () => {
await harness.reset();
});
afterAll(async () => {
await harness?.shutdown();
});
describe('invalid sudo token rejected', () => {
it('rejects malformed sudo token', async () => {
const account = await createTestAccount(harness);
const secret = createTotpSecret();
await enableTotpForAccount(harness, account, secret);
const loggedIn = await loginWithTotp(harness, account, secret);
const invalidTokens = [
'invalid-token',
'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.invalid.signature',
'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0eXBlIjoibm90LXN1ZG8ifQ.fakesignature',
];
for (const invalidToken of invalidTokens) {
const {json: errResp} = await createBuilder<ErrorResponse>(harness, loggedIn.token)
.post('/users/@me/disable')
.header(SUDO_MODE_HEADER, invalidToken)
.body({})
.expect(HTTP_STATUS.FORBIDDEN)
.executeWithResponse();
expect(errResp.code).toBe('SUDO_MODE_REQUIRED');
}
});
it('rejects empty sudo token header', async () => {
const account = await createTestAccount(harness);
const secret = createTotpSecret();
await enableTotpForAccount(harness, account, secret);
const loggedIn = await loginWithTotp(harness, account, secret);
const {json: errResp} = await createBuilder<ErrorResponse>(harness, loggedIn.token)
.post('/users/@me/disable')
.body({})
.expect(HTTP_STATUS.FORBIDDEN)
.executeWithResponse();
expect(errResp.code).toBe('SUDO_MODE_REQUIRED');
});
});
describe('wrong password rejected when verifying sudo', () => {
it('rejects wrong password for password-only user', async () => {
const account = await createTestAccount(harness);
const wrongPasswords = ['wrong-password', `${account.password}extra`, 'password123'];
for (const wrongPassword of wrongPasswords) {
await createBuilder(harness, account.token)
.post('/users/@me/disable')
.body({
password: wrongPassword,
})
.expect(HTTP_STATUS.BAD_REQUEST)
.execute();
}
});
it('requires password for password-only user - returns 403 without password', async () => {
const account = await createTestAccount(harness);
const {json: errResp} = await createBuilder<ErrorResponse>(harness, account.token)
.post('/users/@me/disable')
.body({})
.expect(HTTP_STATUS.FORBIDDEN)
.executeWithResponse();
expect(errResp.code).toBe('SUDO_MODE_REQUIRED');
});
});
describe('wrong MFA code rejected', () => {
it('rejects incorrect TOTP codes', async () => {
const account = await createTestAccount(harness);
const secret = createTotpSecret();
await enableTotpForAccount(harness, account, secret);
const loggedIn = await loginWithTotp(harness, account, secret);
const wrongCodes = ['000000', '123456', '999999', '12345', '1234567', 'abcdef'];
for (const wrongCode of wrongCodes) {
await createBuilder(harness, loggedIn.token)
.post('/users/@me/disable')
.body({
mfa_method: 'totp',
mfa_code: wrongCode,
})
.expect(HTTP_STATUS.BAD_REQUEST)
.execute();
}
});
});
describe('sudo token for wrong user rejected', () => {
it('rejects sudo token from different user', async () => {
const account1 = await createTestAccount(harness);
const secret1 = createTotpSecret();
await enableTotpForAccount(harness, account1, secret1);
const loggedIn1 = await loginWithTotp(harness, account1, secret1);
const user1SudoToken = await getSudoTokenViaMfa(harness, loggedIn1.token, secret1);
const account2 = await createTestAccount(harness);
const secret2 = createTotpSecret();
await enableTotpForAccount(harness, account2, secret2);
const loggedIn2 = await loginWithTotp(harness, account2, secret2);
const {json: errResp} = await createBuilder<ErrorResponse>(harness, loggedIn2.token)
.post('/users/@me/disable')
.header(SUDO_MODE_HEADER, user1SudoToken)
.body({})
.expect(HTTP_STATUS.FORBIDDEN)
.executeWithResponse();
expect(errResp.code).toBe('SUDO_MODE_REQUIRED');
});
});
describe('password user requires password each time', () => {
it('password user does not receive sudo token', async () => {
const account = await createTestAccount(harness);
const {response} = await createBuilder(harness, account.token)
.post('/users/@me/disable')
.body({
password: account.password,
})
.expect(HTTP_STATUS.NO_CONTENT)
.executeWithResponse();
const sudoToken = response.headers.get(SUDO_MODE_HEADER);
expect(sudoToken).toBeFalsy();
});
it('password user must provide password for subsequent sensitive operations', async () => {
const account = await createTestAccount(harness);
await createBuilder(harness, account.token)
.post('/users/@me/disable')
.body({
password: account.password,
})
.expect(HTTP_STATUS.NO_CONTENT)
.execute();
const login = await loginUser(harness, {email: account.email, password: account.password});
if ('mfa' in login && login.mfa) {
throw new Error('Expected non-MFA login');
}
const nonMfaLogin = login as {
user_id: string;
token: string;
};
const {json: errResp} = await createBuilder<ErrorResponse>(harness, nonMfaLogin.token)
.post('/users/@me/disable')
.body({})
.expect(HTTP_STATUS.FORBIDDEN)
.executeWithResponse();
expect(errResp.code).toBe('SUDO_MODE_REQUIRED');
});
});
describe('MFA registration without token fails', () => {
it('WebAuthn registration options do not issue sudo token', async () => {
const account = await createTestAccount(harness);
const secret = createTotpSecret();
await enableTotpForAccount(harness, account, secret);
const loggedIn = await loginWithTotp(harness, account, secret);
const sudoToken = await getSudoTokenViaMfa(harness, loggedIn.token, secret);
const {response} = await createBuilder(harness, loggedIn.token)
.post('/users/@me/mfa/webauthn/credentials/registration-options')
.header(SUDO_MODE_HEADER, sudoToken)
.body({})
.executeWithResponse();
const newSudoToken = response.headers.get(SUDO_MODE_HEADER);
expect(newSudoToken).toBeFalsy();
});
});
describe('existing MFA token allows skipping MFA', () => {
it('sudo token from MFA allows skipping MFA verification on sensitive endpoint', async () => {
const account = await createTestAccount(harness);
const secret = createTotpSecret();
await enableTotpForAccount(harness, account, secret);
const loggedIn = await loginWithTotp(harness, account, secret);
const sudoToken = await getSudoTokenViaMfa(harness, loggedIn.token, secret);
const backupCodes = await createBuilder<BackupCodesResponse>(harness, loggedIn.token)
.post('/users/@me/mfa/backup-codes')
.header(SUDO_MODE_HEADER, sudoToken)
.body({
regenerate: false,
})
.execute();
expect(backupCodes.backup_codes.length).toBeGreaterThan(0);
});
});
});