PEM / JWK / JWKS

Générateur de paires de clés RSA et EC

Créez des paires de clés asymétriques RSA (RS256, PS256, RSA-OAEP) et ECDSA (P-256, P-384, P-521) localement dans votre navigateur via WebCrypto. Obtenez immédiatement les clés PEM PKCS#8 et SPKI, les JWK avec empreinte kid RFC 7638 ainsi qu’un jeu JWKS strictement public.

Fonctionnement technique

La signature JWT asymétrique remplace un secret symétrique partagé par une paire mathématique générée localement via l’API W3C WebCrypto (crypto.subtle.generateKey). Le serveur d’authentification conserve la clé privée pour signer les jetons, tandis que les microservices et passerelles API vérifient chaque signature avec la seule clé publique SPKI PEM ou un point de terminaison JWKS.

Chaque paire produite est exportée en PEM PKCS#8 (clé privée) et PEM SPKI (clé publique) formatés à 64 caractères par ligne, ainsi qu’en objets JWK conformes à la RFC 7517 avec les champs alg et use. Une empreinte SHA-256 selon la RFC 7638 est calculée sur les membres publics triés lexicographiquement afin de fournir un identifiant kid déterministe, accompagné d’un jeu JWKS strictement public.

Guide pas à pas avec exemple réel

Créez, contrôlez et exportez des clés asymétriques prêtes pour JWT aux formats PEM, JWK et JWKS en quatre étapes locales.

1. Choisir la famille RSA ou Courbe Elliptique

Sélectionnez RSASSA-PKCS1-v1_5 (RS256/384/512), RSA-PSS (PS256/384/512), RSA-OAEP pour le chiffrement JWE, ou ECDSA pour des signatures compactes.

2. Régler la taille RSA ou la courbe

Choisissez 2048, 3072 ou 4096 bits avec SHA-256/384/512 pour RSA, ou une courbe NIST P-256 (ES256), P-384 (ES384) ou P-521 (ES512).

3. Générer la paire et l’empreinte kid RFC 7638

WebCrypto calcule les nombres premiers ou scalaires de façon asynchrone en mémoire locale et associe l’identifiant SHA-256 canonique au JWK.

4. Exporter PEM, JWK, JWKS ou commandes OpenSSL

Copiez ou téléchargez le fichier PKCS#8 pour votre coffre-fort, diffusez le JWKS exclusivement public ou exécutez la commande OpenSSL fournie.

Exemple : Calcul d’empreinte JWK selon la RFC 7638 (section 3.1)

Membres publics triés (e, kty, n):{"e":"AQAB","kty":"RSA","n":"0vx7agoebGcQSuuPiLJXZptN9nndrQmbXEps2aiAFbWhM78LhWx..."}
Identifiant kid déterministe en Base64URL:kid: "NzbLsXh8uDCcd-6MNwXF4W_7noWXFZAfHkxZsRGC9Xs"

Comme seules les clés obligatoires ordonnées sans espaces sont hachées en SHA-256, toute bibliothèque conforme retrouve le même kid.

Erreurs fréquentes et notes de sécurité

Publier des champs privés dans un document JWKS

Un fichier JWKS exposé publiquement ne doit contenir que les champs publics (n, e ou x, y, crv). Inclure d, p ou q permettrait à quiconque de signer vos jetons.

Confondre les en-têtes PEM PKCS#1 et PKCS#8

WebCrypto et les runtimes modernes produisent du PKCS#8 (BEGIN PRIVATE KEY) et SPKI (BEGIN PUBLIC KEY). Vérifiez la compatibilité de votre parseur avant déploiement.

Utiliser le navigateur pour des clés racines critiques

Même si rien ne quitte votre navigateur ici, les clés maîtresses d’identité en production doivent idéalement être générées hors ligne ou dans un HSM/KMS (AWS KMS, Vault).

Omettre le paramètre kid lors de la rotation

Sans champ kid stable dans l’en-tête JWT et le JWKS, chaque service doit tester toutes les clés actives lors d’une transition.

PEM (PKCS#8 / SPKI) vs JWK vs JWKS

FormatRôleContenu principalIntégration typique
PEM PKCS#8Clé privée de signatureBEGIN PRIVATE KEY (ASN.1)Variables sécurisées et coffres-forts
PEM SPKIClé publique de contrôleBEGIN PUBLIC KEYProxies API et configurations statiques
JWK JSONClé unique JSONkty, alg, use, kid, coordonnéesAPI WebCrypto et SDK conformes RFC 7517
JWKS PublicJeu de rotation public{ "keys": [ publicJwk... ] }Routes OIDC /.well-known/jwks.json

Extraits de code (Node.js, Python, Java)

Générez l’équivalent directement dans vos scripts serveur ou pipelines CI/CD :

Node.js (TypeScript)
import { generateKeyPairSync, createHash } from 'node:crypto';

const { publicKey, privateKey } = generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: { type: 'spki', format: 'pem' },
  privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
});
const jwk = publicKey.export({ format: 'jwk' });
const kid = createHash('sha256')
  .update(JSON.stringify({ e: jwk.e, kty: 'RSA', n: jwk.n }))
  .digest('base64url');
Python
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization

priv = ec.generate_private_key(ec.SECP256R1())
priv_pem = priv.private_bytes(
    serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption()
)
pub_pem = priv.public_key().public_bytes(
    serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo
)
Java
KeyPairGenerator gen = KeyPairGenerator.getInstance("EC");
gen.initialize(new ECGenParameterSpec("secp256r1"));
KeyPair kp = gen.generateKeyPair();
String spkiB64 = Base64.getMimeEncoder(64, new byte[]{'\n'})
    .encodeToString(kp.getPublic().getEncoded());

Questions fréquentes

Faut-il privilégier RSA 2048 ou ECDSA P-256 pour signer des JWT ?

ECDSA P-256 (ES256) produit des signatures beaucoup plus courtes avec une sécurité équivalente à RSA 3072. Gardez RSA 2048+ si des clients hérités exigent RS256.

Pourquoi la génération RSA 4096 prend-elle plus de temps dans le navigateur ?

Générer du RSA 4096 implique de trouver et valider deux grands nombres premiers de 2048 bits, alors que P-256 tire simplement un scalaire aléatoire de 256 bits.

Le jeu JWKS exporté peut-il contenir par erreur la clé privée ?

Jamais. L’onglet JWKS filtre systématiquement d, p, q, dp, dq, qi et oth afin de ne publier que les paramètres strictement publics.

Comment l’identifiant kid est-il calculé automatiquement ?

Selon la RFC 7638 : les paramètres publics requis sont triés par ordre alphabétique strict sans espaces, hachés en SHA-256 puis encodés en Base64URL.

Quelle différence entre RSA-OAEP et RSA-PSS ?

RSA-PSS (PS256) sert à signer des JWS (use: sig), tandis que RSA-OAEP sert au chiffrement asymétrique des clés dans des jetons JWE (use: enc).

Ces clés conviennent-elles à la production ?

Elles sont générées de manière cryptographiquement sûre en local et parfaites pour les tests et services standards ; pour les clés racines critiques, privilégiez un KMS ou une génération hors ligne.

À propos de l’auteur

Avada Labs développe des outils gratuits pour développeurs, dont ce site, fort de six ans d’expérience en développement web et outils en ligne. Les projets et le code source sont disponibles sur GitHub.

Générateur de clés RSA et EC – PEM, JWK et JWKS