Node.js v21.7.2 ドキュメント

例#

キーの生成#

<SubtleCrypto> クラスを使用して、対称 (秘密) キーまたは非対称キーペア (公開キーと秘密キー) を生成できます。

AES キー#

const { subtle } = globalThis.crypto;

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

  return key;
} copy

ECDSA キーペア#

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

Ed25519/Ed448/X25519/X448 キーペア#

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

HMAC キー#

const { subtle } = globalThis.crypto;

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

  return key;
} copy

RSA キーペア#

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

アルゴリズムマトリックス#

この表は、Node.js Web Crypto API 実装でサポートされているアルゴリズムと、それぞれでサポートされている API を詳しく示しています。

クラス: Crypto#

globalThis.crypto は Crypto クラスのインスタンスです。Crypto は、crypto API の残りにアクセスできるシングルトンです。

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#

cryptoKey.algorithm#

• 型: <AesKeyGenParams> | <RsaHashedKeyGenParams> | <EcKeyGenParams> | <HmacKeyGenParams>

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

読み取り専用。

cryptoKey.extractable#

• 型: <boolean>

true の場合、<CryptoKey> は subtleCrypto.exportKey() または subtleCrypto.wrapKey() を使用して抽出できます。

読み取り専用。

cryptoKey.type#

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

キーが対称（'secret'）キーか、非対称（'private' または 'public'）キーかを識別する文字列。

cryptoKey.usages#

• 型: <string[]>

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

可能な使用法は次のとおりです。

• 'encrypt' - キーはデータを暗号化するために使用できます。
• 'decrypt' - キーはデータを復号化するために使用できます。
• 'sign' - キーはデジタル署名を生成するために使用できます。
• 'verify' - キーはデジタル署名を検証するために使用できます。
• 'deriveKey' - キーは新しいキーを派生させるために使用できます。
• 'deriveBits' - キーはビットを派生させるために使用できます。
• 'wrapKey' - キーは別のキーをラップするために使用できます。
• 'unwrapKey' - キーは別のキーをアンラップするために使用できます。

有効なキーの使用法は、キーアルゴリズム（cryptokey.algorithm.name で識別）によって異なります。

クラス: CryptoKeyPair#

CryptoKeyPair は、非対称キーペアを表す publicKey および privateKey プロパティを持つシンプルな辞書オブジェクトです。

cryptoKeyPair.privateKey#

• 型: <CryptoKey> type が 'private' になる <CryptoKey>。

cryptoKeyPair.publicKey#

• 型: <CryptoKey> type が 'public' になる <CryptoKey>。

クラス: SubtleCrypto#

subtle.decrypt(algorithm, key, data)#

• algorithm: <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• key: <CryptoKey>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> <ArrayBuffer> で解決されます。

subtle.decrypt() は、algorithm で指定されたメソッドとパラメーター、および key で提供されたキー材料を使用して、提供された data の解読を試みます。成功した場合、返された promise は平文の結果を含む <ArrayBuffer> で解決されます。

現在サポートされているアルゴリズムは次のとおりです。

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'

subtle.deriveBits(algorithm, baseKey, length)#

• algorithm: <AlgorithmIdentifier> | <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params>
• baseKey: <CryptoKey>
• length: <number> | <null>
• 戻り値: <Promise> <ArrayBuffer> で解決されます。

subtle.deriveBits() は、algorithm で指定されたメソッドとパラメーター、および baseKey で提供されたキー材料を使用して、length ビットを生成しようとします。

Node.js の実装では、length が数値の場合、8 の倍数である必要があります。

length が null の場合、特定のアルゴリズムの最大ビット数が生成されます。これは、'ECDH'、'X25519'、および 'X448' アルゴリズムで許可されています。

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

現在サポートされているアルゴリズムは次のとおりです。

• 'ECDH'
• 'X25519' ¹
• 'X448' ¹
• 'HKDF'
• 'PBKDF2'

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

• algorithm: <AlgorithmIdentifier> | <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params>
• baseKey: <CryptoKey>
• derivedKeyAlgorithm: <HmacKeyGenParams> | <AesKeyGenParams>
• extractable: <boolean>
• keyUsages: <string[]> キーの使用法を参照してください。
• 戻り値: <Promise> <CryptoKey> で解決されます。

subtle.deriveKey() は、algorithm で指定されたメソッドとパラメーター、および baseKey で提供されたキー材料を使用して、derivedKeyAlgorithm のメソッドとパラメーターに基づいて新しい <CryptoKey> を生成しようとします。

