Uwierzytelnianie w TypeScript: Wzorce Bezpieczeństwa Typów JWT dla Aplikacji Globalnych

W dzisiejszym połączonym świecie tworzenie bezpiecznych i niezawodnych aplikacji globalnych jest najważniejsze. Uwierzytelnianie, proces weryfikacji tożsamości użytkownika, odgrywa kluczową rolę w ochronie wrażliwych danych i zapewnieniu autoryzowanego dostępu. JSON Web Tokens (JWT) stały się popularnym wyborem do implementacji uwierzytelniania ze względu na ich prostotę i przenośność. W połączeniu z potężnym systemem typów TypeScript, uwierzytelnianie JWT może stać się jeszcze bardziej solidne i łatwe w utrzymaniu, szczególnie w przypadku dużych, międzynarodowych projektów.

Dlaczego warto używać TypeScript do uwierzytelniania JWT?

TypeScript wnosi kilka zalet do budowy systemów uwierzytelniania:

• Bezpieczeństwo typów: Statyczne typowanie TypeScript pomaga wychwycić błędy na wczesnym etapie procesu rozwoju, zmniejszając ryzyko niespodzianek w czasie wykonywania. Jest to kluczowe dla komponentów wrażliwych na bezpieczeństwo, takich jak uwierzytelnianie.
• Lepsza łatwość utrzymania kodu: Typy zapewniają jasne kontrakty i dokumentację, ułatwiając zrozumienie, modyfikowanie i refaktoryzację kodu, szczególnie w złożonych aplikacjach globalnych, w których może być zaangażowanych wielu programistów.
• Ulepszone uzupełnianie kodu i narzędzia: Środowiska IDE obsługujące TypeScript oferują lepsze uzupełnianie kodu, nawigację i narzędzia do refaktoryzacji, zwiększając produktywność programistów.
• Zmniejszony kod wypełniający: Funkcje, takie jak interfejsy i typy generyczne, mogą pomóc zmniejszyć ilość kodu wypełniającego i poprawić możliwość ponownego wykorzystania kodu.

Zrozumienie JWT

JWT to kompaktowy, bezpieczny dla adresów URL sposób reprezentowania roszczeń do przekazywania między dwiema stronami. Składa się z trzech części:

1. Nagłówek: Określa algorytm i typ tokenu.
2. Ładunek: Zawiera roszczenia, takie jak identyfikator użytkownika, role i czas wygaśnięcia.
3. Podpis: Zapewnia integralność tokenu przy użyciu klucza tajnego.

JWT są zwykle używane do uwierzytelniania, ponieważ można je łatwo zweryfikować po stronie serwera bez konieczności wykonywania zapytań do bazy danych dla każdego żądania. Jednak przechowywanie wrażliwych informacji bezpośrednio w ładunku JWT jest generalnie odradzane.

Implementacja bezpiecznego dla typów uwierzytelniania JWT w TypeScript

Przyjrzyjmy się niektórym wzorcom tworzenia bezpiecznych dla typów systemów uwierzytelniania JWT w TypeScript.

1. Definiowanie typów ładunku za pomocą interfejsów

Zacznij od zdefiniowania interfejsu, który reprezentuje strukturę ładunku JWT. Zapewnia to bezpieczeństwo typów podczas uzyskiwania dostępu do roszczeń w tokenie.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Issued At (znacznik czasu)
  exp: number; // Czas wygaśnięcia (znacznik czasu)
}

Ten interfejs definiuje oczekiwany kształt ładunku JWT. Uwzględniliśmy standardowe roszczenia JWT, takie jak `iat` (wydany o) i `exp` (czas wygaśnięcia), które są kluczowe dla zarządzania ważnością tokenu. Możesz dodać inne roszczenia istotne dla Twojej aplikacji, takie jak role użytkowników lub uprawnienia. Dobrą praktyką jest ograniczenie roszczeń tylko do niezbędnych informacji, aby zminimalizować rozmiar tokenu i poprawić bezpieczeństwo.

Przykład: Obsługa ról użytkowników na globalnej platformie e-commerce

Rozważmy platformę e-commerce obsługującą klientów na całym świecie. Różni użytkownicy mają różne role:

• Administrator: Pełny dostęp do zarządzania produktami, użytkownikami i zamówieniami.
• Sprzedawca: Może dodawać produkty i zarządzać nimi.
• Klient: Może przeglądać i kupować produkty.

