Generierung von JSON-Web-Tokens (JWTs) für die Authentifizierung von Netzwerk-APIs

Was ist ein JSON-Web-Token (JWT)?

A JWT (JSON Web Token) ist ein offener Standard (RFC 7519) für die sichere Übermittlung von Informationen zwischen Parteien in Form eines JSON-Objekts. Das Objekt kann verschlüsselt und mit einem privaten/öffentlichen Schlüssel signiert werden und wird in der Regel für die Authentifizierung und Autorisierung in Webanwendungen verwendet.

Sie können sich JWT als eine digitale ID-Karte vorstellen, die in Web-Anwendungen verwendet wird, um zu bestätigen, wer Sie sind, ohne sich jedes Mal anmelden zu müssen, wenn Sie mit dieser Anwendung interagieren.

Es ist wichtig zu wissen, wie man ein JWT-Token erzeugt, da die Netzwerk-APIs sie für die Autorisierung verwenden. Es gibt mehrere Möglichkeiten, ein neues JWT-Token zu generieren, wenn Sie Vonage-APIs nutzen:

• Die Verwendung des JWT-Online-Generator. Sie benötigen Ihre Anwendungs-ID und den von der Anwendung generierten privaten Schlüssel in Ihrem Dashboard. Für Netzwerk-APIs sind keine zusätzlichen ACL-Eigenschaften erforderlich.

• Verwendung des Vonage CLI-Tool. Ähnlich wie beim Online-Generator müssen ein privater Schlüssel und eine Anwendungs-ID angegeben werden: vonage jwt --key_file=path/to/private.key --app_id=<Anwendung_id>

• Wenn Sie eines unserer SDKsverwenden, müssen Sie sich nicht um JWT kümmern, da alle SDKs die Erzeugung von JWT-Tokens unterstützen.

Was ist, wenn ich die JWT-Tokens generieren möchte, ohne auf ein externes Tool oder eine Bibliothek angewiesen zu sein? Wenn das der Fall ist, lesen Sie weiter!

JWT-Struktur

Vor der Implementierung von JWT ist es wichtig, seine Struktur zu verstehen.

Ein JWT besteht aus dem Kopfzeile, Nutzdaten, und Unterschrift. Diese Teile werden separat kodiert, indem die Base64url Kodierungsalgorithmus kodiert und mit Punkten verkettet:

jwt = base64url(header) + '.' + base64url(payload) + '.' + base64url(signature)

Lasst uns eintauchen!

Kopfzeile

Gibt an, welcher Algorithmus zur Erzeugung der Signatur verwendet wird. Für Vonage-APIs sieht der Header wie folgt aus:

{ 
  alg: "RS256",
  typ: "JWT"
};

Nutzlast

Er enthält Informationen über den Benutzer und seine Ansprüche, wie z. B. die Anwendungs-ID, den Ausstellungszeitpunkt, den Ablaufzeitpunkt, usw. Die folgende Liste enthält die erforderlichen Schlüssel für die Nutzung der Vonage-APIs:

• anwendung_id. Entspricht der ID der Anwendung mit Fähigkeiten der Netzwerkregistrierung, die im Dashboard des Dashboard des Benutzers.

• iat. Der Zeitpunkt, zu dem der Token ausgegeben wurde.

• nbf. Der Zeitpunkt, zu dem das Token gültig werden soll.

• exp. Der Zeitpunkt, zu dem das Token ablaufen soll.

• acl. Eine Liste von Berechtigungen, die dieses Token haben wird. Für Netzwerk-APIs wird ein leerer Wert verwendet, da die APIs keine zusätzlichen Berechtigungen benötigen.

• jti. Ein eindeutiger Bezeichner für das JWT.

Unterschrift

Er dient als Stempel zur Validierung des Tokens. Er wird durch Kodierung des Headers und der Nutzdaten mit dem Base64url-Kodierungsalgorithmus berechnet und mit einem geheimen Schlüssel signiert. Der private Schlüssel der Anwendung wird zum Signieren des Tokens verwendet. Zur Verifizierung wird der entsprechende öffentliche Schlüssel verwendet. Die Schlüssel befinden sich in den Einstellungen der Anwendung im Dashboard des Benutzers.

Wie man ein JWT in JavaScript generiert

Der erste Schritt wäre die Erstellung der Kopfzeile:

const header = {
  alg: "RS256",
  typ: "JWT",
};

