Node.js-də autentifikasiya: sessiyalar, parollar və JWT

Parolları `crypto.scrypt` ilə duzlu və yavaş heşləmək, cookie sessiyaları və JWT, `HttpOnly`/`Secure`/`SameSite` cookie-ləri, Express-də giriş və çıxış marşrutları, marşrutları qoruyan middleware, refresh token-lər və riskləri, girişə cəhdlərin məhdudlaşdırılması və tipik təhlükəsizlik səhvləri.

  • İrəli
  • 25 dəq
  • 12 sual
  • 39 dərsdən 39-cusu

Bu dərsdə öyrənəcəksən

  • Parolları crypto.scrypt, təsadüfi duz və timingSafeEqual ilə saxlamaq və yoxlamaq
  • Cookie sessiyası ilə JWT-ni müqayisə etmək və refresh token-lərin risklərini izah etmək
  • Express-də qeydiyyat, giriş, çıxış və qorunan marşrutlar yazmaq
  • Girişə cəhdləri məhdudlaşdırmaq və tipik təhlükəsizlik səhvlərindən qaçmaq

Məlumat sızmalarında tez-tez bütöv istifadəçi cədvəlləri yayılır. Parollar açıq mətn kimi və ya MD5 kimi sürətli heşlə saxlanıbsa, hücumçular hər kəsin adı ilə daxil olur, insanlar eyni parolu təkrar işlətdiyi üçün isə onların poçtuna və bankına da. Bu dərsdə Express tətbiqinə hesabları təhlükəsiz yolla əlavə edəcəyik: crypto.scrypt ilə yavaş və duzlu heşlər, HttpOnly cookie-də sessiyalar və ya JWT, giriş və çıxış marşrutları, marşrutları qoruyan middleware və girişə cəhdlərin məhdudlaşdırılması. Heşləmənin nəzəriyyəsi kibertəhlükəsizlik kursundakı «Heşləmə və duz: parollar necə saxlanır» dərsindədir, XSS və CSRF isə «Təhlükəsizlik və yaxşı təcrübələr» dərsindədir.

Autentifikasiya və avtorizasiyaTərif

Autentifikasiya «sən kimsən?» sualına cavabdır: parol, kod və ya token ilə şəxsiyyəti yoxlamaq. Avtorizasiya «sənə nə icazə var?» sualıdır: rollar və hüquqlar. Əvvəlcə autentifikasiya, sonra avtorizasiya; xəta kodları da fərqlidir: 401 — tanınmırsınız, 403 — tanınırsınız, amma icazəniz yoxdur.

Parolları crypto.scrypt ilə heşləmək

Parol heç vaxt saxlanmır və deşifrə olunmur: server heş saxlayır və heşləri müqayisə edir. Ümumi təyinatlı heşlər (SHA-256, MD5) sürətli olmaq üçün yaradılıb — videokartda saniyədə milyardlarla təxmin. Parol heşləri isə qəsdən yavaş və yaddaş tələb edəndir: scrypt, bcrypt, Argon2. Node.js-də scrypt node:crypto-ya daxildir; bcrypt və argon2 npm paketləridir. OWASP ilk növbədə Argon2id, o olmayanda isə scrypt tövsiyə edir. Hər parol öz təsadüfi duzunu alır: eyni parollar fərqli heşlər verir və əvvəlcədən hesablanmış cədvəllər işə yaramır.

JavaScript
// password.mjs
import { scrypt, randomBytes, timingSafeEqual } from 'node:crypto';
import { promisify } from 'node:util';

const scryptAsync = promisify(scrypt);
const COST = { N: 2 ** 17, r: 8, p: 1, maxmem: 256 * 1024 * 1024 };

export async function hashPassword(password) {
  const salt = randomBytes(16);
  const hash = await scryptAsync(password.normalize('NFC'), salt, 32, COST);
  return `scrypt$${salt.toString('base64url')}$${hash.toString('base64url')}`;
}

