Node.js v25.0.0 ドキュメンテーション

鍵の生成#

<SubtleCrypto> クラスは、対称 (秘密) 鍵または非対称鍵ペア (公開鍵と秘密鍵) を生成するために使用できます。

const { subtle } = globalThis.crypto;

async function generateAesKey(length = 256) {
  const key = await subtle.generateKey({
    name: 'AES-CBC',
    length,
  }, true, ['encrypt', 'decrypt']);

  return key;
} copy

const { subtle } = globalThis.crypto;

async function generateEcKey(namedCurve = 'P-521') {
  const {
    publicKey,
    privateKey,
  } = await subtle.generateKey({
    name: 'ECDSA',
    namedCurve,
  }, true, ['sign', 'verify']);

  return { publicKey, privateKey };
} copy

const { subtle } = globalThis.crypto;

async function generateEd25519Key() {
  return subtle.generateKey({
    name: 'Ed25519',
  }, true, ['sign', 'verify']);
}

async function generateX25519Key() {
  return subtle.generateKey({
    name: 'X25519',
  }, true, ['deriveKey']);
} copy

const { subtle } = globalThis.crypto;

async function generateHmacKey(hash = 'SHA-256') {
  const key = await subtle.generateKey({
    name: 'HMAC',
    hash,
  }, true, ['sign', 'verify']);

  return key;
} copy

const { subtle } = globalThis.crypto;
const publicExponent = new Uint8Array([1, 0, 1]);

async function generateRsaKey(modulusLength = 2048, hash = 'SHA-256') {
  const {
    publicKey,
    privateKey,
  } = await subtle.generateKey({
    name: 'RSASSA-PKCS1-v1_5',
    modulusLength,
    publicExponent,
    hash,
  }, true, ['sign', 'verify']);

  return { publicKey, privateKey };
} copy

暗号化と復号#

const crypto = globalThis.crypto;

async function aesEncrypt(plaintext) {
  const ec = new TextEncoder();
  const key = await generateAesKey();
  const iv = crypto.getRandomValues(new Uint8Array(16));

  const ciphertext = await crypto.subtle.encrypt({
    name: 'AES-CBC',
    iv,
  }, key, ec.encode(plaintext));

  return {
    key,
    iv,
    ciphertext,
  };
}

async function aesDecrypt(ciphertext, key, iv) {
  const dec = new TextDecoder();
  const plaintext = await crypto.subtle.decrypt({
    name: 'AES-CBC',
    iv,
  }, key, ciphertext);

  return dec.decode(plaintext);
} copy

鍵のエクスポートとインポート#

const { subtle } = globalThis.crypto;

async function generateAndExportHmacKey(format = 'jwk', hash = 'SHA-512') {
  const key = await subtle.generateKey({
    name: 'HMAC',
    hash,
  }, true, ['sign', 'verify']);

  return subtle.exportKey(format, key);
}

async function importHmacKey(keyData, format = 'jwk', hash = 'SHA-512') {
  const key = await subtle.importKey(format, keyData, {
    name: 'HMAC',
    hash,
  }, true, ['sign', 'verify']);

  return key;
} copy

鍵のラッピングとアンラッピング#

const { subtle } = globalThis.crypto;

async function generateAndWrapHmacKey(format = 'jwk', hash = 'SHA-512') {
  const [
    key,
    wrappingKey,
  ] = await Promise.all([
    subtle.generateKey({
      name: 'HMAC', hash,
    }, true, ['sign', 'verify']),
    subtle.generateKey({
      name: 'AES-KW',
      length: 256,
    }, true, ['wrapKey', 'unwrapKey']),
  ]);

  const wrappedKey = await subtle.wrapKey(format, key, wrappingKey, 'AES-KW');

  return { wrappedKey, wrappingKey };
}

