Kurs NestJS · Moduł 4: Uwierzytelnianie

Session Management i Cookie Auth - alternatywne drogi do fortu

5 min czytania ·
W tej lekcji5

Przepustki JWT mają jedną wadę, o której dotąd milczeliśmy. Legionista okazał się zdrajcą i chcesz go natychmiast wyrzucić z obozu - ale jego przepustka jest ważna jeszcze przez dwadzieścia godzin. Serwer nie ma jak jej unieważnić, bo nigdzie jej nie zapisał. Wszystko, co wie o dokumencie, jest w samym dokumencie.

Istnieje starsza droga do fortu: lista gości przy bramie. Wartownik nie czyta przepustek - zagląda do księgi i sprawdza, czy przybysz jest na liście. Skreślenie z niej działa natychmiast. Tę drogę nazywamy uwierzytelnieniem sesyjnym.

Bezstanowe kontra stanowe

Różnica między tymi dwiema drogami sprowadza się do jednego pytania: czy serwer coś pamięta?

JWT jest bezstanowe (stateless). Cała wiedza o legioniście podróżuje w tokenie, serwer nie przechowuje niczego. Zaletą jest skalowanie - postawisz dziesięć serwerów i każdy odczyta ten sam token, bo do weryfikacji wystarczy mu tajny klucz. Wadą jest właśnie ten zdrajca: nie ma czego skreślić.

Sesja jest stanowa (stateful). Po zalogowaniu serwer zapisuje u siebie wpis - kim jest ten człowiek - i odsyła klientowi jedynie identyfikator sesji w ciasteczku. Ciasteczko samo w sobie nic nie znaczy, to numerek do szatni. Przy każdym żądaniu serwer po tym numerku odnajduje wpis. Wylogowanie to skasowanie wpisu - i przybysz przestaje istnieć natychmiast.

Trzymaj tę parę pojęć razem z ich konsekwencją, bo o to właśnie pytają: stateless = nic do unieważnienia, ale łatwe skalowanie; stateful = natychmiastowe unieważnienie, ale serwer musi pamiętać.

Konfiguracja - cztery kroki

Sesje wprowadzamy w ustalonej kolejności. Zaczynamy od pakietów:

npm install express-session
npm install -D @types/express-session

Drugi pakiet zawiera same typy dla TypeScriptu - stąd flaga -D, bo do działania aplikacji na produkcji nie jest potrzebny.

Krok drugi to podpięcie middleware. Robimy to w main.ts, bo sesje muszą być gotowe, zanim jakiekolwiek żądanie dotrze do kontrolerów:

app.use(
  session({
    secret: process.env.SESSION_SECRET,
    resave: false,
    saveUninitialized: false,
    cookie: {
      httpOnly: true,
      secure: true,
      maxAge: 3600000,
    },
  }),
);

Przejdźmy przez te opcje, bo dwie z nich decydują o bezpieczeństwie całego rozwiązania. secret podpisuje ciasteczko, żeby nikt nie podmienił numerka na cudzy - czytamy go ze zmiennej środowiskowej, tak samo jak klucz JWT.

httpOnly: true to najważniejsza linia w tym bloku. Sprawia, że ciasteczka nie da się odczytać z JavaScriptu w przeglądarce. Gdyby ktoś wstrzyknął na Twoją stronę obcy skrypt, bez tej flagi wykradłby identyfikator sesji jednym document.cookie. secure: true dokłada drugi warunek: ciasteczko podróżuje wyłącznie po HTTPS, więc nie da się go podsłuchać po drodze.

maxAge to czas życia w milisekundach - tutaj godzina. resave: false i saveUninitialized: false ograniczają zbędne zapisy: nie odświeżaj wpisu, gdy nic się nie zmieniło, i nie twórz sesji dla gościa, który jeszcze niczego nie zrobił.

Krok trzeci to sięgnięcie po sesję w kontrolerze:

@Post('login')
login(@Body() dto: LoginDto, @Session() session: Record<string, any>) {
  const user = this.authService.validate(dto);
  session.userId = user.id;
  return { message: 'Zalogowano' };
}

@Get('profile')
getProfile(@Session() session: Record<string, any>) {
  if (!session.userId) {
    throw new UnauthorizedException();
  }
  return this.usersService.findOne(session.userId);
}

Dekorator @Session() wstrzykuje obiekt sesji - zwykły obiekt, do którego wpisujesz, co chcesz zapamiętać. Zauważ, czego tu nie ma: nie zwracamy żadnego tokenu. Klient dostaje ciasteczko automatycznie, w nagłówku odpowiedzi, i równie automatycznie odsyła je przy każdym kolejnym żądaniu. Stąd wrażenie, że "po prostu działa" - i stąd też pułapka, bo działa też wtedy, gdy żądanie wysyła cudza strona. To zagrożenie nazywa się CSRF i wymaga osobnego zabezpieczenia, którego JWT w nagłówku nie potrzebuje.

Krok czwarty: gdzie mieszkają sesje

Domyślnie express-session trzyma wpisy w pamięci procesu Node. To wystarcza na Twoim laptopie i zawodzi na produkcji z dwóch powodów: restart aplikacji wylogowuje wszystkich, a przy dwóch serwerach użytkownik zalogowany na pierwszym jest nieznany drugiemu.

Dlatego na produkcji wskazujemy zewnętrzny magazyn:

