Conas a ghreamhóid tú focail fhaire agus an modúl crypto a úsáid?

Question

Accepted Answer

Soláthraíonn modúl ionsuite Node **`crypto`** feidhmeanna cripteagrafacha: hashing, criptiú, luachanna randamhacha, agus HMAC. An úsáid phraiticiúil is tábhachtaí — **password hashing** — tá riail chriticiúil ann: ná húsáid riamh hashes tapa, gealadhasacha (MD5/SHA-256) do focail fhaire.

## Password hashing: algorithm mall, salainn a úsáid

```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)
}
```

Pointí ábhartha: is **`scrypt`** (nó bcrypt/argon2) *mall de thogra* chun seasamh i gcoinne brute-force; **salt uathúil do gach pasfhocal** a bhíonn ag foluain ar tháblaí rainbow; agus **`timingSafeEqual`** a dhéanann comparáid hashes in am tairiseach chun ionsaithe am-treallach a chosc.

## Cén fáth nach MD5/SHA-256 do focail fhaire

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

Tá hashes tapa ceart go leor do checksums comhad ach tubaisteach do focail fhaire — go díreach go bhfuil a luas ann is gur féidir iad a bhrute-fhorsáil. (Go praiticiúil, is fearr leo leabharlanna cosúil le **bcrypt** nó **argon2** a bheith ann seachas raw scrypt ar dhéas-oibriú.)

## Úsáidí crypto eile

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

## Cén fáth a bhíonn sé tábhachtach

Is é an fhreagra cheart ar stóráil focail fhaire a bheith ina fhreagra criticiúil ar an tsábháilteacht, agus is earráid choiteann agus bhaoil ann hashes tapa a úsáid nó salainn a scipeadh.

Soláthraíonn an modúl `crypto` (nó bcrypt/argon2 ar leibhéal níos airde) na primitives ceart: hashing mall salainneach do focail fhaire, comparáid in am tairiseach, giniúint randamhacha slán do bhreiseáin, agus HMAC ar dhréachtúchán (cosúil le sínithe webhook).

A thuiscint *cén fáth* a mbíonn gá ag focail fhaire do láimhseáil mall, salainneach, in am tairiseach — agus go bhfuil hashes tapa díreach do checksums neamhrúnda — is gá go bhfuil dúinn fhios a bheith againn chun fianú a thógáil nach nochtann siad úsáideoirí do ghoid creidiúint.