export async function verifyPassword(password, stored) {
  const [scheme, saltText, hashText] = stored.split('$');
  if (scheme !== 'scrypt') return false;
  const expected = Buffer.from(hashText, 'base64url');
  const salt = Buffer.from(saltText, 'base64url');
  const actual = await scryptAsync(password.normalize('NFC'), salt, expected.length, COST);
  return timingSafeEqual(actual, expected);
}
N = 2¹⁷, r = 8, p = 1 — OWASP-ın scrypt üçün minimum tövsiyəsi; bu halda scrypt-ə 128 · N · r bayt = 128 MiB yaddaş lazımdır, standart limit isə 32 MiB-dır, ona görə maxmem artırılıb. Saxlanılan sətirdə metod, duz və heş var. timingSafeEqual sabit vaxtda müqayisə edir: cavab vaxtı neçə baytın üst-üstə düşdüyünü açmır. normalize('NFC') müxtəlif üsulla yazılmış ü-nü eyni baytlara çevirir.
JavaScript
// hash-demo.mjs
import { hashPassword, verifyPassword } from './password.mjs';

const first = await hashPassword('Baku-2026-tea');
const second = await hashPassword('Baku-2026-tea');

console.log(first.split('$').map((part) => part.length));
console.log('same hash twice?', first === second);
console.log('right password:', await verifyPassword('Baku-2026-tea', first));
console.log('right password, other hash:', await verifyPassword('Baku-2026-tea', second));
console.log('one letter changed:', await verifyPassword('baku-2026-tea', first));

const start = performance.now();
await hashPassword('Baku-2026-tea');
console.log(`one hash takes about ${Math.round(performance.now() - start)} ms`);

Gözlənilən nəticə

[ 6, 22, 43 ]
same hash twice? false
right password: true
right password, other hash: true
one letter changed: false
one hash takes about 288 ms
Uzunluqlar: scrypt (6), 16 baytlıq duz (22 simvol), 32 baytlıq heş (43 simvol). Eyni parolun iki heşi fərqlidir, çünki duzlar fərqlidir, amma hər ikisi yoxlamadan keçir; bir hərfin registri nəticəni dəyişir. Yoxlama aparılan noutbukda bir heş təxminən 0,3 saniyə çəkdi — giriş üçün normaldır, milyardlarla təxmin edən hücumçu üçün isə çox yavaşdır. Vaxt kompüterdən asılıdır.

Davamını oxumaq üçün pulsuz qeydiyyatdan keç

Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.

Sessiya, yoxsa JWT?

Girişdən sonra server istifadəçini sorğular arasında xatırlamalıdır — HTTP özü hər şeyi unudur. İki geniş yayılmış yol var. Sessiya: server uzun təsadüfi id yaradır, { userId, expiresAt } qeydini yaddaşda, Redis-də və ya bazada saxlayır, id-ni isə cookie-də göndərir; hər sorğuda id-ni axtarır. Çıxış qeydi silməkdir və dərhal qüvvəyə minir. JWT (JSON Web Token): server iddiaları (sub, role, exp) token-ə qoyur və onu imzalayır; heç nə saxlamır, yalnız imzanı yoxlayır.

JWTTərif

Nöqtələrlə ayrılmış üç base64url hissədən ibarət sətir: başlıq, faydalı yük (payload) və imza. İmza (burada serverin sirri ilə HMAC-SHA256) token-i serverin verdiyini və dəyişdirilmədiyini sübut edir. Payload şifrələnmir: onu hər kəs oxuya bilər, ona görə ora heç vaxt sirr qoymayın.

JavaScript
// jwt-demo.mjs
import jwt from 'jsonwebtoken';

const SECRET = process.env.JWT_SECRET;
const options = { algorithm: 'HS256', expiresIn: '15m' };
const token = jwt.sign({ sub: '42', role: 'student' }, SECRET, options);