async function unwrapHmacKey(
  wrappedKey,
  wrappingKey,
  format = 'jwk',
  hash = 'SHA-512') {

  const key = await subtle.unwrapKey(
    format,
    wrappedKey,
    wrappingKey,
    'AES-KW',
    { name: 'HMAC', hash },
    true,
    ['sign', 'verify']);

  return key;
} copy

署名と検証#

const { subtle } = globalThis.crypto;

async function sign(key, data) {
  const ec = new TextEncoder();
  const signature =
    await subtle.sign('RSASSA-PKCS1-v1_5', key, ec.encode(data));
  return signature;
}

async function verify(key, signature, data) {
  const ec = new TextEncoder();
  const verified =
    await subtle.verify(
      'RSASSA-PKCS1-v1_5',
      key,
      signature,
      ec.encode(data));
  return verified;
} copy

ビットと鍵の導出#

const { subtle } = globalThis.crypto;

async function pbkdf2(pass, salt, iterations = 1000, length = 256) {
  const ec = new TextEncoder();
  const key = await subtle.importKey(
    'raw',
    ec.encode(pass),
    'PBKDF2',
    false,
    ['deriveBits']);
  const bits = await subtle.deriveBits({
    name: 'PBKDF2',
    hash: 'SHA-512',
    salt: ec.encode(salt),
    iterations,
  }, key, length);
  return bits;
}

async function pbkdf2Key(pass, salt, iterations = 1000, length = 256) {
  const ec = new TextEncoder();
  const keyMaterial = await subtle.importKey(
    'raw',
    ec.encode(pass),
    'PBKDF2',
    false,
    ['deriveKey']);
  const key = await subtle.deriveKey({
    name: 'PBKDF2',
    hash: 'SHA-512',
    salt: ec.encode(salt),
    iterations,
  }, keyMaterial, {
    name: 'AES-GCM',
    length,
  }, true, ['encrypt', 'decrypt']);
  return key;
} copy

ダイジェスト#

const { subtle } = globalThis.crypto;

async function digest(data, algorithm = 'SHA-512') {
  const ec = new TextEncoder();
  const digest = await subtle.digest(algorithm, ec.encode(data));
  return digest;
} copy

実行時のアルゴリズムサポートの確認#

SubtleCrypto.supports() は、Web Crypto API の機能検出を可能にし、特定のアルゴリズム識別子 (そのパラメータを含む) が与えられた操作でサポートされているかどうかを検出するために使用できます。

この例では、利用可能であれば Argon2、そうでなければ PBKDF2 を使用してパスワードから鍵を導出し、利用可能であれば AES-OCB、そうでなければ AES-GCM を使用してテキストを暗号化および復号します。

const { SubtleCrypto, crypto } = globalThis;

const password = 'correct horse battery staple';
const derivationAlg =
  SubtleCrypto.supports?.('importKey', 'Argon2id') ?
    'Argon2id' :
    'PBKDF2';
const encryptionAlg =
  SubtleCrypto.supports?.('importKey', 'AES-OCB') ?
    'AES-OCB' :
    'AES-GCM';
const passwordKey = await crypto.subtle.importKey(
  derivationAlg === 'Argon2id' ? 'raw-secret' : 'raw',
  new TextEncoder().encode(password),
  derivationAlg,
  false,
  ['deriveKey'],
);
const nonce = crypto.getRandomValues(new Uint8Array(16));
const derivationParams =
  derivationAlg === 'Argon2id' ?
    {
      nonce,
      parallelism: 4,
      memory: 2 ** 21,
      passes: 1,
    } :
    {
      salt: nonce,
      iterations: 100_000,
      hash: 'SHA-256',
    };
