आप पासवर्ड को हैश कैसे करते हैं और crypto मॉड्यूल का उपयोग कैसे करते हैं?

Question

Accepted Answer

Node के अंतर्निर्मित **`crypto`** मॉड्यूल क्रिप्टोग्राफिक कार्य प्रदान करता है: हैशिंग, एन्क्रिप्शन, रैंडम वैल्यूज़ और HMAC। सबसे महत्वपूर्ण व्यावहारिक उपयोग — **पासवर्ड हैशिंग** — एक महत्वपूर्ण नियम है: कभी भी तेज़, सामान्य-प्रयोजन हैश (MD5/SHA-256) को पासवर्ड के लिए उपयोग न करें।

## पासवर्ड हैशिंग: एक धीमा, salted एल्गोरिदम का उपयोग करें

```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** रेनबो टेबल को हराता है; और **`timingSafeEqual`** समय-आधारित हमलों को रोकने के लिए निरंतर समय में हैश की तुलना करता है।

## पासवर्ड के लिए MD5/SHA-256 क्यों नहीं

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

तेज़ हैश फ़ाइल चेकसम के लिए ठीक हैं लेकिन पासवर्ड के लिए विनाशकारी हैं — उनकी गति ही वह चीज़ है जो उन्हें brute-forceable बनाती है। (व्यवहार में, **bcrypt** या **argon2** जैसी लाइब्रेरीज़ आम तौर पर ergonomics के लिए कच्चे scrypt से बेहतर हैं।)

## अन्य 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");
```

## यह क्यों महत्वपूर्ण है

पासवर्ड स्टोरेज को सही तरीके से करना एक महत्वपूर्ण सुरक्षा जिम्मेदारी है, और यह तेज़ हैश का उपयोग करने या salting को छोड़ने की एक सामान्य, खतरनाक गलती है।

`crypto` मॉड्यूल (या उच्च-स्तरीय bcrypt/argon2) सही primitives प्रदान करता है: पासवर्ड के लिए धीमा salted हैशिंग, निरंतर-समय तुलना, tokens के लिए सुरक्षित random generation, और integrity सत्यापित करने के लिए HMAC (जैसे webhook signatures)।

यह समझना कि *पासवर्ड को धीमा, salted, निरंतर-समय हैंडलिंग की आवश्यकता क्यों है* — और तेज़ हैश केवल गैर-गुप्त चेकसम के लिए हैं — प्रामाणीकरण बनाने के लिए आवश्यक है जो users को credential theft से बचाता है।