const [header, payload] = token.split('.');
const readable = JSON.parse(Buffer.from(payload, 'base64url'));
console.log(JSON.parse(Buffer.from(header, 'base64url')));
console.log(readable.sub, readable.role, readable.exp - readable.iat, 'seconds');

const claims = jwt.verify(token, SECRET, { algorithms: ['HS256'] });
console.log('verified:', claims.sub, claims.role);

const forged = Buffer.from(JSON.stringify({ ...readable, role: 'admin' })).toString('base64url');
const tampered = [header, forged, token.split('.')[2]].join('.');
const later = Math.floor(Date.now() / 1000) + 60 * 60;

for (const [name, check] of [
  ['tampered', () => jwt.verify(tampered, SECRET, { algorithms: ['HS256'] })],
  ['wrong secret', () => jwt.verify(token, 'guess', { algorithms: ['HS256'] })],
  ['in one hour', () => jwt.verify(token, SECRET, { algorithms: ['HS256'], clockTimestamp: later })],
]) {
  try {
    check();
  } catch (error) {
    console.log(`${name}: ${error.name} - ${error.message}`);
  }
}

Gözlənilən nəticə

{ alg: 'HS256', typ: 'JWT' }
42 student 900 seconds
verified: 42 student
tampered: JsonWebTokenError - invalid signature
wrong secret: JsonWebTokenError - invalid signature
in one hour: TokenExpiredError - jwt expired
node --env-file=.env jwt-demo.mjs ilə işə salınıb; sirr uzun təsadüfi sətirdir (crypto.randomBytes(32).toString('base64url')), heç vaxt kodda deyil. Payload sirsiz oxundu. role-u admin etmək imzanı pozdu, səhv sirr də; bir saat irəli çəkilmiş clockTimestamp exp-dən sonra nə olduğunu göstərir. verify-a həmişə algorithms: ['HS256'] verin ki, alqoritmi token özü seçməsin.
JavaScript
// jwt-server.mjs
import express from 'express';
import jwt from 'jsonwebtoken';

const SECRET = process.env.JWT_SECRET;
if (!SECRET) throw new Error('JWT_SECRET is not set');

function requireJwt(req, res, next) {
  const [scheme, token] = (req.get('Authorization') ?? '').split(' ');
  if (scheme !== 'Bearer' || !token) return res.status(401).json({ error: 'Missing token' });
  try {
    req.user = jwt.verify(token, SECRET, { algorithms: ['HS256'] });
    next();
  } catch (error) {
    res.status(401).json({ error: error.name === 'TokenExpiredError' ? 'Token expired' : 'Invalid token' });
  }
}

const app = express();
app.post('/api/token', (req, res) => {
  // in a real app: check the password first (see the login route above)
  const token = jwt.sign({ sub: '1', role: 'student' }, SECRET, { algorithm: 'HS256', expiresIn: '15m' });
  res.json({ token });
});
app.get('/api/profile', requireJwt, (req, res) => res.json({ id: req.user.sub, role: req.user.role }));

app.listen(3000, () => console.log('JWT demo on http://localhost:3000'));
JWT ilə qorunan marşrut: Authorization: Bearer <token> başlığı oxunur, jwt.verify uğurludursa, req.user doldurulur. Sirr yoxdursa, server ümumiyyətlə başlamır — zəif standart dəyərdən yaxşıdır.
JavaScript
// jwt-client.mjs
const base = 'http://localhost:3000/api';
const { token } = await (await fetch(`${base}/token`, { method: 'POST' })).json();

for (const auth of [`Bearer ${token}`, undefined, `Bearer ${token}x`]) {
  const res = await fetch(`${base}/profile`, { headers: auth ? { Authorization: auth } : {} });
  console.log(res.status, await res.text());
}

Gözlənilən nəticə

