How does bcrypt work?

Question

I don’t quite understand the workings of salt of bcrypt, in a javascript code (Node):

const bcrypt = require('bcrypt');
const saltRounds = 10;

async function init(plainPassword) {
    let salt = await bcrypt.genSalt(saltRounds);
    console.log(salt);

    let hashPassword = await bcrypt.hash(plainPassword, salt);
    console.log(hashPassword);

    let check = await bcrypt.compare(plainPassword, hashPassword);
    console.log(check);
}
init('cba');

I create a salt and use to create password hash, then I check the password using the function compare, however it is not passed the salt created previously, as then bcrypt makes this comparison, since the value of salt will interfere with the final hash of the password?

Answer 1

The hashPassword includes the salt used. I practically answered this in another matter, but since the question wasn’t specifically about that, then I guess I can answer it here too.

The same way that "works on Node" is the same as it works anywhere, since it implements the same Bcrypt.

---

Bcrypt is deterministic. For this reason it will have the same result if using the same salt as any existing KDF. Bcrypt has three parameters:

• Computational cost.
• Salt.
• Password.

There are other derivative functions (Kdfs) that have other input parameters. Argon2, for example, has individual cost parameters (for memory, iteration, etc.), output length parameters. On the other hand, HKDF does not have computational cost, because it is not intended for passwords, but has hash length, result length, flexible.

As a result will:

• "Hash".

However, the first two values are public, in the case of Bcrypt. Therefore, Bcrypt itself uses a format, similar to Modular Crypt Format, where:

${Algoritmo}${Custo}${Salt}{Hash}

This way the hash is included in values that make it possible to compare the same hash, since we know the algorithm, the cost, the salt and the expected result.

---

A small test, with a result of:

$2b$10$111111111111111111111u1Fg3CCqE4CYDkm0w0C9gxJ.HpXSNHlS

You can get the algorithm, the cost, the salt and the "expected hash", therefore:

    let resultado = '$2b$10$111111111111111111111u1Fg3CCqE4CYDkm0w0C9gxJ.HpXSNHlS';

    let algo = resultado.substring(1, 3);
    let custo = resultado.substring(4, 6);
    let salt = resultado.substring(7, 29);

So just do the bcrypt.hash and you can compare the value, normally:

const crypto = require('crypto');
const bcrypt = require('bcrypt');

async function init(plainPassword) {
    let resultado = '$2b$10$111111111111111111111u1Fg3CCqE4CYDkm0w0C9gxJ.HpXSNHlS';

    let algo = resultado.substring(1, 3);
    let custo = resultado.substring(4, 6);
    let salt = resultado.substring(7, 29);

    let hash = await bcrypt.hash(plainPassword, '$' + algo + '$' + custo + '$' + salt);

    console.log(crypto.timingSafeEqual(Buffer.from(hash), Buffer.from(resultado)));
}

init('cba');

See that there is none bcrypt.compare, the crypto.timingSafeEqual does the same as the ===, however it is safe against timing-Attack. That’s basically what the bcrypt.compare makes, when you include the hashPassword he already has the necessary data. :)