Security Best Practices

// lib/csrf.ts
import {
  createHmac,
  randomBytes,
  timingSafeEqual,
} from "node:crypto";

const csrfSecret = process.env.CSRF_SECRET;

if (!csrfSecret) {
  throw new Error("CSRF_SECRET is not configured");
}

function sign(value: string): string {
  return createHmac("sha256", csrfSecret)
    .update(value)
    .digest("base64url");
}

export function createCsrfToken(): string {
  const nonce = randomBytes(32).toString("base64url");
  return `${nonce}.${sign(nonce)}`;
}

export function isValidCsrfToken(
  tokenFromCookie: string | undefined,
  tokenFromHeader: string | undefined,
): boolean {
  if (!tokenFromCookie || !tokenFromHeader) {
    return false;
  }

  // Обидва значення мають бути однаковими до криптографічної перевірки.
  if (tokenFromCookie !== tokenFromHeader) {
    return false;
  }

  const separatorIndex = tokenFromCookie.lastIndexOf(".");

  if (separatorIndex <= 0) {
    return false;
  }

  const nonce = tokenFromCookie.slice(0, separatorIndex);
  const receivedSignature = tokenFromCookie.slice(separatorIndex + 1);
  const expectedSignature = sign(nonce);

  const received = Buffer.from(receivedSignature);
  const expected = Buffer.from(expectedSignature);

  if (received.length !== expected.length) {
    return false;
  }

  return timingSafeEqual(received, expected);
}

// app/api/csrf/route.ts
import { NextResponse } from "next/server";
import { createCsrfToken } from "@/lib/csrf";

export async function GET() {
  const token = createCsrfToken();
  const response = NextResponse.json({ csrfToken: token });

  response.cookies.set("csrf-token", token, {
    httpOnly: false,
    secure: process.env.NODE_ENV === "production",
    sameSite: "lax",
    path: "/",
    maxAge: 60 * 60,
  });

  return response;
}

const csrfResponse = await fetch("/api/csrf");
const { csrfToken } = await csrfResponse.json();

const response = await fetch("/api/profile", {
  method: "PATCH",
  headers: {
    "Content-Type": "application/json",
    "X-CSRF-Token": csrfToken,
  },
  body: JSON.stringify({ displayName: "Олена" }),
});

const origin = request.headers.get("origin");
const expectedOrigin = process.env.APP_ORIGIN;

if (origin !== expectedOrigin) {
  return NextResponse.json(
    { error: "Недозволене джерело запиту" },
    { status: 403 },
  );
}

const csrfCookie = request.cookies.get("csrf-token")?.value;
const csrfHeader = request.headers.get("x-csrf-token");

if (!isValidCsrfToken(csrfCookie, csrfHeader)) {
  return NextResponse.json(
    { error: "Недійсний CSRF-токен" },
    { status: 403 },
  );
}

export function ProfileName({ name }: { name: string }) {
  return <h1>{name}</h1>;
}

// Погано: значення може містити шкідливий HTML.
<div dangerouslySetInnerHTML={{ __html: comment.body }} />

// Небезпечно: значення може бути javascript:-URL.
<a href={redirectUrl}>Продовжити</a>

export function isSafeLocalPath(value: string): boolean {
  return value.startsWith("/") && !value.startsWith("//");
}

const nextPath = requestUrl.searchParams.get("next");
const destination = nextPath && isSafeLocalPath(nextPath)
  ? nextPath
  : "/account";

response.cookies.set("session", sessionId, {
  httpOnly: true,
  secure: process.env.NODE_ENV === "production",
  sameSite: "lax",
  path: "/",
  maxAge: 60 * 60 * 24 * 7,
});

const oldSessionId = request.cookies.get("session")?.value;

if (oldSessionId) {
  // Стара анонімна або частково створена сесія більше не повинна діяти.
  await sessionStore.delete(oldSessionId);
}

const newSessionId = crypto.randomUUID();

await sessionStore.create(newSessionId, {
  userId: user.id,
  createdAt: Date.now(),
});

response.cookies.set("session", newSessionId, {
  httpOnly: true,
  secure: process.env.NODE_ENV === "production",
  sameSite: "lax",
  path: "/",
  maxAge: 60 * 60 * 24 * 7,
});

const sessionSecret = process.env.SESSION_SECRET;

