TypeScript autentimine: JWT tüübikindluse mustrid globaalsetele rakendustele

Tänapäeva omavahel ühendatud maailmas on turvaliste ja usaldusväärsete globaalsete rakenduste loomine esmatähtis. Autentimine, kasutaja identiteedi kontrollimise protsess, mängib kriitilist rolli tundlike andmete kaitsmisel ja volitatud juurdepääsu tagamisel. JSON veebimärgid (JWT-d) on muutunud populaarseks valikuks autentimise juurutamisel tänu nende lihtsusele ja teisaldatavusele. Koos TypeScripti võimsa tüübisüsteemiga saab JWT autentimise muuta veelgi tugevamaks ja hooldatavamaks, eriti suuremahuliste rahvusvaheliste projektide puhul.

Miks kasutada TypeScripti JWT autentimiseks?

TypeScript pakub autentimissüsteemide loomisel mitmeid eeliseid:

• Tüübi ohutus: TypeScripti staatiline tüüpimine aitab vigu varakult arendusprotsessis tuvastada, vähendades käitusaja üllatuste riski. See on oluline turvatundlike komponentide, näiteks autentimise puhul.
• Parem koodi hooldatavus: Tüübid pakuvad selgeid lepinguid ja dokumentatsiooni, muutes koodi lihtsamaks mõistmiseks, muutmiseks ja refaktoreerimiseks, eriti keerulistes globaalsetes rakendustes, kus võib olla seotud mitu arendajat.
• Täiustatud koodi automaatne täitmine ja tööriistad: TypeScripti teadvustavad IDE-d pakuvad paremat koodi automaatset täitmist, navigeerimist ja refaktoriseerimistööriistu, suurendades arendajate tootlikkust.
• Vähendatud korduvkood (Boilerplate): Funktsioonid nagu liidesed ja geneerikud aitavad vähendada korduvkoodi ja parandada koodi taaskasutatavust.

JWT-de mõistmine

JWT on kompaktne, URL-turvaline vahend kahe osapoole vahel edastatavate väidete esitamiseks. See koosneb kolmest osast:

1. Päis: Määrab algoritmi ja märgi tüübi.
2. Sisu (Payload): Sisaldab väiteid, näiteks kasutaja ID-d, rolle ja aegumisaega.
3. Allkiri: Tagab märgi terviklikkuse salajase võtme abil.

JWT-sid kasutatakse tavaliselt autentimiseks, kuna neid saab hõlpsasti serveripoolel kontrollida, ilma et oleks vaja iga päringu jaoks andmebaasi päringut teha. Tundliku teabe otse JWT sisusse salvestamist üldiselt ei soovitata.

Tüübikindla JWT autentimise juurutamine TypeScriptis

Uurime mõningaid mustreid tüübikindlate JWT autentimissüsteemide loomiseks TypeScriptis.

1. Sisu tüüpide määratlemine liideste abil

Alustage liidese määratlemisest, mis esindab teie JWT sisu struktuuri. See tagab, et teil on märgis olevatele väidetele juurdepääsul tüübikindlus.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Välja antud (ajatemperatuur)
  exp: number; // Aegumisaeg (ajatemperatuur)
}

See liides määratleb JWT sisu oodatava kuju. Oleme lisanud standardsed JWT väited nagu `iat` (välja antud) ja `exp` (aegumisaeg), mis on märgi kehtivuse haldamisel üliolulised. Saate lisada muid teie rakenduse jaoks asjakohaseid väiteid, näiteks kasutajarollid või õigused. Hea tava on piirata väiteid ainult vajaliku teabega, et minimeerida märgi suurust ja parandada turvalisust.

Näide: Kasutajarollide haldamine globaalses e-kaubanduse platvormil

Mõelge e-kaubanduse platvormile, mis teenindab kliente kogu maailmas. Erinevatel kasutajatel on erinevad rollid:

• Administraator: Täielik juurdepääs toodete, kasutajate ja tellimuste haldamiseks.
• Müüja: Saab lisada ja hallata oma tooteid.
• Klient: Saab tooteid sirvida ja osta.

Massiivi `roles` `JwtPayload`-is saab kasutada nende rollide esindamiseks. Saate laiendada `roles` omadust keerukamaks struktuuriks, esindades kasutaja juurdepääsuõigusi detailselt. Näiteks võite luua riikide loendi, kus kasutaja on müüjana tegutsema lubatud, või poodide massiivi, millele kasutajal on administraatori juurdepääs.

2. Tüübitud JWT teenuse loomine

Looge teenus, mis tegeleb JWT loomise ja kontrollimisega. See teenus peaks tüübikindluse tagamiseks kasutama `JwtPayload` liidest.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // Hoidke turvaliselt!

class JwtService {
  static sign(payload: Omit<JwtPayload, 'iat' | 'exp'>, 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;
    }
  }
}

