Примеры

Генерация ключей

Класс <SubtleCrypto> может использоваться для генерации симметричных (секретных) ключей или асимметричных пар ключей (открытый и закрытый ключ).

Ключи AES

const { subtle } = require('node:crypto').webcrypto;

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

  return key;
} copy

Пары ключей ECDSA

const { subtle } = require('node:crypto').webcrypto;

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 } = require('node:crypto').webcrypto;

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 } = require('node:crypto').webcrypto;

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

  return key;
} copy

Пары ключей RSA

const { subtle } = require('node:crypto').webcrypto;
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 = require('node:crypto').webcrypto;

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 } = require('node:crypto').webcrypto;

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 } = require('node:crypto').webcrypto;

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 } = require('node:crypto').webcrypto;

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 } = require('node:crypto').webcrypto;

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: 256,
  }, true, ['encrypt', 'decrypt']);
  return key;
} copy

Хеширование

const { subtle } = require('node:crypto').webcrypto;

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

Вызов require('node:crypto').webcrypto возвращает экземпляр класса Crypto. Crypto — это синглтон, предоставляющий доступ к остальной части крипто-API.

crypto.subtle

• Тип: <SubtleCrypto>

Предоставляет доступ к API SubtleCrypto.

crypto.getRandomValues(typedArray)

• typedArray <Буфер> | <Массив типов данных>
• Возвращает: <Буфер> | <Массив типов данных>

Генерирует криптографически сильные случайные значения. Указанный typedArray заполняется случайными значениями, и возвращается ссылка на typedArray.

Указанный typedArray должен быть целочисленным экземпляром <Массива типов данных>, т.е. Float32Array и Float64Array не принимаются.

Ошибка будет выброшена, если указанный typedArray больше 65 536 байтов.

crypto.randomUUID()

• Возвращает: <строка>

Генерирует случайный UUID версии 4 в соответствии с RFC 4122. 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> Ключ <CryptoKey>, у которого type будет 'private'.

cryptoKeyPair.publicKey

• Тип: <CryptoKey> Ключ <CryptoKey>, у которого type будет 'public'.

Класс: SubtleCrypto

subtle.decrypt(algorithm, key, data)

• algorithm: <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• key: <CryptoKey>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• Возвращает: <Promise>, содержащую <ArrayBuffer>

Используя метод и параметры, указанные в algorithm, и криптографический материал, предоставленный key, subtle.decrypt() пытается расшифровать предоставленный data. В случае успеха возвращаемое обещание будет выполнено с <ArrayBuffer>, содержащим результат расшифровки.

В настоящее время поддерживаются следующие алгоритмы:

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

subtle.deriveBits(algorithm, baseKey, length)

• algorithm: <AlgorithmIdentifier> | <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params>
• baseKey: <CryptoKey>
• length: <число> | <null>
• Возвращает: <Promise>, содержащую <ArrayBuffer>

Используя метод и параметры, указанные в algorithm, и криптографический материал, предоставленный baseKey, subtle.deriveBits() пытается сгенерировать length бит.

В реализации Node.js, если length является числом, оно должно быть кратно 8.

Если length равно null, то для данного алгоритма генерируется максимальное количество бит. Это разрешено для алгоритмов 'ECDH', 'X25519', и 'X448'.

В случае успеха возвращаемое обещание будет выполнено с <ArrayBuffer>, содержащим сгенерированные данные.

В настоящее время поддерживаются следующие алгоритмы:

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

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

• algorithm: <AlgorithmIdentifier> | <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params>
• baseKey: <CryptoKey>
• derivedKeyAlgorithm: <HmacKeyGenParams> | <AesKeyGenParams>
• extractable: <логическое значение>
• keyUsages: <массив строк>. Смотрите Использование ключей.
• Возвращает: <Promise>, содержащую <CryptoKey>

Используя метод и параметры, указанные в algorithm, и криптографический материал, предоставленный baseKey, subtle.deriveKey() пытается сгенерировать новый <CryptoKey> на основе метода и параметров в derivedKeyAlgorithm.