app.use(
  session({
    store: new RedisStore({ client: redisClient }),
    secret: process.env.SESSION_SECRET,
    resave: false,
    saveUninitialized: false,
  }),
);

Redis nadaje się tu najlepiej, bo trzyma dane w pamięci i sam usuwa wpisy po wygaśnięciu. Wszystkie serwery pytają ten sam magazyn, więc numerek z szatni działa niezależnie od tego, który wartownik go obejrzy. I to jest ta cena stanowości, o której mówiliśmy: pamiętanie kosztuje infrastrukturę.

Co wybrać

Reguła praktyczna jest krótka. JWT przy API dla aplikacji mobilnych, mikroserwisów i wszędzie tam, gdzie klientem nie jest przeglądarka - podróżuje w nagłówku, nie wymaga wspólnego magazynu. Sesje przy klasycznych aplikacjach webowych renderowanych po stronie serwera, zwłaszcza gdy potrzebujesz natychmiast kogoś wylogować albo widzieć listę aktywnych sesji.

Nie ma tu lepszego i gorszego rozwiązania - jest wybór między łatwym skalowaniem a natychmiastową kontrolą. I to polecam jako pytanie, od którego zaczynasz: czy muszę móc unieważnić dostęp w sekundę?

Podsumowanie

Fort ma dwie bramy i wiesz, którą kiedy otworzyć:

  • JWT jest bezstanowe: serwer nic nie pamięta, łatwo skaluje, ale nie ma czego unieważnić przed wygaśnięciem tokenu,
  • sesja jest stanowa: serwer trzyma wpis, klient dostaje w ciasteczku sam identyfikator - numerek do szatni,
  • konfiguracja to cztery kroki: instalacja pakietów, middleware w main.ts, @Session() w kontrolerze, wybór magazynu,
  • httpOnly: true odcina ciasteczko od JavaScriptu, secure: true wymusza HTTPS - obie flagi są obowiązkowe,
  • ciasteczko wędruje automatycznie, więc sesje wymagają osobnej ochrony przed CSRF,
  • domyślny magazyn w pamięci nie nadaje się na produkcję: restart wylogowuje wszystkich, a drugi serwer nie zna sesji pierwszego,
  • Redis rozwiązuje oba problemy, bo wszystkie serwery pytają ten sam magazyn.

W następnej lekcji zmierzysz się z projektem: zbudujesz kompletny system uwierzytelniania dla legionu. A na razie zapamiętaj: JWT to przepustka, którą nosi się przy sobie, a sesja to numerek do szatni - dokument mówi sam za siebie, numerek działa tylko tak długo, jak długo wartownik trzyma wpis w księdze.

Kod do tej lekcji: src/auth/session-auth.ts
// Session Management i Cookie Auth w NestJS
import { Controller, Post, Get, Body, Session, HttpCode } from '@nestjs/common';
import { Injectable, CanActivate, ExecutionContext, UnauthorizedException } from '@nestjs/common';

// ============================================
// 1. Session Auth Controller
// ============================================
@Controller('auth')
class SessionAuthController {
  @Post('login')
  @HttpCode(200)
  async login(
    @Body() body: { username: string; password: string },
    @Session() session: Record<string, any>,
  ) {
    // TODO: Waliduj uzytkownika
    // TODO: Zapisz userId, username, role w session
    session.userId = 1;
    session.username = body.username;
    session.role = 'MILES';

    return { message: 'Zalogowano do fortu!' };
  }

  @Get('profile')
  async getProfile(@Session() session: Record<string, any>) {
    // TODO: Sprawdz czy session.userId istnieje
    // TODO: Jesli nie - rzuc UnauthorizedException
    if (!session.userId) {
      throw new UnauthorizedException('Brak aktywnej sesji!');
    }

    return {
      userId: session.userId,
      username: session.username,
      role: session.role,
    };
  }

  @Post('logout')
  @HttpCode(200)
  async logout(@Session() session: Record<string, any>) {
    // TODO: Zniszcz sesje
    const username = session.username;
    session.destroy(() => {});
    return { message: 'Wylogowano: ' + username };
  }
}

// ============================================
// 2. Session Guard
// ============================================
@Injectable()
class SessionGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const session = request.session;

    // TODO: Sprawdz czy sesja zawiera userId
    if (!session || !session.userId) {
      throw new UnauthorizedException('Sesja wygasla!');
    }

    request.user = {
      id: session.userId,
      username: session.username,
      role: session.role,
    };

    return true;
  }
}

// ============================================
// 3. Porownanie JWT vs Session
// ============================================
console.log('=== Session vs JWT ===');
console.log('Session: stan na serwerze, maly cookie z Session ID');
console.log('JWT: stateless, token zawiera dane uzytkownika');
console.log('');
console.log('Session: latwe uniewaznanie (usun z bazy)');
console.log('JWT: trudne uniewaznanie (token wazny do wygasniecia)');
console.log('');
console.log('Session: wymaga shared store (Redis) przy skalowaniu');
console.log('JWT: latwe skalowanie - kazdy serwer weryfikuje token');

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. Jaka jest główna różnica między session-based a JWT authentication?

Zadania praktyczne w grze

  • Układanie w pionie

    Uszereguj kroki konfiguracji session-based auth w NestJS:

  1. PytanieSession-based vs JWT authentication
  2. Ułóż w kolejnościKonfiguracja express-session w NestJS

Przydatne artykuły