const key = await crypto.subtle.deriveKey(
  {
    name: derivationAlg,
    ...derivationParams,
  },
  passwordKey,
  {
    name: encryptionAlg,
    length: 256,
  },
  false,
  ['encrypt', 'decrypt'],
);
const plaintext = 'Hello, world!';
const iv = crypto.getRandomValues(new Uint8Array(16));
const encrypted = await crypto.subtle.encrypt(
  { name: encryptionAlg, iv },
  key,
  new TextEncoder().encode(plaintext),
);
const decrypted = new TextDecoder().decode(await crypto.subtle.decrypt(
  { name: encryptionAlg, iv },
  key,
  encrypted,
)); copy

鍵管理 API#

暗号操作 API#

列の凡例

• 暗号化: subtle.encrypt() / subtle.decrypt()
• 署名と MAC: subtle.sign() / subtle.verify()
• 鍵またはビットの導出: subtle.deriveBits() / subtle.deriveKey()
• 鍵のラッピング: subtle.wrapKey() / subtle.unwrapKey()
• 鍵のカプセル化: subtle.encapsulateBits() / subtle.decapsulateBits() / subtle.encapsulateKey() / subtle.decapsulateKey()
• ダイジェスト: subtle.digest()

crypto.subtle#

• 型: <SubtleCrypto>

SubtleCrypto API へのアクセスを提供します。

crypto.getRandomValues(typedArray)#

• typedArray <Buffer> | <TypedArray>
• 戻り値: <Buffer> | <TypedArray>

暗号学的に強力な乱数値を生成します。指定された typedArray は乱数値で満たされ、typedArray への参照が返されます。

指定された typedArray は、整数ベースの <TypedArray> のインスタンスでなければなりません。つまり、Float32Array と Float64Array は受け付けられません。

指定された typedArray が 65,536 バイトより大きい場合、エラーがスローされます。

crypto.randomUUID()#

• 戻り値: <string>

ランダムな RFC 4122 バージョン 4 UUID を生成します。UUID は、暗号化擬似乱数生成器を使用して生成されます。

cryptoKey.algorithm#

• 型: <KeyAlgorithm> | <RsaHashedKeyAlgorithm> | <EcKeyAlgorithm> | <AesKeyAlgorithm> | <HmacKeyAlgorithm> | <KmacKeyAlgorithm>

鍵が使用できるアルゴリズムと、アルゴリズム固有の追加パラメータを詳述するオブジェクトです。

読み取り専用です。

cryptoKey.extractable#

• 型: <boolean>

true の場合、<CryptoKey> は subtle.exportKey() または subtle.wrapKey() を使用して取り出すことができます。

読み取り専用です。

cryptoKey.type#

• 型: <string> 'secret'、'private'、または 'public' のいずれか。

鍵が対称鍵 ('secret') か非対称鍵 ('private' または 'public') かを識別する文字列です。

cryptoKey.usages#

• 型: <string[]>

鍵が使用できる操作を識別する文字列の配列です。

可能な用途は以下の通りです。

• 'encrypt' - subtle.encrypt() で鍵を使用できるようにします。
• 'decrypt' - subtle.decrypt() で鍵を使用できるようにします。
• 'sign' - subtle.sign() で鍵を使用できるようにします。
• 'verify' - subtle.verify() で鍵を使用できるようにします。
• 'deriveKey' - subtle.deriveKey() で鍵を使用できるようにします。
• 'deriveBits' - subtle.deriveBits() で鍵を使用できるようにします。
• 'encapsulateBits' - subtle.encapsulateBits() で鍵を使用できるようにします。
• 'decapsulateBits' - subtle.decapsulateBits() で鍵を使用できるようにします。
• 'encapsulateKey' - subtle.encapsulateKey() で鍵を使用できるようにします。
• 'decapsulateKey' - subtle.decapsulateKey() で鍵を使用できるようにします。
• 'wrapKey' - subtle.wrapKey() で鍵を使用できるようにします。
• 'unwrapKey' - subtle.unwrapKey() で鍵を使用できるようにします。

有効な鍵の用途は、鍵アルゴリズム (cryptokey.algorithm.name によって識別) に依存します。

列の凡例