Вызов subtle.deriveKey() эквивалентен вызову subtle.deriveBits() для генерации исходного криптографического материала, а затем передаче результата в метод subtle.importKey() с параметрами deriveKeyAlgorithm, extractable, и keyUsages в качестве входных данных.

В настоящее время поддерживаются следующие алгоритмы:

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

subtle.digest(algorithm, data)

• algorithm: <строка> | <объект>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• Возвращает: <Promise>, содержащую <ArrayBuffer>

Используя метод, определенный в algorithm, subtle.digest() пытается вычислить дайджест data . В случае успеха возвращаемое обещание выполняется с <ArrayBuffer>, содержащим вычисленный дайджест.

Если algorithm задано как <строка>, оно должно быть одним из:

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

Если algorithm задано как <объект>, оно должно иметь свойство name, значение которого должно быть одним из вышеперечисленных.

subtle.encrypt(algorithm, key, data)

• algorithm: <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• key: <CryptoKey>
• Возвращает: <Promise>, содержащую <ArrayBuffer>

Используя метод и параметры, указанные в algorithm, и криптографический материал, предоставленный key, subtle.encrypt() пытается зашифровать data . В случае успеха возвращаемое обещание выполняется с <ArrayBuffer>, содержащим зашифрованный результат.

В настоящее время поддерживаются следующие алгоритмы:

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

subtle.exportKey(format, key)

• format: <строка> Должно быть одним из значений 'raw', 'pkcs8', 'spki', или 'jwk'.
• key: <CryptoKey>
• Возвращает: <Promise> содержащий <ArrayBuffer> | <Объект>.

Экспортирует заданный ключ в указанный формат, если это поддерживается.

Если <CryptoKey> не доступен для извлечения, возвращаемый promise отклонится.

Когда format равно либо 'pkcs8', либо 'spki', и экспорт выполнен успешно, возвращаемый promise будет разрешён с <ArrayBuffer>, содержащим данные экспортированного ключа.

Когда format равно 'jwk', и экспорт выполнен успешно, возвращаемый promise будет разрешён с JavaScript-объектом, соответствующим спецификации JSON Web Key.

subtle.generateKey(algorithm, extractable, keyUsages)

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

• extractable: <boolean>
• keyUsages: <массив строк> См. Использование ключей.
• Возвращает: <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: <строка> Должно быть одним из значений 'raw', 'pkcs8', 'spki', или 'jwk'.
• keyData: <ArrayBuffer> | <Массив типов> | <DataView> | <Buffer> | <Объект>

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

• extractable: <boolean>
• keyUsages: <массив строк> См. Использование ключей.
• Возвращает: <Promise> содержащий <CryptoKey>

Метод subtle.importKey() пытается интерпретировать предоставленный keyData как заданный format, чтобы создать экземпляр <CryptoKey> с использованием предоставленных аргументов algorithm, extractable, и keyUsages. Если импорт успешен, возвращаемый 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 в качестве входных данных), а затем передаче результатов в метод subtle.importKey() с использованием unwrappedKeyAlgo, extractable, и keyUsages в качестве входных данных. В случае успеха, возвращаемое 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. Это эквивалентно вызову subtle.exportKey() с format и key в качестве аргументов, а затем передаче результата методу subtle.encrypt() с использованием wrappingKey и wrapAlgo в качестве входных данных. При успешном выполнении возвращаемое promise будет разрешено с помощью <ArrayBuffer>, содержащего зашифрованные данные ключа.

В настоящее время поддерживаются следующие алгоритмы упаковки:

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

Параметры алгоритма

Объекты параметров алгоритма определяют методы и параметры, используемые различными методами <SubtleCrypto>. Хотя они описаны здесь как "классы", это простые объекты JavaScript в формате словаря.

Класс: AlgorithmIdentifier

algorithmIdentifier.name

• Тип: <строка>

Класс: AesCbcParams