Als nächstes erstellen Sie die Nutzlast. In diesem Beispiel legen wir eine Ablaufzeit von einer Stunde fest:

const currentTime = Math.floor(Date.now() / 1000);

const payload = {
  application_id: "123-456-789",
  iat: currentTime,
  nbf: currentTime,
  exp: currentTime + (60 * 60),
  acl: {},                 
  jti: crypto.randomUUID()
};

JavaScript enthält keine Implementierung des Base64URL-Algorithmus, so dass wir unsere eigene Version implementieren müssen:

function base64url(str) {
  let encodedSource = Buffer.from(str).toString('base64');

  // remove padding and replace characters
  return encodedSource
       .replace(/\+/g, '-')
       .replace(/\//g, '_')
       .replace(/=+$/, '');
}

Als nächstes erstellen wir die Signatur:

const crypto = require("crypto");
const fs = require("fs");

// Load your private key generated for the Vonage Application
const privateKey = fs.readFileSync("path/to/private.key", "utf8");

const encodedHeader = base64url(JSON.stringify(header));
const encodedPayload = base64url(JSON.stringify(payload));

const signingInput = `${encodedHeader}.${encodedPayload}`;

// Create RS256 signature (RSA-SHA256)
const signature = crypto.sign("RSA-SHA256", Buffer.from(signingInput), {
  key: privateKey,
});

const encodedSignature = base64url(signature);

Endlich ist unser JWT einsatzbereit:

const jwt = `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
console.log(jwt);

Wie man ein JWT in Python generiert

Der Code zur Implementierung eines JWT ist der JavaScript-Version sehr ähnlich. Beginnen wir mit der Implementierung des Base64URL-Algorithmus:

import base64
import json
import time
import uuid

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding

def base64url(data: bytes) -> str:
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("utf-8")

Als Nächstes definieren wir unseren Header und Payload:

current_time = int(time.time())

header = {"alg": "RS256", "typ": "JWT"}

payload = {
    "application_id": "123-456-789",
    "iat": current_time,
    "nbf": current_time,
    "exp": current_time + 3600,
    "acl": {},
    "jti": str(uuid.uuid4()),
}

Im nächsten Schritt werden sowohl der Header als auch die Payload verschlüsselt:

encoded_header = base64url(json.dumps(header, separators=(",", ":")).encode("utf-8"))
encoded_payload = base64url(json.dumps(payload, separators=(",", ":")).encode("utf-8"))

Wir sind bereit, die Signatur zu erstellen:

app_id = "1234-4567-8901-abcd"
private_key = "/path/to/your/private/key"

with open(private_key, "rb") as f:
    private_key = serialization.load_pem_private_key(f.read(), password=None)

signature = private_key.sign(
    signing_input,
    padding.PKCS1v15(),
    hashes.SHA256(),
)

encoded_signature = base64url(signature)

Unser JWT ist jetzt einsatzbereit:

jwt_token = f"{encoded_header}.{encoded_payload}.{encoded_signature}"
print(jwt_token)

Verwendung von JWT mit Netzwerk-APIs

Die Netzwerk-APIs verwenden JWT während des Autorisierungsschritts, bevor sie einen API-Aufruf tätigen. Da es sich bei Token um Berechtigungsnachweise handelt, sollten wir einige Sicherheitsmaßnahmen in Betracht ziehen, um Sicherheitsprobleme zu vermeiden:

• Die Generierung des JWTs sollte auf der Backend-Seite erfolgen.

• Halten Sie die Verfallszeit der Token nicht länger als erforderlich.

Nach der Generierung sollten die Benutzer in der Lage sein, das Token für den Zugriff auf geschützte Endpunkte zu verwenden. Dies geschieht in der Regel über den Authorization-Header unter Verwendung des Bearer-Schemas:

Authorization: Bearer <token>

Die Dokumentation zur Autorisierung von Netzwerk-APIs enthält eine detaillierte Beschreibung der Verwendung von JWT-Tokens in Frontend und Back-End Szenarien.

Kontakt aufnehmen

Haben Sie JWT in Ihrer Lieblingssprache implementiert? Wir würden uns freuen, Ihren Code zu sehen! Schließen Sie sich uns auf dem Vonage Entwickler-Community Slack oder senden Sie uns eine Nachricht auf Xund wir werden auf Sie zurückkommen.

Vielen Dank fürs Lesen!