Authentication

Store passwords safely with hashing and salt, and issue signed tokens to prove who a user is.

Lesson 11 of 110% of the track complete

What you'll learn

How to hash passwords with scrypt and a salt, verify a login without ever storing the real password, and create and check a signed token.

Why it matters

Passwords leak. When a database is stolen, the damage depends on how the passwords were stored. Done right, attackers get useless scrambled values. Done wrong, every account is exposed, and people reuse passwords on other sites.

Explanation

Authentication means proving who someone is. Authorisation is what they are allowed to do. This lesson covers authentication.

Rule one: never store a password. Store a hash: the output of a one-way function. You cannot turn a hash back into the password, but the same password always produces the same hash, so you can check a login by hashing what the user typed and comparing.

Two more ingredients:

A salt: random bytes added before hashing and stored next to the hash. It makes identical passwords give different hashes and defeats pre-computed tables.
A slow hash made for passwords, such as scrypt, bcrypt or argon2. Fast hashes like plain SHA-256 let attackers guess billions of passwords per second. Node ships scrypt in node:crypto.

Compare hashes with timingSafeEqual so the comparison time does not leak clues.

After login, the server gives the user a token to send with future requests. A simple signed token is a payload plus an HMAC signature made with a secret key only the server knows. If anyone changes the payload, the signature no longer matches. (Real projects often use JWTs or server-side sessions from a library.)

Example

Step-by-step walkthrough

hashPassword creates a random 16-byte salt, hashes the password with scrypt, and stores salt:hash. The plain password is never saved.
verifyPassword splits the stored value, hashes the typed password with the same salt, and compares the two results safely.
The correct password verifies as true, the wrong one as false.
Hashing the same password again produces a different stored value because the salt is new, so true is printed for "different hash".
signToken encodes the payload and signs it with a secret. Verification recomputes the signature and returns the payload when it matches: { userId: 7, role: 'student' }.
Changing the payload to role: "admin" without the secret cannot produce a valid signature, so verifyToken returns null.

Try it yourself

Run it on your computer. Change the secret in verifyToken only, and watch valid tokens start failing.

auth.mjsNode.js

import { scryptSync, randomBytes, timingSafeEqual, createHmac } from "node:crypto";

function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(password, salt, 64).toString("hex");
  return `${salt}:${hash}`;
}

function verifyPassword(password, stored) {
  const [salt, hash] = stored.split(":");
  const attempt = scryptSync(password, salt, 64);
  return timingSafeEqual(attempt, Buffer.from(hash, "hex"));
}

const SECRET = "change-me-in-real-life";

function verifyToken(token) {
  const [body, sig] = token.split(".");
  const expected = createHmac("sha256", SECRET).update(body).digest("base64url");
  if (sig !== expected) return null;
  return JSON.parse(Buffer.from(body, "base64url").toString());
}

const stored = hashPassword("correct horse");
console.log("stored differs from password:", stored !== "correct horse");
console.log("right password:", verifyPassword("correct horse", stored));
console.log("wrong password:", verifyPassword("wrong horse", stored));
console.log("same password, different hash:", hashPassword("correct horse") !== stored);

const token = signToken({ userId: 7, role: "student" });
console.log("valid token:", verifyToken(token));

const forgedBody = Buffer.from(JSON.stringify({ userId: 7, role: "admin" })).toString("base64url");
const tampered = forgedBody + "." + token.split(".")[1];
console.log("tampered token:", verifyToken(tampered));

Ctrl+Enter to run

Common mistakes

Storing plain-text passwords or reversible encryption.
Using a fast hash such as MD5 or SHA-256 alone for passwords.
No salt, or one shared salt for every user.
Putting the signing secret in the code or in git. Load it from an environment variable.

Quick quiz

Question 1 of 3

What should a database store for a user's password?

A salted slow hashThe password itselfThe password encoded in base64

Question 2 of 3

What does a salt do?

Makes identical passwords hash differentlyEncrypts the databaseSpeeds up login

Question 3 of 3

Why can't someone change a signed token's payload?

They cannot produce a matching signature without the secretTokens are encryptedTokens expire instantly

Summary

Never store passwords: store a salted scrypt (or bcrypt or argon2) hash.
Compare with timingSafeEqual; keep secrets in environment variables.
Signed tokens prove identity; in production, use trusted libraries or services.

You finished the Node.js track. Try the practice exercises to lock it in.

JavaScript

import { scryptSync, randomBytes, timingSafeEqual, createHmac } from "node:crypto";

function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(password, salt, 64).toString("hex");
  return `${salt}:${hash}`;
}

function verifyPassword(password, stored) {
  const [salt, hash] = stored.split(":");
  const attempt = scryptSync(password, salt, 64);
  return timingSafeEqual(attempt, Buffer.from(hash, "hex"));
}

const SECRET = "change-me-in-real-life";

function signToken(payload) {
  const body = Buffer.from(JSON.stringify(payload)).toString("base64url");
  const sig = createHmac("sha256", SECRET).update(body).digest("base64url");
  return `${body}.${sig}`;
}

function verifyToken(token) {
  const [body, sig] = token.split(".");
  const expected = createHmac("sha256", SECRET).update(body).digest("base64url");
  if (sig !== expected) return null;
  return JSON.parse(Buffer.from(body, "base64url").toString());
}

const stored = hashPassword("correct horse");
console.log("stored differs from password:", stored !== "correct horse");
console.log("right password:", verifyPassword("correct horse", stored));
console.log("wrong password:", verifyPassword("wrong horse", stored));
console.log("same password, different hash:", hashPassword("correct horse") !== stored);

const token = signToken({ userId: 7, role: "student" });
console.log("valid token:", verifyToken(token));

const tampered = signToken({ userId: 7, role: "student" }).replace(/^[^.]+/, Buffer.from(JSON.stringify({ userId: 7, role: "admin" })).toString("base64url"));
console.log("tampered token:", verifyToken(tampered));