Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja

Bezpieczeństwo aplikacji i OWASP

19 min czytania ·
W tej lekcji5

W poprzednich modułach skupialiśmy się na implementacji uwierzytelniania, zarządzaniu sesjami, systemie ról i uprawnień, middleware ochrony tras oraz Context Providerze dla autentykacji. Teraz przeniesiemy naszą uwagę na szerszy obszar bezpieczeństwa aplikacji internetowych, ze szczególnym uwzględnieniem wytycznych OWASP (Open Web Application Security Project).

OWASP to organizacja non-profit, która pracuje nad poprawą bezpieczeństwa oprogramowania. Regularnie publikuje listę Top 10 najpoważniejszych zagrożeń bezpieczeństwa dla aplikacji internetowych, która stanowi podstawowy punkt odniesienia dla developerów dążących do tworzenia bezpiecznych aplikacji.

OWASP Top 10 i ich zastosowanie w aplikacjach Next.js

Przyjrzymy się, jak zabezpieczyć aplikacje Next.js przed najpoważniejszymi zagrożeniami z listy OWASP Top 10:

1. Broken Access Control (Uszkodzona kontrola dostępu)

Zagrożenie: Nieprawidłowa implementacja kontroli dostępu, pozwalająca nieautoryzowanym użytkownikom na dostęp do chronionych zasobów lub wykonywanie niedozwolonych operacji.

Zabezpieczenia w Next.js:

// 1. Middleware do ochrony tras
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';

export async function middleware(request: NextRequest) {
  const token = await getToken({ req: request });

  // Sprawdź uprawnienia użytkownika
  if (!token) {
    return NextResponse.redirect(new URL('/auth/login', request.url));
  }

  // Kontrola dostępu oparta na rolach
  if (request.nextUrl.pathname.startsWith('/admin') && token.role !== 'admin') {
    return NextResponse.redirect(new URL('/unauthorized', request.url));
  }

  return NextResponse.next();
}

// 2. Weryfikacja uprawnień w Route Handlers
// app/api/protected/resource/route.ts
import { NextResponse } from 'next/server';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/app/api/auth/[...nextauth]/route';

export async function GET() {
  const session = await getServerSession(authOptions);

  if (!session) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
  }

  // Sprawdzanie uprawnień dla konkretnego zasobu
  const hasPermission = await checkResourcePermission(session.user.id, 'resource-id');

  if (!hasPermission) {
    return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
  }

  // Kontynuuj z dostępem do zasobu...
}

// Funkcja sprawdzająca uprawnienia do zasobu
async function checkResourcePermission(userId: string, resourceId: string) {
  // Implementacja sprawdzania uprawnień, np. poprzez zapytanie do bazy danych
  // Warto zaimplementować mechanizm cache'owania dla często sprawdzanych uprawnień
  return true; // Przykładowa implementacja
}

Dodatkowe najlepsze praktyki:

  1. Implementuj kontrolę dostępu na poziomie serwera, nigdy nie polegaj wyłącznie na zabezpieczeniach po stronie klienta
  2. Stosuj zasadę domyślnej odmowy (deny by default)
  3. Regularnie przeglądaj i testuj mechanizmy kontroli dostępu
  4. Implementuj mechanizm blokowania kont po wielu nieudanych próbach logowania

2. Cryptographic Failures (Błędy kryptograficzne)

Zagrożenie: Nieprawidłowe lub niewystarczające zastosowanie kryptografii, prowadzące do ujawnienia wrażliwych danych.

Zabezpieczenia w Next.js:

// 1. Bezpieczne przechowywanie haseł
// lib/auth.ts
import { hash, compare } from 'bcrypt';

// Haszowanie hasła podczas rejestracji
export async function hashPassword(password: string): Promise<string> {
  // Używamy 12 rund dla dobrego kompromisu między bezpieczeństwem a wydajnością
  return hash(password, 12);
}

// Weryfikacja hasła podczas logowania
export async function verifyPassword(password: string, hashedPassword: string): Promise<boolean> {
  return compare(password, hashedPassword);
}

// 2. Szyfrowanie wrażliwych danych w bazie danych
// lib/encryption.ts
import crypto from 'crypto';

const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY as string; // Musi być 32 bajtów (256 bitów)
const IV_LENGTH = 16; // Dla AES, initialization vector wynosi 16 bajtów

export function encrypt(text: string): string {
  const iv = crypto.randomBytes(IV_LENGTH);
  const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(ENCRYPTION_KEY), iv);
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return `${iv.toString('hex')}:${encrypted}`;
}

export function decrypt(text: string): string {
  const [ivHex, encryptedHex] = text.split(':');
  const iv = Buffer.from(ivHex, 'hex');
  const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(ENCRYPTION_KEY), iv);
  let decrypted = decipher.update(encryptedHex, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  return decrypted;
}

Dodatkowe najlepsze praktyki:

  1. Zawsze używaj HTTPS dla wszystkich stron aplikacji
  2. Wdrażaj odpowiednie nagłówki HTTP związane z bezpieczeństwem (HSTS, CSP)
  3. Regularnie aktualizuj biblioteki kryptograficzne
  4. Wdrażaj strategię rotacji kluczy kryptograficznych
  5. Nie przechowuj wrażliwych danych w lokalnych magazynach przeglądarki (localStorage, sessionStorage)

3. Injection (Wstrzykiwanie)