aesCbcParams.iv

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Предоставляет вектор инициализации. Он должен быть ровно 16 байт длиной и должен быть непредсказуемым и криптографически случайным.

aesCbcParams.name

• Тип: <строка> Должно быть 'AES-CBC'.

Класс: AesCtrParams

aesCtrParams.counter

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Начальное значение блока счётчика. Оно должно быть ровно 16 байт длиной.

Метод AES-CTR использует правые length бита блока в качестве счётчика, а оставшиеся биты — в качестве неци.

aesCtrParams.length

• Тип: <число> Количество бит в aesCtrParams.counter для использования в качестве счётчика.

aesCtrParams.name

• Тип: <строка> Должно быть 'AES-CTR'.

Класс: AesGcmParams

aesGcmParams.additionalData

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <undefined>

В методе AES-GCM additionalData — это дополнительный ввод, который не шифруется, но используется для проверки подлинности данных. Использование additionalData необязательно.

aesGcmParams.iv

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Вектор инициализации должен быть уникальным для каждой операции шифрования, использующей данный ключ.

В идеале, это детерминированное значение длиной 12 байт, вычисляемое таким образом, чтобы гарантировать его уникальность во всех вызовах, использующих один и тот же ключ. В качестве альтернативы, вектор инициализации может содержать как минимум 12 криптографически случайных байт. Дополнительную информацию о построении векторов инициализации для AES-GCM см. в разделе 8 NIST SP 800-38D.

aesGcmParams.name

• Тип: <строка> Должно быть 'AES-GCM'.

aesGcmParams.tagLength

• Тип: <число> Размер сгенерированного тега аутентификации в битах. Это значение должно быть одним из 32, 64, 96, 104, 112, 120, или 128. По умолчанию: 128.

Класс: AesKeyGenParams

aesKeyGenParams.length

• Тип: <число>

Длина генерируемого ключа AES. Она должна быть либо 128, либо 192, либо 256.

aesKeyGenParams.name

• Тип: <строка> Должно быть одним из 'AES-CBC', 'AES-CTR', 'AES-GCM', или 'AES-KW'

Класс: EcdhKeyDeriveParams

ecdhKeyDeriveParams.name

• Тип: <строка> Должно быть 'ECDH', 'X25519', или 'X448'.

ecdhKeyDeriveParams.public

• Тип: <CryptoKey>

Вычисление ECDH ключа происходит путём взятия закрытого ключа одной стороны и открытого ключа другой стороны — с использованием обоих для генерации общего секрета. Свойство ecdhKeyDeriveParams.public устанавливается в открытый ключ другой стороны.

Класс: EcdsaParams

ecdsaParams.hash

• Тип: <строка> | <Объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <Объект>, объект должен иметь свойство name, значение которого — одно из перечисленных значений.

ecdsaParams.name

• Тип: <строка> Должно быть 'ECDSA'.

Класс: EcKeyGenParams

ecKeyGenParams.name

• Тип: <строка> Должно быть одним из 'ECDSA' или 'ECDH'.

ecKeyGenParams.namedCurve

• Тип: <строка> Должно быть одним из 'P-256', 'P-384', или 'P-521'.

Класс: EcKeyImportParams

ecKeyImportParams.name

• Тип: <строка> Должно быть одним из 'ECDSA' или 'ECDH'.

ecKeyImportParams.namedCurve

• Тип: <строка> Должно быть одно из 'P-256', 'P-384', 'P-521'.

Класс: Ed448Params

ed448Params.name

• Тип: <строка> Должно быть 'Ed448'.

ed448Params.context

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <undefined>

Член context представляет собой необязательные данные контекста, которые нужно связать с сообщением. Реализация Web Crypto API в Node.js поддерживает только контекст нулевой длины, что эквивалентно отсутствию контекста.

Класс: HkdfParams

hkdfParams.hash

• Тип: <строка> | <объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <объект>, объект должен иметь свойство name, значение которого — одно из перечисленных выше.

