Passwords-ஐ எப்படி hash செய்வீர்கள் மற்றும் crypto module-ஐ எப்படிப் பயன்படுத்துவீர்கள்?

Question

Accepted Answer

Node-இன் built-in **`crypto`** module cryptographic functions-ஐ வழங்குகிறது: hashing, encryption, random values, மற்றும் HMAC. மிக முக்கியமான நடைமுறை பயன்பாடு — **password hashing** — ஒரு முக்கியமான விதியைக் கொண்டுள்ளது: passwords-க்கு வேகமான, பொது-நோக்க 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-ஐ எதிர்க்க *வேண்டுமென்றே மெதுவானது*; ஒவ்வொரு password-க்கும் ஒரு **தனித்துவமான salt** rainbow tables-ஐ தோற்கடிக்கிறது; மற்றும் **`timingSafeEqual`** timing attacks-ஐத் தடுக்க constant time-இல் hashes-ஐ ஒப்பிடுகிறது.

## Passwords-க்கு MD5/SHA-256 ஏன் கூடாது

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

வேகமான hashes file checksums-க்கு நன்றாக இருக்கும் ஆனால் passwords-க்கு பேரழிவு — அவற்றின் வேகம் தான் அவற்றை brute-forceable ஆக்குகிறது. (நடைமுறையில், ergonomics-க்காக raw scrypt-ஐவிட **bcrypt** அல்லது **argon2** போன்ற libraries பொதுவாக விரும்பப்படுகின்றன.)

## பிற 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");
```

## இது ஏன் முக்கியம்

Password storage-ஐ சரியாகச் செய்வது ஒரு முக்கியமான security பொறுப்பு, மேலும் வேகமான hashes-ஐப் பயன்படுத்துவது அல்லது salting-ஐ தவிர்ப்பது ஒரு பொதுவான, ஆபத்தான தவறு.

`crypto` module (அல்லது உயர்-நிலை bcrypt/argon2) சரியான primitives-ஐ வழங்குகிறது: passwords-க்கு slow salted hashing, constant-time comparison, tokens-க்கு secure random generation, மற்றும் integrity-ஐ சரிபார்க்க HMAC (webhook signatures போல).

Passwords ஏன் slow, salted, constant-time கையாளுதல் தேவை என்பதை — மற்றும் வேகமான hashes non-secret checksums-க்கு மட்டுமே என்பதைப் — புரிந்துகொள்வது பயனர்களை credential theft-க்கு வெளிப்படுத்தாத authentication-ஐ உருவாக்க அவசியம்.