तपाईं पासवर्ड हेश गर्नुहुन्छ र क्रिप्टो मोड्युल कसरी प्रयोग गर्नुहुन्छ?

Question

Accepted Answer

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

## पासवर्ड हेसिङ: SLOW, 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 विरुद्ध प्रतिरोधी हुन *जानबूझकर ढिलो* छ; **प्रत्येक पासवर्डको लागि अनन्य नुन** इन्द्रधनुष तालिकाहरूलाई हराउँछ; र **`timingSafeEqual`** timing आक्रमणहरू रोक्न नियमित समयमा हेसहरू तुलना गर्दछ।

## पासवर्डका लागि 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 प्रदान गर्दछ: पासवर्डका लागि ढिलो salted हेसिङ, नियमित-समय तुलना, token का लागि सुरक्षित अनियमित पीढी, र webhook हस्ताक्षरहरू जस्तो अखंडता प्रमाणित गर्न HMAC।

पासवर्डहरू ढिलो, salted, नियमित-समय ह्यान्डलिङ किन आवश्यक छ भन्ने बुझ्नु — र यो कि द्रुत हेसहरू केवल गैर-गोपनीय checksums को लागि छन् — प्रमाणीकरण निर्माण गर्न आवश्यक छ जसले प्रयोगकर्ताहरूलाई क्रेडेन्शियल चोरीको जोखिममा फेला पार्दैन।