subtle.deriveKey() を呼び出すことは、subtle.deriveBits() を呼び出して生のキー材料を生成し、その結果を subtle.importKey() メソッドに deriveKeyAlgorithm、extractable、および keyUsages パラメーターを入力として使用して渡すことと同等です。

現在サポートされているアルゴリズムは次のとおりです。

• 'ECDH'
• 'X25519' ¹
• 'X448' ¹
• 'HKDF'
• 'PBKDF2'

subtle.digest(algorithm, data)#

• algorithm: <string> | <Object>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> <ArrayBuffer> で解決されます。

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

algorithm が <string> として提供されている場合は、次のいずれかである必要があります。

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

algorithm が <Object> として提供されている場合は、値が上記のいずれかである name プロパティが必要です。

subtle.encrypt(algorithm, key, data)#

• algorithm: <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• key: <CryptoKey>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> <ArrayBuffer> で解決されます。

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

現在サポートされているアルゴリズムは次のとおりです。

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'

subtle.exportKey(format, key)#

• format: <string>。'raw'、'pkcs8'、'spki'、または'jwk'のいずれかである必要があります。
• key: <CryptoKey>
• 戻り値: <Promise>。 <ArrayBuffer> | <Object>で解決されます。

指定されたキーを、サポートされている場合は指定された形式にエクスポートします。

<CryptoKey>が抽出可能でない場合、返されるPromiseは拒否されます。

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

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

subtle.generateKey(algorithm, extractable, keyUsages)#

• algorithm: <AlgorithmIdentifier> | <RsaHashedKeyGenParams> | <EcKeyGenParams> | <HmacKeyGenParams> | <AesKeyGenParams>

• extractable: <boolean>
• keyUsages: <string[]> キーの使用法を参照してください。
• 戻り値: <Promise>。 <CryptoKey> | <CryptoKeyPair>で解決されます。

algorithmで提供されたメソッドとパラメータを使用して、subtle.generateKey()は新しいキーマテリアルを生成しようとします。使用されるメソッドに応じて、このメソッドは単一の<CryptoKey>または<CryptoKeyPair>のいずれかを生成する可能性があります。

<CryptoKeyPair>（公開鍵と秘密鍵）を生成するアルゴリズムとしてサポートされているのは次のとおりです。

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'RSA-OAEP'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• 'ECDH'
• 'X25519' ¹
• 'X448' ¹

<CryptoKey>（秘密鍵）を生成するアルゴリズムとしてサポートされているのは次のとおりです。

• 'HMAC'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

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

• format: <string>。'raw'、'pkcs8'、'spki'、または'jwk'のいずれかである必要があります。
• keyData: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <Object>

• algorithm: <AlgorithmIdentifier> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>

• extractable: <boolean>
• keyUsages: <string[]> キーの使用法を参照してください。
• 戻り値: <Promise> <CryptoKey> で解決されます。

subtle.importKey()メソッドは、指定されたkeyDataを、指定されたformatとして解釈し、提供されたalgorithm、extractable、およびkeyUsages引数を使用して<CryptoKey>インスタンスを作成しようとします。インポートが成功した場合、返されるPromiseは作成された<CryptoKey>で解決されます。

'PBKDF2'キーをインポートする場合、extractableはfalseである必要があります。

現在サポートされているアルゴリズムは次のとおりです。

subtle.sign(algorithm, key, data)#

• algorithm: <AlgorithmIdentifier> | <RsaPssParams> | <EcdsaParams> | <Ed448Params>
• key: <CryptoKey>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise> <ArrayBuffer> で解決されます。

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

現在サポートされているアルゴリズムは次のとおりです。

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• 'HMAC'

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

• format: <string>。'raw'、'pkcs8'、'spki'、または'jwk'のいずれかである必要があります。
• wrappedKey: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• unwrappingKey: <CryptoKey>

• unwrapAlgo: <AlgorithmIdentifier> | <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• unwrappedKeyAlgo: <AlgorithmIdentifier> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>

• extractable: <boolean>
• keyUsages: <string[]> キーの使用法を参照してください。
• 戻り値: <Promise> <CryptoKey> で解決されます。

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

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

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

サポートされているラップ解除されたキーアルゴリズムは次のとおりです。

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'RSA-OAEP'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• 'ECDH'
• 'X25519' ¹
• 'X448' ¹
• 'HMAC'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

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

• algorithm: <AlgorithmIdentifier> | <RsaPssParams> | <EcdsaParams> | <Ed448Params>
• key: <CryptoKey>
• signature: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 戻り値: <Promise>。 <boolean>で解決されます。

