तुम्ही पासवर्ड हॅश कसे करता आणि क्रिप्टो मॉड्यूल कसे वापरता?

Question

Accepted Answer

Node चे अंतर्निर्मित **`crypto`** मॉड्यूल क्रिप्टोग्राफिक फंक्शन प्रदान करते: हॅशिंग, एन्क्रिप्शन, यादृच्छिक मूल्य आणि HMAC. सर्वात महत्वाचे व्यावहारिक वापर — **पासवर्ड हॅशिंग** — एक महत्वाचा नियम आहे: पासवर्डसाठी कधीही वेगवान, सामान्य-उद्देश्य हॅश (MD5/SHA-256) वापरू नका.

## पासवर्ड हॅशिंग: मंद, लवणी अल्गोरिदम वापरा

```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 विरुद्ध प्रतिरोधी असण्यासाठी *जाणीवपूर्वक मंद* आहे; **प्रत्येक पासवर्डसाठी अनन्य मीठ** rainbow tables पराजित करते; आणि **`timingSafeEqual`** timing attacks प्रतिबंधित करण्यासाठी स्थिर वेळेत हॅश तुलना करते.

## पासवर्डसाठी MD5/SHA-256 का नाही

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

वेगवान हॅश फाइल checksums साठी ठीक आहेत पण पासवर्डसाठी विनाशकारी आहेत — त्यांचा वेग त्यांना brute-forceable बनवते. (व्यावहारिकदृष्ट्या, **bcrypt** किंवा **argon2** सारख्या लायब्रेरी ergonomics साठी कच्च्या scrypt पेक्षा अधिक पसंत केल्या जातात.)

## इतर क्रिप्टो उपयोग

```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");
```

## हे का महत्वाचे आहे

पासवर्ड संग्रहण बरोबर हा गंभीर सुरक्षा जबाबदारी आहे, आणि वेगवान हॅश वापरणे किंवा लवणी वगळणे हा एक सामान्य, धोकादायक चूक आहे.

`crypto` मॉड्यूल (किंवा उच्च-स्तरीय bcrypt/argon2) योग्य primitives प्रदान करते: पासवर्डसाठी मंद लवणी हॅशिंग, स्थिर-वेळ तुलना, tokens साठी सुरक्षित यादृच्छिक पीढी, आणि webhook signatures सारख्या अखंडता सत्यापनासाठी HMAC.

पासवर्डसाठी मंद, लवणी, स्थिर-वेळ हाताळणी की आवश्यकता आहे हे समजून घेणे — आणि हे की वेगवान हॅश केवळ गैर-गोपनीय checksums साठी आहेत — प्रमाणीकरण बांधणे आवश्यक आहे जे वापरकर्त्यांना credential चोरीचे संरक्षण न करता.