Zagrożenie: Wstrzykiwanie niezaufanych danych do interpreterów jako części komendy lub zapytania, co może prowadzić do wykonania nieautoryzowanych poleceń lub uzyskania dostępu do danych.

Zabezpieczenia w Next.js:

// 1. Bezpieczne zapytania do bazy danych (wykorzystanie ORM)
// app/api/users/route.ts
import { NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma';

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const name = searchParams.get('name');

  // Bezpieczne zapytanie z wykorzystaniem ORM (Prisma)
  // Zamiast bezpośredniego wstrzykiwania parametrów do zapytania SQL
  const users = await prisma.user.findMany({
    where: {
      name: {
        contains: name || '',
      },
    },
    select: {
      id: true,
      name: true,
      email: true,
    },
  });

  return NextResponse.json(users);
}

// 2. Walidacja danych wejściowych z wykorzystaniem biblioteki zod
// app/api/products/route.ts
import { NextResponse } from 'next/server';
import { z } from 'zod';

// Schemat walidacji
const ProductSchema = z.object({
  name: z.string().min(1).max(100),
  price: z.number().positive(),
  description: z.string().optional(),
  categoryId: z.string().uuid(),
});

export async function POST(request: Request) {
  try {
    const body = await request.json();

    // Walidacja danych wejściowych
    const result = ProductSchema.safeParse(body);

    if (!result.success) {
      return NextResponse.json(
        { error: 'Invalid input', details: result.error.format() },
        { status: 400 }
      );
    }

    // Dalsze przetwarzanie bezpiecznych, zwalidowanych danych...

  } catch (error) {
    return NextResponse.json(
      { error: 'Server error' },
      { status: 500 }
    );
  }
}

Dodatkowe najlepsze praktyki:

  1. Filtruj i sanityzuj dane wejściowe i wyjściowe
  2. Stosuj złożone, randomizowane hasła i identyfikatory sesji
  3. Implementuj timeout sesji i ograniczaj liczbę prób logowania
  4. Escape wszelkie dane przed umieszczeniem ich w poleceniach SQL, skryptach, czy HTML
  5. Unikaj dynamicznego generowania kodu JavaScript przez łączenie ciągów

4. Insecure Design (Niebezpieczny projekt)

Zagrożenie: Brak odpowiednich mechanizmów bezpieczeństwa na poziomie projektowania aplikacji, co prowadzi do fundamentalnych luk w zabezpieczeniach.

Zabezpieczenia w Next.js:

// 1. Implementacja polityki bezpieczeństwa haseł
// lib/passwordPolicy.ts
export function isPasswordStrong(password: string): { isValid: boolean; reason?: string } {
  // Minimalna długość 8 znaków
  if (password.length < 8) {
    return { isValid: false, reason: 'Hasło musi mieć co najmniej 8 znaków' };
  }

  // Wymaga wielkich liter
  if (!/[A-Z]/.test(password)) {
    return { isValid: false, reason: 'Hasło musi zawierać co najmniej jedną wielką literę' };
  }

  // Wymaga małych liter
  if (!/[a-z]/.test(password)) {
    return { isValid: false, reason: 'Hasło musi zawierać co najmniej jedną małą literę' };
  }

  // Wymaga cyfr
  if (!/[0-9]/.test(password)) {
    return { isValid: false, reason: 'Hasło musi zawierać co najmniej jedną cyfrę' };
  }

  // Wymaga znaków specjalnych
  if (!/[^A-Za-z0-9]/.test(password)) {
    return { isValid: false, reason: 'Hasło musi zawierać co najmniej jeden znak specjalny' };
  }

  // Sprawdzenie, czy hasło nie jest na liście popularnych, łatwych do odgadnięcia haseł
  const commonPasswords = ['Password123!', 'Admin123!', '12345678Aa!', 'Qwerty123!']; // W praktyce powinna być to większa baza
  if (commonPasswords.includes(password)) {
    return { isValid: false, reason: 'Hasło jest zbyt popularne i łatwe do odgadnięcia' };
  }

  return { isValid: true };
}

// 2. Implementacja systemu uprawnień w oparciu o model danych
// lib/permissions.ts
import { prisma } from '@/lib/prisma';

// Model zezwalaj na określone operacje tylko właścicielowi zasobu
export async function canModifyResource(userId: string, resourceId: string): Promise<boolean> {
  const resource = await prisma.resource.findUnique({
    where: { id: resourceId },
    select: { userId: true },
  });

  // Zasób nie istnieje lub użytkownik nie jest właścicielem
  if (!resource || resource.userId !== userId) {
    return false;
  }

  return true;
}

Dodatkowe najlepsze praktyki:

  1. Implementuj mechanizm wielopoziomowej ochrony (defense in depth)
  2. Przeprowadzaj modelowanie zagrożeń na wczesnym etapie tworzenia aplikacji
  3. Projektuj z myślą o zasadzie najmniejszych uprawnień (principle of least privilege)
  4. Traktuj dane użytkownika jako niezaufane i zawsze je waliduj
  5. Regularnie przeglądaj i aktualizuj mechanizmy bezpieczeństwa

5. Security Misconfiguration (Błędna konfiguracja bezpieczeństwa)

Zagrożenie: Nieprawidłowa konfiguracja zabezpieczeń w jakimkolwiek komponencie aplikacji, co może prowadzić do nieautoryzowanego dostępu lub wycieku danych.

