TypeScript удостоверяване: Модели за типова безопасност на JWT за глобални приложения

В днешния взаимосвързан свят, изграждането на сигурни и надеждни глобални приложения е от първостепенно значение. Удостоверяването, процесът на проверка на самоличността на потребителя, играе решаваща роля в защитата на чувствителни данни и осигуряването на оторизиран достъп. JSON уеб токените (JWT) се превърнаха в популярен избор за внедряване на удостоверяване поради тяхната простота и преносимост. Когато се комбинира с мощната типова система на TypeScript, JWT удостоверяването може да стане още по-надеждно и поддържано, особено за мащабни, международни проекти.

Защо да използвате TypeScript за JWT удостоверяване?

TypeScript носи няколко предимства на масата при изграждането на системи за удостоверяване:

• Типова безопасност: Статичното типизиране на TypeScript помага за откриване на грешки в ранен етап на процеса на разработка, намалявайки риска от изненади по време на изпълнение. Това е от решаващо значение за чувствителни към сигурността компоненти като удостоверяването.
• Подобрена поддръжка на кода: Типовете предоставят ясни договори и документация, което улеснява разбирането, модифицирането и преработването на кода, особено в сложни глобални приложения, където може да участват няколко разработчици.
• Подобрено довършване на кода и инструменти: IDE-тата, които поддържат TypeScript, предлагат по-добро довършване на кода, навигация и инструменти за преработване, което повишава производителността на разработчиците.
• Намален boilerplate: Функции като интерфейси и generics могат да помогнат за намаляване на boilerplate кода и подобряване на повторната употреба на кода.

Разбиране на JWT

JWT е компактно, URL-безопасно средство за представяне на декларации, които трябва да бъдат прехвърлени между две страни. Състои се от три части:

1. Заглавие: Определя алгоритъма и типа на токена.
2. Payload: Съдържа декларации, като например потребителско ID, роли и време на изтичане.
3. Подпис: Гарантира целостта на токена, използвайки секретен ключ.

JWT обикновено се използват за удостоверяване, защото могат лесно да бъдат проверени от страна на сървъра, без да е необходимо да се извършва заявка към база данни за всяка заявка. Въпреки това, съхраняването на чувствителна информация директно в JWT payload обикновено не се препоръчва.

Внедряване на типово безопасно JWT удостоверяване в TypeScript

Нека разгледаме някои модели за изграждане на типово безопасни JWT системи за удостоверяване в TypeScript.

1. Дефиниране на типове Payload с интерфейси

Започнете с дефиниране на интерфейс, който представя структурата на вашия JWT payload. Това гарантира, че имате типова безопасност при достъп до декларациите в токена.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Issued At (timestamp)
  exp: number; // Expiration Time (timestamp)
}

Този интерфейс определя очакваната форма на JWT payload. Включили сме стандартни JWT декларации като `iat` (издаден в) и `exp` (време на изтичане), които са от решаващо значение за управление на валидността на токена. Можете да добавите всякакви други декларации, които са от значение за вашето приложение, като потребителски роли или разрешения. Добра практика е да ограничите декларациите само до необходимата информация, за да минимизирате размера на токена и да подобрите сигурността.

Пример: Обработка на потребителски роли в глобална платформа за електронна търговия

Помислете за платформа за електронна търговия, обслужваща клиенти по целия свят. Различните потребители имат различни роли:

• Администратор: Пълен достъп за управление на продукти, потребители и поръчки.
• Продавач: Може да добавя и управлява свои собствени продукти.
• Клиент: Може да разглежда и купува продукти.

Масивът `roles` в `JwtPayload` може да се използва за представяне на тези роли. Можете да разширите свойството `roles` до по-сложна структура, представяща правата за достъп на потребителя по гранулиран начин. Например, можете да имате списък с държави, в които на потребителя е позволено да оперира като продавач, или масив от магазини, до които потребителят има администраторски достъп.

2. Създаване на типизиран JWT сервиз

