@clsdcltask/dclauth/build/crypt.js

Authentication handling utils

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getToken = exports.compare = exports.decrypt = exports.encrypt = exports.toHashWithSalt = exports.toHash = void 0;
const crypto_1 = require("crypto");
const util_1 = require("util");
const uuid_1 = require("uuid");
const scryptAsync = util_1.promisify(crypto_1.scrypt);
function toHash(password) {
    return __awaiter(this, void 0, void 0, function* () {
        const salt = crypto_1.randomBytes(16).toString('hex');
        let buff;
        try {
            buff = (yield scryptAsync(password, salt, 64));
        }
        catch (error) {
            throw error;
        }
        return Promise.resolve(`${buff.toString('hex')}.${salt}`);
    });
}
exports.toHash = toHash;
function toHashWithSalt(password, salt) {
    return __awaiter(this, void 0, void 0, function* () {
        let buff;
        try {
            buff = (yield scryptAsync(password, salt, 64));
        }
        catch (error) {
            throw error;
        }
        return Promise.resolve(`${buff.toString('hex')}`);
    });
}
exports.toHashWithSalt = toHashWithSalt;
const cryptAlgo = 'aes-256-ctr';
function encrypt(input, secret, iv) {
    const cipher = crypto_1.createCipheriv(cryptAlgo, secret, iv);
    return Buffer.concat([cipher.update(input), cipher.final()]);
}
exports.encrypt = encrypt;
function decrypt(input, secret, iv) {
    const decipher = crypto_1.createDecipheriv(cryptAlgo, secret, iv);
    const decrypted = Buffer.concat([decipher.update(Buffer.from(input, 'hex')), decipher.final()]);
    return decrypted.toString();
}
exports.decrypt = decrypt;
function compare(savedPassword, inputPassword) {
    return __awaiter(this, void 0, void 0, function* () {
        // split the known password to get salt and hashed password
        const [hashedPassword, salt] = savedPassword.split('.');
        // encrypt incoming password with saved salt
        const buff = (yield scryptAsync(inputPassword, salt, 64));
        // return comparison between stored and computed password hashes
        return Promise.resolve(hashedPassword === buff.toString('hex'));
    });
}
exports.compare = compare;
function getToken() {
    return __awaiter(this, void 0, void 0, function* () {
        const uuid = uuid_1.v4();
        const salt = crypto_1.randomBytes(16).toString('hex');
        return Promise.resolve(`${uuid}.${salt}`);
    });
}
exports.getToken = getToken;