See teenus pakub kahte meetodit:

• `sign()`: Loob JWT sisust. See võtab `Omit<JwtPayload, 'iat' | 'exp'>` tagamaks, et `iat` ja `exp` genereeritakse automaatselt. Oluline on `JWT_SECRET` turvaliselt salvestada, ideaalis kasutades keskkonnamuutujat ja salajaste andmete haldamise lahendust.
• `verify()`: Kontrollib JWT-d ja tagastab dekodeeritud sisu, kui see on kehtiv, või `null`, kui see on kehtetu. Kasutame pärast kontrollimist tüübikinnitust `as JwtPayload`, mis on ohutu, kuna `jwt.verify` meetod kas viskab vea (püütakse `catch` blokis) või tagastab objekti, mis vastab meie määratletud sisu struktuurile.

Olulised turvakaalutlused:

• Salajase võtme haldamine: Ärge kunagi kodeerige oma JWT salajast võtit otse koodi. Kasutage keskkonnamuutujat või spetsiaalset salajaste andmete haldamise teenust. Vahetage võtmeid regulaarselt.
• Algoritmi valik: Valige tugev allkirjaalgoritm, näiteks HS256 või RS256. Vältige nõrku algoritme, näiteks `none`.
• Märgi aegumine: Määrake oma JWT-dele sobivad aegumisajad, et piirata kompromiteeritud märkide mõju.
• Märgi salvestamine: Salvestage JWT-d turvaliselt kliendipoolsesse. Valikud hõlmavad HTTP-ainult küpsiseid või kohalikku salvestusruumi koos asjakohaste ettevaatusabinõudega XSS-rünnakute vastu.

3. API lõpp-punktide kaitsmine vahevaraga

Looge vahevara, et kaitsta oma API lõpp-punkte, kontrollides JWT-d `Authorization` päises.

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

  const token = authHeader.split(' ')[1]; // Eeldades Bearer märki
  const decoded = JwtService.verify(token);

  if (!decoded) {
    return res.status(401).json({ message: 'Kehtetu märk' });
  }

  req.user = decoded;
  next();
}

export default authenticate;

See vahevara eraldab JWT `Authorization` päisest, kontrollib seda `JwtService` abil ja lisab dekodeeritud sisu `req.user` objektile. Määratleme ka `RequestWithUser` liidese, et laiendada Express.js-i standardset `Request` liidest, lisades `user` omaduse tüübist `JwtPayload | undefined`. See pakub tüübikindlust, kui pääsete juurde kasutaja teabele kaitstud marsruutidel.

Näide: Ajavööndite haldamine globaalses rakenduses

Kujutage ette, et teie rakendus lubab erinevate ajavööndite kasutajatel sündmusi planeerida. Võimalik, et soovite salvestada kasutaja eelistatud ajavööndi JWT sisusse, et sündmuste ajad õigesti kuvada. Saate lisada `timeZone` väite `JwtPayload` liidesesse:

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

Seejärel saate oma vahevaras või marsruutide käitlejates juurdepääsu `req.user.timeZone`-ile, et vormindada kuupäevi ja aegu vastavalt kasutaja eelistustele.

4. Autenditud kasutaja kasutamine marsruutide käitlejates

Oma kaitstud marsruutide käitlejates saate nüüd juurdepääsu autenditud kasutaja teabele `req.user` objekti kaudu, täieliku tüübikindlusega.

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; // või kasutada RequestWithUser
  res.json({ message: `Tere, ${user.email}!`, userId: user.userId });
});

See näide demonstreerib, kuidas pääseda juurde autenditud kasutaja e-posti aadressile ja ID-le `req.user` objektist. Kuna me määratlesime `JwtPayload` liidese, teab TypeScript `user` objekti oodatavat struktuuri ja saab pakkuda tüübikontrolli ja koodi automaatset täitmist.

5. Rollipõhise juurdepääsu kontrolli (RBAC) juurutamine

Täpsemaks juurdepääsukontrolliks saate juurutada RBAC-i, tuginedes JWT sisus salvestatud rollidele.

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

    next();
  };
}

See `authorize` vahevara kontrollib, kas kasutaja rollid sisaldavad mõnda nõutavat rolli. Kui mitte, tagastab see vea 403 Forbidden.

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

See näide kaitseb `/admin` marsruuti, nõudes, et kasutajal oleks `admin` roll.

Näide: Erinevate valuutade haldamine globaalses rakenduses

Kui teie rakendus tegeleb finantstehingutega, peate võib-olla toetama mitut valuutat. Saate salvestada kasutaja eelistatud valuuta JWT sisusse:

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

Seejärel saate oma taustaprogrammi loogikas kasutada `req.user.currency`-t hindade vormindamiseks ja valuutakonversioonide teostamiseks vastavalt vajadusele.

