Was ist JWT?

JWT steht für JSON Web Token und ist ein offener Stander zur Übertragung von Informationen zwischen Parteien als JSON-Objekt. Es ist kompakt, URL-sicher und wird häufig in Webanwendungen zur Authentifizierung und zum Informationsaustausch verwendet.

JWTs werden mithilfe von Schlüsseln und Geheimnissen digital signiert. Wir verifizieren das JWT mit diesen Schlüsseln und der Signatur, um den Benutzer zu authentifizieren. Die meisten Websysteme verwenden JWTs, um Benutzern den Zugriff auf bestimmte Ressourcen zu autorisieren.

Token-Komponenten

Ein JWT besteht aus drei Hauptkomponenten: dem Header, der Nutzlast und der Signatur. Wenn wir ein Token erstellen, übergeben wir den Header und die Nutzlast, und dann generiert das Token die Signatur.

Headre – Der Header eines JWT enthält Metadaten über das Token. Es enthält drei Werte: alg, typ und kid. „alg“ gibt den zum Signieren des Tokens verwendeten Algorithmus an, „typ“ gibt den Tokentyp an und „kid“ ist ein optionaler Parameter zur Identifizierung des Schlüssels. Ob Sie „Kind“ einbeziehen, hängt von Ihrem Anwendungsfall ab.

{
  "alg": "RS256", // allow [HS256,RS256,ES256]
  "typ": "JWT", // Specific Type Of token
  "kid": "12345" // Used to indicate which key was used to sign 
the JWT. This is particularly useful when multiple keys are in use
}

Nutzlast – In der Nutzlast geben wir einige benutzerdefinierte Daten an, meist fügen wir benutzerspezifische Daten wie Benutzer-ID und Rolle zur Nutzlast hinzu.

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Signatur – Die Signatur wird generiert, indem der Header und die Nutzdaten mit einem geheimen Schlüssel (für HS256) codiert oder mit einem privaten Schlüssel (für RSA) signiert und dann das Ergebnis gehasht werden. Diese Signatur wird zur Überprüfung des Tokens verwendet.

Wie ein Token erstellt wird

Wie wir besprochen haben, besteht ein JWT aus drei Komponenten: dem Header, der Nutzlast und der Signatur. Wir stellen den Header und die Payload bereit und daraus wird die Signatur generiert. Nachdem wir alle diese Komponenten kombiniert haben, erstellen wir den Token.

// Header Encoding
Base64Url Encode({
  "alg": "RS256",
  "typ": "JWT"
}) → eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9


// Payload Encoding
Base64Url Encode({
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}) → eyJzdWIiOiAiMTIzNDU2Nzg5MCIsICJuYW1lIjogIkpvaG4gRG9lIiwgImlhdCI6IDE1MTYyMzkwMjJ9


// Concatenate Encoded header and payload
ConcatenatedHash =  Base64Url Encode(Header)   "."   Base64Url Encode(Payload)

//Create Signature
Hash = SHA-256(ConcatenatedHash)
Signature = RSA Sign(Hash with Private Key) or HS256 Sign(Hash with secrate)

// Create Token
Token = Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload)  "."  Signature

Der Prozess zum Erstellen eines JWT ist also wie folgt: Wir codieren die Nutzdaten und Header und generieren dann daraus die Signatur.

JWT-Tokens überprüfen

Zuvor haben wir besprochen, wie man ein JWT erstellt. Lassen Sie uns nun besprechen, wie ein JWT überprüft wird. Der Verifizierungsprozess ist im Wesentlichen die Umkehrung der Token-Erstellung. Zuerst entschlüsseln wir den Token mit einem geheimen oder öffentlichen Schlüssel. Anschließend verketten wir den Header und die Nutzdaten, um eine Signatur zu generieren. Wenn der generierte Hash mit der Signatur übereinstimmt, ist das Token gültig; andernfalls ist es ungültig.

// Token we recive in this formate
Token = Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload)  "."  Signature

