మీరు పాస్‌వర్డ్‌లను హ్యాష్ చేయడం మరియు crypto మాడ్యూల్‌ను ఎలా ఉపయోగిస్తారు?

Question

Accepted Answer

Node యొక్క built-in **`crypto`** మాడ్యూల్ క్రిప్టోగ్రాఫిక్ ఫంక్షన్‌లను అందించે: hashing, encryption, random values, మరియు HMAC. అత్యంత ముఖ్యమైన ఆచరణాత్మక ఉపయోగం — **password hashing** — ఒక క్లిష్టమైన నియమం కలిగి ఉంది: పాస్‌వర్డ్‌ల కోసం ఎప్పుడూ fast, general-purpose hashes (MD5/SHA-256)ను ఉపయోగించవద్దు.

## Password hashing: SLOW, salted algorithm ఉపయోగించండి

```js
import { scrypt, randomBytes, timingSafeEqual } from "crypto";
import { promisify } from "util";
const scryptAsync = promisify(scrypt);

// HASH a password (on signup)
async function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");          // unique random salt per user
  const derived = await scryptAsync(password, salt, 64); // slow, salted derivation
  return `${salt}:${derived.toString("hex")}`;            // store salt + hash together
}

// VERIFY a password (on login)
async function verify(password, stored) {
  const [salt, hash] = stored.split(":");
  const derived = await scryptAsync(password, salt, 64);
  const hashBuf = Buffer.from(hash, "hex");
  return timingSafeEqual(hashBuf, derived); // constant-time compare (avoid timing attacks)
}
```

ముఖ్య పాయింట్‌లు: **`scrypt`** (లేదా bcrypt/argon2) *ఉద్దేశ్యపూర్వకంగా నెమ్మదిగా* brute-force నిరోధించడానికి; **ప్రతి పాస్‌వర్డ్‌కు ప్రత్యేక salt** rainbow tables ను ఓడిస్తుంది; మరియు **`timingSafeEqual`** timing attacks నిరోధించడానికి constant time లో hashes లను సరిపోల్చుకుంటుంది.

## పాస్‌వర్డ్‌ల కోసం MD5/SHA-256 ఎందుకు కాదు

```js
// ❌ NEVER do this — SHA/MD5 are FAST, so attackers can guess billions/sec
crypto.createHash("sha256").update(password).digest("hex");
```

Fast hashes ఫైల్ checksums కోసం సరిగ్గా ఉన్నాయి కానీ పాస్‌వర్డ్‌ల కోసం విపర్యయమైనవి — వాటి వేగం అవి brute-forceable చేసేది సరిగ్గా అదే. (ఆచరణలో, **bcrypt** లేదా **argon2** వంటి libraries raw scrypt కంటే ergonomics కోసం సాధారణంగా ఇష్టపడతాయి.)

## ఇతర crypto ఉపయోగాలు

```js
import crypto from "crypto";

crypto.randomBytes(32).toString("hex");        // secure random tokens (session ids, CSRF)
crypto.randomUUID();                            // a secure UUID v4

// HMAC — verify integrity/authenticity (e.g. webhook signatures)
crypto.createHmac("sha256", secret).update(payload).digest("hex");

// hashing for NON-secret integrity (file checksums) — SHA is fine here
crypto.createHash("sha256").update(fileBuffer).digest("hex");
```

## ఇది ఎందుకు ముఖ్యమైనది

పాస్‌వర్డ్ storage సరిగ్గా చేయడం ఒక critical security responsibility, మరియు fast hashes ఉపయోగించడం లేదా salting skip చేయడం ఒక సాధారణ, ప్రమాదకరమైన తప్పు.

`crypto` మాడ్యూల్ (లేదా higher-level bcrypt/argon2) సరైన primitives ను అందించે: passwords కోసం slow salted hashing, constant-time comparison, tokens కోసం secure random generation, మరియు integrity verify చేయడానికి HMAC (webhook signatures వంటి).

పాస్‌వర్డ్‌లకు slow, salted, constant-time handling ఎందుకు అవసరమైనవి — మరియు fast hashes non-secret checksums కోసం మాత్రమే — అని అర్థం చేసుకోవడం credential theft నుండి users ను expose చేయని authentication ను నిర్మించడానికి essential.