algorithm で指定されたメソッドとパラメータ、および key で提供された鍵素材を使用して、subtle.verify() は signature が data の有効な暗号署名であるか検証を試みます。返される Promise は、true または false のいずれかで解決されます。

現在サポートされているアルゴリズムは次のとおりです。

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• 'HMAC'

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

• format: <string>。'raw'、'pkcs8'、'spki'、または'jwk'のいずれかである必要があります。
• key: <CryptoKey>
• wrappingKey: <CryptoKey>
• wrapAlgo: <AlgorithmIdentifier> | <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• 戻り値: <Promise> <ArrayBuffer> で解決されます。

暗号化において「鍵をラップする」とは、鍵素材をエクスポートしてから暗号化することを指します。subtle.wrapKey() メソッドは、format で識別される形式に鍵素材をエクスポートし、次に wrapAlgo で指定されたメソッドとパラメータ、および wrappingKey で提供された鍵素材を使用して暗号化します。これは、format と key を引数として使用して subtle.exportKey() を呼び出し、次に結果を wrappingKey と wrapAlgo を入力として使用して subtle.encrypt() メソッドに渡すことと同等です。成功した場合、返される Promise は、暗号化された鍵データを含む <ArrayBuffer> で解決されます。

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

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

アルゴリズムパラメータ#

アルゴリズムパラメータオブジェクトは、さまざまな <SubtleCrypto> メソッドで使用されるメソッドとパラメータを定義します。ここでは「クラス」として説明されていますが、これらは単純な JavaScript 辞書オブジェクトです。

クラス: AlgorithmIdentifier#

algorithmIdentifier.name#

• 型: <string>

クラス: AesCbcParams#

aesCbcParams.iv#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

初期化ベクトルを提供します。これは正確に 16 バイトの長さである必要があり、予測不可能で暗号的にランダムである必要があります。

aesCbcParams.name#

• 型: <string> 'AES-CBC' である必要があります。

クラス: AesCtrParams#

aesCtrParams.counter#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

カウンターブロックの初期値。これは正確に 16 バイト長である必要があります。

AES-CTR メソッドは、ブロックの右端の length ビットをカウンターとして、残りのビットをnonceとして使用します。

aesCtrParams.length#

• 型: <number> aesCtrParams.counter 内でカウンターとして使用されるビット数。

aesCtrParams.name#

• 型: <string> 'AES-CTR' である必要があります。

クラス: AesGcmParams#

aesGcmParams.additionalData#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <undefined>

AES-GCM メソッドでは、additionalData は暗号化されない追加の入力ですが、データの認証に含まれます。additionalData の使用はオプションです。

aesGcmParams.iv#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

初期化ベクトルは、特定の鍵を使用するすべての暗号化操作で一意である必要があります。

理想的には、これは、同じ鍵を使用するすべての呼び出しで一意であることが保証される方法で計算された決定論的な 12 バイトの値です。または、初期化ベクトルは少なくとも 12 バイトの暗号的にランダムなバイトで構成されていてもかまいません。AES-GCM の初期化ベクトルの構築の詳細については、NIST SP 800-38D のセクション 8 を参照してください。

aesGcmParams.name#

• 型: <string> 'AES-GCM' である必要があります。

aesGcmParams.tagLength#

• 型: <number> 生成される認証タグのビット単位のサイズ。この値は、32、64、96、104、112、120、または 128 のいずれかである必要があります。デフォルト: 128。

クラス: AesKeyGenParams#

aesKeyGenParams.length#

• 型: <number>

生成される AES 鍵の長さ。これは 128、192、または 256 のいずれかである必要があります。

aesKeyGenParams.name#

• 型: <string> 'AES-CBC'、'AES-CTR'、'AES-GCM'、または 'AES-KW' のいずれかである必要があります。

クラス: EcdhKeyDeriveParams#

ecdhKeyDeriveParams.name#

• 型: <string> 'ECDH'、'X25519'、または 'X448' である必要があります。

ecdhKeyDeriveParams.public#

• 型: <CryptoKey>

ECDH 鍵導出は、一方の当事者の秘密鍵と他方の当事者の公開鍵を入力として受け取り、両方を使用して共通の共有秘密を生成することによって機能します。ecdhKeyDeriveParams.public プロパティは、他方の当事者の公開鍵に設定されます。

クラス: EcdsaParams#

ecdsaParams.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

ecdsaParams.name#

• 型: <string> 'ECDSA' である必要があります。

クラス: EcKeyGenParams#

ecKeyGenParams.name#

• 型: <string> 'ECDSA' または 'ECDH' のいずれかである必要があります。

ecKeyGenParams.namedCurve#