// Decrypt Signature
TokenHash = RSA Decrypt(Hash with Public Key) or HS256 Sign(Hash with secrate)

// Generate Hash From Encoded Header and Payload
Hash = SHA-256(Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload))

// Compare Hash
if(TokenHash == Hash) "Valid"
else "Not Valid"

Vorteile der Verwendung von JWT

1. Sicherheit – JWTs sind digital signiert, was die Integrität und Authentizität der Daten gewährleistet
2. Kompakt – JWTs sind klein und daher effizient über das Netzwerk zu übertragen.
3. Eigenständig – JWTs enthalten alle notwendigen Informationen über den Benutzer, wodurch die Notwendigkeit reduziert wird, die Datenbank mehrmals abzufragen.

JWT bietet alle oben genannten Vorteile und ist daher eine beliebte Wahl für die meisten Authentifizierungsmechanismen zur Autorisierung von Benutzern. Darüber hinaus kann JWT mit verschiedenen Authentifizierungstechniken wie DPoP und anderen verwendet werden.

So verwenden Sie JWT in Ihrem Code

Um JWT im Code zu verwenden, verwenden wir das jsonwebtoken npm-Paket. Es gibt zwei Methoden für die Arbeit mit JWTs: die einfache Methode mit einem geheimen Schlüssel und die Schlüsselpaarmethode (mit öffentlichen und privaten Schlüsseln).

Geheimnis verwenden

import jwt from 'jsonwebtoken';

// Define the type for the payload
interface Payload {
  userId: number;
  username: string;
}

// Secret key for signing the JWT
const secretKey: string = 'your-very-secure-secret';

// Payload to be included in the JWT
const payload: Payload = {
  userId: 123,
  username: 'exampleUser'
};

// Sign the JWT
const token: string = jwt.sign(payload, secretKey, { expiresIn: '1h' });
console.log('Generated Token:', token);

import jwt from 'jsonwebtoken';

// Secret key for signing the JWT
const secretKey: string = 'your-very-secure-secret';

// Verify the JWT
try {
  const decoded = jwt.verify(token, secretKey) as Payload;
  console.log('Decoded Payload:', decoded);
} catch (err) {
  console.error('Token verification failed:', (err as Error).message);
}

Verwenden der KeyPair-Methode

import * as jwt from 'jsonwebtoken';
import { readFileSync } from 'fs';

// Load your RSA private key
const privateKey = readFileSync('private_key.pem', 'utf8');

// Define your payload
const payload = {
  sub: '1234567890',
  name: 'John Doe',
  iat: Math.floor(Date.now() / 1000) // Issued at
};

// Define JWT sign options
const signOptions: jwt.SignOptions = {
  algorithm: 'RS256',
  expiresIn: '1h' // Token expiration time
};

// Generate the JWT
const token = jwt.sign(payload, privateKey, signOptions);
console.log('Generated JWT:', token);

import * as jwt from 'jsonwebtoken';
import { readFileSync } from 'fs';

// Load your RSA public key
const publicKey = readFileSync('public_key.pem', 'utf8');

// Define JWT verify options
const verifyOptions: jwt.VerifyOptions = {
  algorithms: ['RS256'] // Specify the algorithm used
};

try {
  // Verify the JWT
  const decoded = jwt.verify(token, publicKey, verifyOptions) as jwt.JwtPayload;

  console.log('Decoded Payload:', decoded);
} catch (error) {
  console.error('Error verifying token:', error);
}

Abschluss

Zusammenfassend lässt sich sagen, dass JSON Web Tokens (JWTs) Informationen sicher zwischen Parteien in einem kompakten Format übertragen. Bei der RSA-Signatur und -Verifizierung werden ein privater Schlüssel zum Signieren und ein öffentlicher Schlüssel zur Verifizierung verwendet. Die TypeScript-Beispiele veranschaulichen die Generierung eines JWT mit einem privaten RSA-Schlüssel und dessen Überprüfung mit einem öffentlichen RSA-Schlüssel, um eine sichere tokenbasierte Authentifizierung und Datenintegrität sicherzustellen.