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

Sesje użytkowników i zarządzanie tokenami

15 min czytania ·
W tej lekcji14

W poprzednich modułach omówiliśmy podstawy uwierzytelniania w Next.js oraz implementację logowania z zewnętrznymi dostawcami. Teraz zagłębimy się w kluczowy aspekt każdego systemu uwierzytelniania: zarządzanie sesjami użytkowników i tokenami. Zrozumienie tych mechanizmów jest niezbędne do budowania bezpiecznych i wydajnych aplikacji internetowych.

Podstawy zarządzania sesją

Sesja użytkownika to mechanizm, który pozwala aplikacji "pamiętać" zalogowanego użytkownika podczas nawigacji między stronami i żądaniami. W nowoczesnych aplikacjach webowych sesje są implementowane na dwa główne sposoby:

  1. Sesje po stronie serwera - identyfikator sesji przechowywany w ciasteczku, a dane sesji na serwerze
  2. Sesje bezstanowe (np. JWT) - wszystkie niezbędne informacje przechowywane w tokenie, często w ciasteczku

W Next.js, a szczególnie w połączeniu z NextAuth.js, mamy dostęp do obu tych podejść.

Sesje w NextAuth.js

NextAuth.js oferuje dwie główne strategie zarządzania sesjami:

1. Strategia JWT (domyślna)

W tej strategii wszystkie informacje o sesji są przechowywane w tokenie JWT (JSON Web Token), który jest zapisywany w ciasteczku:

// Konfiguracja strategii JWT w NextAuth.js
export const authOptions = {
  providers: [
    // Konfiguracja dostawców...
  ],
  session: {
    strategy: "jwt",
    maxAge: 30 * 24 * 60 * 60, // 30 dni w sekundach
    updateAge: 24 * 60 * 60,    // 24 godziny w sekundach
  },
  jwt: {
    secret: process.env.NEXTAUTH_SECRET,
    // Można również użyć kluczy prywatnych/publicznych zamiast prostego sekretu
    // encryption: true, // Włącza szyfrowanie JWT
    // signingKey: process.env.JWT_SIGNING_PRIVATE_KEY,
    // encryptionKey: process.env.JWT_ENCRYPTION_KEY,
  }
};

Zalety:

  • Lepsza skalowalność - serwer nie musi przechowywać danych sesji
  • Działa dobrze w środowisku serverless
  • Prostsze w implementacji

Wady:

  • Ograniczona wielkość danych (tokeny nie powinny być zbyt duże)
  • Trudniejsze unieważnienie tokenu przed wygaśnięciem
  • Wrażliwe dane są przechowywane w tokenie (choć zaszyfrowane)

2. Strategia bazy danych

W tej strategii tylko identyfikator sesji jest przechowywany w ciasteczku, a pozostałe dane sesji są przechowywane w bazie danych:

// Konfiguracja strategii bazy danych w NextAuth.js
import { PrismaAdapter } from "@auth/prisma-adapter";
import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

export const authOptions = {
  providers: [
    // Konfiguracja dostawców...
  ],
  adapter: PrismaAdapter(prisma),
  session: {
    strategy: "database",
    maxAge: 30 * 24 * 60 * 60, // 30 dni w sekundach
    updateAge: 24 * 60 * 60,    // 24 godziny w sekundach
  }
};

Zalety:

  • Łatwiejsze unieważnianie sesji (można usunąć wpis w bazie danych)
  • Brak ograniczeń dotyczących ilości danych
  • Bezpieczniejsze dla wrażliwych danych

Wady:

  • Wymaga dostępu do bazy danych przy każdym żądaniu
  • Nieco trudniejsza skalowalność
  • Potrzebny adapter bazy danych

Struktura tokenu JWT w NextAuth.js

Kiedy używamy strategii JWT, NextAuth.js tworzy token zawierający podstawowe informacje o użytkowniku:

{
  "name": "John Doe",
  "email": "john@example.com",
  "sub": "cl5ab1gxk0001t8kgxs4t8j1h", // identyfikator użytkownika
  "iat": 1658309600, // czas wystawienia tokenu
  "exp": 1660901600, // czas wygaśnięcia tokenu
  "jti": "4b32c6a4-d2c5-4f1a-a2b3-5c84c1d94208" // unikalny identyfikator tokenu
}

