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

Класс <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>

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

crypto.getRandomValues(typedArray)

• typedArray <Buffer> | <TypedArray>
• Возвращает: <Buffer> | <TypedArray>

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

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

Если размер указанного typedArray превышает 65 536 байт, будет вызвана ошибка.

crypto.randomUUID()

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

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

cryptoKeyPair.publicKey

• Тип: <CryptoKey> <CryptoKey>, значение type которого будет 'public'.

Статический метод: 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> В зависимости от операции этот аргумент игнорируется либо представляет значение аргумента length для операции "deriveBits", алгоритм производимого ключа для операции "deriveKey", алгоритм экспортируемого перед оборачиванием ключа для операции "wrapKey", алгоритм импортируемого после разворачивания ключа для операции "unwrapKey" или алгоритм ключа, импортируемого после инкапсуляции/декапсуляции, для операции "encapsulateKey" или "decapsulateKey". По умолчанию: null для операции "deriveBits", undefined в остальных случаях.
• Возвращает: <boolean> Указывает, поддерживает ли реализация указанную операцию

Позволяет обнаруживать возможности Web Crypto API и определять, поддерживается ли заданный идентификатор алгоритма (включая его параметры) для указанной операции.

Пример использования этого метода см. в разделе Проверка поддержки алгоритма во время выполнения.

subtle.decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext)

• decapsulationAlgorithm <string> | <Algorithm>
• decapsulationKey <CryptoKey>
• ciphertext <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• Возвращает: <Promise> В случае успеха выполняется с результатом <ArrayBuffer>.

Получатель сообщения использует свой асимметричный закрытый ключ для расшифрования «инкапсулированного ключа» (шифротекста), восстанавливая временный симметричный ключ (представленный как <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>.

Получатель сообщения использует свой асимметричный закрытый ключ для расшифрования «инкапсулированного ключа» (шифротекста), восстанавливая временный симметричный ключ (представленный как <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>.

Используя метод и параметры, заданные в algorithm, а также ключевой материал, предоставленный key, этот метод пытается расшифровать переданные данные data. В случае успеха возвращённый промис будет выполнен с объектом <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>.

Используя метод и параметры, указанные в algorithm, а также ключевой материал, предоставленный baseKey, этот метод пытается сгенерировать length бит.

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

В случае успеха возвращённый промис будет выполнен с объектом <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>.

Используя метод и параметры, указанные в algorithm, а также ключевой материал, предоставленный baseKey, этот метод пытается создать новый <CryptoKey> на основе метода и параметров из derivedKeyAlgorithm.

Вызов этого метода эквивалентен вызову 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>.

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

Если algorithm задан как <string>, он должен принимать одно из следующих значений:

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

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

subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)

• encapsulationAlgorithm <string> | <Algorithm>
• encapsulationKey <CryptoKey>
• Возвращает: <Promise> В случае успеха выполняется с результатом <EncapsulatedBits>.

Использует асимметричный открытый ключ получателя сообщения для шифрования временного симметричного ключа. Этот зашифрованный ключ является «инкапсулированным ключом», представленным как <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>.

Использует асимметричный открытый ключ получателя сообщения для шифрования временного симметричного ключа. Этот зашифрованный ключ является «инкапсулированным ключом», представленным как <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>.

Используя метод и параметры, заданные в algorithm, а также ключевой материал, предоставленный key, этот метод пытается зашифровать data. В случае успеха возвращённый промис выполняется с объектом <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>.

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

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

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

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

subtle.getPublicKey(key, keyUsages)

• key <CryptoKey> Приватный ключ, из которого следует получить соответствующий открытый ключ.
• keyUsages <string[]> См. Назначения ключей.
• Возвращает: <Promise> В случае успеха выполняется с <CryptoKey>.

Получает открытый ключ из заданного приватного ключа.

subtle.generateKey(algorithm, extractable, keyUsages)

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

• extractable <boolean>
• keyUsages <string[]> См. Назначения ключей.
• Возвращает: <Promise> В случае успеха выполняется с <CryptoKey> | <CryptoKeyPair>.

Используя параметры, указанные в 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>.

Этот метод пытается интерпретировать предоставленные keyData как заданный format для создания экземпляра <CryptoKey> с использованием аргументов algorithm, extractable и keyUsages. Если импорт выполнен успешно, возвращённый промис будет выполнен с представлением ключевого материала в виде <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>.

Используя метод и параметры, заданные в algorithm, а также ключевой материал, предоставленный в key, этот метод пытается создать криптографическую подпись для data. В случае успеха возвращённый промис выполняется с <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>.

В криптографии «упаковка ключа» означает экспорт и последующее шифрование ключевого материала. Этот метод пытается расшифровать упакованный ключ и создать экземпляр <CryptoKey>. Он эквивалентен сначала вызову метода subtle.decrypt() для зашифрованных данных ключа (с использованием аргументов wrappedKey, unwrapAlgo и unwrappingKey в качестве входных данных), а затем передаче результата методу subtle.importKey() с использованием аргументов unwrappedKeyAlgo, extractable и keyUsages в качестве входных данных. В случае успеха возвращённое обещание выполняется с объектом <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>.

Используя метод и параметры, заданные в algorithm, а также ключевой материал, предоставленный key, этот метод пытается проверить, является ли signature допустимой криптографической подписью data. Возвращённое обещание выполняется со значением 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>.

В криптографии «упаковка ключа» означает экспорт и последующее шифрование ключевого материала. Этот метод экспортирует ключевой материал в формате, определённом параметром format, а затем шифрует его с использованием метода и параметров, заданных в wrapAlgo, и ключевого материала, предоставленного wrappingKey. Он эквивалентен вызову метода subtle.exportKey() с использованием format и key в качестве аргументов, а затем передаче результата методу subtle.encrypt() с использованием wrappingKey и wrapAlgo в качестве входных данных. В случае успеха возвращённое обещание будет выполнено с объектом <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