cloudron-box/src/users.js

'use strict';

exports = module.exports = {
    removePrivateFields: removePrivateFields,
    removeRestrictedFields: removeRestrictedFields,

    getAll: getAll,
    getAllPaged: getAllPaged,
    create: create,
    isActivated: isActivated,
    verify: verify,
    verifyWithUsername: verifyWithUsername,
    verifyWithEmail: verifyWithEmail,
    remove: removeUser,
    get: get,
    getByResetToken: getByResetToken,
    getByUsername: getByUsername,
    getAllAdmins: getAllAdmins,
    resetPasswordByIdentifier: resetPasswordByIdentifier,
    setPassword: setPassword,
    update: updateUser,
    createOwner: createOwner,
    getOwner: getOwner,
    createInvite: createInvite,
    sendInvite: sendInvite,
    setMembership: setMembership,
    setTwoFactorAuthenticationSecret: setTwoFactorAuthenticationSecret,
    enableTwoFactorAuthentication: enableTwoFactorAuthentication,
    disableTwoFactorAuthentication: disableTwoFactorAuthentication,

    count: count,

    AP_MAIL: 'mail',
    AP_SFTP: 'sftp',
    AP_WEBADMIN: 'webadmin',

    getAppPasswords: getAppPasswords,
    getAppPassword: getAppPassword,
    addAppPassword: addAppPassword,
    delAppPassword: delAppPassword
};

let assert = require('assert'),
    BoxError = require('./boxerror.js'),
    crypto = require('crypto'),
    constants = require('./constants.js'),
    debug = require('debug')('box:user'),
    eventlog = require('./eventlog.js'),
    externalLdap = require('./externalldap.js'),
    groups = require('./groups.js'),
    hat = require('./hat.js'),
    mailer = require('./mailer.js'),
    qrcode = require('qrcode'),
    safe = require('safetydance'),
    settings = require('./settings.js'),
    speakeasy = require('speakeasy'),
    userdb = require('./userdb.js'),
    uuid = require('uuid'),
    validator = require('validator'),
    _ = require('underscore');

var CRYPTO_SALT_SIZE = 64; // 512-bit salt
var CRYPTO_ITERATIONS = 10000; // iterations
var CRYPTO_KEY_LENGTH = 512; // bits
var CRYPTO_DIGEST = 'sha1'; // used to be the default in node 4.1.1 cannot change since it will affect existing db records

// keep this in sync with validateGroupname and validateAlias
function validateUsername(username) {
    assert.strictEqual(typeof username, 'string');

    if (username.length < 1) return new BoxError(BoxError.BAD_FIELD, 'Username must be atleast 1 char');
    if (username.length >= 200) return new BoxError(BoxError.BAD_FIELD, 'Username too long');

    if (constants.RESERVED_NAMES.indexOf(username) !== -1) return new BoxError(BoxError.BAD_FIELD, 'Username is reserved');

    // also need to consider valid LDAP characters here (e.g '+' is reserved)
    if (/[^a-zA-Z0-9.-]/.test(username)) return new BoxError(BoxError.BAD_FIELD, 'Username can only contain alphanumerals, dot and -');

    // app emails are sent using the .app suffix
    if (username.indexOf('.app') !== -1) return new BoxError(BoxError.BAD_FIELD, 'Username pattern is reserved for apps');

    return null;
}

function validateEmail(email) {
    assert.strictEqual(typeof email, 'string');

    if (!validator.isEmail(email)) return new BoxError(BoxError.BAD_FIELD, 'Invalid email');

    return null;
}

function validateToken(token) {
    assert.strictEqual(typeof token, 'string');

    if (token.length !== 64) return new BoxError(BoxError.BAD_FIELD, 'Invalid token'); // 256-bit hex coded token

    return null;
}

function validateDisplayName(name) {
    assert.strictEqual(typeof name, 'string');

    return null;
}

function validatePassword(password) {
    assert.strictEqual(typeof password, 'string');

    if (password.length < 8) return new BoxError(BoxError.BAD_FIELD, 'Password must be atleast 8 characters');
    if (password.length > 256) return new BoxError(BoxError.BAD_FIELD, 'Password cannot be more than 256 characters');

    return null;
}

// remove all fields that should never be sent out via REST API
function removePrivateFields(user) {
    return _.pick(user, 'id', 'username', 'email', 'fallbackEmail', 'displayName', 'groupIds', 'admin', 'active', 'source');
}

