SubtleCrypto: método generateKey()

Baseline Widely available *

This feature is well established and works across many devices and browser versions. It’s been available across browsers since enero de 2020.

* Some parts of this feature may have varying levels of support.

Learn more
See full compatibility

Contexto seguro: Esta función está disponible solo en contextos seguros (HTTPS), en algunos o todos los navegadores que lo soportan.

Nota: Esta característica está disponible en Web Workers.

El método generateKey() de la interfaz SubtleCrypto se utiliza para generar una nueva clave (para algoritmos simétricos) o un par de claves (para algoritmos de clave pública).

Sintaxis

generateKey(algorithm, extractable, keyUsages)

Parámetros

algorithm

Un objeto que define el tipo de clave que se va a generar y proporciona parámetros adicionales específicos del algoritmo.

Para RSASSA-PKCS1-v1_5, RSA-PSS, o RSA-OAEP: pase un objeto RsaHashedKeyGenParams.
Para ECDSA o ECDH: pase un objeto EcKeyGenParams.
Para HMAC: pase un objeto HmacKeyGenParams.
Para AES-CTR, AES-CBC, AES-GCM, o AES-KW: pase un objeto AesKeyGenParams.
Para Ed25519: pase una cadena de texto Ed25519 o un objeto de la forma { name: "Ed25519" }.
Para X25519: pase la cadena de texto X25519 o un objeto de la forma { name: "X25519" }.

extractable

Un valor booleano que indica si será posible exportar la clave utilizando SubtleCrypto.exportKey() o SubtleCrypto.wrapKey(). Tenga en cuenta que al generar un par de claves asimétricas (como una RSA o ECDSA), el parámetro extractable determina si la clave privada se puede exportar; la clave pública siempre es extraíble.

keyUsages

Un Array de cadenas de texto que indica qué se puede hacer con las claves recién generadas. Los valores posibles de los elementos del array son:

encrypt: La clave se puede usar para cifrar mensajes.
decrypt: La clave se puede usar para descifrar mensajes.
sign: La clave se puede usar para firmar mensajes.
verify: La clave se puede usar para verificar firmas.
deriveKey: La clave se puede usar para generar una nueva clave.
deriveBits: La clave se puede usar para derivar bits.
wrapKey: La clave se puede usar para envolver una clave.
unwrapKey: La clave se puede usar para desenvolver una clave.

Valor de retorno

Un objeto Promise que se resuelve con un CryptoKey (para algoritmos simétricos) o una CryptoKeyPair (para algoritmos de clave pública).

Excepciones

La promesa se rechaza cuando se presentan las siguientes excepciones:

SyntaxError DOMException: Se lanza cuando el resultado es un CryptoKey de tipo secret o private pero keyUsages está vacío o no es válido para el tipo de algoritmo.
SyntaxError DOMException: Se lanza cuando el resultado es un CryptoKeyPair y su atributo privateKey.usages está vacío o no es válido para el tipo de algoritmo.

Ejemplos

Nota: Puedes probar los ejemplos prácticos en GitHub.

Generación de un par de claves RSA

Este código genera un par de claves de cifrado RSA-OAEP. Consulta el código completo en GitHub.

let keyPair = await window.crypto.subtle.generateKey(
  {
    name: "RSA-OAEP",
    modulusLength: 4096,
    publicExponent: new Uint8Array([1, 0, 1]),
    hash: "SHA-256",
  },
  true,
  ["encrypt", "decrypt"],
);

Generación de un par de claves de curva elíptica

Este código genera un par de claves de firma ECDSA. Consulta el código completo en GitHub.

let keyPair = await window.crypto.subtle.generateKey(
  {
    name: "ECDSA",
    namedCurve: "P-384",
  },
  true,
  ["sign", "verify"],
);

Generación de clave HMAC

Este código genera una clave de firma HMAC. Consulta el código completo en GitHub.

let key = await window.crypto.subtle.generateKey(
  {
    name: "HMAC",
    hash: { name: "SHA-512" },
  },
  true,
  ["sign", "verify"],
);

Generación de clave AES

Este código genera una clave de cifrado AES-GCM. Consulta el código completo en GitHub.

let key = await window.crypto.subtle.generateKey(
  {
    name: "AES-GCM",
    length: 256,
  },
  true,
  ["encrypt", "decrypt"],
);

Generación de claves Ed25519

Este código genera un par de claves de firma Ed25519. Se deriva de este código fuente en GitHub, que puedes ver en directo aquí.

<input id="run-button" type="button" value="Run" />
<pre id="log">Click "Run" button</pre>

#log {
  height: 170px;
  white-space: pre-wrap; /* envolver los bloques previos */
  overflow-wrap: break-word; /* división de palabras */
  overflow-y: auto;
  padding: 0.5rem;
  border: 1px solid black;
}