200 {"id":"1","role":"student"}
401 {"error":"Missing token"}
401 {"error":"Invalid token"}
Düzgün token — 200, başlıq yoxdur — 401, sonuna bir simvol əlavə olunmuş token — imza uyğun gəlmir, 401.
Cookie sessiyasıJWT
Vəziyyət haradaserverdə (yaddaş, Redis, baza)token-in içində
Çıxış və ləğvqeydi silmək — dərhalexp-ə qədər mümkün deyil (qara siyahı olmadan)
Bir neçə serverortaq anbar lazımdır (Redis)açarı olan hər server yoxlayır
Ölçü43 simvollu idhər sorğuda yüzlərlə bayt
Tipik istifadəbrauzerlə işləyən saytlarmobil tətbiqlərin və servislərin API-ləri

JWT ləğv edilə bilmədiyi üçün onu qısaömürlü edirlər (5–15 dəqiqə) — bu, access token-dir. Hər 15 dəqiqədən bir yenidən daxil olmamaq üçün tətbiq həm də uzunömürlü refresh token (günlər və ya həftələr) alır; onu yalnız bir ünvanda yeni access token-ə dəyişmək olur. Risklər: oğurlanmış refresh token uzun müddətli giriş verir. Ona görə onu HttpOnly cookie-də saxlayın, bazada qeyd edin ki, ləğv etmək mümkün olsun, və fırladın (rotation): hər istifadə yenisini verir, köhnəsini etibarsız edir; köhnə token yenidən gəlirsə, kimsə onu kopyalayıb — bütün ailəni ləğv edin. Qısası: brauzerlə işləyən adi sayt üçün cookie sessiyası daha sadə və daha təhlükəsizdir.

Cookie: HttpOnly, Secure, SameSite

