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

Strategie uwierzytelniania

5 min czytania ·
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

  1. 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
  2. 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
  3. Transport

    • Zawsze używaj HTTPS do przesyłania danych uwierzytelniających
    • Implementuj HSTS (HTTP Strict Transport Security)
    • Zabezpiecz ciasteczka flagami Secure i SameSite
  4. 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. 1. NextAuth.js to:

  2. 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

  1. PytanieNextAuth.js to:
  2. PytanieJWT (JSON Web Token) to:
  3. Ułóż w kolejnościEtapy OAuth 2.0 Authorization Code Flow
  4. Kliknij w kolejnościKolejność: const → { → data:

Przydatne artykuły