// remove all fields that Non-privileged users must not see
function removeRestrictedFields(user) {
    return _.pick(user, 'id', 'username', 'email', 'displayName', 'active');
}

function create(username, password, email, displayName, options, auditSource, callback) {
    assert(username === null || typeof username === 'string');
    assert(password === null || typeof password === 'string');
    assert.strictEqual(typeof email, 'string');
    assert.strictEqual(typeof displayName, 'string');
    assert(options && typeof options === 'object');
    assert(auditSource && typeof auditSource === 'object');

    const isOwner = !!options.owner;
    const isAdmin = !!options.admin;
    const source = options.source || '';        // empty is local user
    const invitor = options.invitor || null;

    var error;

    if (username !== null) {
        username = username.toLowerCase();
        error = validateUsername(username);
        if (error) return callback(error);
    }

    if (password !== null) {
        error = validatePassword(password);
        if (error) return callback(error);
    } else {
        password = hat(8 * 8);
    }

    email = email.toLowerCase();
    error = validateEmail(email);
    if (error) return callback(error);

    error = validateDisplayName(displayName);
    if (error) return callback(error);

    crypto.randomBytes(CRYPTO_SALT_SIZE, function (error, salt) {
        if (error) return callback(new BoxError(BoxError.CRYPTO_ERROR, error));

        crypto.pbkdf2(password, salt, CRYPTO_ITERATIONS, CRYPTO_KEY_LENGTH, CRYPTO_DIGEST, function (error, derivedKey) {
            if (error) return callback(new BoxError(BoxError.CRYPTO_ERROR, error));

            var now = (new Date()).toISOString();
            var user = {
                id: 'uid-' + uuid.v4(),
                username: username,
                email: email,
                fallbackEmail: email,   // for new users the fallbackEmail is also the default email
                password: Buffer.from(derivedKey, 'binary').toString('hex'),
                salt: salt.toString('hex'),
                createdAt: now,
                modifiedAt: now,
                resetToken: '',
                displayName: displayName,
                admin: isOwner || isAdmin,
                source: source
            };

            userdb.add(user.id, user, function (error) {
                if (error) return callback(error);

                // when this is used to create the owner, then we have to patch the auditSource to contain himself
                if (isOwner) {
                    auditSource.userId = user.id;
                    auditSource.username = user.username;
                }

                eventlog.add(eventlog.ACTION_USER_ADD, auditSource, { userId: user.id, email: user.email, user: removePrivateFields(user), invitor: invitor });

                callback(null, user);
            });
        });
    });
}

// returns true if ghost user was matched
function verifyGhost(username, password) {
    assert.strictEqual(typeof username, 'string');
    assert.strictEqual(typeof password, 'string');

    var ghostData = safe.JSON.parse(safe.fs.readFileSync(constants.GHOST_USER_FILE, 'utf8'));
    if (!ghostData) return false;

    if (username in ghostData && ghostData[username] === password) {
        debug('verifyGhost: matched ghost user');
        return true;
    }

    return false;
}

function verifyAppPassword(userId, password, identifier, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof password, 'string');
    assert.strictEqual(typeof identifier, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.getAppPasswords(userId, function (error, results) {
        if (error) return callback(error);

        const hashedPasswords = results.filter(r => r.identifier === identifier).map(r => r.hashedPassword);
        let hash = crypto.createHash('sha256').update(password).digest('base64');

        if (hashedPasswords.includes(hash)) return callback(null);

        return callback(new BoxError(BoxError.INVALID_CREDENTIALS));
    });
}

function verify(userId, password, identifier, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof password, 'string');
    assert.strictEqual(typeof identifier, 'string');
    assert.strictEqual(typeof callback, 'function');

    get(userId, function (error, user) {
        if (error) return callback(error);

        if (!user.active) return callback(new BoxError(BoxError.NOT_FOUND));

        // for just invited users the username may be still null
        if (user.username && verifyGhost(user.username, password)) {
            user.ghost = true;
            return callback(null, user);
        }

        verifyAppPassword(user.id, password, identifier, function (error) {
            if (!error) {
                user.appPassword = true;
                return callback(null, user);
            }

            if (user.source === 'ldap') {
                externalLdap.verifyPassword(user, password, function (error) {
                    if (error) return callback(error);

                    callback(null, user);
                });
            } else {
                var saltBinary = Buffer.from(user.salt, 'hex');
                crypto.pbkdf2(password, saltBinary, CRYPTO_ITERATIONS, CRYPTO_KEY_LENGTH, CRYPTO_DIGEST, function (error, derivedKey) {
                    if (error) return callback(new BoxError(BoxError.CRYPTO_ERROR, error));

                    var derivedKeyHex = Buffer.from(derivedKey, 'binary').toString('hex');
                    if (derivedKeyHex !== user.password) return callback(new BoxError(BoxError.INVALID_CREDENTIALS));

                    callback(null, user);
                });
            }
        });
    });
}