if (!sessionSecret) {
  throw new Error("SESSION_SECRET is not configured");
}

NEXT_PUBLIC_SESSION_SECRET=...

type RateLimitResult = {
  allowed: boolean;
  retryAfterSeconds: number;
};

export async function checkLoginRateLimit(
  key: string,
): Promise<RateLimitResult> {
  // У production цей стан має зберігатися у спільному сховищі.
  const attempts = await rateLimitStore.increment(key, 15 * 60);

  if (attempts > 5) {
    return {
      allowed: false,
      retryAfterSeconds: 15 * 60,
    };
  }

  return {
    allowed: true,
    retryAfterSeconds: 0,
  };
}

return NextResponse.json(
  { error: "Забагато спроб. Повторіть пізніше." },
  {
    status: 429,
    headers: {
      "Retry-After": String(result.retryAfterSeconds),
    },
  },
);

Неправильний email або пароль.

Користувача не знайдено.
Пароль неправильний.

// app/api/login/route.ts
import { randomUUID } from "node:crypto";
import { NextRequest, NextResponse } from "next/server";
import argon2 from "argon2";
import { isValidCsrfToken } from "@/lib/csrf";
import { checkLoginRateLimit } from "@/lib/rate-limit";
import { userStore, sessionStore } from "@/lib/server-stores";

const appOrigin = process.env.APP_ORIGIN;

if (!appOrigin) {
  throw new Error("APP_ORIGIN is not configured");
}

// Цей хеш використовується для однакової поведінки, коли email не існує.
const dummyPasswordHash = process.env.DUMMY_PASSWORD_HASH;

if (!dummyPasswordHash) {
  throw new Error("DUMMY_PASSWORD_HASH is not configured");
}

export async function POST(request: NextRequest) {
  const origin = request.headers.get("origin");

  if (origin !== appOrigin) {
    return NextResponse.json(
      { error: "Недозволене джерело запиту" },
      { status: 403 },
    );
  }

  const csrfCookie = request.cookies.get("csrf-token")?.value;
  const csrfHeader = request.headers.get("x-csrf-token");

  if (!isValidCsrfToken(csrfCookie, csrfHeader)) {
    return NextResponse.json(
      { error: "Недійсний CSRF-токен" },
      { status: 403 },
    );
  }

  let body: { email?: unknown; password?: unknown };

  try {
    body = await request.json();
  } catch {
    return NextResponse.json(
      { error: "Некоректне тіло запиту" },
      { status: 400 },
    );
  }

  const email =
    typeof body.email === "string"
      ? body.email.trim().toLowerCase()
      : "";

  const password =
    typeof body.password === "string"
      ? body.password
      : "";

  if (!email || !password || password.length > 1024) {
    return NextResponse.json(
      { error: "Неправильний email або пароль" },
      { status: 401 },
    );
  }

  const ip = request.headers.get("x-forwarded-for")?.split(",")[0].trim()
    ?? "unknown";

  const rateLimit = await checkLoginRateLimit(`${ip}:${email}`);

  if (!rateLimit.allowed) {
    return NextResponse.json(
      { error: "Забагато спроб. Повторіть пізніше." },
      {
        status: 429,
        headers: {
          "Retry-After": String(rateLimit.retryAfterSeconds),
        },
      },
    );
  }

  const user = await userStore.findByEmail(email);
  const passwordHash = user?.passwordHash ?? dummyPasswordHash;
  const passwordMatches = await argon2.verify(passwordHash, password);

  if (!user || !passwordMatches) {
    return NextResponse.json(
      { error: "Неправильний email або пароль" },
      { status: 401 },
    );
  }

  const oldSessionId = request.cookies.get("session")?.value;

  if (oldSessionId) {
    // Відкликаємо стару сесію, щоб session fixation не дала доступ після входу.
    await sessionStore.delete(oldSessionId);
  }

  const newSessionId = randomUUID();

  await sessionStore.create(newSessionId, {
    userId: user.id,
    createdAt: Date.now(),
  });

  const response = NextResponse.json({ ok: true });

  response.cookies.set("session", newSessionId, {
    httpOnly: true,
    secure: process.env.NODE_ENV === "production",
    sameSite: "lax",
    path: "/",
    maxAge: 60 * 60 * 24 * 7,
  });

  return response;
}