The crypto Module

The crypto module is Node's built-in toolkit for cryptography — creating hashes and HMAC signatures, generating secure random values, and safely deriving and comparing password hashes.

Learn The crypto Module in our free Node.js course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Node.js course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

By the end of this lesson you'll be able to fingerprint data with SHA-256, sign messages with HMAC, generate secure tokens and UUIDs, store passwords the right way with scrypt and a salt, and compare secrets safely with timingSafeEqual.

What You'll Learn in This Lesson

1️⃣ Hashing & HMAC

A hash turns any input into a fixed-size fingerprint. The same input always yields the same digest, the tiniest change yields a wildly different one, and you can't run it backwards. The pattern in Node is always createHash(algo).update(data).digest('hex') .

HMAC is a keyed hash: it mixes in a secret so only someone holding that key can produce or verify the signature. It's how services sign webhooks and API requests so the receiver can trust the message wasn't forged or altered.

2️⃣ Secure Randomness

Never use Math.random() for anything security-related — it's predictable. The crypto module gives you cryptographically strong randomness: randomBytes(n) for raw tokens and salts, randomUUID() for standard v4 IDs, and randomInt(min, max) for a fair integer in a range.

Because these values are random by design, the example checks properties of the output (length, format, range) rather than printing the exact bytes — that way the output is reproducible while the values stay genuinely random.

3️⃣ Passwords Done Right

This is the most important section. Never store a password as a plain SHA-256 hash — it's far too fast, so attackers can guess billions per second. Use a deliberately slow key-derivation function like scrypt (or pbkdf2 ), with a unique random salt per user so identical passwords never share a hash.

When you verify a login, re-derive the hash from the attempt and the stored salt, then compare with crypto.timingSafeEqual — a constant-time compare that won't leak how close a guess was. (We use a fixed salt here only so the demo output is reproducible; real code uses randomBytes .)

Your turn. The program below works once you fill in the two blanks marked ___ . Follow the 👉 hints, then run it and compare with the expected digest.

Mini-Challenge: A Safe Password Check

No blanks this time — just a brief and an outline. Write it yourself, run it, and check your output against the example in the comments. This ties together scryptSync , salts, and timingSafeEqual .

Common Errors (and the fix)

• ❌ Storing passwords as sha256 — Too fast to be safe. ✅ Use scrypt , pbkdf2 , bcrypt, or argon2 with a salt.
• ❌ Reusing one salt for everyone — Identical passwords get identical hashes. ✅ A unique randomBytes salt per user, stored with the hash.
• ❌ Comparing secrets with === — Leaks timing information. ✅ Use crypto.timingSafeEqual on equal-length Buffers.
• ❌ Math.random() for tokens — Predictable, not secure. ✅ crypto.randomBytes or crypto.randomUUID .
• ❌ "digest already called" — A Hash object is single-use. ✅ Create a fresh createHash(...) for each value.

Pro Tips

• 💡 Prefer the async forms ( crypto.scrypt , crypto.randomBytes with a callback) in servers so a slow derivation doesn't block the event loop.
• 💡 Store salt + hash together , often as a single string like salt:hash , so verification has everything it needs.
• 💡 For real auth, consider a vetted library like argon2 or bcrypt — they bake in sensible defaults on top of these primitives.

📋 Quick Reference — crypto

Task

Call

Hash data

createHash('sha256').update(d).digest('hex')

Sign with a key

createHmac('sha256', key)...

Secure token

randomBytes(16).toString('hex')

UUID

randomUUID()

Password hash

scrypt(pw, salt, 32)

Compare secrets

timingSafeEqual(a, b)

Frequently Asked Questions

🎉 Lesson Complete!

• ✅ createHash('sha256') makes a one-way fingerprint of any data
• ✅ createHmac adds a secret key so a signature can be trusted
• ✅ randomBytes , randomUUID , and randomInt give secure randomness
• ✅ Passwords need a slow KDF ( scrypt / pbkdf2 ) and a unique salt — never plain sha256
• ✅ Compare secrets with timingSafeEqual , not ===
• ✅ Next lesson: Promises & async/await Deep Dive — master asynchronous control flow

Practice quiz

Continue this course

• Previous: Worker Threads & Cluster
• Next: Promises & async/await Deep Dive