function verifyWithUsername(username, password, identifier, callback) {
    assert.strictEqual(typeof username, 'string');
    assert.strictEqual(typeof password, 'string');
    assert.strictEqual(typeof identifier, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.getByUsername(username.toLowerCase(), function (error, user) {
        if (error) return callback(error);

        verify(user.id, password, identifier, callback);
    });
}

function verifyWithEmail(email, password, identifier, callback) {
    assert.strictEqual(typeof email, 'string');
    assert.strictEqual(typeof password, 'string');
    assert.strictEqual(typeof identifier, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.getByEmail(email.toLowerCase(), function (error, user) {
        if (error) return callback(error);

        verify(user.id, password, identifier, callback);
    });
}

function removeUser(userId, auditSource, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert(auditSource && typeof auditSource === 'object');
    assert.strictEqual(typeof callback, 'function');

    get(userId, function (error, user) {
        if (error) return callback(error);

        if (settings.isDemo() && user.username === constants.DEMO_USERNAME) return callback(new BoxError(BoxError.BAD_FIELD, 'Not allowed in demo mode'));

        userdb.del(userId, function (error) {
            if (error) return callback(error);

            eventlog.add(eventlog.ACTION_USER_REMOVE, auditSource, { userId: userId, user: removePrivateFields(user) }, callback);
        });
    });
}

function getAll(callback) {
    assert.strictEqual(typeof callback, 'function');

    userdb.getAllWithGroupIds(function (error, results) {
        if (error) return callback(error);

        return callback(null, results);
    });
}

function getAllPaged(search, page, perPage, callback) {
    assert(typeof search === 'string' || search === null);
    assert.strictEqual(typeof page, 'number');
    assert.strictEqual(typeof perPage, 'number');
    assert.strictEqual(typeof callback, 'function');

    userdb.getAllWithGroupIdsPaged(search, page, perPage, function (error, results) {
        if (error) return callback(error);

        return callback(null, results);
    });
}

function count(callback) {
    assert.strictEqual(typeof callback, 'function');

    userdb.count(function (error, count) {
        if (error) return callback(error);

        callback(null, count);
    });
}

function isActivated(callback) {
    assert.strictEqual(typeof callback, 'function');

    count(function (error, count) {
        if (error) return callback(error);

        callback(null, count !== 0);
    });
}

function get(userId, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.get(userId, function (error, result) {
        if (error) return callback(error);

        groups.getMembership(userId, function (error, groupIds) {
            if (error) return callback(error);

            result.groupIds = groupIds;

            return callback(null, result);
        });
    });
}

function getByResetToken(resetToken, callback) {
    assert.strictEqual(typeof resetToken, 'string');
    assert.strictEqual(typeof callback, 'function');

    var error = validateToken(resetToken);
    if (error) return callback(error);

    userdb.getByResetToken(resetToken, function (error, result) {
        if (error) return callback(error);

        callback(null, result);
    });
}

function getByUsername(username, callback) {
    assert.strictEqual(typeof username, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.getByUsername(username.toLowerCase(), function (error, result) {
        if (error) return callback(error);

        get(result.id, callback);
    });
}

function updateUser(userId, data, auditSource, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof data, 'object');
    assert(auditSource && typeof auditSource === 'object');
    assert.strictEqual(typeof callback, 'function');

    var error;
    data = _.pick(data, 'email', 'fallbackEmail', 'displayName', 'username', 'admin', 'active');

    if (_.isEmpty(data)) return callback();

    if (data.username) {
        data.username = data.username.toLowerCase();
        error = validateUsername(data.username);
        if (error) return callback(error);
    }

    if (data.email) {
        data.email = data.email.toLowerCase();
        error = validateEmail(data.email);
        if (error) return callback(error);
    }

    if (data.fallbackEmail) {
        data.fallbackEmail = data.fallbackEmail.toLowerCase();
        error = validateEmail(data.fallbackEmail);
        if (error) return callback(error);
    }

    userdb.get(userId, function (error, oldUser) {
        if (error) return callback(error);

        userdb.update(userId, data, function (error) {
            if (error) return callback(error);

            callback(null);

            get(userId, function (error, result) {
                if (error) return callback(error);

                eventlog.add(eventlog.ACTION_USER_UPDATE, auditSource, {
                    userId: userId,
                    user: removePrivateFields(result),
                    adminStatusChanged: ((result.admin && !oldUser.admin) || (!result.admin && oldUser.admin)),
                    activeStatusChanged: ((result.active && !oldUser.active) || (!result.active && oldUser.active))
                });
            });
        });
    });
}

function setMembership(userId, groupIds, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert(Array.isArray(groupIds));
    assert.strictEqual(typeof callback, 'function');

    groups.setMembership(userId, groupIds, function (error) {
        if (error) return callback(error);

        callback(null);
    });
}

function getAllAdmins(callback) {
    assert.strictEqual(typeof callback, 'function');

    userdb.getAllAdmins(function (error, admins) {
        if (error) return callback(error);

        callback(null, admins);
    });
}

function resetPasswordByIdentifier(identifier, callback) {
    assert.strictEqual(typeof identifier, 'string');
    assert.strictEqual(typeof callback, 'function');

    var getter;
    if (identifier.indexOf('@') === -1) getter = userdb.getByUsername;
    else getter = userdb.getByEmail;

    getter(identifier.toLowerCase(), function (error, result) {
        if (error) return callback(error);

        result.resetToken = hat(256);

        userdb.update(result.id, result, function (error) {
            if (error) return callback(error);

            mailer.passwordReset(result);

            callback(null);
        });
    });
}

function setPassword(userId, newPassword, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof newPassword, 'string');
    assert.strictEqual(typeof callback, 'function');

    var error = validatePassword(newPassword);
    if (error) return callback(error);

    userdb.get(userId, function (error, user) {
        if (error) return callback(error);

        if (settings.isDemo() && user.username === constants.DEMO_USERNAME) return callback(new BoxError(BoxError.BAD_FIELD, 'Not allowed in demo mode'));
        if (user.source) return callback(new BoxError(BoxError.CONFLICT, 'User is from an external directory'));

        var saltBuffer = Buffer.from(user.salt, 'hex');
        crypto.pbkdf2(newPassword, saltBuffer, CRYPTO_ITERATIONS, CRYPTO_KEY_LENGTH, CRYPTO_DIGEST, function (error, derivedKey) {
            if (error) return callback(new BoxError(BoxError.CRYPTO_ERROR, error));

            user.modifiedAt = (new Date()).toISOString();
            user.password = Buffer.from(derivedKey, 'binary').toString('hex');
            user.resetToken = '';

            userdb.update(userId, user, function (error) {
                if (error) return callback(error);

                callback();
            });
        });
    });
}

function createOwner(username, password, email, displayName, auditSource, callback) {
    assert.strictEqual(typeof username, 'string');
    assert.strictEqual(typeof password, 'string');
    assert.strictEqual(typeof email, 'string');
    assert.strictEqual(typeof displayName, 'string');
    assert(auditSource && typeof auditSource === 'object');
    assert.strictEqual(typeof callback, 'function');

    // This is only not allowed for the owner
    if (username === '') return callback(new BoxError(BoxError.BAD_FIELD, 'Username cannot be empty'));

    count(function (error, count) {
        if (error) return callback(error);
        if (count !== 0) return callback(new BoxError(BoxError.ALREADY_EXISTS, 'Owner already exists'));

        create(username, password, email, displayName, { owner: true }, auditSource, function (error, user) {
            if (error) return callback(error);

            callback(null, user);
        });
    });
}

function getOwner(callback) {
    userdb.getOwner(function (error, owner) {
        if (error) return callback(error);

        return callback(null, owner);
    });
}

function inviteLink(user) {
    return `${settings.adminOrigin()}/setupaccount.html?resetToken=${user.resetToken}&email=${encodeURIComponent(user.email)}` + (user.username ? `&username=${encodeURIComponent(user.username)}` : '');
}

function createInvite(userId, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.get(userId, function (error, userObject) {
        if (error) return callback(error);

        if (userObject.source) return callback(new BoxError(BoxError.CONFLICT, 'User is from an external directory'));

        userObject.resetToken = hat(256);

        userdb.update(userId, userObject, function (error) {
            if (error) return callback(error);

            callback(null, { resetToken: userObject.resetToken, inviteLink: inviteLink(userObject) });
        });
    });
}

function sendInvite(userId, options, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof options, 'object');
    assert.strictEqual(typeof callback, 'function');

    userdb.get(userId, function (error, userObject) {
        if (error) return callback(error);

        if (userObject.source) return callback(new BoxError(BoxError.CONFLICT, 'User is from an external directory'));
        if (!userObject.resetToken) return callback(new BoxError(BoxError.CONFLICT, 'Must generate resetToken to send invitation'));

        mailer.sendInvite(userObject, options.invitor || null, inviteLink(userObject));

        callback(null);
    });
}