Zabezpieczenia w Next.js:

// 1. Konfiguracja Content Security Policy
// next.config.js
const ContentSecurityPolicy = `
  default-src 'self';
  script-src 'self' 'unsafe-eval' 'unsafe-inline' https://cdn.example.com;
  style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
  font-src 'self' https://fonts.gstatic.com;
  img-src 'self' data: https:;
  connect-src 'self' https://api.example.com;
  frame-src 'self';
`;

module.exports = {
  async headers() {
    return [
      {
        source: '/(.*)',
        headers: [
          {
            key: 'Content-Security-Policy',
            value: ContentSecurityPolicy.replace(/\s{2,}/g, ' ').trim(),
          },
          {
            key: 'X-Content-Type-Options',
            value: 'nosniff',
          },
          {
            key: 'X-Frame-Options',
            value: 'DENY',
          },
          {
            key: 'X-XSS-Protection',
            value: '1; mode=block',
          },
          {
            key: 'Referrer-Policy',
            value: 'strict-origin-when-cross-origin',
          },
          {
            key: 'Permissions-Policy',
            value: 'camera=(), microphone=(), geolocation=(self)',
          },
        ],
      },
    ];
  },
};

// 2. Bezpieczne korzystanie ze zmiennych środowiskowych
// lib/config.ts
interface Config {
  database: {
    url: string;
  };
  auth: {
    secret: string;
    tokenExpiration: number;
  };
  services: {
    apiKey: string;
    endpoint: string;
  };
}

export const config: Config = {
  database: {
    url: process.env.DATABASE_URL || '',
  },
  auth: {
    secret: process.env.AUTH_SECRET || '',
    tokenExpiration: Number(process.env.TOKEN_EXPIRATION) || 3600,
  },
  services: {
    apiKey: process.env.SERVICE_API_KEY || '',
    endpoint: process.env.SERVICE_ENDPOINT || '',
  },
};

// Funkcja do weryfikacji konfiguracji przy starcie aplikacji
export function validateConfig() {
  const requiredEnvVars = [
    'DATABASE_URL',
    'AUTH_SECRET',
    'SERVICE_API_KEY',
    'SERVICE_ENDPOINT',
  ];

  const missingEnvVars = requiredEnvVars.filter(
    (envVar) => !process.env[envVar]
  );

  if (missingEnvVars.length > 0) {
    throw new Error(`Missing required environment variables: ${missingEnvVars.join(', ')}`);
  }

  if (process.env.AUTH_SECRET && process.env.AUTH_SECRET.length < 32) {
    throw new Error('AUTH_SECRET should be at least 32 characters long for security');
  }

  console.log('Configuration validated successfully');
}

Dodatkowe najlepsze praktyki:

  1. Usuwaj lub wyłączaj niepotrzebne funkcje, komponenty i zależności
  2. Regularnie aktualizuj wszystkie komponenty aplikacji i zależności
  3. Implementuj mechanizm audytowania konfiguracji
  4. Nigdy nie umieszczaj wrażliwych danych w kodzie źródłowym lub plikach dostępnych publicznie
  5. Używaj różnych konfiguracji dla środowisk deweloperskich i produkcyjnych

6. Vulnerable and Outdated Components (Podatne i przestarzałe komponenty)

Zagrożenie: Używanie komponentów i bibliotek zawierających znane luki bezpieczeństwa lub które nie są już wspierane.

Zabezpieczenia w Next.js:

// 1. Automatyczne skanowanie zależności
// package.json
{
  "scripts": {
    "audit": "npm audit",
    "audit:fix": "npm audit fix",
    "outdated": "npm outdated",
    "update": "npm update",
    "deps:check": "npx depcheck",
    "prepare": "husky install"
  },
  "husky": {
    "hooks": {
      "pre-commit": "npm run audit"
    }
  }
}

// 2. Wprowadzenie polityki SRI (Subresource Integrity)
// Dla krytycznych zewnętrznych bibliotek JavaScript
// app/layout.tsx (przykład)
import Script from 'next/script';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <head>
        {/* Wykorzystanie SRI do weryfikacji integralności zewnętrznego skryptu */}
        <Script
          src="https://cdn.example.com/library.min.js"
          integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxy9rx7HNQlGYl1kPzQho1wx4JwY8wC"
          crossOrigin="anonymous"
        />
      </head>
      <body>{children}</body>
    </html>
  );
}

Dodatkowe najlepsze praktyki:

  1. Regularne wykonywanie npm audit lub używanie narzędzi jak Snyk, Dependabot
  2. Usuwanie nieużywanych zależności
  3. Subscrypcja na powiadomienia o lukach bezpieczeństwa w używanych bibliotekach
  4. Stosowanie zaufanych, dobrze utrzymywanych bibliotek z aktywną społecznością
  5. Przygotowanie procedur na szybką aktualizację komponentów po odkryciu luk

7. Identification and Authentication Failures (Błędy identyfikacji i uwierzytelniania)

Zagrożenie: Nieprawidłowa implementacja mechanizmów uwierzytelniania, umożliwiająca atakującym dostęp do kont użytkowników.

Zabezpieczenia w Next.js:

// 1. Implementacja ograniczania prób logowania
// lib/rateLimit.ts
import { Redis } from '@upstash/redis';

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_URL!,
  token: process.env.UPSTASH_REDIS_TOKEN!,
});

