Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Sesje użytkowników i zarządzanie tokenami
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:
- Sesje po stronie serwera - identyfikator sesji przechowywany w ciasteczku, a dane sesji na serwerze
- 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:
Używaj silnych sekretów - upewnij się, że
NEXTAUTH_SECRETjest długim, losowym ciągiem znakówZabezpiecz ciasteczka - używaj flag:
HttpOnly: zapobiega dostępowi do ciasteczka przez JavaScriptSecure: wymaga HTTPSSameSite: chroni przed atakami CSRF
Ustaw odpowiedni czas życia - tokeny/sesje nie powinny być ważne przez zbyt długi okres
Ogranicz dane w tokenie - token JWT powinien zawierać minimum niezbędnych informacji
Implementuj odwołanie sesji - umożliw użytkownikom wylogowanie się ze wszystkich urządzeń
Monitoruj podejrzane działania - wykrywaj próby wielokrotnego logowania i nietypowe wzorce dostępu
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:
- 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*'
],
};- 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>
);
}- 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:
- Poznaliśmy różne strategie sesji w NextAuth.js - JWT i bazodanową
- Nauczyliśmy się rozszerzać tokeny i sesje o własne dane
- Zrozumieliśmy, jak zabezpieczać ciasteczka i konfigurować parametry sesji
- Poznaliśmy mechanizmy odświeżania tokenów dla dostawców OAuth
- Zaimplementowaliśmy zarządzanie wieloma sesjami i wylogowywanie z konkretnych urządzeń
- 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. OAuth 2.0 to:
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