Rate Limiting: обмеження частоти запитів

const http = require('node:http');

class RateLimiter {
  constructor({ limit, windowMs }) {
    this.limit = limit;
    this.windowMs = windowMs;
    this.entries = new Map();

    // Періодично видаляємо застарілі записи, щоб Map не зростав безмежно.
    this.cleanupTimer = setInterval(() => {
      const now = Date.now();

      for (const [key, entry] of this.entries) {
        if (entry.resetAt <= now) {
          this.entries.delete(key);
        }
      }
    }, windowMs);

    this.cleanupTimer.unref();
  }

  check(key) {
    const now = Date.now();
    let entry = this.entries.get(key);

    if (!entry || entry.resetAt <= now) {
      entry = {
        count: 0,
        resetAt: now + this.windowMs
      };

      this.entries.set(key, entry);
    }

    entry.count += 1;

    const retryAfter = Math.max(
      1,
      Math.ceil((entry.resetAt - now) / 1000)
    );

    return {
      allowed: entry.count <= this.limit,
      retryAfter,
      remaining: Math.max(0, this.limit - entry.count)
    };
  }
}

const generalLimiter = new RateLimiter({
  limit: 100,
  windowMs: 60 * 1000
});

const loginByIpLimiter = new RateLimiter({
  limit: 5,
  windowMs: 60 * 1000
});

const loginByUsernameLimiter = new RateLimiter({
  limit: 10,
  windowMs: 60 * 1000
});

function normalizeIp(ip) {
  // Node.js може повертати IPv4 у форматі ::ffff:127.0.0.1.
  return ip.startsWith('::ffff:') ? ip.slice(7) : ip;
}

function sendJson(response, statusCode, data, headers = {}) {
  const body = JSON.stringify(data);

  response.writeHead(statusCode, {
    'Content-Type': 'application/json; charset=utf-8',
    'Content-Length': Buffer.byteLength(body),
    ...headers
  });

  response.end(body);
}

function sendRateLimitResponse(response, retryAfter) {
  sendJson(
    response,
    429,
    {
      error: 'Забагато запитів',
      message: 'Спробуйте ще раз пізніше'
    },
    {
      'Retry-After': String(retryAfter)
    }
  );
}

function readJsonBody(request, maxBytes = 1024 * 16) {
  return new Promise((resolve, reject) => {
    const chunks = [];
    let totalBytes = 0;
    let finished = false;

    request.on('data', (chunk) => {
      if (finished) {
        return;
      }

      totalBytes += chunk.length;

      if (totalBytes > maxBytes) {
        finished = true;
        reject(new Error('REQUEST_TOO_LARGE'));
        request.destroy();
        return;
      }

      chunks.push(chunk);
    });

    request.on('end', () => {
      if (finished) {
        return;
      }

      finished = true;

      try {
        const text = Buffer.concat(chunks).toString('utf8');
        resolve(text ? JSON.parse(text) : {});
      } catch {
        reject(new Error('INVALID_JSON'));
      }
    });

    request.on('error', (error) => {
      if (!finished) {
        finished = true;
        reject(error);
      }
    });
  });
}

async function handleLogin(request, response, ip) {
  let body;

  try {
    body = await readJsonBody(request);
  } catch (error) {
    if (error.message === 'REQUEST_TOO_LARGE') {
      sendJson(response, 413, {
        error: 'Запит надто великий'
      });
      return;
    }

    sendJson(response, 400, {
      error: 'Некоректний JSON'
    });
    return;
  }

  const username =
    typeof body.username === 'string'
      ? body.username.trim().toLowerCase()
      : '';

  if (!username || typeof body.password !== 'string') {
    sendJson(response, 400, {
      error: 'Потрібні username і password'
    });
    return;
  }

  const ipResult = loginByIpLimiter.check(ip);
  const usernameResult = loginByUsernameLimiter.check(username);

  if (!ipResult.allowed || !usernameResult.allowed) {
    const retryAfter = Math.max(
      ipResult.retryAfter,
      usernameResult.retryAfter
    );

    sendRateLimitResponse(response, retryAfter);
    return;
  }

  // Демонстраційні облікові дані. У реальному застосунку пароль
  // потрібно перевіряти через безпечний механізм зберігання паролів.
  const isValid =
    username === 'admin' &&
    body.password === 'demo-password';

  if (!isValid) {
    // Однакова відповідь для неправильного username і неправильного пароля
    // не повинна розкривати, чи існує обліковий запис.
    sendJson(response, 401, {
      error: 'Неправильні облікові дані'
    });
    return;
  }

  sendJson(response, 200, {
    message: 'Вхід виконано'
  });
}

const server = http.createServer(async (request, response) => {
  const ip = normalizeIp(request.socket.remoteAddress || 'unknown');

  const generalResult = generalLimiter.check(ip);

  if (!generalResult.allowed) {
    sendRateLimitResponse(response, generalResult.retryAfter);
    return;
  }

  if (request.method === 'POST' && request.url === '/login') {
    await handleLogin(request, response, ip);
    return;
  }

  sendJson(response, 404, {
    error: 'Маршрут не знайдено'
  });
});

server.listen(3000, () => {
  console.log('Сервер запущено на http://localhost:3000');
});

node server.js

curl -i \
  -X POST http://localhost:3000/login \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"wrong-password"}'

HTTP/1.1 429 Too Many Requests
Retry-After: 42

const ip = normalizeIp(request.socket.remoteAddress || 'unknown');

const username =
  typeof body.username === 'string'
    ? body.username.trim().toLowerCase()
    : '';