Możemy rozszerzyć token o dodatkowe dane za pomocą callbacka jwt:

export const authOptions = {
  //
  callbacks: {
    async jwt({ token, user, account }) {
      // Przy pierwszym logowaniu mamy dostęp do obiektu użytkownika
      if (user) {
        token.role = user.role;
        token.userId = user.id;
        token.provider = account?.provider;
      }

      // Możemy tu dodać logikę odświeżania tokenu
      // np. sprawdzanie, czy token dostępu OAuth nie wygasł

      return token;
    },

    async session({ session, token }) {
      // Dodaj dane z tokenu do obiektu sesji (dostępne w kliencie)
      if (session.user) {
        session.user.role = token.role;
        session.user.id = token.userId;
        session.user.provider = token.provider;
      }

      return session;
    }
  }
};

Konfiguracja ciasteczek sesji

NextAuth.js domyślnie konfiguruje ciasteczka sesji zgodnie z najlepszymi praktykami bezpieczeństwa, ale możemy te ustawienia dostosować:

export const authOptions = {
  //
  cookies: {
    sessionToken: {
      name: `__Secure-next-auth.session-token`,
      options: {
        httpOnly: true,
        sameSite: "lax",
        path: "/",
        secure: true,  // Ustaw na false podczas lokalnego testowania bez HTTPS
        maxAge: 30 * 24 * 60 * 60, // 30 dni w sekundach
      },
    },
    // Możesz też skonfigurować inne ciasteczka używane przez NextAuth.js
    callbackUrl: {
      name: `__Secure-next-auth.callback-url`,
      options: { /* ... */ },
    },
    csrfToken: {
      name: `__Host-next-auth.csrf-token`,
      options: { /* ... */ },
    },
  },
};

Zarządzanie sesją po stronie klienta

W komponentach klienckich możemy używać hooka useSession do uzyskania dostępu do danych sesji i jej statusu:

'use client';

import { useSession } from 'next-auth/react';

export default function ProfileComponent() {
  const { data: session, status } = useSession();

  if (status === 'loading') {
    return <p>Ładowanie...</p>;
  }

  if (status === 'unauthenticated') {
    return <p>Dostęp tylko dla zalogowanych użytkowników</p>;
  }

  return (
    <div>
      <h1>Profil</h1>
      <p>Witaj, {session.user.name}!</p>
      <p>Email: {session.user.email}</p>
      {session.user.role === 'admin' && (
        <p>Masz uprawnienia administratora</p>
      )}
    </div>
  );
}

Możemy również wymagać sesji za pomocą opcji required:

'use client';

import { useSession } from 'next-auth/react';
import { redirect } from 'next/navigation';

export default function ProtectedComponent() {
  const { data: session, status } = useSession({
    required: true,
    onUnauthenticated() {
      redirect('/auth/login?callbackUrl=/profile');
    },
  });

  // Gdy ustawione jest required, nie musimy sprawdzać statusu 'unauthenticated'
  if (status === 'loading') {
    return <p>Ładowanie...</p>;
  }

  return (
    <div>
      <h1>Chroniona zawartość</h1>
      <p>Ta strona jest widoczna tylko dla zalogowanych użytkowników.</p>
    </div>
  );
}

Zarządzanie sesją po stronie serwera

W komponentach serverowych lub Route Handlers możemy używać getServerSession do uzyskania dostępu do danych sesji:

// Komponent serverowy (Server Component)
import { getServerSession } from "next-auth/next";
import { redirect } from "next/navigation";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";

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

  if (!session) {
    redirect('/auth/login?callbackUrl=/profile');
  }

  return (
    <div>
      <h1>Profil (renderowany na serwerze)</h1>
      <p>Witaj, {session.user.name}!</p>
      <p>Email: {session.user.email}</p>
      {/* Zawartość widoczna tylko dla zalogowanych użytkowników */}
    </div>
  );
}

// Route Handler (API Route)
import { getServerSession } from "next-auth/next";
import { NextResponse } from "next/server";
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 });
  }

  // Pobierz dane specyficzne dla zalogowanego użytkownika
  const userData = await fetchUserData(session.user.id);

  return NextResponse.json(userData);
}