export async function rateLimit(
  identifier: string, // IP lub identyfikator użytkownika
  limit: number, // Maksymalna liczba prób
  window: number // Okno czasowe w sekundach
): Promise<{ success: boolean; remaining: number; reset: number }> {
  const now = Math.floor(Date.now() / 1000);
  const key = `ratelimit:${identifier}`;

  // Pobierz aktualne dane o ograniczeniach
  const entry = await redis.hgetall(key);

  if (!entry.count) {
    // Pierwszy wpis
    await redis.hset(key, {
      count: 1,
      reset: now + window,
    });
    await redis.expire(key, window);

    return {
      success: true,
      remaining: limit - 1,
      reset: now + window,
    };
  }

  // Sprawdź, czy okno czasowe minęło
  if (parseInt(entry.reset) < now) {
    // Resetuj licznik
    await redis.hset(key, {
      count: 1,
      reset: now + window,
    });
    await redis.expire(key, window);

    return {
      success: true,
      remaining: limit - 1,
      reset: now + window,
    };
  }

  // Sprawdź, czy przekroczono limit
  const count = parseInt(entry.count);
  if (count >= limit) {
    return {
      success: false,
      remaining: 0,
      reset: parseInt(entry.reset),
    };
  }

  // Aktualizuj licznik
  await redis.hincrby(key, 'count', 1);

  return {
    success: true,
    remaining: limit - count - 1,
    reset: parseInt(entry.reset),
  };
}

// 2. Implementacja strony logowania z ograniczeniem prób
// app/api/auth/login/route.ts
import { NextResponse } from 'next/server';
import { rateLimit } from '@/lib/rateLimit';

export async function POST(request: Request) {
  try {
    const { email, password } = await request.json();

    // Pobierz adres IP użytkownika
    const ip = request.headers.get('x-forwarded-for') || 'unknown';

    // Ogranicz próby logowania: 5 prób w ciągu 15 minut
    const rateLimitResult = await rateLimit(ip, 5, 15 * 60);

    if (!rateLimitResult.success) {
      return NextResponse.json(
        {
          error: 'Too many login attempts. Please try again later.',
          reset: rateLimitResult.reset,
        },
        { status: 429 }
      );
    }

    // Kontynuuj proces logowania...

  } catch (error) {
    console.error('Login error:', error);
    return NextResponse.json(
      { error: 'An error occurred during login' },
      { status: 500 }
    );
  }
}

Dodatkowe najlepsze praktyki:

  1. Implementuj silne wymagania dotyczące haseł
  2. Wymagaj uwierzytelniania wieloskładnikowego (MFA) dla kont administratora i użytkowników z wysokimi uprawnieniami
  3. Nie ujawniaj szczegółowych informacji o błędach uwierzytelniania
  4. Implementuj bezpieczne mechanizmy odzyskiwania haseł
  5. Stosuj mechanizm jednorazowych tokenów do operacji krytycznych

8. Software and Data Integrity Failures (Błędy integralności oprogramowania i danych)

Zagrożenie: Brak weryfikacji integralności oprogramowania i danych, umożliwiający wprowadzanie nieprawidłowych lub złośliwych komponentów.

Zabezpieczenia w Next.js:

// 1. Implementacja mechanizmu podpisów cyfrowych dla krytycznych danych
// lib/signatures.ts
import crypto from 'crypto';

const SIGNATURE_KEY = process.env.SIGNATURE_KEY!;

// Generowanie podpisu dla danych
export function signData(data: any): string {
  const dataString = typeof data === 'string' ? data : JSON.stringify(data);
  return crypto
    .createHmac('sha256', SIGNATURE_KEY)
    .update(dataString)
    .digest('hex');
}

// Weryfikacja podpisu danych
export function verifySignature(data: any, signature: string): boolean {
  const expectedSignature = signData(data);
  return crypto.timingSafeEqual(
    Buffer.from(expectedSignature, 'hex'),
    Buffer.from(signature, 'hex')
  );
}

// 2. Implementacja weryfikacji webhooków zewnętrznych usług
// app/api/webhooks/payment-processor/route.ts
import { NextResponse } from 'next/server';
import { verifySignature } from '@/lib/signatures';

export async function POST(request: Request) {
  const body = await request.text();
  const signature = request.headers.get('X-Webhook-Signature') || '';

  // Weryfikacja podpisu webhook
  if (!verifySignature(body, signature)) {
    console.error('Invalid webhook signature');
    return NextResponse.json(
      { error: 'Invalid signature' },
      { status: 401 }
    );
  }

  // Przetwarzanie zweryfikowanego webhoka...
  const data = JSON.parse(body);

  //
  return NextResponse.json({ status: 'success' });
}

Dodatkowe najlepsze praktyki:

  1. Weryfikuj integralność plików i kodów źródłowych w procesie CI/CD
  2. Weryfikuj pochodzenie zewnętrznych bibliotek i komponentów
  3. Używaj mechanizmów SRI (Subresource Integrity) dla zewnętrznych zasobów
  4. Implementuj automatyczne testy bezpieczeństwa w procesie CI/CD
  5. Monitoruj i analizuj zmiany w plikach konfiguracyjnych i kodzie aplikacji

9. Security Logging and Monitoring Failures (Błędy logowania i monitorowania bezpieczeństwa)

Zagrożenie: Niewystarczające logowanie, monitorowanie i alertowanie o zdarzeniach bezpieczeństwa, co uniemożliwia wykrycie, eskalację i odpowiedź na incydenty.