• 暗号化: subtle.encrypt() / subtle.decrypt()
• 署名と MAC: subtle.sign() / subtle.verify()
• 鍵またはビットの導出: subtle.deriveBits() / subtle.deriveKey()
• 鍵のラッピング: subtle.wrapKey() / subtle.unwrapKey()
• 鍵のカプセル化: subtle.encapsulateBits() / subtle.decapsulateBits() / subtle.encapsulateKey() / subtle.decapsulateKey()

cryptoKeyPair.privateKey#

• 型: <CryptoKey> type が 'private' となる <CryptoKey> です。

cryptoKeyPair.publicKey#

• 型: <CryptoKey> type が 'public' となる <CryptoKey> です。

静的メソッド: SubtleCrypto.supports(operation, algorithm[, lengthOrAdditionalAlgorithm])#

• operation <string> "encrypt", "decrypt", "sign", "verify", "digest", "generateKey", "deriveKey", "deriveBits", "importKey", "exportKey", "getPublicKey", "wrapKey", "unwrapKey", "encapsulateBits", "encapsulateKey", "decapsulateBits", または "decapsulateKey"
• algorithm <string> | <Algorithm>
• lengthOrAdditionalAlgorithm <null> | <number> | <string> | <Algorithm> | <undefined> 操作に応じて、これは無視されるか、操作が "deriveBits" の場合は length 引数の値、操作が "deriveKey" の場合は導出される鍵のアルゴリズム、操作が "wrapKey" の場合はラッピング前にエクスポートされる鍵のアルゴリズム、操作が "unwrapKey" の場合はアンラッピング後にインポートされる鍵のアルゴリズム、操作が "encapsulateKey" または "decapsulateKey" の場合は鍵のカプセル化/カプセル化解除後にインポートされる鍵のアルゴリズムになります。デフォルト: 操作が "deriveBits" の場合は null、それ以外の場合は undefined。
• 戻り値: <boolean> 実装が指定された操作をサポートしているかどうかを示します。

Web Crypto API の機能検出を可能にし、特定のアルゴリズム識別子 (そのパラメータを含む) が与えられた操作でサポートされているかどうかを検出するために使用できます。

このメソッドの使用例については、実行時のアルゴリズムサポートの確認 を参照してください。

subtle.decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext)#

• decapsulationAlgorithm <string> | <Algorithm>
• decapsulationKey <CryptoKey>
• ciphertext <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

メッセージ受信者は、非対称秘密鍵を使用して「カプセル化された鍵」(暗号文) を復号し、それによって一時的な対称鍵 (<ArrayBuffer> として表現) を回復し、それを使用してメッセージを復号します。

現在サポートされているアルゴリズムは以下の通りです。

• 'ML-KEM-512'⁴
• 'ML-KEM-768'⁴
• 'ML-KEM-1024'⁴

subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)#

• decapsulationAlgorithm <string> | <Algorithm>
• decapsulationKey <CryptoKey>
• ciphertext <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• sharedKeyAlgorithm <string> | <Algorithm> | <HmacImportParams> | <AesDerivedKeyParams> | <KmacImportParams>
• extractable <boolean>
• usages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <CryptoKey> で fulfillment されます。

メッセージ受信者は、非対称秘密鍵を使用して「カプセル化された鍵」(暗号文) を復号し、それによって一時的な対称鍵 (<CryptoKey> として表現) を回復し、それを使用してメッセージを復号します。

現在サポートされているアルゴリズムは以下の通りです。

• 'ML-KEM-512'⁴
• 'ML-KEM-768'⁴
• 'ML-KEM-1024'⁴

subtle.decrypt(algorithm, key, data)#

• algorithm <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AeadParams>
• key <CryptoKey>
• data <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