Tablica `roles` w `JwtPayload` może być używana do reprezentowania tych ról. Możesz rozszerzyć właściwość `roles` do bardziej złożonej struktury, reprezentującej prawa dostępu użytkownika w sposób szczegółowy. Na przykład możesz mieć listę krajów, w których użytkownik może działać jako sprzedawca, lub tablicę sklepów, do których użytkownik ma dostęp administracyjny.

2. Tworzenie serwisu JWT z typami

Utwórz usługę, która obsługuje tworzenie i weryfikację JWT. Ta usługa powinna używać interfejsu `JwtPayload`, aby zapewnić bezpieczeństwo typów.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // Przechowuj bezpiecznie!

class JwtService {
  static sign(payload: Omit, expiresIn: string = '1h'): string {
    const now = Math.floor(Date.now() / 1000);
    const payloadWithTimestamps: JwtPayload = {
        ...payload,
        iat: now,
        exp: now + parseInt(expiresIn) * 60 * 60,
    };
    return jwt.sign(payloadWithTimestamps, JWT_SECRET);
  }

  static verify(token: string): JwtPayload | null {
    try {
      const decoded = jwt.verify(token, JWT_SECRET) as JwtPayload;
      return decoded;
    } catch (error) {
      console.error('Błąd weryfikacji JWT:', error);
      return null;
    }
  }
}

Ta usługa udostępnia dwie metody:

• `sign()`: Tworzy JWT z ładunku. Przyjmuje `Omit`, aby upewnić się, że `iat` i `exp` są generowane automatycznie. Ważne jest, aby bezpiecznie przechowywać `JWT_SECRET`, najlepiej używając zmiennych środowiskowych i rozwiązania do zarządzania sekretami.
• `verify()`: Weryfikuje JWT i zwraca zdekodowany ładunek, jeśli jest ważny, lub `null`, jeśli jest nieprawidłowy. Używamy asercji typu `as JwtPayload` po weryfikacji, która jest bezpieczna, ponieważ metoda `jwt.verify` albo zgłasza błąd (wychwytywany w bloku `catch`), albo zwraca obiekt pasujący do struktury ładunku, którą zdefiniowaliśmy.

Ważne uwagi dotyczące bezpieczeństwa:

• Zarządzanie kluczem tajnym: Nigdy nie umieszczaj na stałe klucza tajnego JWT w kodzie. Użyj zmiennych środowiskowych lub dedykowanej usługi zarządzania sekretami. Regularnie zmieniaj klucze.
• Wybór algorytmu: Wybierz silny algorytm podpisywania, taki jak HS256 lub RS256. Unikaj słabych algorytmów, takich jak `none`.
• Wygasanie tokenu: Ustaw odpowiednie czasy wygaśnięcia tokenów JWT, aby ograniczyć wpływ naruszonych tokenów.
• Przechowywanie tokenu: Bezpiecznie przechowuj tokeny JWT po stronie klienta. Opcje obejmują pliki cookie HTTP-only lub lokalny magazyn z odpowiednimi środkami ostrożności przed atakami XSS.

3. Ochrona punktów końcowych API za pomocą oprogramowania pośredniczącego

Utwórz oprogramowanie pośredniczące, aby chronić punkty końcowe API, weryfikując JWT w nagłówku `Authorization`.

import { Request, Response, NextFunction } from 'express';

interface RequestWithUser extends Request {
  user?: JwtPayload;
}

function authenticate(req: RequestWithUser, res: Response, next: NextFunction) {
  const authHeader = req.headers.authorization;

  if (!authHeader) {
    return res.status(401).json({ message: 'Brak autoryzacji' });
  }

  const token = authHeader.split(' ')[1]; // Zakładając token Bearer
  const decoded = JwtService.verify(token);

  if (!decoded) {
    return res.status(401).json({ message: 'Nieprawidłowy token' });
  }

  req.user = decoded;
  next();
}

export default authenticate;

To oprogramowanie pośredniczące wyodrębnia JWT z nagłówka `Authorization`, weryfikuje go za pomocą `JwtService` i dołącza zdekodowany ładunek do obiektu `req.user`. Definiujemy również interfejs `RequestWithUser`, aby rozszerzyć standardowy interfejs `Request` z Express.js, dodając właściwość `user` typu `JwtPayload | undefined`. Zapewnia to bezpieczeństwo typów podczas uzyskiwania dostępu do informacji o użytkowniku w chronionych trasach.

