SubtleCrypto: Methode exportKey()

Baseline

Weitgehend verfügbar

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Januar 2020 browserübergreifend verfügbar.

* Einige Teile dieser Funktion werden möglicherweise unterschiedlich gut unterstützt.

Vollständige Kompatibilität anzeigen
Mehr erfahren

Sicherer Kontext: Diese Funktion ist nur in sicheren Kontexten (HTTPS) in einigen oder allen unterstützenden Browsern verfügbar.

Hinweis: Diese Funktion ist in Web Workers verfügbar.

Die Methode exportKey() des SubtleCrypto-Interfaces exportiert einen Schlüssel: Sie nimmt ein CryptoKey-Objekt entgegen und gibt den Schlüssel in einem externen, portablen Format zurück.

Damit ein Schlüssel exportiert werden kann, muss CryptoKey.extractable auf true gesetzt sein.

Schlüssel können in mehreren Formaten exportiert werden. Einzelheiten finden Sie unter Unterstützte Formate auf der Seite zu SubtleCrypto.importKey().

Schlüssel werden nicht in einem verschlüsselten Format exportiert. Wenn Sie Schlüssel beim Exportieren verschlüsseln möchten, verwenden Sie stattdessen die API SubtleCrypto.wrapKey().

Syntax

exportKey(format, key)

Parameter

format

Ein String-Wert, der das Datenformat beschreibt, in dem der Schlüssel exportiert werden soll. Möglich sind:

key

Der zu exportierende CryptoKey.

Rückgabewert

Eine Promise.

Wenn format den Wert jwk hat, wird die Promise mit einem JSON-Objekt erfüllt, das den Schlüssel enthält.
Andernfalls wird die Promise mit einem ArrayBuffer erfüllt, der den Schlüssel enthält.

Ausnahmen

Die Promise wird abgelehnt, wenn eine der folgenden Ausnahmen auftritt:

InvalidAccessError DOMException: Tritt auf, wenn versucht wird, einen nicht extrahierbaren Schlüssel zu exportieren.
NotSupportedError DOMException: Tritt auf, wenn versucht wird, in ein unbekanntes Format zu exportieren.
TypeError: Tritt auf, wenn versucht wird, ein ungültiges Format zu verwenden.

Beispiele

Hinweis: Sie können die funktionsfähigen Beispiele auf GitHub ausprobieren.

Raw-Export

Dieses Beispiel exportiert einen AES-Schlüssel als ArrayBuffer, der die Bytes des Schlüssels enthält. Den vollständigen Code finden Sie auf GitHub.

/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
  const exported = await window.crypto.subtle.exportKey("raw", key);
  const exportedKeyBuffer = new Uint8Array(exported);

  const exportKeyOutput = document.querySelector(".exported-key");
  exportKeyOutput.textContent = `[${exportedKeyBuffer}]`;
}

/*
Generate an encrypt/decrypt secret key,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
  .generateKey(
    {
      name: "AES-GCM",
      length: 256,
    },
    true,
    ["encrypt", "decrypt"],
  )
  .then((key) => {
    const exportButton = document.querySelector(".raw");
    exportButton.addEventListener("click", () => {
      exportCryptoKey(key);
    });
  });

PKCS #8-Export

Dieses Beispiel exportiert einen privaten RSA-Signaturschlüssel als PKCS #8-Objekt. Der exportierte Schlüssel wird anschließend PEM-kodiert. Den vollständigen Code finden Sie auf GitHub.

/*
Convert an ArrayBuffer into a string
from https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string/
*/
function ab2str(buf) {
  return String.fromCharCode.apply(null, new Uint8Array(buf));
}

/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
  const exported = await window.crypto.subtle.exportKey("pkcs8", key);
  const exportedAsString = ab2str(exported);
  const exportedAsBase64 = window.btoa(exportedAsString);
  const pemExported = `-----BEGIN PRIVATE KEY-----\n${exportedAsBase64}\n-----END PRIVATE KEY-----`;

  const exportKeyOutput = document.querySelector(".exported-key");
  exportKeyOutput.textContent = pemExported;
}

/*
Generate a sign/verify key pair,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
  .generateKey(
    {
      name: "RSA-PSS",
      // Consider using a 4096-bit key for systems that require long-term security
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: "SHA-256",
    },
    true,
    ["sign", "verify"],
  )
  .then((keyPair) => {
    const exportButton = document.querySelector(".pkcs8");
    exportButton.addEventListener("click", () => {
      exportCryptoKey(keyPair.privateKey);
    });
  });

SubjectPublicKeyInfo-Export

Dieses Beispiel exportiert einen öffentlichen RSA-Verschlüsselungsschlüssel als PEM-kodiertes SubjectPublicKeyInfo-Objekt. Den vollständigen Code finden Sie auf GitHub.

/*
Convert an ArrayBuffer into a string
from https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string/
*/
function ab2str(buf) {
  return String.fromCharCode.apply(null, new Uint8Array(buf));
}

/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
  const exported = await window.crypto.subtle.exportKey("spki", key);
  const exportedAsString = ab2str(exported);
  const exportedAsBase64 = window.btoa(exportedAsString);
  const pemExported = `-----BEGIN PUBLIC KEY-----\n${exportedAsBase64}\n-----END PUBLIC KEY-----`;

  const exportKeyOutput = document.querySelector(".exported-key");
  exportKeyOutput.textContent = pemExported;
}

/*
Generate an encrypt/decrypt key pair,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
  .generateKey(
    {
      name: "RSA-OAEP",
      // Consider using a 4096-bit key for systems that require long-term security
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: "SHA-256",
    },
    true,
    ["encrypt", "decrypt"],
  )
  .then((keyPair) => {
    const exportButton = document.querySelector(".spki");
    exportButton.addEventListener("click", () => {
      exportCryptoKey(keyPair.publicKey);
    });
  });

JSON Web Key-Export

Dieses Beispiel exportiert einen privaten ECDSA-Signaturschlüssel als JSON Web Key-Objekt. Den vollständigen Code finden Sie auf GitHub.

/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
  const exported = await window.crypto.subtle.exportKey("jwk", key);
  const exportKeyOutput = document.querySelector(".exported-key");
  exportKeyOutput.textContent = JSON.stringify(exported, null, " ");
}

/*
Generate a sign/verify key pair,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
  .generateKey(
    {
      name: "ECDSA",
      namedCurve: "P-384",
    },
    true,
    ["sign", "verify"],
  )
  .then((keyPair) => {
    const exportButton = document.querySelector(".jwk");
    exportButton.addEventListener("click", () => {
      exportCryptoKey(keyPair.privateKey);
    });
  });

Spezifikationen

Spezifikation
Web Cryptography Level 2 # SubtleCrypto-method-exportKey

Browser-Kompatibilität

Siehe auch

Help improve MDN

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden