PEM / JWK / JWKS

Generador de claves asimétricas RSA y EC

Genere pares de claves asimétricas RSA (RS256, PS256, RSA-OAEP) y ECDSA (P-256, P-384, P-521) directamente en su navegador mediante WebCrypto. Exporte claves privadas PKCS#8 y públicas SPKI en PEM, objetos JWK con huella kid RFC 7638 y un conjunto JWKS solo público.

Cómo funciona

La firma asimétrica de JWT sustituye un secreto compartido por un par matemático de clave privada y pública generado en su navegador mediante WebCrypto crypto.subtle.generateKey. El servidor de identidad firma con la clave privada y cada microservicio o gateway valida tokens usando únicamente la clave pública PEM SPKI o el endpoint JWKS.

La herramienta exporta claves privadas PKCS#8 y públicas SPKI en formato PEM de 64 caracteres por línea, genera objetos JWK según RFC 7517 con campos alg y use, calcula la huella SHA-256 RFC 7638 sobre los miembros públicos ordenados alfabéticamente para fijar el kid, y prepara un conjunto JWKS estrictamente público sin ningún componente privado.

Guía paso a paso con ejemplo real

Genere, inspeccione y exporte pares asimétricos en PEM, JWK y JWKS público en cuatro pasos locales sin salir de su navegador.

1. Seleccione la familia RSA o curva elíptica

Elija entre RSASSA-PKCS1-v1_5 (RS256/384/512), RSA-PSS (PS256/384/512), RSA-OAEP para cifrado JWE o ECDSA con curvas NIST.

2. Ajuste bits RSA o curva EC

Defina 2048, 3072 o 4096 bits junto al hash SHA para RSA, o elija P-256 (ES256), P-384 (ES384) o P-521 (ES512) en ECDSA.

3. Genere las claves y la huella kid

WebCrypto ejecuta la generación de forma asíncrona en memoria local y etiqueta el JWK con su thumbprint SHA-256 conforme a RFC 7638.

4. Copie PEM, JWK, JWKS o comando OpenSSL

Descargue la clave privada PKCS#8 para su gestor de secretos, publique el JWKS solo público o utilice el comando OpenSSL equivalente sin conexión.

Ejemplo verificado: Huella JWK RFC 7638 Sección 3.1

Miembros públicos RSA ordenados (e, kty, n):{"e":"AQAB","kty":"RSA","n":"0vx7agoebGcQSuuPiLJXZptN9nndrQmbXEps2aiAFbWhM78LhWx..."}
Identificador kid calculado en Base64URL:kid: "NzbLsXh8uDCcd-6MNwXF4W_7noWXFZAfHkxZsRGC9Xs"

Al serializar únicamente las propiedades públicas requeridas sin espacios antes de aplicar SHA-256, cualquier SDK estándar obtiene exactamente el mismo kid.

Errores comunes y notas de seguridad

Exponer parámetros privados en el JSON de JWKS

El archivo JWKS publicado debe incluir exclusivamente atributos públicos (n, e en RSA; crv, x, y en EC). Filtrar d, p o q compromete todas sus firmas.

Mezclar cabeceras PKCS#1 y PKCS#8 en PEM

WebCrypto exporta PKCS#8 (BEGIN PRIVATE KEY) y SPKI (BEGIN PUBLIC KEY). Verifique que su librería backend acepte PKCS#8 antes de desplegar.

Generar claves raíz de alta sensibilidad solo en navegador

Aunque aquí nada abandona su equipo, los secretos raíz críticos de producción deben generarse sin conexión o dentro de un HSM/KMS (AWS KMS, Vault).

Omitir el campo kid al rotar claves públicas

Incluir un kid estable permite a los verificadores localizar de inmediato la clave correcta dentro de un JWKS durante rotaciones activas.

Comparativa entre PEM, JWK y JWKS

FormatoAlcanceEstructura típicaUso principal
PEM PKCS#8Clave privada de firmaBEGIN PRIVATE KEY (ASN.1 DER)Gestores de secretos y variables seguras
PEM SPKIClave pública de validaciónBEGIN PUBLIC KEYConfiguración estática en API gateways
JWKClave individual JSONkty, alg, use, kid, n/e o x/yWebCrypto e integraciones RFC 7517
JWKSConjunto público de claves{ "keys": [ publicJwk... ] }Endpoints OIDC /.well-known/jwks.json

Ejemplos de código (Node.js, Python, Java)

Genere pares equivalentes y calcule huellas RFC 7638 directamente en su backend o entorno local:

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

Preguntas frecuentes

¿Conviene más usar RSA 2048 o ECDSA P-256 en JWT?

ECDSA P-256 (ES256) ofrece firmas mucho más compactas, validación rápida y nivel criptográfico cercano a RSA 3072. Use RSA 2048+ cuando deba soportar clientes antiguos.

¿Por qué RSA 4096 tarda varios segundos en generarse?

Calcular RSA de 4096 bits requiere buscar y validar dos números primos de 2048 bits, mientras que P-256 solo muestrea un escalar aleatorio de 256 bits.

¿El JWKS exportado contiene alguna parte privada?

Nunca. El formato JWKS generado elimina d, p, q, dp, dq, qi y oth para que pueda servirse de forma segura por HTTPS.

¿Cómo se obtiene exactamente el identificador kid?

Según RFC 7638: se serializan los campos públicos obligatorios en orden lexicográfico sin espacios, se calcula su SHA-256 y se codifica en Base64URL.

¿Para qué sirve RSA-OAEP frente a RSA-PSS?

RSA-PSS (PS256) firma tokens JWS (use: sig), mientras que RSA-OAEP cifra claves dentro de tokens JWE cifrados (use: enc).

¿Es seguro utilizar claves generadas en este sitio en producción?

La generación usa crypto.subtle localmente sin envíos de red; aun así, para claves de identidad críticas recomendamos un KMS gestionado o generación offline.

Acerca del autor

Avada Labs crea herramientas gratuitas para desarrolladores, incluido este sitio, con seis años de experiencia en desarrollo web y herramientas en línea. Los proyectos y el código fuente están en GitHub.

Generador de claves RSA y EC – PEM, JWK y JWKS