algorithm で指定されたメソッドとパラメータ、および key で提供された鍵マテリアルを使用して、このメソッドは提供された data を復号しようとします。成功した場合、返された Promise は平文の結果を含む <ArrayBuffer> で解決されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'AES-CBC'
• 'AES-CTR'
• 'AES-GCM'
• 'AES-OCB'⁴
• 'ChaCha20-Poly1305'⁴
• 'RSA-OAEP'

subtle.deriveBits(algorithm, baseKey[, length])#

• algorithm <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params> | <Argon2Params>
• baseKey <CryptoKey>
• length <number> | <null> デフォルト: null
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

algorithm で指定されたメソッドとパラメータ、および baseKey で提供された鍵マテリアルを使用して、このメソッドは length ビットを生成しようとします。

length が提供されていないか null の場合、特定のアルゴリズムの最大ビット数が生成されます。これは 'ECDH'、'X25519'、および 'X448'⁵ アルゴリズムで許可されており、他のアルゴリズムでは length は数値である必要があります。

成功した場合、返された Promise は生成されたデータを含む <ArrayBuffer> で解決されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'Argon2d'⁴
• 'Argon2i'⁴
• 'Argon2id'⁴
• 'ECDH'
• 'HKDF'
• 'PBKDF2'
• 'X25519'
• 'X448'⁵

subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)#

• algorithm <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params> | <Argon2Params>
• baseKey <CryptoKey>
• derivedKeyAlgorithm <string> | <Algorithm> | <HmacImportParams> | <AesDerivedKeyParams> | <KmacImportParams>
• extractable <boolean>
• keyUsages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <CryptoKey> で fulfillment されます。

algorithm で指定されたメソッドとパラメータ、および baseKey で提供された鍵マテリアルを使用して、このメソッドは derivedKeyAlgorithm のメソッドとパラメータに基づいて新しい <CryptoKey> を生成しようとします。

このメソッドの呼び出しは、subtle.deriveBits() を呼び出して生の鍵マテリアルを生成し、その結果を subtle.importKey() メソッドに入力として deriveKeyAlgorithm、extractable、keyUsages パラメータを使用して渡すことと同等です。

現在サポートされているアルゴリズムは以下の通りです。

• 'Argon2d'⁴
• 'Argon2i'⁴
• 'Argon2id'⁴
• 'ECDH'
• 'HKDF'
• 'PBKDF2'
• 'X25519'
• 'X448'⁵

subtle.digest(algorithm, data)#

• algorithm <string> | <Algorithm> | <CShakeParams>
• data <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

algorithm で識別されるメソッドを使用して、このメソッドは data のダイジェストを生成しようとします。成功した場合、返された Promise は計算されたダイジェストを含む <ArrayBuffer> で解決されます。

algorithm が <string> として提供された場合、それは以下のいずれかでなければなりません。

• 'cSHAKE128'⁴
• 'cSHAKE256'⁴
• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'
• 'SHA3-256'⁴
• 'SHA3-384'⁴
• 'SHA3-512'⁴

algorithm が <Object> として提供された場合、その name プロパティの値は上記のうちの 1 つでなければなりません。

subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)#

• encapsulationAlgorithm <string> | <Algorithm>
• encapsulationKey <CryptoKey>
• 戻り値: <Promise> 成功すると <EncapsulatedBits> で fulfillment されます。

メッセージ受信者の非対称公開鍵を使用して一時的な対称鍵を暗号化します。この暗号化された鍵は、「カプセル化された鍵」であり、<EncapsulatedBits>として表現されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'ML-KEM-512'⁴
• 'ML-KEM-768'⁴
• 'ML-KEM-1024'⁴

subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)#

• encapsulationAlgorithm <string> | <Algorithm>
• encapsulationKey <CryptoKey>
• sharedKeyAlgorithm <string> | <Algorithm> | <HmacImportParams> | <AesDerivedKeyParams> | <KmacImportParams>
• extractable <boolean>
• usages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <EncapsulatedKey> で fulfillment されます。