Przykład: Obsługa stref czasowych w aplikacji globalnej

Wyobraź sobie, że Twoja aplikacja umożliwia użytkownikom z różnych stref czasowych planowanie wydarzeń. Możesz chcieć przechowywać preferowaną strefę czasową użytkownika w ładunku JWT, aby poprawnie wyświetlać czasy wydarzeń. Możesz dodać roszczenie `timeZone` do interfejsu `JwtPayload`:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  timeZone: string; // np. 'America/Los_Angeles', 'Asia/Tokyo'
  iat: number;
  exp: number;
}

Następnie, w oprogramowaniu pośredniczącym lub programach obsługi tras, możesz uzyskać dostęp do `req.user.timeZone`, aby formatować daty i godziny zgodnie z preferencjami użytkownika.

4. Używanie uwierzytelnionego użytkownika w programach obsługi tras

W programach obsługi chronionych tras możesz teraz uzyskać dostęp do informacji uwierzytelnionego użytkownika za pośrednictwem obiektu `req.user`, z pełnym bezpieczeństwem typów.

import express, { Request, Response } from 'express';
import authenticate from './middleware/authenticate';

const app = express();

app.get('/profile', authenticate, (req: Request, res: Response) => {
  const user = (req as any).user; // lub użyj RequestWithUser
  res.json({ message: `Witaj, ${user.email}!`, userId: user.userId });
});

Ten przykład pokazuje, jak uzyskać dostęp do adresu e-mail i identyfikatora uwierzytelnionego użytkownika z obiektu `req.user`. Ponieważ zdefiniowaliśmy interfejs `JwtPayload`, TypeScript zna oczekiwaną strukturę obiektu `user` i może zapewnić sprawdzanie typów i uzupełnianie kodu.

5. Implementacja kontroli dostępu opartej na rolach (RBAC)

Aby uzyskać bardziej szczegółową kontrolę dostępu, możesz zaimplementować RBAC w oparciu o role przechowywane w ładunku JWT.

function authorize(roles: string[]) {
  return (req: RequestWithUser, res: Response, next: NextFunction) => {
    const user = req.user;

    if (!user || !user.roles.some(role => roles.includes(role))) {
      return res.status(403).json({ message: 'Zabronione' });
    }

    next();
  };
}

To oprogramowanie pośredniczące `authorize` sprawdza, czy role użytkownika zawierają którekolwiek z wymaganych ról. Jeśli nie, zwraca błąd 403 Forbidden.

app.get('/admin', authenticate, authorize(['admin']), (req: Request, res: Response) => {
  res.json({ message: 'Witaj, administratorze!' });
});

Ten przykład chroni trasę `/admin`, wymagając od użytkownika roli `administratora`.

Przykład: Obsługa różnych walut w aplikacji globalnej

Jeśli Twoja aplikacja obsługuje transakcje finansowe, możesz potrzebować obsługi wielu walut. Możesz przechowywać preferowaną walutę użytkownika w ładunku JWT:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  currency: string; // np. 'USD', 'EUR', 'JPY'
  iat: number;
  exp: number;
}

Następnie, w logice backendu, możesz użyć `req.user.currency` do formatowania cen i wykonywania konwersji walut w razie potrzeby.

6. Odświeżanie tokenów

JWT są z założenia krótkotrwałe. Aby uniknąć częstego logowania się użytkowników, zaimplementuj tokeny odświeżania. Token odświeżania to długotrwały token, który można wykorzystać do uzyskania nowego tokenu dostępu (JWT) bez konieczności ponownego wprowadzania danych uwierzytelniających. Bezpiecznie przechowuj tokeny odświeżania w bazie danych i powiąż je z użytkownikiem. Gdy token dostępu użytkownika wygaśnie, może on użyć tokenu odświeżania, aby zażądać nowego. Proces ten należy wdrożyć ostrożnie, aby uniknąć luk w zabezpieczeniach.

Zaawansowane techniki bezpieczeństwa typów

1. Unie rozłączne do precyzyjnej kontroli

Czasami możesz potrzebować różnych ładunków JWT w zależności od roli użytkownika lub typu żądania. Unie rozłączne mogą pomóc w osiągnięciu tego celu z zachowaniem bezpieczeństwa typów.