Sessiya id-si cookie ilə gedir və onu üç atribut qoruyur: HttpOnly — səhifədəki JavaScript cookie-ni oxuya bilmir, XSS skripti sessiyanı oğurlaya bilmir; Secure — yalnız HTTPS ilə göndərilir (bir çox brauzer inkişaf zamanı http://localhost üçün istisna edir); SameSite=Lax — başqa saytlardan gələn POST sorğularına əlavə olunmur, bu da CSRF-in çox hissəsini bağlayır. Max-Age ömrü məhdudlaşdırır. Express-də res.cookie(ad, dəyər, seçimlər) Set-Cookie başlığını qurur, res.clearCookie isə eyni seçimlərlə cookie-ni silir.

JavaScript
// sessions.mjs
import { randomBytes } from 'node:crypto';

const sessions = new Map();
const TTL_MS = 60 * 60 * 1000;

export function createSession(userId) {
  const id = randomBytes(32).toString('base64url');
  sessions.set(id, { userId, expiresAt: Date.now() + TTL_MS });
  return id;
}

export function getSession(id) {
  const session = sessions.get(id);
  if (session && session.expiresAt < Date.now()) sessions.delete(id);
  return sessions.get(id) ?? null;
}

export function destroySession(id) {
  sessions.delete(id);
}

export function readCookie(req, name) {
  for (const part of (req.headers.cookie ?? '').split(';')) {
    const [key, ...value] = part.trim().split('=');
    if (key === name) return decodeURIComponent(value.join('='));
  }
  return null;
}
32 təsadüfi bayt 43 simvollu id verir — onu tapmaq mümkün deyil. getSession müddəti də yoxlayır. Real layihədə Map Redis və ya baza cədvəli ilə əvəz olunur ki, sessiyalar yenidən başlamadan sonra da qalsın və bir neçə serverdə işləsin. Cookie burada əl ilə oxunur; cookie-parser paketi eyni işi görür.

Giriş, çıxış və qorunan marşrutlar

JavaScript
// auth-routes.mjs
import { Router } from 'express';
import { hashPassword, verifyPassword } from './password.mjs';
import { createSession, destroySession, readCookie } from './sessions.mjs';
import { loginLimiter } from './rate-limit.mjs';

export const users = new Map();
export const auth = Router();
const cookie = { httpOnly: true, secure: true, sameSite: 'lax', maxAge: 60 * 60 * 1000 };
const DUMMY_HASH = await hashPassword('timing-equalizer');

auth.post('/register', async (req, res) => {
  const { email, password } = req.body ?? {};
  if (typeof email !== 'string' || !email.includes('@') || typeof password !== 'string' || password.length < 10) {
    return res.status(400).json({ error: 'A valid email and a password of 10+ characters are required' });
  }
  if (users.has(email)) return res.status(409).json({ error: 'This email is already registered' });
  users.set(email, { id: users.size + 1, email, passwordHash: await hashPassword(password) });
  res.status(201).json({ id: users.get(email).id, email });
});

auth.post('/login', loginLimiter, async (req, res) => {
  const user = users.get(req.body?.email);
  const ok = await verifyPassword(String(req.body?.password ?? ''), user?.passwordHash ?? DUMMY_HASH);
  if (!user || !ok) return res.status(401).json({ error: 'Wrong email or password' });
  res.cookie('sid', createSession(user.id), cookie).json({ message: `Welcome, ${user.email}` });
});

auth.post('/logout', (req, res) => {
  destroySession(readCookie(req, 'sid'));
  res.clearCookie('sid', cookie).json({ message: 'Logged out' });
});
«Belə istifadəçi yoxdur» və «parol səhvdir» üçün eyni mesaj — API hansı e-poçtların qeydiyyatda olduğunu açmır. İstifadəçi olmayanda da kod DUMMY_HASH ilə verifyPassword işlədir, ona görə cavab vaxtı da bunu açmır. Hər girişdə yeni təsadüfi id yaranır (sessiya fiksasiyasına qarşı).
JavaScript
// app.mjs
import express from 'express';
import { auth, users } from './auth-routes.mjs';
import { getSession, readCookie } from './sessions.mjs';

const app = express();
app.use(express.json({ limit: '10kb' }));
app.use('/api/auth', auth);

function requireAuth(req, res, next) {
  const session = getSession(readCookie(req, 'sid'));
  if (!session) return res.status(401).json({ error: 'Please log in' });
  req.user = [...users.values()].find((user) => user.id === session.userId);
  next();
}

app.get('/api/me', requireAuth, (req, res) => {
  res.json({ id: req.user.id, email: req.user.email });
});

app.listen(3000, () => console.log('Auth demo on http://localhost:3000'));
requireAuth adi middleware-dir: etibarlı sessiya yoxdursa — 401, varsa req.user doldurulur və next() çağırılır. Onu girişi tələb edən istənilən marşruta əlavə edin.
JavaScript
// flow.mjs
const base = 'http://localhost:3000/api';
let cookie = '';

async function call(method, path, body) {
  const res = await fetch(base + path, {
    method,
    headers: { 'Content-Type': 'application/json', Cookie: cookie },
    body: body && JSON.stringify(body),
  });
  console.log(`${method} ${path} → ${res.status} ${await res.text()}`);
  const setCookie = res.headers.get('set-cookie');
  if (!setCookie) return;
  console.log('  Set-Cookie:', setCookie.replace(/=[^;]{20,}/g, '=…'));
  if (res.ok && path === '/auth/login') cookie = setCookie.split(';')[0];
}

const aysel = { email: 'aysel@example.com', password: 'tea-and-baklava-26' };
await call('POST', '/auth/register', { email: 'aysel@example.com', password: '12345' });
await call('POST', '/auth/register', aysel);
await call('POST', '/auth/register', aysel);
await call('GET', '/me');
await call('POST', '/auth/login', { ...aysel, password: 'wrong-password' });
await call('POST', '/auth/login', { email: 'nobody@example.com', password: 'whatever-123' });
await call('POST', '/auth/login', aysel);
await call('GET', '/me');
await call('POST', '/auth/logout');
await call('GET', '/me');

Gözlənilən nəticə

POST /auth/register → 400 {"error":"A valid email and a password of 10+ characters are required"}
POST /auth/register → 201 {"id":1,"email":"aysel@example.com"}
POST /auth/register → 409 {"error":"This email is already registered"}
GET /me → 401 {"error":"Please log in"}
POST /auth/login → 401 {"error":"Wrong email or password"}
POST /auth/login → 401 {"error":"Wrong email or password"}
POST /auth/login → 200 {"message":"Welcome, aysel@example.com"}
  Set-Cookie: sid=…; Max-Age=3600; Path=/; Expires=…; HttpOnly; Secure; SameSite=Lax
GET /me → 200 {"id":1,"email":"aysel@example.com"}
POST /auth/logout → 200 {"message":"Logged out"}
  Set-Cookie: sid=; Path=/; Expires=…; HttpOnly; Secure; SameSite=Lax
GET /me → 401 {"error":"Please log in"}
Birinci giriş parolu səhvdir, ikincisi olmayan istifadəçi üçündür — cavablar eynidir. Cookie dəyəri və tarix gizlədilib (…): hər işə salınmada fərqlidir. Çıxışda server sessiyanı silir və cookie-ni 1970-ci ilə aid Expires ilə qaytarır ki, brauzer onu silsin; kimsə köhnə id-ni saxlasa belə, o artıq işləmir.

Girişə cəhdləri məhdudlaşdırmaq

Yavaş heş belə kiminsə bir hesaba qarşı ən yayılmış 1000 parolu sınamasına mane olmur. Cəhdləri məhdudlaşdırın: burada hər «IP ünvanı + e-poçt» cütü üçün 15 dəqiqədə ən çox 5 cəhd; 6-cı cəhd Retry-After başlığı (neçə saniyə gözləmək lazımdır) ilə 429 Too Many Requests alır. Sayğac Map-də saxlanır — bir server üçün kifayətdir; bir neçə serverdə Redis kimi ortaq anbar və ya Redis anbarı ilə express-rate-limit paketi işlədin. Proksi (nginx, yük balanslaşdırıcı) arxasında app.set('trust proxy', …) da qoyun, yoxsa req.ip proksinin ünvanı olacaq.

JavaScript
// rate-limit.mjs
const WINDOW_MS = 15 * 60 * 1000;
const MAX_ATTEMPTS = 5;
const attempts = new Map();

export function loginLimiter(req, res, next) {
  const email = String(req.body?.email ?? '').toLowerCase();
  const key = `${req.ip}|${email}`;
  const now = Date.now();
  let entry = attempts.get(key);
  if (!entry || entry.resetAt <= now) {
    entry = { count: 0, resetAt: now + WINDOW_MS };
    attempts.set(key, entry);
  }
  entry.count++;
  if (entry.count > MAX_ATTEMPTS) {
    res.set('Retry-After', String(Math.ceil((entry.resetAt - now) / 1000)));
    return res.status(429).json({ error: 'Too many attempts, try again later' });
  }
  next();
}
JavaScript
// brute.mjs
const statuses = [];
for (let i = 1; i <= 7; i++) {
  const res = await fetch('http://localhost:3000/api/auth/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email: 'murad@example.com', password: `guess-${i}` }),
  });
  statuses.push(res.status);
  if (res.status === 429) console.log('Retry-After:', res.headers.get('retry-after'), 'seconds');
}
console.log(statuses.join(' '));