メッセージ受信者の非対称公開鍵を使用して一時的な対称鍵を暗号化します。この暗号化された鍵は、「カプセル化された鍵」であり、<EncapsulatedKey>として表現されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'ML-KEM-512'⁴
• 'ML-KEM-768'⁴
• 'ML-KEM-1024'⁴

subtle.encrypt(algorithm, key, data)#

• algorithm <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AeadParams>
• key <CryptoKey>
• data <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

algorithm で指定されたメソッドとパラメータ、および key で提供された鍵マテリアルを使用して、このメソッドは data を暗号化しようとします。成功した場合、返された Promise は暗号化された結果を含む <ArrayBuffer> で解決されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'AES-CBC'
• 'AES-CTR'
• 'AES-GCM'
• 'AES-OCB'⁴
• 'ChaCha20-Poly1305'⁴
• 'RSA-OAEP'

subtle.exportKey(format, key)#

• format <string> 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret'⁴, 'raw-public'⁴, または 'raw-seed'⁴ のいずれかでなければなりません。
• key <CryptoKey>
• 戻り値: <Promise> 成功すると <ArrayBuffer> | <Object> で fulfillment されます。

指定された鍵を、サポートされていれば指定されたフォーマットにエクスポートします。

<CryptoKey> が取り出し可能でない場合、返された Promise は reject されます。

format が 'pkcs8' または 'spki' のいずれかで、エクスポートが成功した場合、返された Promise はエクスポートされた鍵データを含む <ArrayBuffer> で解決されます。

format が 'jwk' でエクスポートが成功した場合、返された Promise は JSON Web Key 仕様に準拠した JavaScript オブジェクトで解決されます。

subtle.getPublicKey(key, keyUsages)#

• key <CryptoKey> 対応する公開鍵を導出する元の秘密鍵。
• keyUsages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <CryptoKey> で fulfillment されます。

与えられた秘密鍵から公開鍵を導出します。

subtle.generateKey(algorithm, extractable, keyUsages)#

• algorithm <string> | <Algorithm> | <RsaHashedKeyGenParams> | <EcKeyGenParams> | <HmacKeyGenParams> | <AesKeyGenParams> | <KmacKeyGenParams>

• extractable <boolean>
• keyUsages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <CryptoKey> | <CryptoKeyPair> で fulfillment されます。

algorithm で提供されたパラメータを使用して、このメソッドは新しい鍵マテリアルを生成しようとします。使用されるアルゴリズムに応じて、単一の <CryptoKey> または <CryptoKeyPair> が生成されます。

<CryptoKeyPair> (公開鍵と秘密鍵) を生成するサポートされているアルゴリズムは以下の通りです。

• 'ECDH'
• 'ECDSA'
• 'Ed25519'
• 'Ed448'⁵
• 'ML-DSA-44'⁴
• 'ML-DSA-65'⁴
• 'ML-DSA-87'⁴
• 'ML-KEM-512'⁴
• 'ML-KEM-768'⁴
• 'ML-KEM-1024'⁴
• 'RSA-OAEP'
• 'RSA-PSS'
• 'RSASSA-PKCS1-v1_5'
• 'X25519'
• 'X448'⁵

<CryptoKey> (秘密鍵) を生成するサポートされているアルゴリズムは以下の通りです。

• 'AES-CBC'
• 'AES-CTR'
• 'AES-GCM'
• 'AES-KW'
• 'AES-OCB'⁴
• 'ChaCha20-Poly1305'⁴
• 'HMAC'
• 'KMAC128'⁴
• 'KMAC256'⁴

subtle.importKey(format, keyData, algorithm, extractable, keyUsages)#

• format <string> 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret'⁴, 'raw-public'⁴, または 'raw-seed'⁴ のいずれかでなければなりません。
• keyData <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <Object>

• algorithm <string> | <Algorithm> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams> | <KmacImportParams>