function setTwoFactorAuthenticationSecret(userId, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.get(userId, function (error, result) {
        if (error) return callback(error);

        if (result.twoFactorAuthenticationEnabled) return callback(new BoxError(BoxError.ALREADY_EXISTS));

        var secret = speakeasy.generateSecret({ name: `Cloudron ${settings.adminFqdn()} (${result.username})` });

        userdb.update(userId, { twoFactorAuthenticationSecret: secret.base32, twoFactorAuthenticationEnabled: false }, function (error) {
            if (error) return callback(error);

            qrcode.toDataURL(secret.otpauth_url, function (error, dataUrl) {
                if (error) return callback(new BoxError(BoxError.INTERNAL_ERROR, error));

                callback(null, { secret: secret.base32, qrcode: dataUrl });
            });
        });
    });
}

function enableTwoFactorAuthentication(userId, totpToken, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof totpToken, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.get(userId, function (error, result) {
        if (error) return callback(error);

        var verified = speakeasy.totp.verify({ secret: result.twoFactorAuthenticationSecret, encoding: 'base32', token: totpToken, window: 2 });
        if (!verified) return callback(new BoxError(BoxError.INVALID_CREDENTIALS));

        if (result.twoFactorAuthenticationEnabled) return callback(new BoxError(BoxError.ALREADY_EXISTS));

        userdb.update(userId, { twoFactorAuthenticationEnabled: true }, function (error) {
            if (error) return callback(error);

            callback(null);
        });
    });
}