Refresh tokeny i zarządzanie dostępem OAuth

Jeśli korzystamy z dostawców OAuth, możemy chcieć przechowywać i odświeżać tokeny dostępu, aby używać API tych dostawców:

export const authOptions = {
  //
  callbacks: {
    async jwt({ token, user, account }) {
      // Przy pierwszym logowaniu zapisz tokeny dostępu/odświeżania
      if (account && user) {
        token.accessToken = account.access_token;
        token.refreshToken = account.refresh_token;
        token.accessTokenExpires = account.expires_at * 1000; // Konwersja na milisekundy
        token.userId = user.id;
        return token;
      }

      // Jeśli token dostępu nie wygasł, zwróć go
      if (Date.now() < token.accessTokenExpires) {
        return token;
      }

      // Jeśli token dostępu wygasł, odśwież go
      return refreshAccessToken(token);
    },

    async session({ session, token }) {
      // Przekaż token dostępu do klienta (ale nie token odświeżania!)
      session.accessToken = token.accessToken;
      session.user.id = token.userId;

      return session;
    },
  },
};

async function refreshAccessToken(token) {
  try {
    // Przykład odświeżania tokenu Google OAuth
    const url = "https://oauth2.googleapis.com/token";
    const response = await fetch(url, {
      headers: { "Content-Type": "application/x-www-form-urlencoded" },
      method: "POST",
      body: new URLSearchParams({
        client_id: process.env.GOOGLE_CLIENT_ID,
        client_secret: process.env.GOOGLE_CLIENT_SECRET,
        grant_type: "refresh_token",
        refresh_token: token.refreshToken,
      }),
    });

    const refreshedTokens = await response.json();

    if (!response.ok) {
      throw refreshedTokens;
    }

    return {
      ...token,
      accessToken: refreshedTokens.access_token,
      accessTokenExpires: Date.now() + refreshedTokens.expires_in * 1000,
      // Zachowaj refresh token, chyba że otrzymaliśmy nowy
      refreshToken: refreshedTokens.refresh_token ?? token.refreshToken,
    };
  } catch (error) {
    console.error("Error refreshing access token", error);
    // Token odświeżania mógł wygasnąć, użytkownik będzie musiał się ponownie zalogować
    return {
      ...token,
      error: "RefreshAccessTokenError",
    };
  }
}

Wylogowywanie i unieważnianie sesji

NextAuth.js udostępnia funkcję signOut() do wylogowywania:

'use client';

import { signOut } from 'next-auth/react';

export function LogoutButton() {
  return (
    <button
      onClick={() => signOut({ callbackUrl: '/' })}
      className="bg-red-500 text-white px-4 py-2 rounded"
    >
      Wyloguj się
    </button>
  );
}

W przypadku strategii opartej na bazie danych, możemy ręcznie unieważnić sesję, usuwając ją z bazy danych:

// app/api/auth/invalidate-sessions/route.ts
import { NextResponse } from "next/server";
import { getServerSession } from "next-auth/next";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { prisma } from "@/lib/prisma";