• extractable <boolean>
• keyUsages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <CryptoKey> で fulfillment されます。

このメソッドは、提供された keyData を指定された format として解釈し、提供された algorithm、extractable、keyUsages 引数を使用して <CryptoKey> インスタンスを作成しようとします。インポートが成功した場合、返された Promise は鍵マテリアルの <CryptoKey> 表現で解決されます。

KDF アルゴリズムの鍵をインポートする場合、extractable は false でなければなりません。

現在サポートされているアルゴリズムは以下の通りです。

subtle.sign(algorithm, key, data)#

• algorithm <string> | <Algorithm> | <RsaPssParams> | <EcdsaParams> | <ContextParams> | <KmacParams>
• key <CryptoKey>
• data <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

algorithm で指定されたメソッドとパラメータ、および key で提供された鍵マテリアルを使用して、このメソッドは data の暗号署名を生成しようとします。成功した場合、返された Promise は生成された署名を含む <ArrayBuffer> で解決されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'ECDSA'
• 'Ed25519'
• 'Ed448'⁵
• 'HMAC'
• 'KMAC128'⁴
• 'KMAC256'⁴
• 'ML-DSA-44'⁴
• 'ML-DSA-65'⁴
• 'ML-DSA-87'⁴
• 'RSA-PSS'
• 'RSASSA-PKCS1-v1_5'

subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)#

• format <string> 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret'⁴, 'raw-public'⁴, または 'raw-seed'⁴ のいずれかでなければなりません。
• wrappedKey <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• unwrappingKey <CryptoKey>

• unwrapAlgo <string> | <Algorithm> | <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AeadParams>
• unwrappedKeyAlgo <string> | <Algorithm> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams> | <KmacImportParams>

• extractable <boolean>
• keyUsages <string[]> 鍵の用途を参照してください。
• 戻り値: <Promise> 成功すると <CryptoKey> で fulfillment されます。

暗号学では、「鍵のラッピング」とは、鍵マテリアルをエクスポートしてから暗号化することを指します。このメソッドは、ラップされた鍵を復号し、<CryptoKey> インスタンスを作成しようとします。これは、まず暗号化された鍵データに対して subtle.decrypt() を呼び出し（wrappedKey、unwrapAlgo、unwrappingKey 引数を入力として使用）、その結果を subtle.importKey() メソッドに入力として unwrappedKeyAlgo、extractable、keyUsages 引数を使用して渡すことと同等です。成功した場合、返された Promise は <CryptoKey> オブジェクトで解決されます。

現在サポートされているラッピングアルゴリズムは以下の通りです。

• 'AES-CBC'
• 'AES-CTR'
• 'AES-GCM'
• 'AES-KW'
• 'AES-OCB'⁴
• 'ChaCha20-Poly1305'⁴
• 'RSA-OAEP'

サポートされているアンラップされた鍵アルゴリズムは以下の通りです。

• 'AES-CBC'
• 'AES-CTR'
• 'AES-GCM'
• 'AES-KW'
• 'AES-OCB'⁴
• 'ChaCha20-Poly1305'⁴
• 'ECDH'
• 'ECDSA'
• 'Ed25519'
• 'Ed448'⁵
• 'HMAC'
• 'KMAC128'⁵
• 'KMAC256'⁵
• 'ML-DSA-44'⁴
• 'ML-DSA-65'⁴
• 'ML-DSA-87'⁴
• 'ML-KEM-512'⁴
• 'ML-KEM-768'⁴
• 'ML-KEM-1024'⁴v
• 'RSA-OAEP'
• 'RSA-PSS'
• 'RSASSA-PKCS1-v1_5'
• 'X25519'
• 'X448'⁵

subtle.verify(algorithm, key, signature, data)#

• algorithm <string> | <Algorithm> | <RsaPssParams> | <EcdsaParams> | <ContextParams> | <KmacParams>
• key <CryptoKey>
• signature <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• data <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> 成功すると <boolean> で fulfillment されます。