hkdfParams.info

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Предоставляет прикладные контекстные входные данные для алгоритма HKDF. Может быть нулевой длины, но должно быть предоставлено.

hkdfParams.name

• Тип: <строка> Должно быть 'HKDF'.

hkdfParams.salt

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Значение соли существенно повышает надежность алгоритма HKDF. Оно должно быть случайным или псевдослучайным и иметь длину, равную результату функции хеширования (например, если используется 'SHA-256', соль должна содержать 256 бит случайных данных).

Класс: HmacImportParams

hmacImportParams.hash

• Тип: <строка> | <объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <объект>, объект должен иметь свойство name, значение которого — одно из перечисленных выше.

hmacImportParams.length

• Тип: <число>

Необязательное число бит в ключе HMAC. Оно необязательно и должно быть опущено в большинстве случаев.

hmacImportParams.name

• Тип: <строка> Должно быть 'HMAC'.

Класс: HmacKeyGenParams

hmacKeyGenParams.hash

• Тип: <строка> | <объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <объект>, объект должен иметь свойство name, значение которого — одно из перечисленных выше.

hmacKeyGenParams.length

• Тип: <число>

Количество бит для генерации ключа HMAC. Если опущено, длина определяется используемым алгоритмом хеширования. Необязательно и должно быть опущено в большинстве случаев.

hmacKeyGenParams.name

• Тип: <строка> Должно быть 'HMAC'.

Класс: Pbkdf2Params

pbkdb2Params.hash

• Тип: <строка> | <объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <объект>, объект должен иметь свойство name, значение которого — одно из перечисленных выше.

pbkdf2Params.iterations

• Тип: <число>

Количество итераций, которое алгоритм PBKDF2 должен выполнить при выводе бит.

pbkdf2Params.name

• Тип: <строка> Должно быть 'PBKDF2'.

pbkdf2Params.salt

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Должно содержать как минимум 16 случайных или псевдослучайных байтов.

Класс: RsaHashedImportParams

rsaHashedImportParams.hash

• Тип: <строка> | <объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <Объект>, объект должен иметь свойство name со значением, указанным в списке выше.

rsaHashedImportParams.name

• Тип: <строка> Должно быть одно из 'RSASSA-PKCS1-v1_5', 'RSA-PSS', или 'RSA-OAEP'.

Класс: RsaHashedKeyGenParams

rsaHashedKeyGenParams.hash

• Тип: <строка> | <Объект>

Если представлено как <строка>, значение должно быть одним из:

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

Если представлено как <Объект>, объект должен иметь свойство name со значением из вышеперечисленных.

rsaHashedKeyGenParams.modulusLength

• Тип: <число>

Длина в битах модуля RSA. В качестве рекомендации, она должна быть не менее 2048.

rsaHashedKeyGenParams.name

• Тип: <строка> Должно быть одно из 'RSASSA-PKCS1-v1_5', 'RSA-PSS', или 'RSA-OAEP'.

rsaHashedKeyGenParams.publicExponent

• Тип: <Uint8Array>

Общественный показатель RSA. Он должен быть <Uint8Array>, содержащим целое беззнаковое число в формате big-endian, которое должно помещаться в 32 бита. <Uint8Array> может содержать произвольное количество ведущих нулевых битов. Значение должно быть простым числом. Если нет причины использовать другое значение, используйте new Uint8Array([1, 0, 1]) (65537) в качестве открытого показателя.

Класс: RsaOaepParams

rsaOaepParams.label

• Тип: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

Дополнительный набор байтов, которые не будут зашифрованы, но будут связаны с созданным зашифрованным текстом.

Параметр rsaOaepParams.label является необязательным.

rsaOaepParams.name

• Тип: <строка> должна быть 'RSA-OAEP'.

Класс: RsaPssParams

rsaPssParams.name

• Тип: <строка> Должно быть 'RSA-PSS'.

rsaPssParams.saltLength

• Тип: <число>

Длина (в байтах) случайной соли для использования.