Generador gratis de pares de claves RSA — ECDSA y Ed25519
Genera claves RSA online: la clave privada nunca sale de tu navegador. RSA 2048/4096, ECDSA, Ed25519, PEM PKCS#8 o PKCS#1, JWK y huella SHA-256.
PKCS#8 (BEGIN PRIVATE KEY) es el valor por defecto moderno y lo que espera el JDK. PKCS#1 (BEGIN RSA PRIVATE KEY) es la forma tradicional de OpenSSL, que algunas pasarelas todavía exigen. Cambiar recodifica la misma clave.
Mantenla en secreto. Cualquiera que la tenga puede suplantarte.
Genera el mismo tipo de par de claves con OpenSSL
Nuestro equipo verifica la conversión de PKCS#8 a PKCS#1 byte a byte contra la salida de referencia del módulo crypto de Node, de modo que una clave exportada aquí es idéntica a la que OpenSSL produciría para el mismo material.
¿Qué es un generador de claves RSA?
Un generador de claves RSA produce un par ligado matemáticamente: una clave privada que guardas y una clave pública que repartes. Todo lo firmado con la mitad privada se verifica con la mitad pública, y solo la mitad pública es segura de publicar. Esa asimetría es justamente el objetivo: permite que quien verifica compruebe tus firmas sin adquirir la capacidad de falsificarlas, algo que un secreto compartido nunca puede ofrecer.
Este generador se ejecuta dentro de tu navegador mediante la API Web Crypto, así que la clave privada se crea en la pestaña y la página no hace ninguna petición de red mientras genera. Además de RSA, produce pares ECDSA y Ed25519, que cumplen la misma función con claves mucho más cortas: una clave privada Ed25519 ocupa 48 bytes en PKCS#8, mientras que una clave RSA de 2048 bits supera 1,2 KB.
Lo que hace tropezar a la gente no son las matemáticas sino el empaquetado. La misma clave puede escribirse como PKCS#8, PKCS#1, SPKI o JWK, y una biblioteca que rechaza uno a menudo acepta otro sin más explicación que un error de análisis. La tabla de más abajo asocia cada contenedor a los ecosistemas que lo esperan.
// Verify a downloaded key pair matches, using OpenSSL: openssl pkey -in rsa-2048-private.pem -pubout | diff - rsa-2048-public.pem // No output means the public key really belongs to that private key.
Características principales
Generado en tu navegador
Las claves salen de la API Web Crypto en tu propia pestaña, y la página no hace ninguna petición de red mientras genera. Corta la conexión y sigue funcionando, lo que demuestra que la herramienta no necesita servidor alguno para hacer su trabajo.
RSA, ECDSA y Ed25519
RSA 2048, 3072 y 4096; ECDSA sobre P-256, P-384 y P-521; y Ed25519, todo desde una sola página y con las mismas opciones de exportación.
Salida PKCS#8 y PKCS#1
Alterna entre BEGIN PRIVATE KEY y la disposición tradicional BEGIN RSA PRIVATE KEY sin tocar OpenSSL. El selector recodifica la clave que ya está en pantalla, así que sigue siendo la misma clave.
Exportación a JWK
Ambas mitades están disponibles como JSON Web Keys. La JWK pública es la que va a un documento JWKS o a un verificador JOSE; la JWK privada es solo para tu firmante y nunca debe publicarse.
Huella SHA-256
Cada par viene con una huella de su clave pública para que puedas verificar por un canal aparte que ambos lados tienen la misma clave.
Comandos de OpenSSL equivalentes
Debajo de la salida se muestran los comandos equivalentes para generar el mismo tipo de clave en local, por si prefieres pasarte a la línea de comandos.
Descargas con nombres útiles
Los archivos se guardan como rsa-2048-private.pem y rsa-2048-public.pem, no con un nombre genérico que luego tengas que renombrar.
Sin cuenta y sin límite de uso
No interviene ningún servidor, así que no hay nada a lo que registrarse ni ninguna cuota que agotar.
Ejemplos prácticos
Par Ed25519, mostrado completo
Algoritmo: Ed25519
-----BEGIN PRIVATE KEY----- MC4CAQAwBQYDK2VwBCIEIA2HJVU1qChbOJN8XksXVhyD0IjYVt0UU6Mwz814rOFf -----END PRIVATE KEY----- -----BEGIN PUBLIC KEY----- MCowBQYDK2VwAyEAV5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU= -----END PUBLIC KEY-----
Una clave privada Ed25519 ocupa 48 bytes en PKCS#8 y la pública 44 bytes, así que cada PEM cabe en una sola línea de base64. Este par es una demostración desechable: genera el tuyo en lugar de copiar este.
Las cabeceras PKCS#8 y PKCS#1 son distintas
Algoritmo: RSA 2048, estructura alternada
PKCS#8: -----BEGIN PRIVATE KEY----- PKCS#1: -----BEGIN RSA PRIVATE KEY-----
La misma clave con dos envoltorios. PKCS#8 añade un identificador de algoritmo alrededor de la estructura RSA, y por eso sirve para cualquier algoritmo mientras que PKCS#1 solo existe para RSA. Accionar el selector recodifica la clave que ya está en pantalla, así que la huella no cambia.
Clave pública RSA 2048
Algoritmo: RSA 2048
-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni eSccN1uleXFRBb1g2TN6bk/fbpPCGDyh71m73oB9Bk8+fKVkSThXyWTtpgblB7pX iQBtTvSWVZGHprkLgMGkU2Yw8Z43m1WpoRuYyXNFe92S5viIdVuKTj/VEUuEpzHd ffWMIUw70LaUdTP04iQdkNVeS3M6VHkpTwsPSQfsFSwObtLVNy2Lf+ODwJRqCk2r C749hgKqBdJqkcIj49R7UP4SMQ/9V3yy8DFMrIcgsjC4tHwlQSCGeXNxTNlapGSa ke55LUR83FASryVJRbUs678SCZSFkyGcT0qLZ/olu/e7Jj2lB0Qy/SJawkrs9hPE 4QIDAQAB -----END PUBLIC KEY-----
El prefijo MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A es el identificador del algoritmo rsaEncryption: es lo que permite reconocer a simple vista una clave SPKI de RSA.
Clave pública como JWK
Algoritmo: Ed25519, panel JWK
{
"key_ops": [
"verify"
],
"ext": true,
"alg": "Ed25519",
"crv": "Ed25519",
"x": "V5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU",
"kty": "OKP"
} Esta es la exportación literal, incluidos los miembros key_ops y ext que Web Crypto añade siempre. Una entrada de JWKS no los quiere: elimina ambos y añade en su lugar kid y use para que quien verifica pueda seleccionar la clave correcta durante una rotación. Ed25519 cae en el tipo de clave OKP; las claves RSA aparecen con kty RSA y los miembros n y e.
Huella SHA-256
Algoritmo: Ed25519
SHA256(SPKI) = KAXVxapxpG4zLsTVMpPafovT+X1NLWc8fsOXqtrb59o=
Un resumen SHA-256 de la estructura de la clave pública, lo bastante corto para leerlo por teléfono. Ojo: no es el valor que imprime ssh-keygen, porque OpenSSH aplica el hash a su propio formato de transporte y los dos nunca coinciden para la misma clave.
Cómo usar el generador de claves RSA
- 1
Elige el algoritmo
RSA cubre el abanico más amplio de sistemas heredados. ECDSA da una fortaleza equivalente con claves mucho más pequeñas. Ed25519 es la opción moderna por defecto para cualquier firma nueva.
- 2
Elige el tamaño de clave
RSA 2048 cumple las recomendaciones actuales; 3072 y 4096 añaden margen para claves de larga vida. ECDSA ofrece P-256, P-384 y P-521. Ed25519 tiene un único tamaño fijo.
- 3
Selecciona la estructura PEM
PKCS#8 emite BEGIN PRIVATE KEY y funciona en casi todas partes, incluido el JDK. Cambia a PKCS#1 solo cuando algo exija específicamente BEGIN RSA PRIVATE KEY.
- 4
Copia o descarga ambas mitades
La clave privada va a tu gestor de secretos. La clave pública va a quien verifica tus firmas. Nunca envíes la mitad privada a ningún sitio.
- 5
Verifica la huella
Compara la huella SHA-256 por un canal aparte para confirmar que la otra parte instaló la clave pública que realmente generaste.
Errores comunes de formato de clave
Pegar la clave pública donde va la privada
Firmar requiere la mitad privada. Una biblioteca que recibe BEGIN PUBLIC KEY donde esperaba una clave privada suele devolver un error de análisis poco útil en lugar de nombrar el problema real.
-----BEGIN PUBLIC KEY-----
-----BEGIN PRIVATE KEY-----
Estructura PEM equivocada para la biblioteca
Unos pocos ecosistemas leen solo la disposición RSA tradicional: la propia salida -traditional de OpenSSL, algunos SDK de pasarelas de pago, herramientas antiguas de Ruby y Perl. La mayoría de bibliotecas modernas, y el JDK en particular, esperan PKCS#8. Cambia el selector de estructura PEM en vez de buscar un comando de conversión.
-----BEGIN RSA PRIVATE KEY-----
-----BEGIN PRIVATE KEY-----
Perder el salto de línea final
Los archivos PEM terminan con un salto de línea después del último delimitador. Copiar a través de un campo de formulario que recorta espacios produce un archivo que algunos analizadores rechazan de plano, y como el carácter que falta es invisible, el archivo parece correcto en un editor.
-----END PRIVATE KEY-----[EOF]
-----END PRIVATE KEY-----↵[EOF]
Un carácter perdido por el camino
Lo que rompe un PEM es un carácter perdido, insertado o sustituido, no el ancho de línea: casi todos los analizadores aceptan cualquier plegado. Una copia que pasa por un cliente de chat o un campo de formulario puede convertir en silencio un salto de línea en un espacio, y el base64 no da ninguna pista sobre qué carácter falló; la clave simplemente no carga. Usa el botón de copiar en lugar de seleccionar a mano.
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni eSccN1uleXFRBb1g2TN6bk
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni eSccN1uleXFRBb1g2TN6bk
Usar un secreto HS256 donde está configurado RS256
HS256 toma un único secreto compartido; RS256 toma un par de claves. Darle una cadena aleatoria a un firmante RS256 falla ya en el análisis. Genera el par aquí, o usa nuestro generador de secreto JWT si lo que querías era HS256.
alg: RS256, key: 8f3a9c2e1b7d
alg: RS256, key: -----BEGIN PRIVATE KEY-----
Pegar un PEM en authorized_keys
Una clave pública SSH tiene el formato de una sola línea de OpenSSH, ssh-ed25519 AAAA…, y no un bloque PEM, así que pegar la clave pública de esta página en authorized_keys no funcionará. Para una clave RSA puedes derivar la línea correcta en local con ssh-keygen -y; para el acceso SSH en general, generar en la máquina de destino sigue siendo mejor.
-----BEGIN PUBLIC KEY-----
ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub
Quién usa esta herramienta
- Firmar JWT con RS256 o EdDSA
- Los algoritmos JWT asimétricos necesitan un par de claves en lugar de un secreto compartido. Firmas con la clave privada, publicas la clave pública y quienes verifican nunca tienen nada con lo que emitir tokens. Nuestro codificador JWT acepta las claves que produce esta página.
- Firmar webhooks y releases
- Publica la clave pública una vez, firma cada carga útil con la clave privada y quien consume el servicio podrá comprobar la autenticidad sin una credencial compartida que se pueda filtrar.
- Desarrollo local y pruebas
- Las suites de pruebas que ejercitan la verificación de firmas necesitan un par desechable. Generar uno aquí es más rápido que recordar la invocación de OpenSSL.
- Entender cómo es un par de claves
- Alternar entre algoritmos y estructuras PEM uno al lado del otro hace tangibles las diferencias de una forma que leer la especificación no consigue.
- Preparar un endpoint JWKS
- La JWK pública encaja directamente en el array keys de un documento de descubrimiento de OpenID Connect. Añade un kid para que quien verifica pueda seleccionarla durante una rotación, y mantén la JWK privada fuera de ese archivo.
- Migrar fuera de RSA
- Genera el sustituto Ed25519 junto al original RSA y compara los tamaños antes de comprometerte con el cambio.
- Resolver un desajuste de formato
- Cuando una biblioteca rechaza una clave con un error de análisis, volver a emitirla en la otra estructura PEM suele ser toda la solución.
Los formatos PEM y cómo funciona el generador
- Qué contenedor va en cada sitio
- Una clave, cinco empaquetados. Elegir el equivocado es el motivo más habitual de que una clave sea rechazada, y el mensaje de error rara vez es más concreto que un fallo de análisis.
Para convertir archivos que ya tienes,Contenedor Cabecera PEM Contiene Dónde te lo encuentras PKCS#8 BEGIN PRIVATE KEY Cualquier algoritmo Web Crypto, el JDK, Go, .NET: la mayoría de bibliotecas modernas PKCS#1 BEGIN RSA PRIVATE KEY Solo RSA Salida tradicional de OpenSSL, algunas pasarelas de pago, herramientas antiguas de Ruby y Perl SPKI / X.509 BEGIN PUBLIC KEY Cualquier algoritmo, mitad pública La clave pública que espera casi cualquier biblioteca PKCS#1 pública BEGIN RSA PUBLIC KEY Solo RSA, mitad pública Herramientas RSA heredadas JWK ninguna: es JSON Cualquier algoritmo Endpoints JWKS, descubrimiento OIDC, bibliotecas JOSE openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pemhace la conversión en un sentido yopenssl rsa -traditional -in pkcs8.pem -out pkcs1.pemen el otro. - La aleatoriedad viene del sistema operativo
- Web Crypto alimenta la generación de claves desde la fuente de entropía de la plataforma: getrandom en Linux, y el CSPRNG del sistema en Windows y macOS. Es la misma clase de fuente de la que bebe OpenSSL, no un generador pseudoaleatorio de JavaScript.
- La generación no congela la página
- crypto.subtle.generateKey es asíncrona y, en los principales motores de navegador, la búsqueda de primos ocurre fuera del hilo principal, así que la interfaz sigue respondiendo mientras se busca un módulo de 4096 bits. Aun así la página muestra un indicador de progreso, porque lo que tarda esa búsqueda depende de la suerte del sorteo.
- PKCS#8 envuelve a PKCS#1
- Un PrivateKeyInfo de PKCS#8 es un número de versión, un identificador de algoritmo y un OCTET STRING. En una clave rsaEncryption sin cifrar, ese OCTET STRING contiene una RSAPrivateKey de PKCS#1 completa, que es exactamente cómo esta página convierte entre ambos sin volver a derivar nada.
- Las claves públicas usan SubjectPublicKeyInfo
- BEGIN PUBLIC KEY es un SubjectPublicKeyInfo de X.509: un identificador de algoritmo más un BIT STRING. Lo que hay dentro de esos bits depende del algoritmo: en RSA es una RSAPublicKey de PKCS#1, y por eso BEGIN RSA PUBLIC KEY resulta más corta; en ECDSA es el punto de curva sin comprimir, y en Ed25519 la clave en bruto de 32 bytes.
- El exponente público es 65537
- Todas las claves RSA de aquí usan e = 65537, escrito 0x010001. Es lo bastante grande para evitar los ataques de exponente pequeño y solo tiene dos bits a uno, así que verificar cuesta 16 elevaciones al cuadrado y una única multiplicación.
- Las huellas resumen el DER, no el PEM
- La huella SHA-256 se calcula sobre el SubjectPublicKeyInfo binario. Resumir en su lugar el texto base64 haría que cambiara cada vez que cambiase el salto de línea. El equivalente en local es
openssl pkey -in private.pem -pubout -outform DER | openssl dgst -sha256 -binary | openssl base64.
Buenas prácticas de gestión de claves
- Genera las claves donde se vayan a usar
- Una clave privada que viaja por una red ha quedado expuesta en cada salto del camino. Generarla en el navegador mantiene la clave misma fuera de la red, aunque el código de la página sí llegue por ella; generarla en la máquina de destino elimina incluso el paso de copiarla. Para una clave que protege sistemas de producción, prefiere la máquina de destino.
- Prefiere Ed25519 salvo que algo exija RSA
- Ed25519 ofrece seguridad sólida en una clave de 32 bytes, con firma rápida y sin parámetros que puedas configurar mal. Recurre a RSA cuando una contraparte o una biblioteca antigua no te deje otra opción.
- Trata los 2048 bits como el suelo
- NIST SP 800-131A prohíbe RSA por debajo de 2048 bits para generar firmas desde 2013, y ninguna autoridad de certificación pública emitirá contra una clave menor. Elige 3072 o 4096 para claves que vayan a permanecer en servicio muchos años.
- Nunca subas una clave privada al repositorio
- Guarda las claves privadas en un gestor de secretos o en una variable de entorno que se cargue en tiempo de ejecución. Una vez que una clave llega a un repositorio, rotarla es la única respuesta segura.
- Rota por calendario, no solo después de un incidente
- Publica las claves públicas nuevas con un identificador de clave antes de retirar las antiguas, para que quien verifica pueda aceptar ambas durante el solapamiento. La rotación que se practica por rutina es la que funciona bajo presión.
Preguntas frecuentes
¿Es seguro generar una clave privada en un sitio web?
¿Cuál es la diferencia entre PKCS#8 y PKCS#1?
¿Cómo convierto una clave PKCS#1 a PKCS#8, o al revés?
¿Cómo obtengo la clave pública a partir de una clave privada RSA?
¿Debería elegir RSA o Ed25519?
¿RSA de 2048 bits sigue siendo lo bastante fuerte?
¿Puedo usar estas claves para firmar JWT?
¿Puede esto generar una clave SSH?
¿Puedo proteger la clave privada con una frase de contraseña?
¿Para qué sirve la huella?
Herramientas relacionadas
Ver todas las herramientas →Descifrado AES — Compatible con OpenSSL y CryptoJS
Herramientas de Seguridad
Descifra AES en línea — GCM/CBC/CTR, frase de contraseña o clave sin procesar, detecta automáticamente el formato "U2FsdGVkX1" de OpenSSL y CryptoJS. 100 % en el navegador, las claves nunca salen de la página.
Herramienta de Cifrado AES — GCM, CBC y CTR
Herramientas de Seguridad
Cifrado AES online y gratuito — AES-128/192/256, GCM/CBC/CTR, frase de contraseña (PBKDF2) o clave sin procesar. Se ejecuta 100 % en tu navegador; nada se sube a un servidor.
Generador y verificador de hash bcrypt
Herramientas de Seguridad
Genera y verifica hashes bcrypt de contraseñas online — coste ajustable, prefijos $2b$/$2a$/$2y$. 100 % en tu navegador; tu contraseña nunca se sube.
Generador HMAC y verificador de firmas
Herramientas de Seguridad
Generador y verificador HMAC en línea gratis. Calcula HMAC-SHA256/SHA1/SHA384/SHA512 con claves en texto, hex o Base64 y salida Hex/Base64/Base64URL. 100 % en tu navegador: las claves nunca salen de la página.
Decodificador JWT
Herramientas de Seguridad
Decodifica tokens JWT online con nuestro decodificador JWT gratis. Inspecciona encabezado, carga útil, firma, expiración y reclamaciones al instante. 100% navegador — tu token nunca sale del dispositivo. Sin registro ni rastreo.
Codificador y Generador JWT
Herramientas de Seguridad
Generador y codificador JWT gratis online. Construye el encabezado y la carga útil, firma con HS256, RS256 o ES256 al instante. 100% en el navegador — tu secreto y tu clave nunca salen de tu dispositivo.