algorithm で指定されたメソッドとパラメータ、および key で提供された鍵マテリアルを使用して、このメソッドは signature が data の有効な暗号署名であることを検証しようとします。返された Promise は true または false のいずれかで解決されます。

現在サポートされているアルゴリズムは以下の通りです。

• 'ECDSA'
• 'Ed25519'
• 'Ed448'⁵
• 'HMAC'
• 'KMAC128'⁵
• 'KMAC256'⁵
• 'ML-DSA-44'⁴
• 'ML-DSA-65'⁴
• 'ML-DSA-87'⁴
• 'RSA-PSS'
• 'RSASSA-PKCS1-v1_5'

subtle.wrapKey(format, key, wrappingKey, wrapAlgo)#

• format <string> 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret'⁴, 'raw-public'⁴, または 'raw-seed'⁴ のいずれかでなければなりません。
• key <CryptoKey>
• wrappingKey <CryptoKey>
• wrapAlgo <string> | <Algorithm> | <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AeadParams>
• 戻り値: <Promise> 成功すると <ArrayBuffer> で fulfillment されます。

暗号学では、「鍵のラッピング」とは、鍵マテリアルをエクスポートしてから暗号化することを指します。このメソッドは、鍵マテリアルを format で識別されるフォーマットにエクスポートし、wrapAlgo で指定されたメソッドとパラメータ、および wrappingKey で提供された鍵マテリアルを使用して暗号化します。これは、subtle.exportKey() を format と key を引数として呼び出し、その結果を subtle.encrypt() メソッドに wrappingKey と wrapAlgo を入力として渡すことと同等です。成功した場合、返された Promise は暗号化された鍵データを含む <ArrayBuffer> で解決されます。

現在サポートされているラッピングアルゴリズムは以下の通りです。

• 'AES-CBC'
• 'AES-CTR'
• 'AES-GCM'
• 'AES-KW'
• 'AES-OCB'⁴
• 'ChaCha20-Poly1305'⁴
• 'RSA-OAEP'

クラス: Algorithm#

クラス: AeadParams#

クラス: AesDerivedKeyParams#

クラス: AesCbcParams#

クラス: AesCtrParams#

クラス: AesKeyAlgorithm#

クラス: AesKeyGenParams#

クラス: Argon2Params#

クラス: ContextParams#

クラス: CShakeParams#

クラス: EcdhKeyDeriveParams#

クラス: EcdsaParams#

クラス: EcKeyAlgorithm#

クラス: EcKeyGenParams#

クラス: EcKeyImportParams#

クラス: EncapsulatedBits#

メッセージ暗号化のための一時的な対称秘密鍵 (<ArrayBuffer> として表される) と、この共有鍵で暗号化された暗号文 (メッセージとともにメッセージ受信者に送信可能) です。受信者は自身の秘密鍵を使用して共有鍵が何かを特定し、それによってメッセージを復号化できます。

クラス: EncapsulatedKey#

メッセージ暗号化のための一時的な対称秘密鍵 (<CryptoKey> として表される) と、この共有鍵で暗号化された暗号文 (メッセージとともにメッセージ受信者に送信可能) です。受信者は自身の秘密鍵を使用して共有鍵が何かを特定し、それによってメッセージを復号化できます。

クラス: HkdfParams#

クラス: HmacImportParams#

クラス: HmacKeyAlgorithm#

クラス: HmacKeyGenParams#

クラス: KeyAlgorithm#

クラス: KmacImportParams#

クラス: KmacKeyAlgorithm#

クラス: KmacKeyGenParams#

クラス: KmacParams#

クラス: Pbkdf2Params#

クラス: RsaHashedImportParams#

クラス: RsaHashedKeyAlgorithm#

クラス: RsaHashedKeyGenParams#

クラス: RsaOaepParams#

クラス: RsaPssParams#