Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Strategie uwierzytelniania
W tej lekcji6
W poprzednich częściach omówiliśmy podstawy uwierzytelniania oraz zaimplementowaliśmy prostą autoryzację z użyciem JWT. Teraz zagłębimy się w różne strategie uwierzytelniania, które możesz zastosować w swoich aplikacjach.
Uwierzytelnianie oparte na tokenach vs. sesyjne
Dwa główne podejścia do uwierzytelniania to:
1. Uwierzytelnianie sesyjne (Session-based Authentication)
W tym podejściu serwer utrzymuje stan sesji dla każdego zalogowanego użytkownika:
// Przykład konfiguracji sesji w Express
import express from 'express';
import session from 'express-session';
const app = express();
app.use(session({
secret: 'tajny-klucz-sesji',
resave: false,
saveUninitialized: false,
cookie: { secure: true, maxAge: 3600000 } // 1 godzina
}));
app.post('/login', (req, res) => {
// Po pomyślnym uwierzytelnieniu
req.session.authenticated = true;
req.session.userId = user.id;
res.send({ success: true });
});
app.get('/protected', (req, res) => {
if (req.session.authenticated) {
// Użytkownik ma ważną sesję
res.send('Dane chronione');
} else {
res.status(401).send('Brak dostępu');
}
});Zalety:
- Łatwość implementacji i utrzymania
- Możliwość natychmiastowego unieważnienia sesji
- Nie wymaga dodatkowego przetwarzania po stronie klienta
Wady:
- Obciążenie serwera (przechowywanie stanu)
- Problemy ze skalowalnością w architekturze rozproszonej
- Trudności w implementacji dla aplikacji mobilnych
2. Uwierzytelnianie oparte na tokenach (Token-based Authentication)
W tym podejściu serwer generuje token, który klient przechowuje i przesyła z każdym żądaniem:
// Przykład implementacji JWT w Express
import express from 'express';
import jwt from 'jsonwebtoken';
const app = express();
const JWT_SECRET = 'tajny-klucz-jwt';
app.post('/login', (req, res) => {
// Po pomyślnym uwierzytelnieniu
const token = jwt.sign(
{ userId: user.id, email: user.email },
JWT_SECRET,
{ expiresIn: '1h' }
);
res.send({ token });
});
// Middleware weryfikujący token
const verifyToken = (req, res, next) => {
const token = req.headers.authorization?.split(' ')[1];
if (!token) {
return res.status(401).send('Brak tokenu autoryzacji');
}
try {
const decoded = jwt.verify(token, JWT_SECRET);
req.user = decoded;
next();
} catch (error) {
return res.status(401).send('Nieprawidłowy token');
}
};
app.get('/protected', verifyToken, (req, res) => {
res.send('Dane chronione');
});Zalety:
- Bezstanowość (stateless) - łatwiejsze skalowanie
- Działa dobrze w aplikacjach mobilnych i SPA
- Możliwość przechowywania dodatkowych informacji w tokenie
Wady:
- Trudniejsze unieważnienie tokenu przed wygaśnięciem
- Podatność na kradzież (jeśli nie zastosowano odpowiednich zabezpieczeń)
- Większe tokeny mogą zwiększyć obciążenie sieci
OAuth 2.0 i uwierzytelnianie społecznościowe
OAuth 2.0 to standard protokołu autoryzacji, który umożliwia aplikacjom dostęp do zasobów użytkownika na innym serwerze bez konieczności dzielenia się danymi uwierzytelniającymi.
Implementacja uwierzytelniania przez Google
// Implementacja OAuth z Google w Express i Passport
import express from 'express';
import passport from 'passport';
import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
const app = express();
// Konfiguracja Passport
passport.use(new GoogleStrategy({
clientID: 'TWOJE_GOOGLE_CLIENT_ID',
clientSecret: 'TWOJE_GOOGLE_CLIENT_SECRET',
callbackURL: 'http://localhost:3000/auth/google/callback'
},
function(accessToken, refreshToken, profile, done) {
// Znajdź lub utwórz użytkownika w bazie danych
User.findOrCreate({ googleId: profile.id }, function (err, user) {
return done(err, user);
});
}
));
// Trasy uwierzytelniania
app.get('/auth/google',
passport.authenticate('google', { scope: ['profile', 'email'] }));
app.get('/auth/google/callback',
passport.authenticate('google', { failureRedirect: '/login' }),
(req, res) => {
// Przekierowanie po pomyślnym uwierzytelnieniu
res.redirect('/dashboard');
}
);Uwierzytelnianie wieloskładnikowe (MFA)
Uwierzytelnianie wieloskładnikowe (Multi-Factor Authentication) zwiększa bezpieczeństwo, wymagając od użytkownika dostarczenia dwóch lub więcej dowodów tożsamości.
Przykład implementacji MFA z użyciem TOTP (Time-based One-Time Password)
// Implementacja 2FA z TOTP w Node.js
import express from 'express';
import speakeasy from 'speakeasy';
import QRCode from 'qrcode';
const app = express();
app.use(express.json());
// Generowanie tajnego klucza dla użytkownika
app.post('/generate-2fa', (req, res) => {
const secret = speakeasy.generateSecret({
name: 'MojaAplikacja:' + req.user.email
});
// Zapisz secret.base32 w bazie danych dla tego użytkownika
saveUserSecret(req.user.id, secret.base32);
// Generuj kod QR
QRCode.toDataURL(secret.otpauth_url, (err, imageUrl) => {
if (err) {
return res.status(500).send('Błąd generowania kodu QR');
}
res.json({
secret: secret.base32,
qrCode: imageUrl
});
});
});
// Weryfikacja kodu jednorazowego
app.post('/verify-2fa', (req, res) => {
const { token } = req.body;
// Pobierz secret użytkownika z bazy danych
const userSecret = getUserSecret(req.user.id);
const verified = speakeasy.totp.verify({
secret: userSecret,
encoding: 'base32',
token: token
});
if (verified) {
// Włącz 2FA dla użytkownika w bazie danych
enableUser2FA(req.user.id);
res.json({ success: true });
} else {
res.status(400).json({ success: false, message: 'Nieprawidłowy kod' });
}
});Single Sign-On (SSO)
Single Sign-On to proces uwierzytelniania, który pozwala użytkownikowi na dostęp do wielu aplikacji po jednorazowym zalogowaniu.
Implementacja SSO z SAML
// Przykład implementacji SAML SSO w Express
import express from 'express';
import passport from 'passport';
import { Strategy as SAMLStrategy } from 'passport-saml';
const app = express();
passport.use(new SAMLStrategy({
path: '/login/callback',
entryPoint: 'https://sso.example.com/saml2/idp/SSOService.php',
issuer: 'moja-aplikacja',
cert: 'CERTYFIKAT_DOSTAWCY_TOŻSAMOŚCI'
}, (profile, done) => {
// Znajdź lub utwórz użytkownika w bazie danych
return done(null, {
id: profile.nameID,
email: profile.email,
name: profile.displayName
});
}));
app.get('/login',
passport.authenticate('saml', { failureRedirect: '/login/fail' }),
(req, res) => res.redirect('/')
);
app.post('/login/callback',
passport.authenticate('saml', { failureRedirect: '/login/fail' }),
(req, res) => res.redirect('/')
);Najlepsze praktyki bezpieczeństwa uwierzytelniania
Bezpieczne hasła
- Wymagaj mocnych haseł (długość, złożoność)
- Przechowuj wyłącznie zaszyfrowane hasła (używaj silnych algorytmów jak bcrypt)
- Implementuj ograniczenia liczby prób logowania
Zabezpieczenie tokenów
- Przechowuj tokeny JWT bezpiecznie (HttpOnly cookies)
- Używaj krótkiego czasu ważności tokenów
- Implementuj rotację i unieważnianie tokenów
Transport
- Zawsze używaj HTTPS do przesyłania danych uwierzytelniających
- Implementuj HSTS (HTTP Strict Transport Security)
- Zabezpiecz ciasteczka flagami Secure i SameSite
Ogólne zasady
- Regularnie przeprowadzaj audyty bezpieczeństwa
- Implementuj logowanie i monitorowanie aktywności
- Zawsze stosuj zasadę najmniejszych uprawnień (principle of least privilege)
Podsumowanie
Wybór odpowiedniej strategii uwierzytelniania zależy od wielu czynników, takich jak:
- Wymagania bezpieczeństwa aplikacji
- Docelowa grupa użytkowników
- Rodzaj aplikacji (mobilna, webowa, hybrydowa)
- Skalowalność i wydajność
Pamiętaj, że bezpieczeństwo uwierzytelniania to proces ciągły, wymagający regularnej aktualizacji i dostosowywania się do nowych zagrożeń i standardów bezpieczeństwa.
W następnych lekcjach przejdziemy do implementacji zaawansowanych mechanizmów autoryzacji i zarządzania uprawnieniami użytkowników.
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. NextAuth.js to:
2. JWT (JSON Web Token) to:
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj etapy OAuth 2.0 Authorization Code Flow:
- Klikanie w kolejności
Ułóż składnię destrukturyzacji useSession w NextAuth