Gözlənilən nəticə

Retry-After: 899 seconds
Retry-After: 899 seconds
401 401 401 401 401 429 429
Beş səhv cəhd — 401, sonra 429. Retry-After pəncərənin bitməsinə qalan saniyələrdir (burada 899; ədəd vaxtdan asılıdır).

Tapşırıq

JWT-nin payload-unun açıq olduğunu öz gözünüzlə görün: decodeJwt(token) token-i üç hissəyə bölsün və başlıq ilə payload-u base64url-dən açıb obyekt kimi qaytarsın (imzanı yoxlamadan!). atob base64 gözləyir: - → +, _ → / və uzunluğu 4-ə bölünənə qədər = əlavə edin.

Tapşırıq · JavaScript
const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0MiIsIm5hbWUiOiJBeXNlbCIsInJvbGUiOiJzdHVkZW50IiwiaWF0IjoxNzkwMDAwMDAwLCJleHAiOjE3OTAwMDA5MDB9.S_90FLlU7cJl1QX0meBDxhNqz8Y8oEA1mrvQki44-Cc';

function base64UrlToText(part) {
  // - → +, _ → /, pad with '=' to a multiple of 4, then atob()
}

function decodeJwt(jwt) {
  // split on '.', parse header and payload
}

const { header, payload } = decodeJwt(token);
console.log(header.alg, header.typ);
console.log(`${payload.name} (${payload.role}), user ${payload.sub}`);
console.log('valid for', (payload.exp - payload.iat) / 60, 'minutes');
console.log('expires', new Date(payload.exp * 1000).toISOString());
Gözlənilən nəticə
HS256 JWT
Aysel (student), user 42
valid for 15 minutes
expires 2026-09-21T14:28:20.000Z

