તમે પાસવર્ડ્સને હેશ કરો અને crypto મોડ્યુલનો ઉપયોગ કેવી રીતે કરો છો?

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) *હેતુથી ધીમું* બ્રુટ-ફોર્સ સામે પ્રતિરોધ કરવા માટે; **પ્રત્યેક પાસવર્ડ માટે અનન્ય મીઠું** રેઇનબો ટેબલ્સને પરાજિત કરે છે; અને **`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");
```

ઝડપી હેશ્સ ફાઇલ ચેકસમ્સ માટે બરાબર છે પણ પાસવર્ડ્સ માટે વિનાશક છે — તેમની ગતિ બરાબર તે છે જે તેમને બ્રુટ-ફોર્સથી વિભાજિત કરે છે. (વ્યવહારમાં, લાઇબ્રેરીઓ જેમ **bcrypt** અથવા **argon2** સામાન્ય રીતે કાચું 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");
```

## શા માટે તે મહત્વપૂર્ણ છે

પાસવર્ડ સંગ્રહણ સાચો હોવું એક નિર્ણાયક સુરક્ષા જવાબદારી છે, અને તે એક સામાન્ય, જોખમી ભૂલ છે ઝડપી હેશ્સ ઉપયોગ કરવી અથવા મીઠું છોડી જવું.

`crypto` મોડ્યુલ (અથવા ઉચ્ચતર-સ્તરીય bcrypt/argon2) સાચા પ્રાથમિકતાઓ પ્રદાન કરે છે: પાસવર્ડ્સ માટે ધીમું મીઠું હેશિંગ, સતત-સમય સરખામણી, ટોકન્સ માટે સુરક્ષિત રેન્ડમ પેઢી, અને HMAC તાલીમ ચકાસણી માટે (જેવું webhook સીંગણતર).

સમજવું *શા માટે* પાસવર્ડ્સને ધીમું, મીઠું, સતત-સમય હેન્ડલિંગ જરૂર છે — અને તે ઝડપી હેશ્સ ફક્ત બિન-ગુપ્ત ચેકસમ્સ માટે છે — એવું અપરિહાર્ય છે પુરૂષોત્તમ તપાસણી બનાવવા કે જે ઉપયોગકર્તાઓને પ્રમાણપત્ર ચોરીથી બચાવતું નથી.