GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — doc,crypto: cleanup unlinked and self method references webcrypto.md · nodejs/node@5bfdc7e

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

doc/api
- webcrypto.md

Expand file treeCollapse file tree

Open diff view settings

Collapse file

`‎doc/api/webcrypto.md‎`

Copy file name to clipboardExpand all lines: doc/api/webcrypto.md

+17-17Lines changed: 17 additions & 17 deletions

Display the source diff
Display the rich diff

Original file line number	Diff line number	Diff line change
`@@ -653,7 +653,7 @@ added: v15.0.0`
`653`	`653`	`* Type: {boolean}`
`654`	`654`
`655`	`655`	When `true`, the {CryptoKey} can be extracted using either
`656`		-`subtleCrypto.exportKey()` or `subtleCrypto.wrapKey()`.
	`656`	+[`subtle.exportKey()`][] or [`subtle.wrapKey()`][].
`657`	`657`
`658`	`658`	`Read-only.`
`659`	`659`
`@@ -845,7 +845,7 @@ changes:`
`845`	`845`	`* Returns: {Promise} Fulfills with an {ArrayBuffer} upon success.`
`846`	`846`
`847`	`847`	Using the method and parameters specified in `algorithm` and the keying
`848`		-material provided by `key`, `subtle.decrypt()` attempts to decipher the
	`848`	+material provided by `key`, this method attempts to decipher the
`849`	`849`	provided `data`. If successful, the returned promise will be resolved with
`850`	`850`	`an {ArrayBuffer} containing the plaintext result.`
`851`	`851`
`@@ -887,7 +887,7 @@ changes:`
`887`	`887`	`<!--lint enable maximum-line-length remark-lint-->`
`888`	`888`
`889`	`889`	Using the method and parameters specified in `algorithm` and the keying
`890`		-material provided by `baseKey`, `subtle.deriveBits()` attempts to generate
	`890`	+material provided by `baseKey`, this method attempts to generate
`891`	`891`	`length` bits.
`892`	`892`
`893`	`893`	When `length` is not provided or `null` the maximum number of bits for a given
`@@ -929,12 +929,12 @@ changes:`
`929`	`929`	`<!--lint enable maximum-line-length remark-lint-->`
`930`	`930`
`931`	`931`	Using the method and parameters specified in `algorithm`, and the keying
`932`		-material provided by `baseKey`, `subtle.deriveKey()` attempts to generate
	`932`	+material provided by `baseKey`, this method attempts to generate
`933`	`933`	a new {CryptoKey} based on the method and parameters in `derivedKeyAlgorithm`.
`934`	`934`
`935`		-Calling `subtle.deriveKey()` is equivalent to calling `subtle.deriveBits()` to
	`935`	+Calling this method is equivalent to calling [`subtle.deriveBits()`][] to
`936`	`936`	`generate raw keying material, then passing the result into the`
`937`		-`subtle.importKey()` method using the `deriveKeyAlgorithm`, `extractable`, and
	`937`	+[`subtle.importKey()`][] method using the `deriveKeyAlgorithm`, `extractable`, and
`938`	`938`	`keyUsages` parameters as input.
`939`	`939`
`940`	`940`	`The algorithms currently supported include:`
`@@ -962,7 +962,7 @@ changes:`
`962`	`962`	* `data` {ArrayBuffer\|TypedArray\|DataView\|Buffer}
`963`	`963`	`* Returns: {Promise} Fulfills with an {ArrayBuffer} upon success.`
`964`	`964`
`965`		-Using the method identified by `algorithm`, `subtle.digest()` attempts to
	`965`	+Using the method identified by `algorithm`, this method attempts to
`966`	`966`	generate a digest of `data`. If successful, the returned promise is resolved
`967`	`967`	`with an {ArrayBuffer} containing the computed digest.`
`968`	`968`
`@@ -1039,7 +1039,7 @@ changes:`
`1039`	`1039`	`* Returns: {Promise} Fulfills with an {ArrayBuffer} upon success.`
`1040`	`1040`
`1041`	`1041`	Using the method and parameters specified by `algorithm` and the keying
`1042`		-material provided by `key`, `subtle.encrypt()` attempts to encipher `data`.
	`1042`	+material provided by `key`, this method attempts to encipher `data`.