function disableTwoFactorAuthentication(userId, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.update(userId, { twoFactorAuthenticationEnabled: false, twoFactorAuthenticationSecret: '' }, function (error) {
        if (error) return callback(error);

        callback(null);
    });
}

function validateAppPasswordName(name) {
    assert.strictEqual(typeof name, 'string');

    if (name.length < 1) return new BoxError(BoxError.BAD_FIELD, 'name must be atleast 1 char');
    if (name.length >= 200) return new BoxError(BoxError.BAD_FIELD, 'name too long');

    return null;
}

function getAppPassword(id, callback) {
    assert.strictEqual(typeof id, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.getAppPassword(id, function (error, result) {
        if (error) return callback(error);

        callback(null, _.omit(result, 'hashedPassword'));
    });
}

function addAppPassword(userId, identifier, name, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof identifier, 'string');
    assert.strictEqual(typeof name, 'string');
    assert.strictEqual(typeof callback, 'function');

    let error = validateAppPasswordName(name);
    if (error) return callback(error);

    if (identifier.length < 1) return callback(new BoxError(BoxError.BAD_FIELD, 'identifier must be atleast 1 char'));

    const password = hat(8 * 4);
    const hashedPassword = crypto.createHash('sha256').update(password).digest('base64');

    var appPassword = {
        id: 'uid-' + uuid.v4(),
        name,
        userId,
        identifier,
        password,
        hashedPassword
    };

    userdb.addAppPassword(appPassword.id, appPassword, function (error) {
        if (error) return callback(error);

        callback(null, _.omit(appPassword, 'hashedPassword'));
    });
}

function getAppPasswords(userId, callback) {
    assert.strictEqual(typeof userId, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.getAppPasswords(userId, function (error, results) {
        if (error) return callback(error);

        results.map(r => delete r.hashedPassword);

        callback(null, results);
    });
}

function delAppPassword(id, callback) {
    assert.strictEqual(typeof id, 'string');
    assert.strictEqual(typeof callback, 'function');

    userdb.delAppPassword(id, function (error) {
        if (error) return callback(error);

        callback(null);
    });
}