export async function POST(request: Request) {
  const session = await getServerSession(authOptions);

  if (!session || session.user.role !== 'admin') {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const { userId } = await request.json();

  // Usuń wszystkie sesje użytkownika o podanym ID
  await prisma.session.deleteMany({
    where: {
      userId,
    },
  });

  return NextResponse.json({ success: true });
}

W przypadku strategii JWT jest to trudniejsze, ponieważ tokeny są samodzielne. Możemy jednak zaimplementować "czarną listę" tokenów lub mechanizm rotacji sekretów:

// Implementacja czarnej listy dla tokena JWT
const revokedTokens = new Set();

export const authOptions = {
  //
  callbacks: {
    async jwt({ token }) {
      // Sprawdź, czy token jest na czarnej liście
      if (revokedTokens.has(token.jti)) {
        return null; // Token unieważniony
      }
      return token;
    },
  },
  events: {
    async signOut({ token }) {
      // Dodaj token do czarnej listy przy wylogowaniu
      if (token?.jti) {
        revokedTokens.add(token.jti);
      }
    },
  },
};

To proste rozwiązanie działa tylko dla pojedynczego serwera. W przypadku wielu serwerów lub rozwiązań serverless, musielibyśmy użyć współdzielonego magazynu danych (np. Redis) do przechowywania listy unieważnionych tokenów.

Wykrywanie nieaktywności i automatyczne wylogowywanie

Możemy zaimplementować mechanizm wykrywania nieaktywności użytkownika i automatycznego wylogowywania:

'use client';

import { useSession, signOut } from 'next-auth/react';
import { useEffect, useState } from 'react';

export function InactivityDetector({ timeoutMinutes = 30 }) {
  const { data: session } = useSession();

  useEffect(() => {
    if (!session) return;

    let timeout;
    const timeoutMs = timeoutMinutes * 60 * 1000;

    const resetTimeout = () => {
      if (timeout) clearTimeout(timeout);
      timeout = setTimeout(() => {
        signOut({ callbackUrl: '/auth/login?timeout=true' });
      }, timeoutMs);
    };

    // Zresetuj timer przy każdej aktywności użytkownika
    const events = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart'];

    // Ustaw początkowy timer
    resetTimeout();

    // Dodaj nasłuchiwanie zdarzeń
    events.forEach(event => {
      window.addEventListener(event, resetTimeout);
    });

    return () => {
      // Wyczyść timer i nasłuchiwanie przy odmontowaniu
      if (timeout) clearTimeout(timeout);
      events.forEach(event => {
        window.removeEventListener(event, resetTimeout);
      });
    };
  }, [session, timeoutMinutes]);

  // Komponent nie renderuje niczego widocznego
  return null;
}

Następnie można dodać ten komponent do głównego layoutu aplikacji:

// app/layout.tsx
import { Providers } from "./providers";
import { InactivityDetector } from "@/components/InactivityDetector";

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="pl">
      <body>
        <Providers>
          {children}
          <InactivityDetector timeoutMinutes={30} />
        </Providers>
      </body>
    </html>
  );
}

Obsługa wielu urządzeń i sesji

Jeśli używamy strategii opartej na bazie danych, możemy zaimplementować zarządzanie wieloma sesjami dla tego samego użytkownika, umożliwiając mu przegląd aktywnych sesji i wylogowanie z konkretnych urządzeń:

// app/settings/sessions/page.tsx
import { getServerSession } from "next-auth/next";
import { redirect } from "next/navigation";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { prisma } from "@/lib/prisma";
import { SessionList } from "./SessionList";

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

  if (!session) {
    redirect('/auth/login?callbackUrl=/settings/sessions');
  }

  // Pobierz wszystkie aktywne sesje użytkownika
  const userSessions = await prisma.session.findMany({
    where: {
      userId: session.user.id,
      expires: {
        gt: new Date(), // Tylko aktywne sesje
      },
    },
    orderBy: {
      expires: 'desc',
    },
  });

  // Oznacz aktualną sesję
  const currentSessionToken = session.user.sessionToken; // Musisz dostosować, aby mieć dostęp do tokenu
  const enhancedSessions = userSessions.map(s => ({
    ...s,
    isCurrent: s.sessionToken === currentSessionToken,
  }));

  return (
    <div className="max-w-4xl mx-auto p-6">
      <h1 className="text-2xl font-bold mb-6">Aktywne sesje</h1>
      <SessionList sessions={enhancedSessions} currentSessionId={session.user.id} />
    </div>
  );
}

// app/settings/sessions/SessionList.tsx (komponent kliencki)
'use client';

import { useState } from 'react';
import { useRouter } from 'next/navigation';