6. Värskendusmärgid (Refresh Tokens)

JWT-d on oma olemuselt lühiajalised. Et vältida kasutajatelt sagedast sisselogimist, juurutage värskendusmärgid. Värskendusmärk on pikaajaline märk, mida saab kasutada uue juurdepääsumärgi (JWT) hankimiseks, ilma et kasutaja peaks oma mandaate uuesti sisestama. Salvestage värskendusmärgid turvaliselt andmebaasi ja seostage need kasutajaga. Kui kasutaja juurdepääsumärk aegub, saab ta uue märgi taotlemiseks kasutada värskendusmärki. See protsess tuleb turvaaukude vältimiseks hoolikalt juurutada.

Täiustatud tüübikindluse tehnikad

1. Diskrimineeritud ühendused peeneteralise kontrolli jaoks

Mõnikord võite vajada erinevaid JWT sisu sõltuvalt kasutaja rollist või päringu tüübist. Diskrimineeritud ühendused aitavad teil seda tüübikindlalt saavutada.

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('Administraatori e-posti aadress:', payload.email); // E-posti aadressile on ohutu juurde pääseda
  } else {
    // payload.email ei ole siin juurdepääsetav, kuna tüüp on 'user'
    console.log('Kasutaja ID:', payload.userId);
  }
}

See näide määratleb kaks erinevat JWT sisu tüüpi, `AdminJwtPayload` ja `UserJwtPayload`, ning ühendab need diskrimineeritud ühenduseks `JwtPayload`. Omadus `type` toimib diskrimineerijana, võimaldades teil ohutult juurde pääseda omadustele vastavalt sisu tüübile.

2. Geneerikud korduvkasutatava autentimisloogika jaoks

Kui teil on mitu autentimisskeemi erinevate sisu struktuuridega, saate kasutada geneerikuid korduvkasutatava autentimisloogika loomiseks.

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

function verifyToken<T extends BaseJwtPayload>(token: string): T | null {
  try {
    const decoded = jwt.verify(token, JWT_SECRET) as T;
    return decoded;
  } catch (error) {
    console.error('JWT kontrolliviga:', error);
    return null;
  }
}

const adminToken = verifyToken<AdminJwtPayload>('admin-token');
if (adminToken) {
  console.log('Administraatori e-posti aadress:', adminToken.email);
}

See näide määratleb funktsiooni `verifyToken`, mis võtab geneerilise tüübi `T`, mis laiendab `BaseJwtPayload`. See võimaldab teil kontrollida erineva sisu struktuuriga märke, tagades samal ajal, et neil kõigil on vähemalt `userId`, `iat` ja `exp` omadused.

Globaalse rakenduse kaalutlused

Globaalsete rakenduste autentimissüsteemide loomisel arvestage järgmiste punktidega:

• Lokaliseerimine: Veenduge, et veateated ja kasutajaliidese elemendid oleksid lokaliseeritud erinevatele keeltele ja piirkondadele.
• Ajavööndid: Käsitsege ajavööndeid õigesti märkide aegumisaegade määramisel ja kuupäevade ning kellaaegade kuvamisel kasutajatele.
• Andmete privaatsus: Järgige andmekaitsemäärusi, nagu GDPR ja CCPA. Minimeerige JWT-desse salvestatud isikuandmete hulka.
• Juurdepääsetavus: Kujundage oma autentimisvood nii, et need oleksid juurdepääsetavad puuetega kasutajatele.
• Kultuuriline tundlikkus: Olge kasutajaliideste ja autentimisvoogude kujundamisel teadlik kultuurilistest erinevustest.

Kokkuvõte

Kasutades ära TypeScripti tüübisüsteemi, saate luua tugevaid ja hooldatavaid JWT autentimissüsteeme globaalsete rakenduste jaoks. Sisu tüüpide määratlemine liideste abil, tüübitud JWT teenuste loomine, API lõpp-punktide kaitsmine vahevaraga ja RBAC-i juurutamine on olulised sammud turvalisuse ja tüübikindluse tagamisel. Arvestades globaalse rakenduse kaalutlusi, nagu lokaliseerimine, ajavööndid, andmete privaatsus, juurdepääsetavus ja kultuuriline tundlikkus, saate luua autentimiskogemusi, mis on kaasavad ja kasutajasõbralikud mitmekesisele rahvusvahelisele publikule. Ärge unustage alati seada esikohale turvalisuse parimad tavad JWT-de käitlemisel, sealhulgas turvaline võtmehaldus, algoritmi valik, märgi aegumine ja märgi salvestamine. Kasutage ära TypeScripti võimsust turvaliste, skaleeritavate ja usaldusväärsete autentimissüsteemide loomiseks oma globaalsetele rakendustele.