• 型: <string> 'P-256'、'P-384'、'P-521' のいずれかである必要があります。

クラス: EcKeyImportParams#

ecKeyImportParams.name#

• 型: <string> 'ECDSA' または 'ECDH' のいずれかである必要があります。

ecKeyImportParams.namedCurve#

• 型: <string> 'P-256'、'P-384'、'P-521' のいずれかである必要があります。

クラス: Ed448Params#

ed448Params.name#

• 型: <string> 'Ed448' である必要があります。

ed448Params.context#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <undefined>

contextメンバーは、メッセージに関連付けるオプションのコンテキストデータを表します。 Node.js Web Crypto API実装では、長さがゼロのコンテキストのみをサポートしており、これはコンテキストをまったく提供しないことと同じです。

クラス: HkdfParams#

hkdfParams.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

hkdfParams.info#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

HKDFアルゴリズムにアプリケーション固有のコンテキスト入力を提供します。これは長さがゼロでも構いませんが、必ず指定する必要があります。

hkdfParams.name#

• 型: <string> 'HKDF' である必要があります。

hkdfParams.salt#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

ソルト値は、HKDFアルゴリズムの強度を大幅に向上させます。ランダムまたは擬似ランダムである必要があり、ダイジェスト関数の出力と同じ長さにする必要があります（たとえば、ダイジェストとして 'SHA-256' を使用する場合は、ソルトは256ビットのランダムデータである必要があります）。

クラス: HmacImportParams#

hmacImportParams.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

hmacImportParams.length#

• 型: <number>

HMACキーのオプションのビット数。これはオプションであり、ほとんどの場合省略する必要があります。

hmacImportParams.name#

• 型: <string> 'HMAC' である必要があります。

クラス: HmacKeyGenParams#

hmacKeyGenParams.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

hmacKeyGenParams.length#

• 型: <number>

HMACキー用に生成するビット数。省略した場合、長さは使用されるハッシュアルゴリズムによって決定されます。これはオプションであり、ほとんどの場合省略する必要があります。

hmacKeyGenParams.name#

• 型: <string> 'HMAC' である必要があります。

クラス: Pbkdf2Params#

pbkdb2Params.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

pbkdf2Params.iterations#

• 型: <number>

PBKDF2アルゴリズムがビットを派生させる際に実行する反復回数。

pbkdf2Params.name#

• 型: <string> 'PBKDF2' である必要があります。

pbkdf2Params.salt#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

少なくとも16個のランダムまたは擬似ランダムなバイトである必要があります。

クラス: RsaHashedImportParams#

rsaHashedImportParams.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

rsaHashedImportParams.name#

• 型: <string> 'RSASSA-PKCS1-v1_5'、'RSA-PSS'、または 'RSA-OAEP' のいずれかである必要があります。

クラス: RsaHashedKeyGenParams#

rsaHashedKeyGenParams.hash#

• 型: <string> | <Object>

<string> として表される場合、値は次のいずれかである必要があります

• 'SHA-1'
• 'SHA-256'
• 'SHA-384'
• 'SHA-512'

<Object> として表される場合、オブジェクトは、値が上記リストの値のいずれかである name プロパティを持つ必要があります。

rsaHashedKeyGenParams.modulusLength#

• 型: <number>

RSAモジュラスのビット単位の長さ。ベストプラクティスとして、これは少なくとも 2048 である必要があります。

rsaHashedKeyGenParams.name#

• 型: <string> 'RSASSA-PKCS1-v1_5'、'RSA-PSS'、または 'RSA-OAEP' のいずれかである必要があります。

rsaHashedKeyGenParams.publicExponent#

• 型: <Uint8Array>

RSA公開指数。これは、32ビットに収まる必要があるビッグエンディアンの符号なし整数を含む<Uint8Array>である必要があります。 <Uint8Array>には、任意の数の先頭のゼロビットを含めることができます。値は素数である必要があります。異なる値を使用する理由がない限り、公開指数としてnew Uint8Array([1, 0, 1])（65537）を使用してください。

クラス: RsaOaepParams#

rsaOaepParams.label#

• 型: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

暗号化されないが、生成された暗号文にバインドされる追加のバイトのコレクション。

rsaOaepParams.label パラメータはオプションです。

rsaOaepParams.name#

• 型: <string> 'RSA-OAEP' である必要があります。

クラス: RsaPssParams#

rsaPssParams.name#

• 型: <string> 'RSA-PSS' である必要があります。

rsaPssParams.saltLength#

• 型: <number>

使用するランダムソルトの長さ（バイト単位）。