`1043`	`1043`	`If successful, the returned promise is resolved with an {ArrayBuffer}`
`1044`	`1044`	`containing the encrypted result.`
`1045`	`1045`
`@@ -1229,7 +1229,7 @@ changes:`
`1229`	`1229`	* `keyUsages` {string\[]} See [Key usages][].
`1230`	`1230`	`* Returns: {Promise} Fulfills with a {CryptoKey} upon success.`
`1231`	`1231`
`1232`		-The `subtle.importKey()` method attempts to interpret the provided `keyData`
	`1232`	+The [`subtle.importKey()`][] method attempts to interpret the provided `keyData`
`1233`	`1233`	as the given `format` to create a {CryptoKey} instance using the provided
`1234`	`1234`	`algorithm`, `extractable`, and `keyUsages` arguments. If the import is
`1235`	`1235`	`successful, the returned promise will be resolved with the created {CryptoKey}.`
`@@ -1290,7 +1290,7 @@ changes:`
`1290`	`1290`	`<!--lint enable maximum-line-length remark-lint-->`
`1291`	`1291`
`1292`	`1292`	Using the method and parameters given by `algorithm` and the keying material
`1293`		-provided by `key`, `subtle.sign()` attempts to generate a cryptographic
	`1293`	+provided by `key`, this method attempts to generate a cryptographic
`1294`	`1294`	signature of `data`. If successful, the returned promise is resolved with
`1295`	`1295`	`an {ArrayBuffer} containing the generated signature.`
`1296`	`1296`
`@@ -1336,11 +1336,11 @@ changes:`
`1336`	`1336`	`* Returns: {Promise} Fulfills with a {CryptoKey} upon success.`
`1337`	`1337`
`1338`	`1338`	`In cryptography, "wrapping a key" refers to exporting and then encrypting the`
`1339`		-keying material. The `subtle.unwrapKey()` method attempts to decrypt a wrapped
	`1339`	`+keying material. This method attempts to decrypt a wrapped`
`1340`	`1340`	`key and create a {CryptoKey} instance. It is equivalent to calling`
`1341`		-`subtle.decrypt()` first on the encrypted key data (using the `wrappedKey`,
	`1341`	+[`subtle.decrypt()`][] first on the encrypted key data (using the `wrappedKey`,
`1342`	`1342`	`unwrapAlgo`, and `unwrappingKey` arguments as input) then passing the results
`1343`		-in to the `subtle.importKey()` method using the `unwrappedKeyAlgo`,
	`1343`	+to the [`subtle.importKey()`][] method using the `unwrappedKeyAlgo`,
`1344`	`1344`	`extractable`, and `keyUsages` arguments as inputs. If successful, the returned
`1345`	`1345`	`promise is resolved with a {CryptoKey} object.`
`1346`	`1346`
`@@ -1405,7 +1405,7 @@ changes:`
`1405`	`1405`	`<!--lint enable maximum-line-length remark-lint-->`
`1406`	`1406`
`1407`	`1407`	Using the method and parameters given in `algorithm` and the keying material
`1408`		-provided by `key`, `subtle.verify()` attempts to verify that `signature` is
	`1408`	+provided by `key`, this method attempts to verify that `signature` is
`1409`	`1409`	a valid cryptographic signature of `data`. The returned promise is resolved
`1410`	`1410`	with either `true` or `false`.
`1411`	`1411`
`@@ -1446,12 +1446,12 @@ changes:`
`1446`	`1446`	`<!--lint enable maximum-line-length remark-lint-->`
`1447`	`1447`
`1448`	`1448`	`In cryptography, "wrapping a key" refers to exporting and then encrypting the`
`1449`		-keying material. The `subtle.wrapKey()` method exports the keying material into
	`1449`	`+keying material. This method exports the keying material into`
`1450`	`1450`	the format identified by `format`, then encrypts it using the method and
`1451`	`1451`	parameters specified by `wrapAlgo` and the keying material provided by
`1452`		-`wrappingKey`. It is the equivalent to calling `subtle.exportKey()` using
	`1452`	+`wrappingKey`. It is the equivalent to calling [`subtle.exportKey()`][] using
`1453`	`1453`	`format` and `key` as the arguments, then passing the result to the
`1454`		-`subtle.encrypt()` method using `wrappingKey` and `wrapAlgo` as inputs. If
	`1454`	+[`subtle.encrypt()`][] method using `wrappingKey` and `wrapAlgo` as inputs. If
`1455`	`1455`	`successful, the returned promise will be resolved with an {ArrayBuffer}`
`1456`	`1456`	`containing the encrypted key data.`
`1457`	`1457`

0 commit comments

Comments

0 (0)

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.