Създайте сервиз, който обработва създаването и проверката на JWT. Този сервиз трябва да използва интерфейса `JwtPayload`, за да осигури типова безопасност.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // Store securely!

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('JWT verification error:', error);
      return null;
    }
  }
}

Този сервиз предоставя два метода:

• `sign()`: Създава JWT от payload. Той приема `Omit`, за да се гарантира, че `iat` и `exp` се генерират автоматично. Важно е да съхранявате `JWT_SECRET` сигурно, в идеалния случай използвайки променливи на средата и решение за управление на тайни.
• `verify()`: Проверява JWT и връща декодирания payload, ако е валиден, или `null`, ако е невалиден. Използваме type assertion `as JwtPayload` след проверката, което е безопасно, защото методът `jwt.verify` или хвърля грешка (заловена в блока `catch`), или връща обект, съответстващ на структурата на payload, която сме дефинирали.

Важни съображения за сигурност:

• Управление на секретни ключове: Никога не кодирайте твърдо вашия JWT секретен ключ в кода си. Използвайте променливи на средата или специализирана услуга за управление на тайни. Редовно сменяйте ключовете.
• Избор на алгоритъм: Изберете силен алгоритъм за подписване, като HS256 или RS256. Избягвайте слаби алгоритми като `none`.
• Срок на валидност на токена: Задайте подходящи срокове на валидност за вашите JWT, за да ограничите въздействието на компрометирани токени.
• Съхранение на токени: Съхранявайте JWT сигурно от страна на клиента. Опциите включват HTTP-only cookies или локално хранилище с подходящи предпазни мерки срещу XSS атаки.

3. Защита на API endpoints с middleware

