Comment générer des jetons Web JSON (JWT) pour l'authentification des API de réseau

Qu'est-ce qu'un jeton Web JSON (JWT) ?

A JWT (JSON Web Token) est une norme ouverte (RFC 7519) pour la transmission sécurisée d'informations entre parties sous la forme d'un objet JSON. L'objet pourrait être crypté et signé avec une clé privée/publique, et il est couramment utilisé pour l'authentification et l'autorisation dans les applications web.

Vous pouvez considérer le JWT comme une carte d'identité numérique utilisée dans les applications web pour confirmer votre identité sans avoir à vous connecter à chaque fois que vous interagissez avec cette application.

Il est important de savoir comment générer un jeton JWT, car les API du réseau les utilisent pour effectuer l'autorisation. Il existe plusieurs façons de générer un nouveau jeton JWT lorsque vous utilisez les API de Vonage :

• Utiliser le générateur en ligne de générateur de JWT en ligne. Vous aurez besoin de votre identifiant d'application et de la clé privée générée par l'application dans votre tableau de bord. Les API réseau ne nécessitent aucune propriété ACL supplémentaire.

• Utiliser l'outil outil CLI de Vonage. Comme pour le générateur en ligne, une clé privée et un identifiant d'application doivent être fournis : vonage jwt --key_file=path/to/private.key --app_id=<application_id>

• Si vous utilisez l'un de nos SDKvous n'avez pas à vous préoccuper des JWT, car tous les SDK prennent en charge la génération de jetons JWT.

Et si je veux générer les jetons JWT sans dépendre d'un outil ou d'une bibliothèque externe ? Si c'est le cas, continuez à lire !

Structure JWT

Avant de mettre en œuvre le JWT, il est important de comprendre sa structure.

Un JWT se compose des éléments suivants l'en-tête, charge utile, et de la signature. Ces parties sont codées séparément à l'aide de la méthode Base64url et concaténées à l'aide de points :

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

Plongeons dans l'aventure !

En-tête

Spécifie l'algorithme utilisé pour générer la signature. Pour les API de Vonage, l'en-tête ressemblera à ceci :

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

Charge utile

Elle comprend des informations sur l'utilisateur et ses demandes, telles que l'ID de la demande, l'heure d'émission, l'heure d'expiration, etc. La liste suivante contient les clés nécessaires à l'utilisation des API de Vonage :

• application_id. Correspond à l'identifiant de l'application avec Capacités du registre réseaucréée dans le tableau de bord de l'utilisateur.

• iat. L'heure à laquelle le jeton a été émis.

• nbf. Heure à laquelle le jeton doit devenir valide.

• exp. Heure à laquelle le jeton doit expirer.

• acl. Une liste de permissions que ce jeton aura. Pour les Network APIs, nous utiliserons une valeur vide car les APIs n'ont pas besoin de permissions supplémentaires.

• jti. Un identifiant unique pour le JWT.

Signature

Il sert de tampon pour valider le jeton. Il est calculé en encodant l'en-tête et la charge utile à l'aide de l'algorithme d'encodage Base64url, et signé à l'aide d'une clé secrète. La clé privée de l'application est utilisée pour signer le jeton. La clé publique correspondante est utilisée pour le vérifier. Les clés peuvent être trouvées dans les paramètres de l'application dans le tableau de bord de l'utilisateur.

Comment générer un JWT en JavaScript

La première étape consiste à créer l'en-tête :

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

Ensuite, créez la charge utile. Dans cet exemple, nous avons fixé un délai d'expiration d'une heure :

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 n'inclut pas d'implémentation de l'algorithme Base64URL, nous devons donc implémenter notre propre version :

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

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

Ensuite, créons la signature :

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);

Enfin, notre JWT est prêt à être utilisé :

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

Comment générer un JWT en Python

Le code pour implémenter un JWT est très similaire à la version JavaScript. Commençons par implémenter l'algorithme Base64URL :

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")

Ensuite, nous définissons notre en-tête et notre charge utile :

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()),
}

L'étape suivante consiste à coder l'en-tête et la charge utile :

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

Nous sommes prêts à créer la signature :

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)

Notre JWT est prêt à être utilisé :

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

Comment utiliser JWT avec des API de réseau

Les API de réseau utilisent le JWT au cours de l'étape d'autorisation avant d'effectuer un appel d'API. Étant donné que les jetons sont des informations d'identification, nous devons prendre en considération certaines mesures de sécurité pour éviter les problèmes de sécurité :

• La génération du JWT doit se faire du côté du backend.

• Le délai d'expiration des jetons ne doit pas être plus long que nécessaire.

Une fois généré, les utilisateurs doivent pouvoir utiliser le jeton pour accéder aux points d'extrémité protégés. Cela se fait généralement à l'aide de l'en-tête Authorization qui utilise le schéma Bearer :

Authorization: Bearer <token>

La documentation sur l'autorisation des API de réseau contient une description détaillée de l'utilisation des jetons JWT dans les applications front-end et back-end front-end et back-end.

Prendre contact

Avez-vous implémenté JWT dans votre langage préféré ? Nous aimerions voir votre code ! Rejoignez-nous sur le Communauté des développeurs de Vonage Slack ou envoyez-nous un message sur Xet nous vous répondrons.

Merci de votre lecture !