Node.js based forum software built for the modern web
'use strict';
const assert = require('assert');
const db = require('../mocks/databasemock');
const helpers = require('../helpers');
const meta = require('../../src/meta');
const user = require('../../src/user');
const groups = require('../../src/groups');
const plugins = require('../../src/plugins');
const utils = require('../../src/utils');
describe('email confirmation (library methods)', () => {
let uid;
async function dummyEmailerHook() {
// pretend to handle sending emails
}
before(() => {
// Attach an emailer hook so related requests do not error
plugins.hooks.register('emailer-test', {
hook: 'static:email.send',
method: dummyEmailerHook,
});
});
beforeEach(async () => {
uid = await user.create({
username: utils.generateUUID().slice(0, 10),
password: utils.generateUUID(),
});
});
after(async () => {
plugins.hooks.unregister('emailer-test', 'static:email.send');
});
describe('isValidationPending', () => {
it('should return false if user did not request email validation', async () => {
const pending = await user.email.isValidationPending(uid);
assert.strictEqual(pending, false);
});
it('should return false if user did not request email validation (w/ email checking)', async () => {
const email = '[email protected]';
const pending = await user.email.isValidationPending(uid, email);
assert.strictEqual(pending, false);
});
it('should return true if user requested email validation', async () => {
const email = '[email protected]';
await user.email.sendValidationEmail(uid, {
email,
});
const pending = await user.email.isValidationPending(uid);
assert.strictEqual(pending, true);
});
it('should return true if user requested email validation (w/ email checking)', async () => {
const email = '[email protected]';
await user.email.sendValidationEmail(uid, {
email,
});
const pending = await user.email.isValidationPending(uid, email);
assert.strictEqual(pending, true);
});
});
describe('getValidationExpiry', () => {
it('should return null if there is no validation available', async () => {
const expiry = await user.email.getValidationExpiry(uid);
assert.strictEqual(expiry, null);
});
it('should return a number smaller than configured expiry if validation available', async () => {
const email = '[email protected]';
await user.email.sendValidationEmail(uid, {
email,
});
const expiry = await user.email.getValidationExpiry(uid);
assert(isFinite(expiry));
assert(expiry > 0);
assert(expiry <= meta.config.emailConfirmExpiry * 24 * 60 * 60 * 1000);
});
});
describe('expireValidation', () => {
it('should invalidate any confirmation in-progress', async () => {
const email = '[email protected]';
await user.email.sendValidationEmail(uid, {
email,
});
await user.email.expireValidation(uid);
assert.strictEqual(await user.email.isValidationPending(uid), false);
assert.strictEqual(await user.email.isValidationPending(uid, email), false);
assert.strictEqual(await user.email.canSendValidation(uid, email), true);
});
});
describe('remove', () => {
it('should invalidate outstanding password reset codes', async () => {
const resetUid = await user.create({
username: utils.generateUUID().slice(0, 10),
password: utils.generateUUID(),
email: `${utils.generateUUID()}@example.org`,
}, { emailVerification: 'verify' });
const code = await user.reset.generate(resetUid);
assert.strictEqual(await user.reset.validate(code), true);
await user.email.remove(resetUid);
assert.strictEqual(await user.reset.validate(code), false);
});
});
describe('canSendValidation', () => {
it('should return true if no validation is pending', async () => {
const ok = await user.email.canSendValidation(uid, '[email protected]');
assert(ok);
});
it('should return false if it has been too soon to re-send confirmation', async () => {
const email = '[email protected]';
await user.email.sendValidationEmail(uid, {
email,
});
const ok = await user.email.canSendValidation(uid, email);
assert.strictEqual(ok, false);
});
it('should return true if it has been long enough to re-send confirmation', async () => {
const email = '[email protected]';
await user.email.sendValidationEmail(uid, {
email,
});
const code = await db.get(`confirm:byUid:${uid}`);
await db.setObjectField(`confirm:${code}`, 'expires', Date.now() + 1000);
const ok = await user.email.canSendValidation(uid, email);
assert(ok);
});
});
});
describe('email confirmation (v3 api)', () => {
let userObj;
let jar;
before(async function () {
await helpers.registerUser({
username: 'fake-user',
password: 'derpioansdosa',
email: '[email protected]',
gdpr_consent: true,
});
// Attach an emailer hook so related requests do not error
plugins.hooks.register('emailer-test', {
hook: 'static:email.send',
method: async () => {},
});
this.emailTestEmail = `${utils.generateUUID()}@example.org`;
({ body: userObj, jar } = await helpers.registerUser({
username: 'email-test',
password: 'abcdef',
email: this.emailTestEmail,
gdpr_consent: true,
acceptTos: true,
}));
});
after(async () => {
plugins.hooks.unregister('emailer-test', 'static:email.send');
});
it('should have a pending validation', async function () {
assert.strictEqual(await user.email.isValidationPending(userObj.uid, this.emailTestEmail), true);
});
it('should not list their email', async () => {
const { response, body } = await helpers.request('get', `/api/v3/users/${userObj.uid}/emails`, {
jar,
json: true,
});
assert.strictEqual(response.statusCode, 200);
assert.deepStrictEqual(body, JSON.parse('{"status":{"code":"ok","message":"OK"},"response":{"emails":[]}}'));
});
it('should not allow confirmation if they are not an admin', async function () {
const { response } = await helpers.request('post', `/api/v3/users/${userObj.uid}/emails/${encodeURIComponent(this.emailTestEmail)}/confirm`, {
jar,
});
assert.strictEqual(response.statusCode, 403);
});
it('should not confirm an email that is not pending or set', async () => {
await groups.join('administrators', userObj.uid);
const { response } = await helpers.request('post', `/api/v3/users/${userObj.uid}/emails/${encodeURIComponent('[email protected]')}/confirm`, {
jar,
});
assert.strictEqual(response.statusCode, 404);
await groups.leave('administrators', userObj.uid);
});
it('should confirm their email (using the pending validation)', async function () {
await groups.join('administrators', userObj.uid);
const { response, body } = await helpers.request('post', `/api/v3/users/${userObj.uid}/emails/${encodeURIComponent(this.emailTestEmail)}/confirm`, {
jar,
});
assert.strictEqual(response.statusCode, 200);
assert.deepStrictEqual(body, JSON.parse('{"status":{"code":"ok","message":"OK"},"response":{}}'));
await groups.leave('administrators', userObj.uid);
});
it('should still confirm the email (as email is set in user hash)', async function () {
await user.email.remove(userObj.uid);
await user.setUserField(userObj.uid, 'email', this.emailTestEmail);
({ jar } = await helpers.loginUser('email-test', 'abcdef')); // email removal logs out everybody
await groups.join('administrators', userObj.uid);
const { response, body } = await helpers.request('post', `/api/v3/users/${userObj.uid}/emails/${encodeURIComponent(this.emailTestEmail)}/confirm`, {
jar,
json: true,
});
assert.strictEqual(response.statusCode, 200);
assert.deepStrictEqual(body, JSON.parse('{"status":{"code":"ok","message":"OK"},"response":{}}'));
await groups.leave('administrators', userObj.uid);
});
});
describe('GET /api/v3/users/:uid/emails/:email (email enumeration)', () => {
let attackerUid;
let attackerJar;
let victimUid;
let victimEmail;
before(async () => {
victimEmail = `${utils.generateUUID()}@example.org`;
const victim = await helpers.registerUser({
username: 'email-victim',
password: 'password123',
email: victimEmail,
gdpr_consent: true,
acceptTos: true,
});
victimUid = victim.body.uid;
// Confirm victim's email so it appears in email:uid index
await groups.join('administrators', victimUid);
await helpers.request('post', `/api/v3/users/${victimUid}/emails/${encodeURIComponent(victimEmail)}/confirm`, {
jar: victim.jar,
});
await groups.leave('administrators', victimUid);
const attacker = await helpers.registerUser({
username: 'email-attacker',
password: 'password456',
email: `${utils.generateUUID()}@other.org`,
gdpr_consent: true,
acceptTos: true,
});
attackerUid = attacker.body.uid;
attackerJar = attacker.jar;
});
it('should return 404 when querying own uid with another user\'s email', async () => {
const { response } = await helpers.request('get', `/api/v3/users/${attackerUid}/emails/${encodeURIComponent(victimEmail)}`, {
jar: attackerJar,
});
assert.strictEqual(response.statusCode, 404);
});
it('should return 404 when querying own uid with a non-existent email', async () => {
const { response } = await helpers.request('get', `/api/v3/users/${attackerUid}/emails/${encodeURIComponent('[email protected]')}`, {
jar: attackerJar,
});
assert.strictEqual(response.statusCode, 404);
});
it('should return 404 when querying victim uid with victim email (no privileges)', async () => {
const { response } = await helpers.request('get', `/api/v3/users/${victimUid}/emails/${encodeURIComponent(victimEmail)}`, {
jar: attackerJar,
});
assert.strictEqual(response.statusCode, 404);
});
});