Zabezpieczenia w Next.js:

// 1. Implementacja rozbudowanego logowania
// lib/logger.ts
import winston from 'winston';

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  defaultMeta: { service: 'next-app' },
  transports: [
    // Lokalne zapisywanie logów na poziomie error
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    // Lokalne zapisywanie wszystkich logów
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// W środowisku produkcyjnym wysyłaj logi do usługi monitoringu
if (process.env.NODE_ENV === 'production') {
  // Przykład dla Datadog
  // Wymaga instalacji '@datadog/winston'
  // import { datadog } from '@datadog/winston';
  // logger.add(new datadog({
  //   apiKey: process.env.DATADOG_API_KEY,
  //   hostname: process.env.HOSTNAME,
  //   service: 'next-app',
  //   ddsource: 'nodejs',
  // }));
}

// Funkcje do logowania zdarzeń bezpieczeństwa
export function logSecurityEvent(
  eventType: string,
  data: any,
  severity: 'info' | 'warn' | 'error' = 'info'
) {
  logger.log({
    level: severity,
    message: `Security event: ${eventType}`,
    eventType,
    data,
    timestamp: new Date().toISOString(),
  });
}

export function logAuthEvent(
  userId: string | null,
  action: 'login' | 'logout' | 'failed_login' | 'password_reset' | 'account_locked',
  details: any = {}
) {
  logSecurityEvent(
    `auth_${action}`,
    {
      userId,
      ip: details.ip,
      userAgent: details.userAgent,
      ...details,
    },
    action === 'failed_login' || action === 'account_locked' ? 'warn' : 'info'
  );
}

// 2. Implementacja middleware do logowania żądań HTTP
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { logSecurityEvent } from '@/lib/logger';

export function middleware(request: NextRequest) {
  // Zapisz podstawowe informacje o żądaniu
  const requestInfo = {
    method: request.method,
    path: request.nextUrl.pathname,
    ip: request.ip || 'unknown',
    userAgent: request.headers.get('user-agent') || 'unknown',
    referer: request.headers.get('referer') || 'unknown',
  };

  // Loguj tylko istotne ścieżki (pomijaj zasoby statyczne, itp.)
  if (!request.nextUrl.pathname.match(/\.(ico|png|jpg|jpeg|svg|css|js)$/)) {
    logSecurityEvent('http_request', requestInfo);
  }

  // Wykrywanie potencjalnych ataków
  if (detectPotentialAttack(request)) {
    logSecurityEvent('potential_attack', requestInfo, 'warn');
  }

  return NextResponse.next();
}

// Funkcja wykrywająca potencjalne ataki na podstawie wzorów w żądaniu
function detectPotentialAttack(request: NextRequest): boolean {
  const url = request.nextUrl.toString().toLowerCase();
  const body = request.body; // Może być niedostępne w middleware

  // Wykrywanie podstawowych prób ataków
  const attackPatterns = [
    /(\.\.\/|\.\.\\/)/i, // Path traversal
    /('|")(;|--|\+|\%|\#|\)/i, // Podstawowe SQL injection
    /<script>[^<]*<\/script>/i, // Basic XSS
    /etc\/passwd/i, // Path disclosure
    /\/(wp-admin|wp-content|wp-includes)/i, // WordPress scanning
  ];

  return attackPatterns.some(pattern => pattern.test(url));
}

Dodatkowe najlepsze praktyki:

  1. Implementuj centralizowany system logowania i monitorowania
  2. Konfiguruj automatyczne alertowanie o podejrzanych zdarzeniach
  3. Zapewnij mechanizmy korelacji zdarzeń z różnych części aplikacji
  4. Regularnie analizuj logi pod kątem nieautoryzowanych działań
  5. Przechowuj logi przez odpowiednio długi czas zgodnie z regulacjami i potrzebami biznesowymi

10. Server-Side Request Forgery (Fałszerstwo żądań po stronie serwera)

Zagrożenie: Ataki SSRF pozwalają atakującemu na wywoływanie żądań HTTP z serwera aplikacji do zasobów wewnętrznych lub zewnętrznych, do których serwer ma dostęp.

Zabezpieczenia w Next.js:

// 1. Implementacja bezpiecznego pobierania URLów
// lib/safeFetch.ts
import { URL } from 'url';
import fetch from 'node-fetch';

// Lista dozwolonych domen
const ALLOWED_HOSTS = [
  'api.example.com',
  'api.trusted-service.com',
  'cdn.example.com',
];

// Lista zabronionych adresów IP (prywatne zakresy IP)
const BLOCKED_IP_RANGES = [
  // Lokalne
  /^127\.\d+\.\d+\.\d+$/, // 127.0.0.0/8
  /^10\.\d+\.\d+\.\d+$/, // 10.0.0.0/8
  /^172\.(1[6-9]|2\d|3[0-1])\.\d+\.\d+$/, // 172.16.0.0/12
  /^192\.168\.\d+\.\d+$/, // 192.168.0.0/16
  // Lokalne linki
  /^169\.254\.\d+\.\d+$/, // 169.254.0.0/16
  // Multicast
  /^2(2[4-9]|3\d)\.\d+\.\d+\.\d+$/, // 224.0.0.0/4
];

export async function safeFetch(urlString: string, options: RequestInit = {}) {
  try {
    // Parsuj URL, aby sprawdzić jego komponenty
    const url = new URL(urlString);

    // Sprawdź, czy domena jest na liście dozwolonych
    if (!ALLOWED_HOSTS.includes(url.hostname)) {
      throw new Error(`Host not allowed: ${url.hostname}`);
    }

    // Sprawdź, czy adres IP nie jest na liście zablokowanych
    // To wymaga dodatkowej logiki do rozpoznawania DNS
    // Uproszczona wersja sprawdzania bezpośrednio hosta
    if (BLOCKED_IP_RANGES.some(pattern => pattern.test(url.hostname))) {
      throw new Error(`IP address not allowed: ${url.hostname}`);
    }

    // Sprawdź, czy protokół jest bezpieczny
    if (url.protocol !== 'https:') {
      throw new Error(`Protocol not allowed: ${url.protocol}`);
    }

    // Wykonaj żądanie HTTP po weryfikacji URL
    return fetch(url.toString(), options);
  } catch (error) {
    console.error('Safe fetch error:', error);
    throw new Error(`Invalid or disallowed URL: ${urlString}`);
  }
}

// 2. Implementacja API proxy z walidacją URL
// app/api/proxy/route.ts
import { NextResponse } from 'next/server';
import { safeFetch } from '@/lib/safeFetch';

export async function GET(request: Request) {
  try {
    const { searchParams } = new URL(request.url);
    const targetUrl = searchParams.get('url');

    if (!targetUrl) {
      return NextResponse.json(
        { error: 'URL parameter is required' },
        { status: 400 }
      );
    }

    try {
      // Użyj bezpiecznej funkcji fetch
      const response = await safeFetch(targetUrl);
      const data = await response.text();

      return new NextResponse(data, {
        status: response.status,
        headers: {
          'Content-Type': response.headers.get('Content-Type') || 'text/plain',
        },
      });
    } catch (error) {
      return NextResponse.json(
        { error: 'Invalid or disallowed URL' },
        { status: 400 }
      );
    }
  } catch (error) {
    console.error('Proxy error:', error);
    return NextResponse.json(
      { error: 'Server error' },
      { status: 500 }
    );
  }
}

Dodatkowe najlepsze praktyki:

  1. Implementuj listy dozwolonych domen zamiast list blokowanych
  2. Używaj zapory sieciowej (firewall) do blokowania połączeń do wewnętrznych zasobów
  3. Filtruj i sanityzuj dane wejściowe zawierające URL
  4. Używaj minimalnych uprawnień dla kont serwisowych i aplikacji
  5. Unikaj przekazywania pełnych odpowiedzi z zewnętrznych API do klienta

Implementacja Security Headers w Next.js

Nagłówki bezpieczeństwa są kluczowym elementem ochrony aplikacji internetowych. Next.js umożliwia łatwą konfigurację tych nagłówków w pliku next.config.js:

// next.config.js
const securityHeaders = [
  {
    key: 'X-DNS-Prefetch-Control',
    value: 'on',
  },
  {
    key: 'Strict-Transport-Security',
    value: 'max-age=63072000; includeSubDomains; preload',
  },
  {
    key: 'X-XSS-Protection',
    value: '1; mode=block',
  },
  {
    key: 'X-Frame-Options',
    value: 'SAMEORIGIN',
  },
  {
    key: 'X-Content-Type-Options',
    value: 'nosniff',
  },
  {
    key: 'Referrer-Policy',
    value: 'strict-origin-when-cross-origin',
  },
  {
    key: 'Permissions-Policy',
    value: 'camera=(), microphone=(), geolocation=(self), interest-cohort=()',
  },
];

module.exports = {
  async headers() {
    return [
      {
        // Zastosuj te nagłówki do wszystkich ścieżek
        source: '/(.*)',
        headers: securityHeaders,
      },
    ];
  },
  // Inne konfiguracje Next.js...
};

Testy penetracyjne i automatyzacja testowania bezpieczeństwa

Testy są kluczowym elementem zapewnienia bezpieczeństwa aplikacji. Poniżej przedstawiono przykład integracji testów bezpieczeństwa z procesem CI/CD:

# .github/workflows/security.yml
name: Security Checks

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  schedule:
    - cron: '0 0 * * 0' # Cotygodniowe skanowanie

jobs:
  security-checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '16'

      - name: Install dependencies
        run: npm ci

      - name: Run npm audit
        run: npm audit --audit-level=high

      - name: OWASP ZAP Scan
        uses: zaproxy/action-baseline@v0.6.1
        with:
          target: 'https://staging.example.com' # URL Twojego środowiska staging

      - name: Run Snyk to check for vulnerabilities
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

      - name: Check for secrets in code
        uses: gitleaks/gitleaks-action@v1.6.0

Lista kontrolna bezpieczeństwa dla aplikacji Next.js

Poniżej przedstawiono listę kontrolną, którą możesz wykorzystać do oceny bezpieczeństwa swojej aplikacji Next.js:

Ogólne zabezpieczenia

  • Wdrożono odpowiednie nagłówki HTTP związane z bezpieczeństwem
  • Używany jest HTTPS dla wszystkich środowisk
  • Wdrożono mechanizm walidacji danych wejściowych
  • Nieaktywne sesje są automatycznie wylogowywane
  • Wrażliwe informacje nie są przechowywane w plikach dostępnych publicznie
  • Logi nie zawierają wrażliwych danych

Uwierzytelnianie i autoryzacja

  • Hasła są odpowiednio haszowane i solone
  • Zaimplementowano mechanizm ograniczania prób logowania
  • Wdrożono politykę bezpieczeństwa haseł
  • System ról i uprawnień działa poprawnie
  • Sesje są bezpiecznie zarządzane
  • Zaimplementowano uwierzytelnianie wieloskładnikowe (MFA) dla kont administratora

Przetwarzanie danych

  • Dane są odpowiednio sanityzowane przed renderowaniem
  • Zapytania do bazy danych są parametryzowane (zabezpieczone przed SQL Injection)
  • Wdrożono mechanizmy zapobiegające atakom XSS
  • API endpoints są zabezpieczone przed nieautoryzowanym dostępem
  • Implementacja CSRF tokenów zapobiega atakom CSRF

Zależności i kod

  • Wszystkie zależności są aktualne i wolne od znanych luk
  • Kod jest regularnie skanowany pod kątem luk bezpieczeństwa
  • Stosowane są najlepsze praktyki kodowania
  • Nie ma twardych kodów sekretów i kluczy w kodzie

Monitorowanie i reakcja na incydenty

  • Wdrożono mechanizm logowania zdarzeń bezpieczeństwa
  • Zdefiniowano procedury reagowania na incydenty bezpieczeństwa
  • Regularne testy penetracyjne są przeprowadzane
  • Mechanizmy monitorowania i alertowania są wdrożone

Podsumowanie

Bezpieczeństwo aplikacji internetowych, w tym aplikacji Next.js, wymaga kompleksowego podejścia i ciągłej uwagi. W tym module omówiliśmy najważniejsze zagrożenia zdefiniowane w OWASP Top 10 oraz sposób ich minimalizacji w kontekście aplikacji Next.js.

Kluczowe punkty do zapamiętania:

  1. Kompleksowe podejście - bezpieczeństwo powinno być uwzględniane na każdym etapie tworzenia aplikacji
  2. Zasada najmniejszych uprawnień - przydzielaj minimalne uprawnienia niezbędne do wykonania zadania
  3. Walidacja i sanityzacja - zawsze waliduj i sanityzuj dane wejściowe
  4. Aktualizacje i patche - regularnie aktualizuj zależności i stosuj patche bezpieczeństwa
  5. Monitorowanie i logowanie - implementuj rozbudowane mechanizmy monitorowania i logowania
  6. Testowanie - regularnie przeprowadzaj testy bezpieczeństwa

Pamiętaj, że bezpieczeństwo to proces, nie produkt. Wymaga ciągłego doskonalenia i dostosowywania do nowych zagrożeń.

W następnym module przyjrzymy się audytowi i monitoringowi bezpieczeństwa, aby lepiej zrozumieć, jak wykrywać i reagować na potencjalne incydenty bezpieczeństwa.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Demo: OWASP Top 10
interface Vulnerability {
  id: string;
  name: string;
  owaspId: string;
  severity: 'critical' | 'high' | 'medium';
  description: string;
  example: string;
  prevention: string[];
}

const owaspTop10: Vulnerability[] = [
  { id: '1', name: 'Broken Access Control', owaspId: 'A01:2021', severity: 'critical',
    description: 'Brak kontroli dostepu - uzytkownicy dzialaja poza uprawnieniami.',
    example: 'GET /api/users/123/data - brak weryfikacji tożsamosci',
    prevention: ['Domyslnie odmawiaj dostepu', 'Implementuj RBAC', 'Waliduj po stronie serwera'] },
  { id: '2', name: 'Cryptographic Failures', owaspId: 'A02:2021', severity: 'critical',
    description: 'Slabe szyfrowanie lub brak szyfrowania danych.',
    example: 'Hasla w postaci jawnej w bazie danych',
    prevention: ['bcrypt/argon2 do hasel', 'HTTPS', 'Nie przechowuj niepotrzebnych danych'] },
  { id: '3', name: 'Injection', owaspId: 'A03:2021', severity: 'critical',
    description: 'SQL, NoSQL, OS command injection.',
    example: 'SELECT * FROM users WHERE id = userInput (bez parametryzacji)',
    prevention: ['Parametryzowane zapytania', 'Walidacja danych', 'Uzywaj ORM'] },
  { id: '4', name: 'Insecure Design', owaspId: 'A04:2021', severity: 'high',
    description: 'Brak wzorcow bezpieczenstwa w architekturze.',
    example: 'Brak rate limiting na logowaniu',
    prevention: ['Modelowanie zagrozen', 'Wzorce bezpieczenstwa', 'Security code review'] },
  { id: '5', name: 'Security Misconfiguration', owaspId: 'A05:2021', severity: 'high',
    description: 'Domyslne ustawienia, otwarte porty, debug w produkcji.',
    example: 'Szczegolowe bledy w produkcji',
    prevention: ['Hardening', 'Minimalne uprawnienia', 'Audyty konfiguracji'] },
  { id: '6', name: 'Vulnerable Components', owaspId: 'A06:2021', severity: 'medium',
    description: 'Biblioteki z znanymi podatnosciami.',
    example: 'Stara wersja lodash z prototype pollution',
    prevention: ['npm audit', 'Aktualizuj zaleznosci', 'Monitoruj CVE'] },
  { id: '7', name: 'Auth Failures', owaspId: 'A07:2021', severity: 'critical',
    description: 'Slabe hasla, brak MFA, podatne tokeny.',
    example: 'Brak limitu prob logowania',
    prevention: ['MFA', 'Silne polityki hasel', 'Rate limiting'] },
  { id: '8', name: 'Data Integrity', owaspId: 'A08:2021', severity: 'high',
    description: 'Bledy integralnosci oprogramowania i danych.',
    example: 'CI/CD bez weryfikacji artefaktow',
    prevention: ['Podpisywanie artefaktow', 'Weryfikacja integralnosci', 'Bezpieczny CI/CD'] },
];

const sevColors: Record<string, string> = { critical: '#ef4444', high: '#f59e0b', medium: '#3b82f6' };

function OWASPDemo() {
  const [selected, setSelected] = useState<Vulnerability | null>(null);
  const [checked, setChecked] = useState<Set<string>>(new Set());
  const toggle = (id: string) => setChecked(prev => { const n = new Set(prev); n.has(id) ? n.delete(id) : n.add(id); return n; });
  const score = Math.round((checked.size / owaspTop10.length) * 100);

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
      <h1 style={{ color: '#64ffda', marginBottom: '8px' }}>OWASP Top 10 Checklist</h1>

      <div style={{ display: 'flex', alignItems: 'center', gap: '16px', marginBottom: '24px', padding: '16px', background: '#1a1a2e', borderRadius: '8px', border: '1px solid #333' }}>
        <div style={{ width: '60px', height: '60px', borderRadius: '50%', border: '3px solid ' + (score >= 75 ? '#10b981' : score >= 50 ? '#f59e0b' : '#ef4444'), display: 'flex', alignItems: 'center', justifyContent: 'center', fontSize: '20px', fontWeight: 'bold', color: score >= 75 ? '#10b981' : score >= 50 ? '#f59e0b' : '#ef4444' }}>{score}%</div>
        <div><strong>Security Score</strong><div style={{ fontSize: '13px', color: '#8892b0' }}>{checked.size}/{owaspTop10.length} zabezpieczonych</div></div>
      </div>

      <div style={{ display: 'grid', gridTemplateColumns: selected ? '1fr 1fr' : '1fr', gap: '20px' }}>
        <div style={{ display: 'grid', gap: '8px' }}>
          {owaspTop10.map(v => (
            <div key={v.id} onClick={() => setSelected(v)} style={{
              padding: '12px 16px', borderRadius: '8px', cursor: 'pointer',
              background: selected?.id === v.id ? '#1a2a3e' : '#1a1a2e',
              border: selected?.id === v.id ? '1px solid #64ffda' : '1px solid #333',
              display: 'flex', alignItems: 'center', gap: '12px',
            }}>
              <input type="checkbox" checked={checked.has(v.id)} onChange={() => toggle(v.id)} onClick={e => e.stopPropagation()} />
              <span style={{ fontSize: '12px', padding: '2px 8px', borderRadius: '12px', background: sevColors[v.severity] + '30', color: sevColors[v.severity] }}>{v.severity}</span>
              <strong style={{ fontSize: '14px' }}>{v.owaspId}: {v.name}</strong>
            </div>
          ))}
        </div>
        {selected && (
          <div style={{ background: '#1a1a2e', padding: '20px', borderRadius: '12px', border: '1px solid #333' }}>
            <h3 style={{ color: '#64ffda', marginTop: 0 }}>{selected.owaspId}: {selected.name}</h3>
            <p style={{ color: '#8892b0' }}>{selected.description}</p>
            <div style={{ background: '#0f0f23', padding: '12px', borderRadius: '6px', marginBottom: '12px' }}>
              <strong style={{ color: '#ef4444', fontSize: '13px' }}>Przyklad:</strong>
              <pre style={{ fontSize: '12px', color: '#f59e0b', margin: '8px 0 0', whiteSpace: 'pre-wrap' }}>{selected.example}</pre>
            </div>
            <strong style={{ color: '#10b981', fontSize: '13px' }}>Zapobieganie:</strong>
            <ul style={{ fontSize: '13px', color: '#8892b0', paddingLeft: '20px', margin: '8px 0 0' }}>
              {selected.prevention.map((p, i) => <li key={i}>{p}</li>)}
            </ul>
          </div>
        )}
      </div>
    </div>
  );
}

export default OWASPDemo;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Multi-Factor Authentication (MFA) dodaje:

  2. 2. CSRF attacks można zapobiec przez:

To 2 z 6 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż składnię importu i użycia redirect

  • Klikanie w kolejności

    Ułóż strukturę JWT tokena:

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: Track requests → Check limits → Block/Al

  • Układanie w pionie

    Uporządkuj cykl życia tokena JWT:

  1. PytanieMulti-Factor Authentication (MFA) dodaje:
  2. PytanieCSRF attacks można zapobiec przez:
  3. PytanieSession hijacking można zapobiec przez:
  4. Ułóż w kolejnościSkładnia redirect z next/navigation
  5. PytanieWebAuthn/FIDO2 oferuje:
  6. Kliknij w kolejnościStruktura JWT tokena: Header.Payload.Signature
  7. Ułóż w kolejnościKolejność: Track requests → Check limits → Block/Allow
  8. Ułóż w kolejnościCykl życia tokena JWT
  9. PytanieRate limiting w authentication pomaga przeciw:
  10. PytanieOWASP i bezpieczeństwo aplikacji

Przydatne artykuły