export function SessionList({ sessions, currentSessionId }) {
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState('');
  const router = useRouter();

  const handleRevokeSession = async (sessionToken) => {
    if (confirm('Czy na pewno chcesz wylogować to urządzenie?')) {
      setIsLoading(true);
      setError('');

      try {
        const response = await fetch('/api/auth/revoke-session', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ sessionToken }),
        });

        if (!response.ok) {
          throw new Error('Nie udało się unieważnić sesji');
        }

        // Odśwież stronę
        router.refresh();
      } catch (e) {
        setError(e.message);
      } finally {
        setIsLoading(false);
      }
    }
  };

  const formatDate = (dateString) => {
    return new Date(dateString).toLocaleString();
  };

  return (
    <div>
      {error && (
        <div className="p-4 mb-4 text-sm text-red-700 bg-red-100 rounded-lg">
          {error}
        </div>
      )}

      <div className="overflow-x-auto">
        <table className="min-w-full divide-y divide-gray-200">
          <thead className="bg-gray-50">
            <tr>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Urządzenie</th>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Ostatnia aktywność</th>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Wygasa</th>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Akcje</th>
            </tr>
          </thead>
          <tbody className="bg-white divide-y divide-gray-200">
            {sessions.map((session) => (
              <tr key={session.id}>
                <td className="px-6 py-4 whitespace-nowrap">
                  <div className="flex items-center">
                    <div className="ml-4">
                      <div className="text-sm font-medium text-gray-900">
                        {session.isCurrent ? 'Aktualne urządzenie' : 'Inne urządzenie'}
                      </div>
                    </div>
                  </div>
                </td>
                <td className="px-6 py-4 whitespace-nowrap">
                  <div className="text-sm text-gray-900">{formatDate(session.updatedAt)}</div>
                </td>
                <td className="px-6 py-4 whitespace-nowrap">
                  <div className="text-sm text-gray-900">{formatDate(session.expires)}</div>
                </td>
                <td className="px-6 py-4 whitespace-nowrap text-sm font-medium">
                  <button
                    onClick={() => handleRevokeSession(session.sessionToken)}
                    disabled={isLoading || session.isCurrent}
                    className={`text-red-600 hover:text-red-900 ${(isLoading || session.isCurrent) ? 'opacity-50 cursor-not-allowed' : ''}`}
                  >
                    {session.isCurrent ? 'Aktualna sesja' : 'Wyloguj'}
                  </button>
                </td>
              </tr>
            ))}
          </tbody>
        </table>
      </div>
    </div>
  );
}

// app/api/auth/revoke-session/route.ts
import { NextResponse } from "next/server";
import { getServerSession } from "next-auth/next";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { prisma } from "@/lib/prisma";

export async function POST(request: Request) {
  const session = await getServerSession(authOptions);

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

  const { sessionToken } = await request.json();

  // Znajdź sesję, upewniając się, że należy do zalogowanego użytkownika
  const sessionToRevoke = await prisma.session.findFirst({
    where: {
      sessionToken,
      userId: session.user.id,
    },
  });

  if (!sessionToRevoke) {
    return NextResponse.json(
      { error: "Session not found or not owned by current user" },
      { status: 404 }
    );
  }

  // Usuń sesję
  await prisma.session.delete({
    where: {
      id: sessionToRevoke.id,
    },
  });

  return NextResponse.json({ success: true });
}

Bezpieczeństwo tokenów i sesji

Przy implementacji zarządzania sesją i tokenami, należy pamiętać o kilku kluczowych aspektach bezpieczeństwa:

  1. Używaj silnych sekretów - upewnij się, że NEXTAUTH_SECRET jest długim, losowym ciągiem znaków

  2. Zabezpiecz ciasteczka - używaj flag:

    • HttpOnly: zapobiega dostępowi do ciasteczka przez JavaScript
    • Secure: wymaga HTTPS
    • SameSite: chroni przed atakami CSRF
  3. Ustaw odpowiedni czas życia - tokeny/sesje nie powinny być ważne przez zbyt długi okres

  4. Ogranicz dane w tokenie - token JWT powinien zawierać minimum niezbędnych informacji

  5. Implementuj odwołanie sesji - umożliw użytkownikom wylogowanie się ze wszystkich urządzeń

  6. Monitoruj podejrzane działania - wykrywaj próby wielokrotnego logowania i nietypowe wzorce dostępu

  7. Rotacja sekretów - okresowo zmieniaj sekrety używane do podpisywania tokenów

Testy sesji i tokenów

Testy są kluczowym elementem zapewnienia niezawodności mechanizmów sesji i tokenów. Oto przykład testu jednostkowego dla funkcjonalności odświeżania tokenu:

// __tests__/refreshToken.test.ts
import { refreshAccessToken } from '@/lib/auth';
import fetchMock from 'jest-fetch-mock';