const logElement = document.querySelector("#log");
function log(text) {
  logElement.innerText = `${logElement.innerText}${text}\n`;
  logElement.scrollTop = logElement.scrollHeight;
}

JavaScript

A continuación se muestra el código para generar un par de claves utilizando el algoritmo Ed25519 y registrar la información de cada clave. Tenga en cuenta que el código se ejecuta dentro de un bloque try..catch ya que no todos los navegadores admiten este algoritmo.

El código JavaScript primero obtiene los elementos #sign-button y #message <input> y luego añade un detector de evento "click" en el botón. El manejador de evento borra el registro y ejecuta las demás operaciones pasando el contenido del elemento <input>.

const button = document.querySelector("#run-button");
const input = document.querySelector("#log");

button.addEventListener("click", () => {
  // Borra los registros
  logElement.innerText = "";
  logElement.scrollTop = logElement.scrollHeight;
  // Ejecuta la función test
  test();
});

async function test() {
  try {
    // Crea un par de claves y usa desestructuración para asignarlas a las variables.
    const { publicKey, privateKey } = await crypto.subtle.generateKey(
      {
        name: "Ed25519",
      },
      true,
      ["sign", "verify"],
    );

    // Muestra las propiedades de las claves
    log(`Clave pública: ${publicKey}`);
    log(`Tipo: ${publicKey.type}`);
    log(`Extraíble: ${publicKey.extractable}`);
    log(`Algoritmo: ${JSON.stringify(publicKey.algorithm)}`);
    log(`Usos: ${publicKey.usages}`);
    log(`Clave privada: ${privateKey}`);
    log(`Tipo: ${privateKey.type}`);
    log(`Extraíble: ${privateKey.extractable}`);
    log(`Algoritmo: ${JSON.stringify(privateKey.algorithm)}`);
    log(`Usos: ${privateKey.usages}`);
  } catch (error) {
    log(error);
  }
}

Resultado

La información sobre las claves creadas se muestra a continuación (o un mensaje de error en el navegador si no permite crear la clave).

Generación de clave X25519

Este código genera un par de claves pública y privada X25519 que se puede utilizar en SubtleCrypto.deriveKey() para crear una clave compartida o en SubtleCrypto.deriveBits() para crear un secreto compartido.

<input id="run-button" type="button" value="Run" />
<pre id="log">Click "Run" button</pre>

#log {
  height: 170px;
  white-space: pre-wrap; /* envolver el bloque previo */
  overflow-wrap: break-word; /* división de palabras */
  overflow-y: auto;
  padding: 0.5rem;
  border: 1px solid black;
}

const logElement = document.querySelector("#log");
function log(text) {
  logElement.innerText = `${logElement.innerText}${text}\n`;
  logElement.scrollTop = logElement.scrollHeight;
}

JavaScript

A continuación se muestra el código para generar un par de claves utilizando el algoritmo X25519 y registrar la información de cada clave. Tenga en cuenta que el código se ejecuta dentro de un bloque try..catch ya que no todos los navegadores admiten este algoritmo.

El código JavaScript primero obtiene los elementos #run-button y #log <input>, luego agrega un detector de evento click en el botón. El manejador de evento borra el registro, genera un par de claves X25519 y registra algunas de sus propiedades.

const button = document.querySelector("#run-button");
const input = document.querySelector("#log");

button.addEventListener("click", () => {
  // Borra los registros
  logElement.innerText = "";
  logElement.scrollTop = logElement.scrollHeight;
  // Ejecuta función test
  test();
});

async function test() {
  try {
    // Crea un par de claves y usa desestructuración para asignarlas a las variables.
    const { publicKey, privateKey } = await crypto.subtle.generateKey(
      {
        name: "X25519",
      },
      true,
      ["deriveKey", "deriveBits"],
    );

    // Registra las propiedades de las claves
    log(`Clave pública: ${publicKey}`);
    log(`Tipo: ${publicKey.type}`);
    log(`Extraíble: ${publicKey.extractable}`);
    log(`Algoritmo: ${JSON.stringify(publicKey.algorithm)}`);
    log(`Uso: ${publicKey.usages}`);
    log(`Clave privada: ${privateKey}`);
    log(`Tipo: ${privateKey.type}`);
    log(`Extraíble: ${privateKey.extractable}`);
    log(`Algoritmo: ${JSON.stringify(privateKey.algorithm)}`);
    log(`Uso: ${privateKey.usages}`);
  } catch (error) {
    log(error);
  }
}

Resultado

A continuación se registra la información sobre las claves creadas (o un mensaje de error si el navegador no permite crear la clave).

Especificaciones

Specification
Web Cryptography Level 2 # SubtleCrypto-method-generateKey

Compatibilidad con navegadores

Véase también

Help improve MDN

Learn how to contribute

This page was last modified on 16 jun 2026 by MDN contributors.

View this page on GitHub • Report a problem with this content