interface AdminJwtPayload {
  type: 'admin';
  userId: string;
  email: string;
  roles: string[];
  iat: number;
  exp: number;
}

interface UserJwtPayload {
  type: 'user';
  userId: string;
  email: string;
  iat: number;
  exp: number;
}

type JwtPayload = AdminJwtPayload | UserJwtPayload;

function processToken(payload: JwtPayload) {
  if (payload.type === 'admin') {
    console.log('Email administratora:', payload.email); // Bezpieczny dostęp do adresu e-mail
  } else {
    // payload.email nie jest tutaj dostępny, ponieważ typ to 'user'
    console.log('ID użytkownika:', payload.userId);
  }
}

Ten przykład definiuje dwa różne typy ładunku JWT, `AdminJwtPayload` i `UserJwtPayload`, i łączy je w unię rozłączną `JwtPayload`. Właściwość `type` działa jako dyskryminator, umożliwiając bezpieczny dostęp do właściwości na podstawie typu ładunku.

2. Typy generyczne dla logiki uwierzytelniania wielokrotnego użytku

Jeśli masz wiele schematów uwierzytelniania z różnymi strukturami ładunku, możesz użyć typów generycznych, aby utworzyć logikę uwierzytelniania wielokrotnego użytku.

interface BaseJwtPayload {
  userId: string;
  iat: number;
  exp: number;
}

function verifyToken(token: string): T | null {
  try {
    const decoded = jwt.verify(token, JWT_SECRET) as T;
    return decoded;
  } catch (error) {
    console.error('Błąd weryfikacji JWT:', error);
    return null;
  }
}

const adminToken = verifyToken('admin-token');
if (adminToken) {
  console.log('Email administratora:', adminToken.email);
}

Ten przykład definiuje funkcję `verifyToken`, która przyjmuje typ generyczny `T` rozszerzający `BaseJwtPayload`. Umożliwia to weryfikację tokenów o różnych strukturach ładunku, zapewniając jednocześnie, że wszystkie mają co najmniej właściwości `userId`, `iat` i `exp`.

Uwagi dotyczące aplikacji globalnych

Budując systemy uwierzytelniania dla aplikacji globalnych, weź pod uwagę następujące kwestie:

• Lokalizacja: Upewnij się, że komunikaty o błędach i elementy interfejsu użytkownika są zlokalizowane dla różnych języków i regionów.
• Strefy czasowe: Prawidłowo obsługuj strefy czasowe podczas ustawiania czasów wygaśnięcia tokenów oraz wyświetlania dat i godzin użytkownikom.
• Prywatność danych: Przestrzegaj przepisów dotyczących prywatności danych, takich jak RODO i CCPA. Zminimalizuj ilość danych osobowych przechowywanych w JWT.
• Dostępność: Zaprojektuj przepływy uwierzytelniania tak, aby były dostępne dla użytkowników niepełnosprawnych.
• Wrażliwość kulturowa: Pamiętaj o różnicach kulturowych podczas projektowania interfejsów użytkownika i przepływów uwierzytelniania.

Wnioski

Wykorzystując system typów TypeScript, możesz budować solidne i łatwe w utrzymaniu systemy uwierzytelniania JWT dla aplikacji globalnych. Definiowanie typów ładunku za pomocą interfejsów, tworzenie serwisów JWT z typami, ochrona punktów końcowych API za pomocą oprogramowania pośredniczącego i implementacja RBAC to podstawowe kroki w zapewnieniu bezpieczeństwa i bezpieczeństwa typów. Biorąc pod uwagę kwestie dotyczące aplikacji globalnych, takie jak lokalizacja, strefy czasowe, prywatność danych, dostępność i wrażliwość kulturowa, możesz tworzyć doświadczenia uwierzytelniające, które są inkluzywne i przyjazne dla użytkowników zróżnicowanej międzynarodowej publiczności. Pamiętaj, aby zawsze priorytetowo traktować najlepsze praktyki w zakresie bezpieczeństwa podczas obsługi JWT, w tym bezpieczne zarządzanie kluczami, wybór algorytmu, wygasanie tokenu i przechowywanie tokenu. Wykorzystaj moc TypeScript do budowania bezpiecznych, skalowalnych i niezawodnych systemów uwierzytelniania dla Twoich globalnych aplikacji.