fetchMock.enableMocks();

beforeEach(() => {
  fetchMock.resetMocks();
});

describe('refreshAccessToken', () => {
  it('should refresh the token successfully', async () => {
    // Przygotuj mock odpowiedzi z serwera OAuth
    fetchMock.mockResponseOnce(JSON.stringify({
      access_token: 'new_access_token',
      expires_in: 3600
    }));

    const originalToken = {
      accessToken: 'old_access_token',
      refreshToken: 'refresh_token',
      accessTokenExpires: Date.now() - 1000, // Wygasły token
    };

    const refreshedToken = await refreshAccessToken(originalToken);

    expect(refreshedToken.accessToken).toBe('new_access_token');
    expect(refreshedToken.refreshToken).toBe('refresh_token'); // Powinien zachować stary refresh token
    expect(refreshedToken.accessTokenExpires).toBeGreaterThan(Date.now());
    expect(fetchMock).toHaveBeenCalledTimes(1);
  });

  it('should handle refresh token errors', async () => {
    // Symuluj błąd odświeżania
    fetchMock.mockRejectOnce(new Error('Failed to refresh token'));

    const originalToken = {
      accessToken: 'old_access_token',
      refreshToken: 'refresh_token',
      accessTokenExpires: Date.now() - 1000,
    };

    const result = await refreshAccessToken(originalToken);

    expect(result.error).toBe('RefreshAccessTokenError');
    expect(result.accessToken).toBe('old_access_token'); // Powinien zachować stary token
  });
});

Dobre praktyki w kontekście Next.js App Router

W architekturze Next.js App Router, ważne jest, aby przestrzegać następujących zasad przy implementacji uwierzytelniania:

  1. Używaj middleware do ochrony całych katalogów lub grup 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ź, czy użytkownik ma dostęp do żądanej strony
  if (!token) {
    const url = new URL('/auth/login', request.url);
    url.searchParams.set('callbackUrl', request.nextUrl.pathname);
    return NextResponse.redirect(url);
  }

  // Sprawdzanie uprawnień na podstawie ścieżki i roli
  if (request.nextUrl.pathname.startsWith('/admin') && token.role !== 'admin') {
    return NextResponse.redirect(new URL('/dashboard', request.url));
  }

  return NextResponse.next();
}

export const config = {
  matcher: [
    '/dashboard/:path*',
    '/settings/:path*',
    '/admin/:path*',
    '/api/protected/:path*'
  ],
};
  1. Używaj Server Components gdzie to możliwe, aby zmniejszyć ilość kodu JavaScript po stronie klienta i poprawić bezpieczeństwo wrażliwych operacji:
// app/admin/dashboard/page.tsx (Server Component)
import { getServerSession } from "next-auth/next";
import { redirect } from "next/navigation";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";

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

  if (!session || session.user.role !== 'admin') {
    redirect('/');
  }

  // Pobierz dane administracyjne bezpośrednio na serwerze
  // bez narażania API keys lub innych wrażliwych informacji klientowi
  const adminData = await fetchAdminData();

  return (
    <div>
      <h1>Panel administratora</h1>
      {/* Renderuj dane administratora */}
    </div>
  );
}
  1. Używaj Route Handlers do zabezpieczenia API:
// app/api/protected/user-data/route.ts
import { getServerSession } from "next-auth/next";
import { NextResponse } from "next/server";
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 });
  }

  // Wykonaj chronione operacje
  const userData = await fetchUserData(session.user.id);

  // Zwróć dane bez wrażliwych informacji
  const sanitizedData = sanitizeUserData(userData);

  return NextResponse.json(sanitizedData);
}

Podsumowanie

W tym module omówiliśmy szczegółowo, jak zarządzać sesjami użytkowników i tokenami w aplikacjach Next.js:

  1. Poznaliśmy różne strategie sesji w NextAuth.js - JWT i bazodanową
  2. Nauczyliśmy się rozszerzać tokeny i sesje o własne dane
  3. Zrozumieliśmy, jak zabezpieczać ciasteczka i konfigurować parametry sesji
  4. Poznaliśmy mechanizmy odświeżania tokenów dla dostawców OAuth
  5. Zaimplementowaliśmy zarządzanie wieloma sesjami i wylogowywanie z konkretnych urządzeń
  6. Omówiliśmy najlepsze praktyki bezpieczeństwa dla tokenów i sesji

