როგორ ჰეშავთ პароლებს და როგორ გამოიყენებთ 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) *განზრახ ნელი* არის 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** უფრო სასურველია ბუნდოვანი 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");
```

## რატომ არის მნიშვნელოვანი

პაროლის შენახვა სწორი გზით არის კრიტიკული უსაფრთხოების პასუხისმგებლობა, და ეს არის კომუნალური, საშიში შეცდომა გამოიყენოთ სწრაფი ჰეშები ან გამოტოვოთ salting.

`crypto` მოდული (ან უფრო მაღალი დონის bcrypt/argon2) იძლევა სწორი პრიმიტივებს: ნელი დაჩალული ჰეშირება პაროლებისთვის, მუდმივი დროის შედარება, უსაფრთხო შემთხვევითი გენერაცია token-ებისთვის, და HMAC ინტეგრალობის შესამოწმებლად (როგორც webhook ხელმოწერები).

გაგება *რატომ* აჭირებთ პაროლებს ნელი, დაჩალული, მუდმივი დროის დამუშავება — და ის, რომ სწრაფი ჰეშები მხოლოდ არა-საიდუმლო checksums-ისთვისაა — აუცილებელია ავტენტიფიკაციის აგებისთვის, რომელიც არ ამჟღავნებს მომხმარებლებს სამეთალო ქურდობის მიმართ.