non-blocking-bcrypt-nodejs/non-blocking-bcrypt-nodejs.js at master · amit221/non-blocking-bcrypt-nodejs · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
const bcrypt = require('bcrypt-nodejs');

const genSalt = (rounds = 10) => {
    return new Promise((resolve, reject) => {
        bcrypt.genSalt(rounds, function (err, salt) {
            if (err) {
                reject(err);
            }
            else {
                resolve({
                    salt: salt
                });
            }
        });
    });
};
const genHash = (salt, password) => {
    return new Promise((resolve, reject) => {
        bcrypt.hash(password, salt, null, function (err, hash) {
            if (err) {
                reject(err);
            }
            else {
                resolve({
                    salt: salt,
                    password: password,
                    hash: hash
                });
            }
        });
    });
};
const compare = (password, hashedPassword) => {
    return new Promise((resolve, reject) => {
        bcrypt.compare(password, hashedPassword, (err, isMatch) => {
            if (err) {
                return reject(err);
            }
            resolve(isMatch);
        });
    });
};
const getRounds = (encrypted) => {
    return new Promise((resolve, reject) => {
        bcrypt.getRounds(encrypted, (err, result) => {
            if (err) {
                return reject(err);
            }
            resolve(result);
        });
    });
};

process.on('message', async (msg) => {
    let result = {};
    try {

        switch (msg.method) {
            case 'genSalt' : {
                result = await genSalt(msg.rounds || 10);
                break;
            }
            case 'genHash' : {
                result = await genHash(msg.salt, msg.password);
                break;
            }
            case 'saltAndHash' : {
                const salt = await genSalt(msg.password, msg.rounds || 10);
                result = await genHash(salt.salt, msg.password);
                break;
            }
            case 'compare' : {
                result.match = await compare(msg.password, msg.hashedPassword);
                break;
            }
            case 'getRounds' : {
                result = await getRounds(msg.encrypted);
                break;
            }


        }

        result.microTime = msg.microTime;
        process.send(result);

    }
    catch (err) {
        result.microTime = msg.microTime;
        result.err = err;
        process.send(result);
    }

});