Bcrypt与Scrypt加密哪个更安全？Node.js新手选型求助

Hey there! Let's break this down for you since you're new to Node.js and feeling stuck choosing between bcrypt and scrypt for password hashing. First, we'll walk through the scrypt code you shared, then compare it to bcrypt to help you make a call.

Breaking Down Your Scrypt Code #

Your code uses Node.js's built-in crypto module to implement scrypt hashing—let's unpack each part:

The hash Function #

const crypto = require("crypto")
async function hash(password) {
  return new Promise((resolve, reject) => {
    const salt = crypto.randomBytes(8).toString("hex")
    crypto.scrypt(password, salt, 64, (err, derivedKey) => {
      if (err) reject(err);
      resolve(salt + ":" + derivedKey.toString('hex'));
    });
  })
}

• Unique Salt Generation: It creates a random 8-byte salt (converted to a hex string) for every password. This is super important—even if two users have the exact same password, their hashes will be totally different because each gets a unique salt.
• Scrypt Hashing Logic: The crypto.scrypt function takes your password, the generated salt, and a desired key length (64 bytes) to create a secure derived key. It then combines the salt and hashed key into one string (separated by :) so you can store both together easily.

The verify Function #

async function verify(password, hash) {
  return new Promise((resolve, reject) => {
    const [salt, key] = hash.split(":")
    crypto.scrypt(password, salt, 64, (err, derivedKey) => {
      if (err) reject(err);
      resolve(key == derivedKey.toString('hex'));
    });
  })
}

• Split Salt & Hash: When verifying a password, it splits the stored string back into the original salt and the hashed key.
• Recompute & Compare: It runs scrypt again with the input password and stored salt, then checks if the new derived key matches the stored one. If they match, the password is correct.

The Test Runner #

(async function run () {
  const password1 = await hash("123456")
  const password2 = await hash("123456")
  console.log("password1", await verify("123456", password1)); // Logs true
  console.log("password2", await verify("123456", password2)); // Logs true
  console.log("password1 == password2", password1 == password2); // Logs false
})()

This demo perfectly shows why salts matter: even though we hashed the same password twice, the outputs are different (thanks to unique salts), but verification still works because we use the matching salt each time.

Bcrypt vs Scrypt: Which Should You Pick? #

Now that you understand scrypt, let's weigh it against bcrypt to help you decide:

Bcrypt Pros & Cons #

• Pros:
  • Been around for years, widely adopted, and battle-tested for security.
  • Super easy to implement with dedicated libraries (like the bcrypt npm package) that handle salt generation and hashing in simple, one-line functions.
  • Built-in cost factor adjustment: you can crank up the computational effort required to hash passwords as hardware gets better, keeping brute-force attacks at bay.
• Cons:
  • Less memory-intensive than scrypt, which makes it slightly more vulnerable to brute-force attacks using specialized hardware (like ASICs/FPGAs)—though this is a niche threat for most small to medium apps.

Scrypt Pros & Cons #

• Pros:
  • Designed to be memory-hard: it uses a ton of RAM during hashing, making it way harder to run brute-force attacks with specialized hardware.
  • No extra dependencies needed—it's built right into Node.js's crypto module, like your code uses.
• Cons:
  • Slightly less widely used than bcrypt (though it's still a fully secure choice).
  • Requires manual salt management (like your code does), whereas bcrypt libraries handle this automatically for you.

Recommendation for a New Node.js Dev #

• If you want simplicity and a tried-and-true tool: Go with bcrypt. Libraries like bcrypt take care of salt storage and hashing logic, so you don't have to write as much boilerplate code. For example, bcrypt's hash function returns a string that includes the salt and cost factor, so verification is just a single function call.
• If you want maximum resistance to hardware-based attacks and don't mind a bit of extra code: Stick with scrypt. It's secure, and using the built-in crypto module avoids adding extra dependencies to your project.

Either way, you're already making a great choice—both are way better than outdated methods like MD5 or SHA-1.

内容的提问来源于stack exchange，提问作者Rishabh Garg