Właściwe zarządzanie sesjami i tokenami jest kluczowym aspektem bezpieczeństwa aplikacji internetowych. Dobrze zaprojektowany system uwierzytelniania nie tylko chroni dane użytkowników, ale także zapewnia dobre doświadczenie użytkownika, umożliwiając łatwe logowanie, wylogowywanie i zarządzanie dostępem z różnych urządzeń.

W następnym module zajmiemy się implementacją systemu ról i uprawnień, który pozwoli na bardziej granularne zarządzanie dostępem użytkowników do różnych funkcji aplikacji.

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

// Demo: Sesje uzytkownikow i zarzadzanie tokenami
interface SessionInfo {
  id: string;
  createdAt: string;
  ipAddress: string;
  userAgent: string;
}

function SessionTokenDemo() {
  const [activeTab, setActiveTab] = useState<'session' | 'jwt' | 'refresh'>('session');
  const [sessions, setSessions] = useState<SessionInfo[]>([]);
  const [jwtPayload, setJwtPayload] = useState<any>(null);
  const [tokenExpiry, setTokenExpiry] = useState(100);
  const [isRefreshing, setIsRefreshing] = useState(false);

  useEffect(() => {
    if (jwtPayload && tokenExpiry > 0) {
      const timer = setInterval(() => {
        setTokenExpiry(prev => prev <= 1 ? 0 : prev - 1);
      }, 100);
      return () => clearInterval(timer);
    }
  }, [jwtPayload, tokenExpiry]);

  const createSession = () => {
    const session: SessionInfo = {
      id: 'ses_' + Math.random().toString(36).substr(2, 9),
      createdAt: new Date().toLocaleTimeString(),
      ipAddress: '192.168.1.' + Math.floor(Math.random() * 255),
      userAgent: ['Chrome/120', 'Firefox/121', 'Safari/17'][Math.floor(Math.random() * 3)],
    };
    setSessions(prev => [...prev, session]);
  };

  const generateJWT = () => {
    const now = Math.floor(Date.now() / 1000);
    setJwtPayload({ sub: 'user_001', email: 'jan@quantum.city', role: 'admin', iat: now, exp: now + 3600 });
    setTokenExpiry(100);
  };

  const refreshToken = async () => {
    setIsRefreshing(true);
    await new Promise(r => setTimeout(r, 800));
    const now = Math.floor(Date.now() / 1000);
    setJwtPayload((prev: any) => prev ? { ...prev, iat: now, exp: now + 3600 } : null);
    setTokenExpiry(100);
    setIsRefreshing(false);
  };

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
      <h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Sesje i Tokeny</h1>
      <p style={{ color: '#8892b0', marginBottom: '24px' }}>Zarzadzanie sesjami uzytkownikow i tokenami JWT</p>

      <div style={{ display: 'flex', gap: '8px', marginBottom: '24px' }}>
        {[{ id: 'session' as const, label: 'Sesje' }, { id: 'jwt' as const, label: 'JWT' }, { id: 'refresh' as const, label: 'Refresh' }].map(tab => (
          <button key={tab.id} onClick={() => setActiveTab(tab.id)} style={{
            padding: '10px 20px', borderRadius: '8px', border: 'none', cursor: 'pointer',
            background: activeTab === tab.id ? '#64ffda' : '#1a1a2e', color: activeTab === tab.id ? '#0f0f23' : '#8892b0', fontWeight: 'bold',
          }}>
            {tab.label}
          </button>
        ))}
      </div>

      {activeTab === 'session' && (
        <div>
          <button onClick={createSession} style={{ padding: '10px 20px', borderRadius: '8px', background: '#7c3aed', color: '#fff', border: 'none', cursor: 'pointer', marginBottom: '16px' }}>+ Utworz sesje</button>
          {sessions.map(s => (
            <div key={s.id} style={{ background: '#1a1a2e', padding: '12px', borderRadius: '8px', border: '1px solid #333', marginBottom: '8px', display: 'flex', justifyContent: 'space-between' }}>
              <div>
                <code style={{ color: '#64ffda' }}>{s.id}</code>
                <div style={{ fontSize: '12px', color: '#8892b0' }}>IP: {s.ipAddress} | UA: {s.userAgent} | {s.createdAt}</div>
              </div>
              <button onClick={() => setSessions(prev => prev.filter(x => x.id !== s.id))} style={{ background: '#ef4444', color: '#fff', border: 'none', borderRadius: '4px', padding: '4px 8px', cursor: 'pointer', fontSize: '12px' }}>Revoke</button>
            </div>
          ))}
          {sessions.length === 0 && <p style={{ color: '#555' }}>Brak sesji</p>}
        </div>
      )}

      {activeTab === 'jwt' && (
        <div>
          <button onClick={generateJWT} style={{ padding: '10px 20px', borderRadius: '8px', background: '#f59e0b', color: '#0f0f23', border: 'none', cursor: 'pointer', marginBottom: '16px', fontWeight: 'bold' }}>Wygeneruj JWT</button>
          {jwtPayload && (
            <div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', border: '1px solid #333' }}>
              <div style={{ display: 'flex', alignItems: 'center', gap: '8px', marginBottom: '12px' }}>
                <span>Token:</span>
                <div style={{ flex: 1, height: '8px', background: '#333', borderRadius: '4px', overflow: 'hidden' }}>
                  <div style={{ width: tokenExpiry + '%', height: '100%', background: tokenExpiry > 30 ? '#10b981' : tokenExpiry > 10 ? '#f59e0b' : '#ef4444', transition: 'width 0.1s' }} />
                </div>
                <span style={{ color: tokenExpiry > 30 ? '#10b981' : '#ef4444' }}>{tokenExpiry}%</span>
              </div>
              {tokenExpiry === 0 && <div style={{ color: '#ef4444', fontWeight: 'bold', marginBottom: '8px' }}>Token wygasl!</div>}
              <pre style={{ background: '#0f0f23', padding: '12px', borderRadius: '6px', fontSize: '13px', overflow: 'auto' }}>{JSON.stringify(jwtPayload, null, 2)}</pre>
            </div>
          )}
        </div>
      )}

      {activeTab === 'refresh' && (
        <div style={{ background: '#1a1a2e', padding: '24px', borderRadius: '8px', border: '1px solid #333' }}>
          <h3 style={{ color: '#64ffda', marginTop: 0 }}>Refresh Token Flow</h3>
          {['Access token wygasa', 'Klient wysyla refresh token', 'Serwer weryfikuje refresh token', 'Nowy access + refresh token'].map((step, i) => (
            <div key={i} style={{ display: 'flex', alignItems: 'center', gap: '12px', marginBottom: '12px' }}>
              <div style={{ width: '32px', height: '32px', borderRadius: '50%', background: '#7c3aed', display: 'flex', alignItems: 'center', justifyContent: 'center', fontSize: '14px', fontWeight: 'bold', flexShrink: 0 }}>{i + 1}</div>
              <span>{step}</span>
            </div>
          ))}
          <button onClick={refreshToken} disabled={isRefreshing} style={{ marginTop: '12px', padding: '10px 20px', borderRadius: '8px', background: isRefreshing ? '#333' : '#7c3aed', color: '#fff', border: 'none', cursor: isRefreshing ? 'default' : 'pointer' }}>
            {isRefreshing ? 'Odswiezanie...' : 'Symuluj Refresh'}
          </button>
        </div>
      )}
    </div>
  );
}

export default SessionTokenDemo;

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. OAuth 2.0 to:

  2. 2. PKCE (Proof Key for Code Exchange) używa się w:

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz komponent ProtectedRoute używający useSession do ochrony przed nieautoryzowanym dostępem

  • Edytor kodu

    Utwórz credentials provider w NextAuth z email/password authentication i bcrypt hashing

  1. PytanieOAuth 2.0 to:
  2. PytaniePKCE (Proof Key for Code Exchange) używa się w:
  3. Zadanie z kodemPraktyka: Utwórz komponent ProtectedRoute używający
  4. Zadanie z kodemPraktyka: Utwórz credentials provider w NextAuth z

Przydatne artykuły