Създайте middleware, за да защитите вашите API endpoints, като проверите JWT в заглавката `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: 'Unauthorized' });
  }

  const token = authHeader.split(' ')[1]; // Assuming Bearer token
  const decoded = JwtService.verify(token);

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

  req.user = decoded;
  next();
}

export default authenticate;

Този middleware извлича JWT от заглавката `Authorization`, проверява го с помощта на `JwtService` и прикачва декодирания payload към обекта `req.user`. Също така дефинираме интерфейс `RequestWithUser`, за да разширим стандартния интерфейс `Request` от Express.js, добавяйки свойство `user` от тип `JwtPayload | undefined`. Това осигурява типова безопасност при достъп до потребителската информация в защитени маршрути.

Пример: Обработка на часови зони в глобално приложениеПредставете си, че вашето приложение позволява на потребители от различни часови зони да планират събития. Може да искате да съхранявате предпочитаната часова зона на потребителя в JWT payload, за да показвате правилно часовете на събитията. Можете да добавите декларация `timeZone` към интерфейса `JwtPayload`:

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

След това, във вашите middleware или route handlers, можете да получите достъп до `req.user.timeZone`, за да форматирате датите и часовете според предпочитанията на потребителя.

4. Използване на удостоверените потребители в Route Handlers

Във вашите защитени route handlers вече можете да получите достъп до информацията на удостоверените потребители чрез обекта `req.user`, с пълна типова безопасност.

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; // or use RequestWithUser
  res.json({ message: `Hello, ${user.email}!`, userId: user.userId });
});

Този пример показва как да получите достъп до имейла и ID на удостоверените потребители от обекта `req.user`. Тъй като дефинирахме интерфейса `JwtPayload`, TypeScript знае очакваната структура на обекта `user` и може да предостави проверка на типовете и довършване на кода.

5. Внедряване на Role-Based Access Control (RBAC)

За по-прецизен контрол на достъпа можете да внедрите RBAC въз основа на ролите, съхранени в JWT payload.

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: 'Forbidden' });
    }

    next();
  };
}

Този middleware `authorize` проверява дали ролите на потребителя включват някоя от необходимите роли. Ако не, той връща грешка 403 Forbidden.

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

Този пример защитава маршрута `/admin`, изисквайки потребителят да има ролята `admin`.

Пример: Обработка на различни валути в глобално приложение

Ако вашето приложение обработва финансови транзакции, може да се наложи да поддържате множество валути. Можете да съхранявате предпочитаната валута на потребителя в JWT payload:

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

След това, във вашата back-end логика, можете да използвате `req.user.currency`, за да форматирате цените и да извършвате валутни конверсии според нуждите.

6. Refresh Tokens

JWT са краткотрайни по дизайн. За да избегнете честото изискване от потребителите да влизат, внедрете refresh tokens. Refresh token е дълготраен токен, който може да се използва за получаване на нов access token (JWT), без да се изисква потребителят да въвежда повторно своите идентификационни данни. Съхранявайте refresh tokens сигурно в база данни и ги свързвайте с потребителя. Когато access token на потребителя изтече, той може да използва refresh token, за да поиска нов. Този процес трябва да бъде внедрен внимателно, за да се избегнат уязвимости в сигурността.

Разширени техники за типова безопасност

1. Discriminated Unions за прецизен контрол

Понякога може да се нуждаете от различни JWT payloads в зависимост от ролята на потребителя или типа на заявката. Discriminated unions могат да ви помогнат да постигнете това с типова безопасност.

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('Admin email:', payload.email); // Safe to access email
  } else {
    // payload.email is not accessible here because type is 'user'
    console.log('User ID:', payload.userId);
  }
}

Този пример дефинира два различни типа JWT payload, `AdminJwtPayload` и `UserJwtPayload`, и ги комбинира в discriminated union `JwtPayload`. Свойството `type` действа като дискриминатор, което ви позволява безопасно да получавате достъп до свойства въз основа на типа на payload.

2. Generics за многократно използваема логика за удостоверяване

Ако имате множество схеми за удостоверяване с различни структури на payload, можете да използвате generics, за да създадете многократно използваема логика за удостоверяване.

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('JWT verification error:', error);
    return null;
  }
}

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

Този пример дефинира функция `verifyToken`, която приема generic тип `T`, разширяващ `BaseJwtPayload`. Това ви позволява да проверявате токени с различни структури на payload, като същевременно гарантирате, че всички те имат поне свойствата `userId`, `iat` и `exp`.

Съображения за глобални приложения

Когато изграждате системи за удостоверяване за глобални приложения, обмислете следното:

• Локализация: Уверете се, че съобщенията за грешки и елементите на потребителския интерфейс са локализирани за различни езици и региони.
• Часови зони: Обработвайте правилно часовите зони при задаване на срокове на валидност на токените и показване на дати и часове на потребителите.
• Поверителност на данните: Спазвайте разпоредбите за поверителност на данните като GDPR и CCPA. Минимизирайте количеството лични данни, съхранявани в JWT.
• Достъпност: Проектирайте вашите потоци за удостоверяване, така че да бъдат достъпни за потребители с увреждания.
• Културна чувствителност: Имайте предвид културните различия при проектирането на потребителски интерфейси и потоци за удостоверяване.

Заключение

Като използвате типовата система на TypeScript, можете да изградите надеждни и поддържани JWT системи за удостоверяване за глобални приложения. Дефинирането на типове payload с интерфейси, създаването на типизирани JWT сервизи, защитата на API endpoints с middleware и внедряването на RBAC са основни стъпки за осигуряване на сигурност и типова безопасност. Като вземете предвид съображенията за глобални приложения, като локализация, часови зони, поверителност на данните, достъпност и културна чувствителност, можете да създадете изживявания за удостоверяване, които са приобщаващи и удобни за потребителите за разнообразна международна аудитория. Не забравяйте винаги да давате приоритет на най-добрите практики за сигурност при обработката на JWT, включително сигурно управление на ключове, избор на алгоритъм, срок на валидност на токена и съхранение на токени. Прегърнете силата на TypeScript, за да изградите сигурни, мащабируеми и надеждни системи за удостоверяване за вашите глобални приложения.