API Security · fullstack.org.ua

fullstack.org.ua

API Security · fullstack.org.ua

javascript

const allowedCurrencies = new Set(["UAH", "USD", "EUR"]);

if (
  Number.isInteger(body.amount) &&
  body.amount > 0 &&
  body.amount <= 1_000_000 &&
  typeof body.currency === "string" &&
  allowedCurrencies.has(body.currency)
) {
  // Дані відповідають очікуваному формату
}

javascript

const http = require("node:http");
const crypto = require("node:crypto");

const PORT = 3000;
const MAX_BODY_SIZE = 1_000_000;
const RATE_LIMIT = 10;
const RATE_WINDOW_MS = 60_000;

// Демонстраційний токен. У production його не зберігають у коді.
const validTokens = new Map([
  ["demo-access-token", { userId: "user-123" }]
]);

const rateLimits = new Map();
const idempotencyStore = new Map();

function sendJson(response, statusCode, body, extraHeaders = {}) {
  response.writeHead(statusCode, {
    "Content-Type": "application/json; charset=utf-8",
    ...extraHeaders
  });
  response.end(JSON.stringify(body));
}

function getClientKey(request) {
  // За проксі потрібно окремо налаштувати довіру до proxy-заголовків.
  return request.socket.remoteAddress || "unknown";
}

function isRateLimited(clientKey) {
  const now = Date.now();
  const current = rateLimits.get(clientKey);

  if (!current || now >= current.resetAt) {
    rateLimits.set(clientKey, {
      count: 1,
      resetAt: now + RATE_WINDOW_MS
    });
    return false;
  }

  current.count += 1;
  return current.count > RATE_LIMIT;
}

function getBearerToken(request) {
  const header = request.headers.authorization;

  if (!header || !header.startsWith("Bearer ")) {
    return null;
  }

  return header.slice("Bearer ".length).trim();
}

function readJsonBody(request) {
  return new Promise((resolve, reject) => {
    let body = "";
    let size = 0;

    request.setEncoding("utf8");

    request.on("data", (chunk) => {
      size += Buffer.byteLength(chunk);

      if (size > MAX_BODY_SIZE) {
        reject(new Error("BODY_TOO_LARGE"));
        request.destroy();
        return;
      }

      body += chunk;
    });

    request.on("end", () => {
      try {
        resolve(body ? JSON.parse(body) : null);
      } catch {
        reject(new Error("INVALID_JSON"));
      }
    });

    request.on("error", reject);
  });
}

function validatePayment(body) {
  const allowedCurrencies = new Set(["UAH", "USD", "EUR"]);

  if (!body || typeof body !== "object" || Array.isArray(body)) {
    return "Тіло запиту має бути JSON-об'єктом";
  }

  if (!Number.isInteger(body.amount) || body.amount < 1 || body.amount > 1_000_000) {
    return "amount має бути цілим числом від 1 до 1000000";
  }

  if (
    typeof body.currency !== "string" ||
    !allowedCurrencies.has(body.currency)
  ) {
    return "currency має бути одним із: UAH, USD, EUR";
  }

  const allowedFields = new Set(["amount", "currency"]);
  const unknownFields = Object.keys(body).filter(
    (field) => !allowedFields.has(field)
  );

  if (unknownFields.length > 0) {
    return "Запит містить невідомі поля";
  }

  return null;
}

const server = http.createServer(async (request, response) => {
  const clientKey = getClientKey(request);

  if (isRateLimited(clientKey)) {
    sendJson(
      response,
      429,
      { error: "Забагато запитів" },
      { "Retry-After": "60" }
    );
    return;
  }

  if (request.method !== "POST" || request.url !== "/payments") {
    sendJson(response, 404, { error: "Маршрут не знайдено" });
    return;
  }

  const token = getBearerToken(request);
  const session = token ? validTokens.get(token) : null;

  if (!session) {
    sendJson(response, 401, { error: "Потрібна автентифікація" });
    return;
  }

  const idempotencyKey = request.headers["idempotency-key"];

  if (
    typeof idempotencyKey !== "string" ||
    idempotencyKey.length < 16 ||
    idempotencyKey.length > 128
  ) {
    sendJson(response, 400, {
      error: "Потрібен коректний Idempotency-Key"
    });
    return;
  }

  const storageKey = `${session.userId}:POST:/payments:${idempotencyKey}`;

  try {
    const body = await readJsonBody(request);
    const validationError = validatePayment(body);

    if (validationError) {
      sendJson(response, 400, { error: validationError });
      return;
    }

    const payloadHash = crypto
      .createHash("sha256")
      .update(JSON.stringify(body))
      .digest("hex");

    const saved = idempotencyStore.get(storageKey);

    if (saved) {
      if (saved.payloadHash !== payloadHash) {
        sendJson(response, 409, {
          error: "Цей Idempotency-Key вже використано з іншими даними"
        });
        return;
      }

      sendJson(response, saved.statusCode, saved.body);
      return;
    }

    // Тут у реальному сервісі виконувалася б транзакція в базі даних.
    const result = {
      paymentId: crypto.randomUUID(),
      userId: session.userId,
      amount: body.amount,
      currency: body.currency,
      status: "accepted"
    };

    const savedResponse = {
      statusCode: 201,
      body: result,
      payloadHash
    };

    idempotencyStore.set(storageKey, savedResponse);
    sendJson(response, 201, result);
  } catch (error) {
    if (error.message === "BODY_TOO_LARGE") {
      sendJson(response, 413, { error: "Тіло запиту завелике" });
      return;
    }

    if (error.message === "INVALID_JSON") {
      sendJson(response, 400, { error: "Некоректний JSON" });
      return;
    }

    sendJson(response, 500, { error: "Внутрішня помилка сервера" });
  }
});

server.listen(PORT, () => {
  console.log(`API запущено на http://localhost:${PORT}`);
});

bash

curl -i -X POST http://localhost:3000/payments \
  -H "Authorization: Bearer demo-access-token" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 4f8d2f7a-0f5e-4b6d-9f1e-123456789abc" \
  -d '{"amount":2500,"currency":"UAH"}'