Tapşırıq

Cəhd limitini test oluna bilən sinif kimi yazın: LoginLimiter(maxAttempts, windowMs) və attempt(key, now) metodu. Pəncərə ilk cəhddə başlayır; limit daxilində { allowed: true, left }, limitdən sonra { allowed: false, retryAfterSec } qaytarılsın (yuxarı yuvarlaqlaşdırılmış saniyələr). Pəncərə bitəndə sayğac yenidən başlayır. Vaxt now parametri ilə verilir — Date.now() yox, ona görə nəticə həmişə eynidir.

Tapşırıq · JavaScript
class LoginLimiter {
  constructor(maxAttempts, windowMs) {
    this.maxAttempts = maxAttempts;
    this.windowMs = windowMs;
    this.entries = new Map();
  }

  attempt(key, now) {
    // new or expired entry → { count: 0, resetAt: now + windowMs }
    // count++ → allowed or not
  }
}

const limiter = new LoginLimiter(3, 60_000);
const times = [0, 1_000, 2_000, 3_000, 30_500, 61_000];
for (const t of times) {
  console.log(t, JSON.stringify(limiter.attempt('1.2.3.4|aysel@example.com', t)));
}
console.log('other user:', JSON.stringify(limiter.attempt('1.2.3.4|murad@example.com', 3_000)));
Gözlənilən nəticə
0 {"allowed":true,"left":2}
1000 {"allowed":true,"left":1}
2000 {"allowed":true,"left":0}
3000 {"allowed":false,"retryAfterSec":57}
30500 {"allowed":false,"retryAfterSec":30}
61000 {"allowed":true,"left":2}
other user: {"allowed":true,"left":2}

Yadda saxla

  • Parollar yalnız yavaş duzlu heş kimi saxlanır (crypto.scrypt, Argon2id, bcrypt) və timingSafeEqual ilə müqayisə olunur.
  • Sessiya: serverdə qeyd, cookie-də təsadüfi id, dərhal ləğv. JWT: imzalı, şifrələnməmiş token, exp-ə qədər ləğv olunmur.
  • Access token qısaömürlüdür; refresh token HttpOnly cookie-də, bazada qeydli və hər istifadədə fırladılır.
  • Cookie: HttpOnly (XSS), Secure (HTTPS), SameSite=Lax (CSRF), Max-Age; çıxışda sessiyanı silin və clearCookie çağırın.
  • Qorunan marşrut = requireAuth middleware-i; giriş cəhdləri məhdudlaşdırılır (429 + Retry-After), sirlər mühit dəyişənlərindədir.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. Niyə parolları SHA-256 ilə heşləmək pis fikirdir?