Массив строк, определяющих операции, для которых может быть использован ключ.
Возможные варианты использования следующие:
'encrypt' - ключ может быть использован для шифрования данных.
'decrypt' - ключ может быть использован для расшифровки данных.
'sign' - Ключ может использоваться для создания цифровых подписей.
'verify' - Ключ может использоваться для проверки цифровых подписей.
'deriveKey' - Ключ может быть использован для получения нового ключа.
'deriveBits' - Ключ может быть использован для получения битов.
'wrapKey' - Ключ может быть использован для получения другого ключа.
'unwrapKey' - Ключ может быть использован для разворачивания другого ключа.
Допустимые варианты использования ключа зависят от алгоритма ключа (определяется cryptokey.algorithm.name).
Key Type
'encrypt'
'decrypt'
'sign'
'verify'
'deriveKey'
'deriveBits'
'wrapKey'
'unwrapKey'
'AES-CBC'
✔
✔
✔
✔
'AES-CTR'
✔
✔
✔
✔
'AES-GCM'
✔
✔
✔
✔
'AES-KW'
✔
✔
'ECDH'
✔
✔
'X25519' [5]
✔
✔
'X448' [6]
✔
✔
'ECDSA'
✔
✔
'Ed25519' [7]
✔
✔
'Ed448' [8]
✔
✔
'HDKF'
✔
✔
<
## Класс: `CryptoKeyPair`
`CryptoKeyPair` - это простой словарный объект со свойствами `publicKey` и `privateKey`, представляющий пару асимметричных ключей.
### `cryptoKeyPair.privateKey`
- Тип: {CryptoKey} Криптоключ {CryptoKey}, `тип` которого будет `'private'`.
### `cryptoKeyPair.publicKey`
- Тип: {CryptoKey} Криптоключ {CryptoKey}, `тип` которого будет `"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`: {number|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`: {boolean}
- `keyUsages`: {string\[\]} See [Key usages](#cryptokeyusages).
- Возвращает: {Promise}, содержащий {CryptoKey}.
Используя метод и параметры, указанные в `algorithm`, и ключевой материал, предоставленный `baseKey`, `subtle.deriveKey()` пытается сгенерировать новый {CryptoKey} на основе метода и параметров в `derivedKeyAlgorithm`.
Вызов `subtle.deriveKey()` эквивалентен вызову `subtle.deriveBits()` для генерации исходного ключевого материала, а затем передаче результата в метод `subtle.importKey()` с использованием параметров `deriveKeyAlgorithm`, `extractable` и `keyUsages` в качестве входных.
В настоящее время поддерживаются следующие алгоритмы:
- `'ECDH'`
- `'X25519'` \[11\]
- `'X448'` \[12\]
- `'HKDF'`
- `ПБКДФ2`
### `subtle.digest(algorithm, data)`
- `алгоритм`: {string|Object}
- `данные`: {ArrayBuffer|TypedArray|DataView|Buffer}
- Возвращает: {Promise}, содержащий {ArrayBuffer}
Используя метод, определенный `алгоритмом`, `subtle.digest()` пытается сгенерировать дайджест `данных`. В случае успеха возвращаемое обещание разрешается с {ArrayBuffer}, содержащим вычисленный дайджест.
Если `algorithm` указан как {string}, он должен быть одним из:
- `'SHA-1'`
- `SHA-256`
- `SHA-384`
- `SHA-512`.
Если `algorithm` предоставлен как {Object}, он должен иметь свойство `name`, значение которого является одним из вышеперечисленных.
### `subtle.encrypt(algorithm, key, data)`
- `алгоритм`: {RsaOaepParams|AesCtrParams|AesCbcParams|AesGcmParams}
- `ключ`: {CryptoKey}
- Возвращает: {Promise}, содержащий {ArrayBuffer}.
Используя метод и параметры, указанные `algorithm`, и ключевой материал, предоставленный `key`, `subtle.encrypt()` пытается зашифровать `данные`. В случае успеха возвращаемое обещание разрешается с {ArrayBuffer}, содержащим зашифрованный результат.
В настоящее время поддерживаются следующие алгоритмы:
- `RSA-OAEP`
- `AES-CTR`
- `AES-CBC`
- `AES-GCM`
### `subtle.exportKey(format, key)`
- `format`: {string} Must be one of `'raw'`, `'pkcs8'`, `'spki'`, or `'jwk'`.
- `key`: {CryptoKey}
- Возвращает: {Promise}, содержащий {ArrayBuffer|Object}.
Экспортирует заданный ключ в указанный формат, если он поддерживается.
Если {CryptoKey} не может быть извлечен, возвращаемое обещание будет отклонено.
Если `формат` равен `'pkcs8'` или `'spki'` и экспорт успешен, возвращаемое обещание будет разрешено с {ArrayBuffer}, содержащим экспортированные данные ключа.
Если `формат` равен `'jwk'` и экспорт успешен, возвращаемое обещание будет разрешено в объект JavaScript, соответствующий спецификации [JSON Web Key](https://tools.ietf.org/html/rfc7517).
Key Type
'spki'
'pkcs8'
'jwk'
'raw'
'AES-CBC'
✔
✔
'AES-CTR'
✔
✔
'AES-GCM'
✔
✔
'AES-KW'
✔
✔
'ECDH'
✔
✔
✔
✔
'ECDSA'
✔
✔
✔
✔
'Ed25519' [13]
✔
✔
✔
✔
'Ed448' [14]
✔
✔
✔
✔
'HDKF'
'HMAC'
✔
✔
'PBKDF2'
'RSA-OAEP'
✔
✔
✔
'RSA-PSS'
✔
✔
✔
'RSASSA-PKCS1-v1_5'
✔
✔
✔
### `subtle.generateKey(algorithm, extractable, keyUsages)`
- `algorithm`: {AlgorithmIdentifier|RsaHashedKeyGenParams|EcKeyGenParams|HmacKeyGenParams|AesKeyGenParams}
- `extractable`: {boolean}
- `keyUsages`: {string\[\]} See [Key usages](#cryptokeyusages).
- Возвращает: {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|TypedArray|DataView|Buffer|Object}
- `algorithm`: {AlgorithmIdentifier|RsaHashedImportParams|EcKeyImportParams|HmacImportParams}
- `extractable`: {boolean}
- `keyUsages`: {string\[\]} См. [Key Usages](#cryptokeyusages).
- Возвращает: {Promise}, содержащий {CryptoKey}.
Метод `subtle.importKey()` пытается интерпретировать предоставленные `keyData` в заданном `формате` для создания экземпляра {CryptoKey} с использованием предоставленных аргументов `algorithm`, `extractable` и `keyUsages`. Если импорт прошел успешно, возвращаемое обещание будет разрешено с созданным {CryptoKey}.
Если импортируется ключ `'PBKDF2`, `extractable` должно быть `false`.
В настоящее время поддерживаются следующие алгоритмы:
Key Type
'spki'
'pkcs8'
'jwk'
'raw'
'AES-CBC'
✔
✔
'AES-CTR'
✔
✔
'AES-GCM'
✔
✔
'AES-KW'
✔
✔
'ECDH'
✔
✔
✔
✔
'X25519' [19]
✔
✔
✔
✔
'X448' [20]
✔
✔
✔
✔
'ECDSA'
✔
✔
✔
✔
'Ed25519' [21]
✔
✔
✔
✔
'Ed448' [22]
✔
✔
✔
✔
'HDKF'
✔
'HMAC'
✔
✔
'PBKDF2'
✔
'RSA-OAEP'
✔
✔
✔
'RSA-PSS'
✔
✔
✔
'RSASSA-PKCS1-v1_5'
✔
✔
✔
### `subtle.sign(algorithm, key, data)`
- `algorithm`: {AlgorithmIdentifier|RsaPssParams|EcdsaParams|Ed448Params}
- `key`: {CryptoKey}
- `data`: {ArrayBuffer|TypedArray|DataView|Buffer}
- Возвращает: {Promise}, содержащий {ArrayBuffer}.
Используя метод и параметры, заданные `algorithm`, и ключевой материал, предоставленный `key`, `subtle.sign()` пытается сгенерировать криптографическую подпись `data`. В случае успеха возвращаемое обещание разрешается с {ArrayBuffer}, содержащим сгенерированную подпись.
В настоящее время поддерживаются следующие алгоритмы:
- `'RSASSA-PKCS1-v1_5'`
- `'RSA-PSS'`
- `'ECDSA'`
- `'Ed25519'` \[23\]
- `'Ed448'` \[24\]
- `'HMAC'`
### `subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)`.
- `format`: {строка} Должен быть одним из `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\[\]} См. [Key Usages](#cryptokeyusages).
- Возвращает: {Promise}, содержащий {CryptoKey}.
В криптографии "обертывание ключа" означает экспорт и последующее шифрование ключевого материала. Метод `subtle.unwrapKey()` пытается расшифровать обернутый ключ и создать экземпляр {CryptoKey}. Это эквивалентно вызову `subtle.decrypt()` сначала на зашифрованных ключевых данных (используя аргументы `wrappedKey`, `unwrapAlgo` и `unwrappingKey` в качестве входных данных), а затем передаче результатов в метод `subtle.importKey()`, используя аргументы `unwrappedKeyAlgo`, `extractable` и `keyUsages` в качестве входных данных. В случае успеха возвращаемое обещание разрешается с объектом {CryptoKey}.
В настоящее время поддерживаются следующие алгоритмы обертывания:
- `'RSA-OAEP'`
- `'AES-CTR'`
- `'AES-CBC'`
- `'AES-GCM'`
- `'AES-KW'`
Поддерживаемые алгоритмы развернутого ключа включают:
- `'RSASSA-PKCS1-v1_5'`
- `'RSA-PSS'`
- `'RSA-OAEP'`
- `'ECDSA'`
- `'Ed25519'` \[25\]
- `'Ed448'` \[26\]
- `'ECDH'`
- `'X25519'` \[27\]
- `'X448'` \[28\]
- `'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` является действительной криптографической подписью `данных`. Возвращаемое обещание разрешается либо с `true`, либо с `false`.
В настоящее время поддерживаются следующие алгоритмы:
- `'RSASSA-PKCS1-v1_5'`
- `'RSA-PSS'`
- `'ECDSA'`
- `'Ed25519'`
- `'Ed448'`
- `'HMAC'`
### `subtle.wrapKey(format, key, wrappingKey, wrapAlgo)`.
- `format`: {строка} Должен быть одним из `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` в качестве входных данных. В случае успеха возвращенное обещание будет разрешено с {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` использует самые правые биты `длины` блока в качестве счетчика, а оставшиеся биты - в качестве несе.
#### `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] (https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf).
#### `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`.
Если объект представлен в виде {Object}, он должен иметь свойство `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` представляет необязательные данные контекста для связи с сообщением. Реализация Node.js Web Crypto API поддерживает только контекст нулевой длины, что эквивалентно отсутствию контекста вообще.
### Класс: `HkdfParams`
#### `hkdfParams.hash`
- Тип: {строка|Объект}
Если представлено как {строка}, значение должно быть одним из:
- `SHA-1`
- `SHA-256`
- `SHA-384`
- `SHA-512`.
Если объект представлен в виде {Object}, он должен иметь свойство `name`, значение которого равно одному из перечисленных выше значений.
#### `hkdfParams.info`
- Тип: {ArrayBuffer|TypedArray|DataView|Buffer}
Предоставляет контекстный вход для алгоритма HKDF, специфичный для приложения. Он может быть нулевой длины, но должен быть предоставлен.
#### `hkdfParams.name`
- Тип: {строка} Должно быть `HKDF`.
#### `hkdfParams.salt`
- Тип: {ArrayBuffer|TypedArray|DataView|Buffer}
Значение соли значительно повышает стойкость алгоритма HKDF. Оно должно быть случайным или псевдослучайным и иметь ту же длину, что и выход функции дайджеста (например, если в качестве дайджеста используется `'SHA-256'`, соль должна представлять собой 256 бит случайных данных).
### Класс: `HmacImportParams`
#### `hmacImportParams.hash`
- Тип: {string|Object}
Если представлено как {строка}, значение должно быть одним из:
- `SHA-1`
- `SHA-256`
- `SHA-384`
- `SHA-512`
Если объект представлен в виде {Object}, он должен иметь свойство `name`, значение которого равно одному из перечисленных выше значений.
#### `hmacImportParams.length`
- Тип: {число}
Необязательное количество битов в ключе HMAC. Это необязательное значение, и в большинстве случаев его следует опускать.
#### `hmacImportParams.name`
- Тип: {строка} Должно быть `HMAC`.
### Класс: `HmacKeyGenParams`
#### `hmacKeyGenParams.hash`
- Тип: {string|Object}
Если представлено как {строка}, значение должно быть одним из:
- `SHA-1`
- `SHA-256`
- `SHA-384`
- `SHA-512`
Если объект представлен в виде {Object}, он должен иметь свойство `name`, значение которого равно одному из перечисленных выше значений.
#### `hmacKeyGenParams.length`
- Тип: {число}
Количество битов для генерации ключа HMAC. Если опущено, длина будет определяться используемым алгоритмом хэширования. Этот параметр является необязательным и в большинстве случаев должен быть опущен.
#### `hmacKeyGenParams.name`
- Тип: {строка} Должно быть `HMAC`.
### Класс: `Pbkdf2Params`
#### `pbkdb2Params.hash`
- Тип: {string|Object}
Если представлено как {строка}, значение должно быть одним из:
- `SHA-1`
- `SHA-256`
- `SHA-384`
- `SHA-512`
Если объект представлен в виде {Object}, он должен иметь свойство `name`, значение которого равно одному из перечисленных выше значений.
#### `pbkdf2Params.iterations`
- Тип: {число}
Количество итераций, которые должен сделать алгоритм PBKDF2 при выведении битов.
#### `pbkdf2Params.name`
- Тип: {строка} Должно быть `'PBKDF2'`.
#### `pbkdf2Params.salt`
- Тип: {ArrayBuffer|TypedArray|DataView|Buffer}
Должно быть не менее 16 случайных или псевдослучайных байт.
### Класс: `RsaHashedImportParams`
#### `rsaHashedImportParams.hash`
- Тип: {string|Object}
Если представлено как {строка}, значение должно быть одним из:
- `SHA-1`
- `SHA-256`
- `SHA-384`
- `SHA-512`
Если объект представлен в виде {Object}, он должен иметь свойство `name`, значение которого равно одному из перечисленных выше значений.
#### `rsaHashedImportParams.name`
- Тип: {строка} Должно быть одним из `'RSASSA-PKCS1-v1_5'`, `'RSA-PSS'` или `'RSA-OAEP'`.
### Класс: `RsaHashedKeyGenParams`
#### `rsaHashedKeyGenParams.hash`
- Тип: {string|Object}
Если представлено как {строка}, значение должно быть одним из:
- `SHA-1`
- `SHA-256`
- `SHA-384`
- `SHA-512`
Если объект представлен в виде {Object}, он должен иметь свойство `name`, значение которого равно одному из перечисленных выше значений.
#### `rsaHashedKeyGenParams.modulusLength`
- Тип: {число}
Длина в битах модуля RSA. В соответствии с наилучшей практикой, она должна быть не менее `2048`.
#### `rsaHashedKeyGenParams.name`
- Тип: {строка} Должно быть одним из `'RSASSA-PKCS1-v1_5'`, `'RSA-PSS'` или `'RSA-OAEP'`.
#### `rsaHashedKeyGenParams.publicExponent`
- Тип: {Uint8Array}
Публичная экспонента RSA. Это должен быть {Uint8Array}, содержащий беззнаковое целое число, которое должно укладываться в 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`
- Тип: {число}
Длина (в байтах) используемой случайной соли.