2012-02-27 20:08:02 +01:00
|
|
|
# Crypto
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-07-16 00:35:38 +02:00
|
|
|
> Stability: 2 - Stable
|
2012-03-03 00:14:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `crypto` module provides cryptographic functionality that includes a set of
|
|
|
|
wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign and verify functions.
|
|
|
|
|
2010-10-28 14:18:16 +02:00
|
|
|
Use `require('crypto')` to access this module.
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
|
|
|
|
const secret = 'abcdefg';
|
|
|
|
const hash = crypto.createHmac('sha256', secret)
|
|
|
|
.update('I love cupcakes')
|
|
|
|
.digest('hex');
|
|
|
|
console.log(hash);
|
|
|
|
// Prints:
|
|
|
|
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
|
|
|
|
```
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-03-09 00:31:31 +01:00
|
|
|
## Determining if crypto support is unavailable
|
|
|
|
|
|
|
|
It is possible for Node.js to be built without including support for the
|
|
|
|
`crypto` module. In such cases, calling `require('crypto')` will result in an
|
|
|
|
error being thrown.
|
|
|
|
|
|
|
|
```js
|
|
|
|
var crypto;
|
|
|
|
try {
|
|
|
|
crypto = require('crypto');
|
|
|
|
} catch (err) {
|
|
|
|
console.log('crypto support is disabled!');
|
|
|
|
}
|
|
|
|
```
|
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: Certificate
|
2012-10-13 01:26:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
SPKAC is a Certificate Signing Request mechanism originally implemented by
|
|
|
|
Netscape and now specified formally as part of [HTML5's `keygen` element][].
|
|
|
|
|
|
|
|
The `crypto` module provides the `Certificate` class for working with SPKAC
|
|
|
|
data. The most common usage is handling output generated by the HTML5
|
|
|
|
`<keygen>` element. Node.js uses [OpenSSL's SPKAC implementation][] internally.
|
|
|
|
|
|
|
|
### new crypto.Certificate()
|
|
|
|
|
|
|
|
Instances of the `Certificate` class can be created using the `new` keyword
|
|
|
|
or by calling `crypto.Certificate()` as a function:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const cert1 = new crypto.Certificate();
|
|
|
|
const cert2 = crypto.Certificate();
|
|
|
|
```
|
2012-10-13 01:26:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### certificate.exportChallenge(spkac)
|
2012-10-13 01:26:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `spkac` data structure includes a public key and a challenge. The
|
|
|
|
`certificate.exportChallenge()` returns the challenge component in the
|
|
|
|
form of a Node.js [`Buffer`][]. The `spkac` argument can be either a string
|
|
|
|
or a [`Buffer`][].
|
2012-10-13 01:26:14 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const cert = require('crypto').Certificate();
|
|
|
|
const spkac = getSpkacSomehow();
|
|
|
|
const challenge = cert.exportChallenge(spkac);
|
|
|
|
console.log(challenge.toString('utf8'));
|
|
|
|
// Prints the challenge as a UTF8 string
|
|
|
|
```
|
2012-10-13 01:26:14 +02:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### certificate.exportPublicKey(spkac)
|
2012-10-13 01:26:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `spkac` data structure includes a public key and a challenge. The
|
|
|
|
`certificate.exportPublicKey()` returns the public key component in the
|
|
|
|
form of a Node.js [`Buffer`][]. The `spkac` argument can be either a string
|
|
|
|
or a [`Buffer`][].
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const cert = require('crypto').Certificate();
|
|
|
|
const spkac = getSpkacSomehow();
|
|
|
|
const publicKey = cert.exportPublicKey(spkac);
|
|
|
|
console.log(publicKey);
|
|
|
|
// Prints the public key as <Buffer ...>
|
|
|
|
```
|
2012-10-13 02:44:11 +02:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### certificate.verifySpkac(spkac)
|
2012-10-13 02:44:11 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns `true` if the given `spkac` data structure is valid, `false` otherwise.
|
|
|
|
The `spkac` argument must be a Node.js [`Buffer`][].
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const cert = require('crypto').Certificate();
|
|
|
|
const spkac = getSpkacSomehow();
|
2016-04-25 04:36:57 +02:00
|
|
|
console.log(cert.verifySpkac(Buffer.from(spkac)));
|
2016-01-17 18:39:07 +01:00
|
|
|
// Prints true or false
|
|
|
|
```
|
2012-10-13 02:44:11 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: Cipher
|
2012-10-13 02:44:11 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Instances of the `Cipher` class are used to encrypt data. The class can be
|
|
|
|
used in one of two ways:
|
2012-10-13 02:44:11 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
- As a [stream][] that is both readable and writable, where plain unencrypted
|
|
|
|
data is written to produce encrypted data on the readable side, or
|
2016-02-15 01:40:53 +01:00
|
|
|
- Using the [`cipher.update()`][] and [`cipher.final()`][] methods to produce
|
|
|
|
the encrypted data.
|
2015-06-08 18:26:16 +02:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`crypto.createCipher()`][] or [`crypto.createCipheriv()`][] methods are
|
|
|
|
used to create `Cipher` instances. `Cipher` objects are not to be created
|
|
|
|
directly using the `new` keyword.
|
2015-06-08 18:26:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Example: Using `Cipher` objects as streams:
|
2015-06-08 18:26:16 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const cipher = crypto.createCipher('aes192', 'a password');
|
2015-06-08 18:26:16 +02:00
|
|
|
|
2016-01-22 03:04:39 +01:00
|
|
|
var encrypted = '';
|
2016-01-17 18:39:07 +01:00
|
|
|
cipher.on('readable', () => {
|
|
|
|
var data = cipher.read();
|
|
|
|
if (data)
|
2016-01-22 03:04:39 +01:00
|
|
|
encrypted += data.toString('hex');
|
|
|
|
});
|
|
|
|
cipher.on('end', () => {
|
|
|
|
console.log(encrypted);
|
|
|
|
// Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504
|
2016-01-17 18:39:07 +01:00
|
|
|
});
|
2015-06-08 18:26:16 +02:00
|
|
|
|
2016-01-22 03:04:39 +01:00
|
|
|
cipher.write('some clear text data');
|
2016-01-17 18:39:07 +01:00
|
|
|
cipher.end();
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Example: Using `Cipher` and piped streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const fs = require('fs');
|
|
|
|
const cipher = crypto.createCipher('aes192', 'a password');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const input = fs.createReadStream('test.js');
|
|
|
|
const output = fs.createWriteStream('test.enc');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
input.pipe(cipher).pipe(output);
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Example: Using the [`cipher.update()`][] and [`cipher.final()`][] methods:
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const cipher = crypto.createCipher('aes192', 'a password');
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-01-22 03:04:39 +01:00
|
|
|
var encrypted = cipher.update('some clear text data', 'utf8', 'hex');
|
|
|
|
encrypted += cipher.final('hex');
|
|
|
|
console.log(encrypted);
|
|
|
|
// Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504
|
2016-01-17 18:39:07 +01:00
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
### cipher.final([output_encoding])
|
|
|
|
|
|
|
|
Returns any remaining enciphered contents. If `output_encoding`
|
2016-06-02 18:55:36 +02:00
|
|
|
parameter is one of `'latin1'`, `'base64'` or `'hex'`, a string is returned.
|
2015-12-27 05:54:01 +01:00
|
|
|
If an `output_encoding` is not provided, a [`Buffer`][] is returned.
|
|
|
|
|
|
|
|
Once the `cipher.final()` method has been called, the `Cipher` object can no
|
|
|
|
longer be used to encrypt data. Attempts to call `cipher.final()` more than
|
|
|
|
once will result in an error being thrown.
|
2014-06-25 12:11:09 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### cipher.setAAD(buffer)
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
When using an authenticated encryption mode (only `GCM` is currently
|
2016-02-15 01:40:53 +01:00
|
|
|
supported), the `cipher.setAAD()` method sets the value used for the
|
2015-12-27 05:54:01 +01:00
|
|
|
_additional authenticated data_ (AAD) input parameter.
|
|
|
|
|
|
|
|
### cipher.getAuthTag()
|
|
|
|
|
|
|
|
When using an authenticated encryption mode (only `GCM` is currently
|
|
|
|
supported), the `cipher.getAuthTag()` method returns a [`Buffer`][] containing
|
|
|
|
the _authentication tag_ that has been computed from the given data.
|
|
|
|
|
|
|
|
The `cipher.getAuthTag()` method should only be called after encryption has
|
2016-02-15 01:40:53 +01:00
|
|
|
been completed using the [`cipher.final()`][] method.
|
2012-10-22 19:37:20 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### cipher.setAutoPadding(auto_padding=true)
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
When using block encryption algorithms, the `Cipher` class will automatically
|
|
|
|
add padding to the input data to the appropriate block size. To disable the
|
|
|
|
default padding call `cipher.setAutoPadding(false)`.
|
|
|
|
|
|
|
|
When `auto_padding` is `false`, the length of the entire input data must be a
|
2016-02-15 01:40:53 +01:00
|
|
|
multiple of the cipher's block size or [`cipher.final()`][] will throw an Error.
|
2015-12-27 05:54:01 +01:00
|
|
|
Disabling automatic padding is useful for non-standard padding, for instance
|
|
|
|
using `0x0` instead of PKCS padding.
|
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The `cipher.setAutoPadding()` method must be called before [`cipher.final()`][].
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### cipher.update(data[, input_encoding][, output_encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Updates the cipher with `data`. If the `input_encoding` argument is given,
|
2016-06-02 18:55:36 +02:00
|
|
|
it's value must be one of `'utf8'`, `'ascii'`, or `'latin1'` and the `data`
|
2015-12-27 05:54:01 +01:00
|
|
|
argument is a string using the specified encoding. If the `input_encoding`
|
|
|
|
argument is not given, `data` must be a [`Buffer`][]. If `data` is a
|
|
|
|
[`Buffer`][] then `input_encoding` is ignored.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
The `output_encoding` specifies the output format of the enciphered
|
2016-06-02 18:55:36 +02:00
|
|
|
data, and can be `'latin1'`, `'base64'` or `'hex'`. If the `output_encoding`
|
2015-12-27 05:54:01 +01:00
|
|
|
is specified, a string using the specified encoding is returned. If no
|
|
|
|
`output_encoding` is provided, a [`Buffer`][] is returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `cipher.update()` method can be called multiple times with new data until
|
2016-02-15 01:40:53 +01:00
|
|
|
[`cipher.final()`][] is called. Calling `cipher.update()` after
|
|
|
|
[`cipher.final()`][] will result in an error being thrown.
|
2011-04-03 10:09:00 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: Decipher
|
2011-04-03 10:09:00 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Instances of the `Decipher` class are used to decrypt data. The class can be
|
|
|
|
used in one of two ways:
|
|
|
|
|
|
|
|
- As a [stream][] that is both readable and writable, where plain encrypted
|
|
|
|
data is written to produce unencrypted data on the readable side, or
|
2016-02-15 01:40:53 +01:00
|
|
|
- Using the [`decipher.update()`][] and [`decipher.final()`][] methods to
|
|
|
|
produce the unencrypted data.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`crypto.createDecipher()`][] or [`crypto.createDecipheriv()`][] methods are
|
|
|
|
used to create `Decipher` instances. `Decipher` objects are not to be created
|
2015-12-27 05:54:01 +01:00
|
|
|
directly using the `new` keyword.
|
|
|
|
|
|
|
|
Example: Using `Decipher` objects as streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const decipher = crypto.createDecipher('aes192', 'a password');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-22 03:04:39 +01:00
|
|
|
var decrypted = '';
|
2016-01-17 18:39:07 +01:00
|
|
|
decipher.on('readable', () => {
|
|
|
|
var data = decipher.read();
|
|
|
|
if (data)
|
2016-07-15 07:41:29 +02:00
|
|
|
decrypted += data.toString('utf8');
|
2016-01-22 03:04:39 +01:00
|
|
|
});
|
|
|
|
decipher.on('end', () => {
|
|
|
|
console.log(decrypted);
|
|
|
|
// Prints: some clear text data
|
2016-01-17 18:39:07 +01:00
|
|
|
});
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-22 03:04:39 +01:00
|
|
|
var encrypted = 'ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504';
|
|
|
|
decipher.write(encrypted, 'hex');
|
2016-01-17 18:39:07 +01:00
|
|
|
decipher.end();
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Example: Using `Decipher` and piped streams:
|
|
|
|
|
2016-01-25 15:28:43 +01:00
|
|
|
```js
|
2016-01-17 18:39:07 +01:00
|
|
|
const crypto = require('crypto');
|
|
|
|
const fs = require('fs');
|
|
|
|
const decipher = crypto.createDecipher('aes192', 'a password');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const input = fs.createReadStream('test.enc');
|
|
|
|
const output = fs.createWriteStream('test.js');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
input.pipe(decipher).pipe(output);
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Example: Using the [`decipher.update()`][] and [`decipher.final()`][] methods:
|
2011-04-03 10:09:00 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const decipher = crypto.createDecipher('aes192', 'a password');
|
2011-04-03 10:09:00 +02:00
|
|
|
|
2016-01-22 03:04:39 +01:00
|
|
|
var encrypted = 'ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504';
|
|
|
|
var decrypted = decipher.update(encrypted, 'hex', 'utf8');
|
|
|
|
decrypted += decipher.final('utf8');
|
|
|
|
console.log(decrypted);
|
|
|
|
// Prints: some clear text data
|
2016-01-17 18:39:07 +01:00
|
|
|
```
|
2011-04-03 10:09:00 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### decipher.final([output_encoding])
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns any remaining deciphered contents. If `output_encoding`
|
2016-06-02 18:55:36 +02:00
|
|
|
parameter is one of `'latin1'`, `'base64'` or `'hex'`, a string is returned.
|
2015-12-27 05:54:01 +01:00
|
|
|
If an `output_encoding` is not provided, a [`Buffer`][] is returned.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Once the `decipher.final()` method has been called, the `Decipher` object can
|
|
|
|
no longer be used to decrypt data. Attempts to call `decipher.final()` more
|
|
|
|
than once will result in an error being thrown.
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### decipher.setAAD(buffer)
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
When using an authenticated encryption mode (only `GCM` is currently
|
2016-02-15 01:40:53 +01:00
|
|
|
supported), the `cipher.setAAD()` method sets the value used for the
|
2015-12-27 05:54:01 +01:00
|
|
|
_additional authenticated data_ (AAD) input parameter.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### decipher.setAuthTag(buffer)
|
2012-10-11 00:44:47 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
When using an authenticated encryption mode (only `GCM` is currently
|
|
|
|
supported), the `decipher.setAuthTag()` method is used to pass in the
|
2016-02-15 01:40:53 +01:00
|
|
|
received _authentication tag_. If no tag is provided, or if the cipher text
|
|
|
|
has been tampered with, [`decipher.final()`][] with throw, indicating that the
|
|
|
|
cipher text should be discarded due to failed authentication.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### decipher.setAutoPadding(auto_padding=true)
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
When data has been encrypted without standard block padding, calling
|
2016-04-04 20:43:35 +02:00
|
|
|
`decipher.setAutoPadding(false)` will disable automatic padding to prevent
|
2016-02-15 01:40:53 +01:00
|
|
|
[`decipher.final()`][] from checking for and removing padding.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Turning auto padding off will only work if the input data's length is a
|
|
|
|
multiple of the ciphers block size.
|
|
|
|
|
|
|
|
The `decipher.setAutoPadding()` method must be called before
|
2016-02-15 01:40:53 +01:00
|
|
|
[`decipher.update()`][].
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### decipher.update(data[, input_encoding][, output_encoding])
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Updates the decipher with `data`. If the `input_encoding` argument is given,
|
2016-06-02 18:55:36 +02:00
|
|
|
it's value must be one of `'latin1'`, `'base64'`, or `'hex'` and the `data`
|
2015-12-27 05:54:01 +01:00
|
|
|
argument is a string using the specified encoding. If the `input_encoding`
|
|
|
|
argument is not given, `data` must be a [`Buffer`][]. If `data` is a
|
|
|
|
[`Buffer`][] then `input_encoding` is ignored.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `output_encoding` specifies the output format of the enciphered
|
2016-06-02 18:55:36 +02:00
|
|
|
data, and can be `'latin1'`, `'ascii'` or `'utf8'`. If the `output_encoding`
|
2015-12-27 05:54:01 +01:00
|
|
|
is specified, a string using the specified encoding is returned. If no
|
|
|
|
`output_encoding` is provided, a [`Buffer`][] is returned.
|
|
|
|
|
|
|
|
The `decipher.update()` method can be called multiple times with new data until
|
2016-02-15 01:40:53 +01:00
|
|
|
[`decipher.final()`][] is called. Calling `decipher.update()` after
|
|
|
|
[`decipher.final()`][] will result in an error being thrown.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: DiffieHellman
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `DiffieHellman` class is a utility for creating Diffie-Hellman key
|
|
|
|
exchanges.
|
|
|
|
|
|
|
|
Instances of the `DiffieHellman` class can be created using the
|
2016-02-15 01:40:53 +01:00
|
|
|
[`crypto.createDiffieHellman()`][] function.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const assert = require('assert');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Generate Alice's keys...
|
2016-03-01 18:26:32 +01:00
|
|
|
const alice = crypto.createDiffieHellman(2048);
|
2016-01-17 18:39:07 +01:00
|
|
|
const alice_key = alice.generateKeys();
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Generate Bob's keys...
|
2016-03-01 18:26:32 +01:00
|
|
|
const bob = crypto.createDiffieHellman(alice.getPrime(), alice.getGenerator());
|
2016-01-17 18:39:07 +01:00
|
|
|
const bob_key = bob.generateKeys();
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Exchange and generate the secret...
|
|
|
|
const alice_secret = alice.computeSecret(bob_key);
|
|
|
|
const bob_secret = bob.computeSecret(alice_key);
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-03-01 18:26:32 +01:00
|
|
|
// OK
|
|
|
|
assert.equal(alice_secret.toString('hex'), bob_secret.toString('hex'));
|
2016-01-17 18:39:07 +01:00
|
|
|
```
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.computeSecret(other_public_key[, input_encoding][, output_encoding])
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Computes the shared secret using `other_public_key` as the other
|
2015-12-27 05:54:01 +01:00
|
|
|
party's public key and returns the computed shared secret. The supplied
|
|
|
|
key is interpreted using the specified `input_encoding`, and secret is
|
2015-11-04 17:23:03 +01:00
|
|
|
encoded using specified `output_encoding`. Encodings can be
|
2016-06-02 18:55:36 +02:00
|
|
|
`'latin1'`, `'hex'`, or `'base64'`. If the `input_encoding` is not
|
2015-12-27 05:54:01 +01:00
|
|
|
provided, `other_public_key` is expected to be a [`Buffer`][].
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If `output_encoding` is given a string is returned; otherwise, a
|
|
|
|
[`Buffer`][] is returned.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.generateKeys([encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Generates private and public Diffie-Hellman key values, and returns
|
2015-12-27 05:54:01 +01:00
|
|
|
the public key in the specified `encoding`. This key should be
|
2016-06-02 18:55:36 +02:00
|
|
|
transferred to the other party. Encoding can be `'latin1'`, `'hex'`,
|
2016-02-15 01:40:53 +01:00
|
|
|
or `'base64'`. If `encoding` is provided a string is returned; otherwise a
|
2015-12-27 05:54:01 +01:00
|
|
|
[`Buffer`][] is returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.getGenerator([encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns the Diffie-Hellman generator in the specified `encoding`, which can
|
2016-06-02 18:55:36 +02:00
|
|
|
be `'latin1'`, `'hex'`, or `'base64'`. If `encoding` is provided a string is
|
2015-12-27 05:54:01 +01:00
|
|
|
returned; otherwise a [`Buffer`][] is returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.getPrime([encoding])
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns the Diffie-Hellman prime in the specified `encoding`, which can
|
2016-06-02 18:55:36 +02:00
|
|
|
be `'latin1'`, `'hex'`, or `'base64'`. If `encoding` is provided a string is
|
2015-12-27 05:54:01 +01:00
|
|
|
returned; otherwise a [`Buffer`][] is returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.getPrivateKey([encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns the Diffie-Hellman private key in the specified `encoding`,
|
2016-06-02 18:55:36 +02:00
|
|
|
which can be `'latin1'`, `'hex'`, or `'base64'`. If `encoding` is provided a
|
2015-12-27 05:54:01 +01:00
|
|
|
string is returned; otherwise a [`Buffer`][] is returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.getPublicKey([encoding])
|
2011-07-24 08:56:23 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns the Diffie-Hellman public key in the specified `encoding`, which
|
2016-06-02 18:55:36 +02:00
|
|
|
can be `'latin1'`, `'hex'`, or `'base64'`. If `encoding` is provided a
|
2015-12-27 05:54:01 +01:00
|
|
|
string is returned; otherwise a [`Buffer`][] is returned.
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.setPrivateKey(private_key[, encoding])
|
2014-10-19 16:31:22 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Sets the Diffie-Hellman private key. If the `encoding` argument is provided
|
2016-06-02 18:55:36 +02:00
|
|
|
and is either `'latin1'`, `'hex'`, or `'base64'`, `private_key` is expected
|
2015-12-27 05:54:01 +01:00
|
|
|
to be a string. If no `encoding` is provided, `private_key` is expected
|
|
|
|
to be a [`Buffer`][].
|
2014-10-19 16:31:22 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.setPublicKey(public_key[, encoding])
|
2011-07-24 08:56:23 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Sets the Diffie-Hellman public key. If the `encoding` argument is provided
|
2016-06-02 18:55:36 +02:00
|
|
|
and is either `'latin1'`, `'hex'` or `'base64'`, `public_key` is expected
|
2015-12-27 05:54:01 +01:00
|
|
|
to be a string. If no `encoding` is provided, `public_key` is expected
|
|
|
|
to be a [`Buffer`][].
|
2011-07-24 08:56:23 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### diffieHellman.verifyError
|
2012-06-12 22:02:35 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
A bit field containing any warnings and/or errors resulting from a check
|
|
|
|
performed during initialization of the `DiffieHellman` object.
|
|
|
|
|
|
|
|
The following values are valid for this property (as defined in `constants`
|
|
|
|
module):
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
* `DH_CHECK_P_NOT_SAFE_PRIME`
|
|
|
|
* `DH_CHECK_P_NOT_PRIME`
|
|
|
|
* `DH_UNABLE_TO_CHECK_GENERATOR`
|
|
|
|
* `DH_NOT_SUITABLE_GENERATOR`
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: ECDH
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `ECDH` class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH)
|
|
|
|
key exchanges.
|
|
|
|
|
|
|
|
Instances of the `ECDH` class can be created using the
|
2016-02-15 01:40:53 +01:00
|
|
|
[`crypto.createECDH()`][] function.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const assert = require('assert');
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Generate Alice's keys...
|
|
|
|
const alice = crypto.createECDH('secp521r1');
|
|
|
|
const alice_key = alice.generateKeys();
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Generate Bob's keys...
|
|
|
|
const bob = crypto.createECDH('secp521r1');
|
|
|
|
const bob_key = bob.generateKeys();
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Exchange and generate the secret...
|
|
|
|
const alice_secret = alice.computeSecret(bob_key);
|
|
|
|
const bob_secret = bob.computeSecret(alice_key);
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
assert(alice_secret, bob_secret);
|
|
|
|
// OK
|
|
|
|
```
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### ecdh.computeSecret(other_public_key[, input_encoding][, output_encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Computes the shared secret using `other_public_key` as the other
|
2015-12-27 05:54:01 +01:00
|
|
|
party's public key and returns the computed shared secret. The supplied
|
|
|
|
key is interpreted using specified `input_encoding`, and the returned secret
|
|
|
|
is encoded using the specified `output_encoding`. Encodings can be
|
2016-06-02 18:55:36 +02:00
|
|
|
`'latin1'`, `'hex'`, or `'base64'`. If the `input_encoding` is not
|
2015-12-27 05:54:01 +01:00
|
|
|
provided, `other_public_key` is expected to be a [`Buffer`][].
|
2011-12-27 09:43:58 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If `output_encoding` is given a string will be returned; otherwise a
|
|
|
|
[`Buffer`][] is returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### ecdh.generateKeys([encoding[, format]])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Generates private and public EC Diffie-Hellman key values, and returns
|
2015-12-27 05:54:01 +01:00
|
|
|
the public key in the specified `format` and `encoding`. This key should be
|
2015-11-04 17:23:03 +01:00
|
|
|
transferred to the other party.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `format` arguments specifies point encoding and can be `'compressed'`,
|
|
|
|
`'uncompressed'`, or `'hybrid'`. If `format` is not specified, the point will
|
|
|
|
be returned in `'uncompressed'` format.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-06-02 18:55:36 +02:00
|
|
|
The `encoding` argument can be `'latin1'`, `'hex'`, or `'base64'`. If
|
2015-12-27 05:54:01 +01:00
|
|
|
`encoding` is provided a string is returned; otherwise a [`Buffer`][]
|
|
|
|
is returned.
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### ecdh.getPrivateKey([encoding])
|
2011-12-02 21:04:13 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns the EC Diffie-Hellman private key in the specified `encoding`,
|
2016-06-02 18:55:36 +02:00
|
|
|
which can be `'latin1'`, `'hex'`, or `'base64'`. If `encoding` is provided
|
2015-12-27 05:54:01 +01:00
|
|
|
a string is returned; otherwise a [`Buffer`][] is returned.
|
2011-12-02 21:04:13 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### ecdh.getPublicKey([encoding[, format]])
|
2013-11-19 22:38:15 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns the EC Diffie-Hellman public key in the specified `encoding` and
|
|
|
|
`format`.
|
2013-11-19 22:38:15 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `format` argument specifies point encoding and can be `'compressed'`,
|
|
|
|
`'uncompressed'`, or `'hybrid'`. If `format` is not specified the point will be
|
|
|
|
returned in `'uncompressed'` format.
|
2014-03-04 06:05:23 +01:00
|
|
|
|
2016-06-02 18:55:36 +02:00
|
|
|
The `encoding` argument can be `'latin1'`, `'hex'`, or `'base64'`. If
|
2015-12-27 05:54:01 +01:00
|
|
|
`encoding` is specified, a string is returned; otherwise a [`Buffer`][] is
|
|
|
|
returned.
|
2014-03-04 06:05:23 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### ecdh.setPrivateKey(private_key[, encoding])
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2016-06-02 18:55:36 +02:00
|
|
|
Sets the EC Diffie-Hellman private key. The `encoding` can be `'latin1'`,
|
2015-12-27 05:54:01 +01:00
|
|
|
`'hex'` or `'base64'`. If `encoding` is provided, `private_key` is expected
|
|
|
|
to be a string; otherwise `private_key` is expected to be a [`Buffer`][]. If
|
|
|
|
`private_key` is not valid for the curve specified when the `ECDH` object was
|
|
|
|
created, an error is thrown. Upon setting the private key, the associated
|
|
|
|
public point (key) is also generated and set in the ECDH object.
|
2015-11-19 20:00:00 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
### ecdh.setPublicKey(public_key[, encoding])
|
2015-11-19 20:00:00 +01:00
|
|
|
|
2016-07-16 00:35:38 +02:00
|
|
|
> Stability: 0 - Deprecated
|
2015-11-19 20:00:00 +01:00
|
|
|
|
2016-06-02 18:55:36 +02:00
|
|
|
Sets the EC Diffie-Hellman public key. Key encoding can be `'latin1'`,
|
2015-12-27 05:54:01 +01:00
|
|
|
`'hex'` or `'base64'`. If `encoding` is provided `public_key` is expected to
|
|
|
|
be a string; otherwise a [`Buffer`][] is expected.
|
|
|
|
|
|
|
|
Note that there is not normally a reason to call this method because `ECDH`
|
|
|
|
only requires a private key and the other party's public key to compute the
|
2016-02-15 01:40:53 +01:00
|
|
|
shared secret. Typically either [`ecdh.generateKeys()`][] or
|
|
|
|
[`ecdh.setPrivateKey()`][] will be called. The [`ecdh.setPrivateKey()`][] method
|
|
|
|
attempts to generate the public point/key associated with the private key being
|
|
|
|
set.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Example (obtaining a shared secret):
|
2011-07-24 08:56:23 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const alice = crypto.createECDH('secp256k1');
|
|
|
|
const bob = crypto.createECDH('secp256k1');
|
2011-07-24 08:56:23 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Note: This is a shortcut way to specify one of Alice's previous private
|
|
|
|
// keys. It would be unwise to use such a predictable private key in a real
|
|
|
|
// application.
|
|
|
|
alice.setPrivateKey(
|
|
|
|
crypto.createHash('sha256').update('alice', 'utf8').digest()
|
|
|
|
);
|
2015-11-19 20:00:00 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// Bob uses a newly generated cryptographically strong
|
|
|
|
// pseudorandom key pair bob.generateKeys();
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const alice_secret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
|
|
|
|
const bob_secret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
// alice_secret and bob_secret should be the same shared secret value
|
|
|
|
console.log(alice_secret === bob_secret);
|
|
|
|
```
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: Hash
|
2011-12-27 09:43:58 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Hash` class is a utility for creating hash digests of data. It can be
|
|
|
|
used in one of two ways:
|
|
|
|
|
|
|
|
- As a [stream][] that is both readable and writable, where data is written
|
|
|
|
to produce a computed hash digest on the readable side, or
|
2016-02-15 01:40:53 +01:00
|
|
|
- Using the [`hash.update()`][] and [`hash.digest()`][] methods to produce the
|
2015-12-27 05:54:01 +01:00
|
|
|
computed hash.
|
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`crypto.createHash()`][] method is used to create `Hash` instances. `Hash`
|
2015-12-27 05:54:01 +01:00
|
|
|
objects are not to be created directly using the `new` keyword.
|
|
|
|
|
|
|
|
Example: Using `Hash` objects as streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const hash = crypto.createHash('sha256');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
hash.on('readable', () => {
|
|
|
|
var data = hash.read();
|
|
|
|
if (data)
|
|
|
|
console.log(data.toString('hex'));
|
|
|
|
// Prints:
|
|
|
|
// 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
|
|
|
|
});
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
hash.write('some data to hash');
|
|
|
|
hash.end();
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Example: Using `Hash` and piped streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const fs = require('fs');
|
|
|
|
const hash = crypto.createHash('sha256');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const input = fs.createReadStream('test.js');
|
|
|
|
input.pipe(hash).pipe(process.stdout);
|
|
|
|
```
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Example: Using the [`hash.update()`][] and [`hash.digest()`][] methods:
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const hash = crypto.createHash('sha256');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
hash.update('some data to hash');
|
|
|
|
console.log(hash.digest('hex'));
|
|
|
|
// Prints:
|
|
|
|
// 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
|
|
|
|
```
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### hash.digest([encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Calculates the digest of all of the data passed to be hashed (using the
|
2016-06-02 18:55:36 +02:00
|
|
|
[`hash.update()`][] method). The `encoding` can be `'hex'`, `'latin1'` or
|
2016-02-15 01:40:53 +01:00
|
|
|
`'base64'`. If `encoding` is provided a string will be returned; otherwise
|
2015-12-27 05:54:01 +01:00
|
|
|
a [`Buffer`][] is returned.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Hash` object can not be used again after `hash.digest()` method has been
|
|
|
|
called. Multiple calls will cause an error to be thrown.
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### hash.update(data[, input_encoding])
|
2011-12-02 21:04:13 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Updates the hash content with the given `data`, the encoding of which
|
|
|
|
is given in `input_encoding` and can be `'utf8'`, `'ascii'` or
|
2016-06-02 18:55:36 +02:00
|
|
|
`'latin1'`. If `encoding` is not provided, and the `data` is a string, an
|
2016-03-02 12:43:39 +01:00
|
|
|
encoding of `'utf8'` is enforced. If `data` is a [`Buffer`][] then
|
2015-11-04 17:23:03 +01:00
|
|
|
`input_encoding` is ignored.
|
2011-12-02 21:04:13 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
This can be called many times with new data as it is streamed.
|
2013-11-19 22:38:15 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
## Class: Hmac
|
2013-11-19 22:38:15 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Hmac` Class is a utility for creating cryptographic HMAC digests. It can
|
|
|
|
be used in one of two ways:
|
|
|
|
|
|
|
|
- As a [stream][] that is both readable and writable, where data is written
|
|
|
|
to produce a computed HMAC digest on the readable side, or
|
2016-02-15 01:40:53 +01:00
|
|
|
- Using the [`hmac.update()`][] and [`hmac.digest()`][] methods to produce the
|
2015-12-27 05:54:01 +01:00
|
|
|
computed HMAC digest.
|
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`crypto.createHmac()`][] method is used to create `Hmac` instances. `Hmac`
|
2015-12-27 05:54:01 +01:00
|
|
|
objects are not to be created directly using the `new` keyword.
|
|
|
|
|
|
|
|
Example: Using `Hmac` objects as streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const hmac = crypto.createHmac('sha256', 'a secret');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
hmac.on('readable', () => {
|
|
|
|
var data = hmac.read();
|
|
|
|
if (data)
|
|
|
|
console.log(data.toString('hex'));
|
|
|
|
// Prints:
|
|
|
|
// 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
|
|
|
|
});
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
hmac.write('some data to hash');
|
|
|
|
hmac.end();
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Example: Using `Hmac` and piped streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const fs = require('fs');
|
|
|
|
const hmac = crypto.createHmac('sha256', 'a secret');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const input = fs.createReadStream('test.js');
|
|
|
|
input.pipe(hmac).pipe(process.stdout);
|
|
|
|
```
|
2014-03-04 06:05:23 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Example: Using the [`hmac.update()`][] and [`hmac.digest()`][] methods:
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const hmac = crypto.createHmac('sha256', 'a secret');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
hmac.update('some data to hash');
|
|
|
|
console.log(hmac.digest('hex'));
|
|
|
|
// Prints:
|
|
|
|
// 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
|
|
|
|
```
|
2014-03-04 06:05:23 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
### hmac.digest([encoding])
|
2013-11-19 22:38:15 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Calculates the HMAC digest of all of the data passed using [`hmac.update()`][].
|
2016-06-02 18:55:36 +02:00
|
|
|
The `encoding` can be `'hex'`, `'latin1'` or `'base64'`. If `encoding` is
|
2016-02-15 01:40:53 +01:00
|
|
|
provided a string is returned; otherwise a [`Buffer`][] is returned;
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Hmac` object can not be used again after `hmac.digest()` has been
|
|
|
|
called. Multiple calls to `hmac.digest()` will result in an error being thrown.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-03-01 03:03:14 +01:00
|
|
|
### hmac.update(data[, input_encoding])
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-03-01 03:03:14 +01:00
|
|
|
Updates the `Hmac` content with the given `data`, the encoding of which
|
|
|
|
is given in `input_encoding` and can be `'utf8'`, `'ascii'` or
|
2016-06-02 18:55:36 +02:00
|
|
|
`'latin1'`. If `encoding` is not provided, and the `data` is a string, an
|
2016-03-01 03:03:14 +01:00
|
|
|
encoding of `'utf8'` is enforced. If `data` is a [`Buffer`][] then
|
|
|
|
`input_encoding` is ignored.
|
|
|
|
|
|
|
|
This can be called many times with new data as it is streamed.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2012-10-30 23:46:43 +01:00
|
|
|
## Class: Sign
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Sign` Class is a utility for generating signatures. It can be used in one
|
|
|
|
of two ways:
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
- As a writable [stream][], where data to be signed is written and the
|
2016-02-15 01:40:53 +01:00
|
|
|
[`sign.sign()`][] method is used to generate and return the signature, or
|
|
|
|
- Using the [`sign.update()`][] and [`sign.sign()`][] methods to produce the
|
2015-12-27 05:54:01 +01:00
|
|
|
signature.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`crypto.createSign()`][] method is used to create `Sign` instances. `Sign`
|
2015-12-27 05:54:01 +01:00
|
|
|
objects are not to be created directly using the `new` keyword.
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Example: Using `Sign` objects as streams:
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
2016-02-02 20:11:07 +01:00
|
|
|
const sign = crypto.createSign('RSA-SHA256');
|
2013-10-04 13:59:38 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
sign.write('some data to sign');
|
|
|
|
sign.end();
|
2013-10-04 13:59:38 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const private_key = getPrivateKeySomehow();
|
|
|
|
console.log(sign.sign(private_key, 'hex'));
|
|
|
|
// Prints the calculated signature
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Example: Using the [`sign.update()`][] and [`sign.sign()`][] methods:
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
2016-02-02 20:11:07 +01:00
|
|
|
const sign = crypto.createSign('RSA-SHA256');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
sign.update('some data to sign');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const private_key = getPrivateKeySomehow();
|
|
|
|
console.log(sign.sign(private_key, 'hex'));
|
|
|
|
// Prints the calculated signature
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-05-17 15:38:25 +02:00
|
|
|
A `Sign` instance can also be created by just passing in the digest
|
2016-04-08 00:38:00 +02:00
|
|
|
algorithm name, in which case OpenSSL will infer the full signature algorithm
|
|
|
|
from the type of the PEM-formatted private key, including algorithms that
|
|
|
|
do not have directly exposed name constants, e.g. 'ecdsa-with-SHA256'.
|
|
|
|
|
|
|
|
Example: signing using ECDSA with SHA256
|
|
|
|
|
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const sign = crypto.createSign('sha256');
|
|
|
|
|
|
|
|
sign.update('some data to sign');
|
|
|
|
|
|
|
|
const private_key = '-----BEGIN EC PRIVATE KEY-----\n' +
|
|
|
|
'MHcCAQEEIF+jnWY1D5kbVYDNvxxo/Y+ku2uJPDwS0r/VuPZQrjjVoAoGCCqGSM49\n' +
|
|
|
|
'AwEHoUQDQgAEurOxfSxmqIRYzJVagdZfMMSjRNNhB8i3mXyIMq704m2m52FdfKZ2\n' +
|
|
|
|
'pQhByd5eyj3lgZ7m7jbchtdgyOF8Io/1ng==\n' +
|
|
|
|
'-----END EC PRIVATE KEY-----\n';
|
|
|
|
|
|
|
|
console.log(sign.sign(private_key).toString('hex'));
|
|
|
|
```
|
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### sign.sign(private_key[, output_format])
|
|
|
|
|
|
|
|
Calculates the signature on all the data passed through using either
|
2016-02-15 01:40:53 +01:00
|
|
|
[`sign.update()`][] or [`sign.write()`][stream-writable-write].
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
The `private_key` argument can be an object or a string. If `private_key` is a
|
|
|
|
string, it is treated as a raw key with no passphrase. If `private_key` is an
|
|
|
|
object, it is interpreted as a hash containing two properties:
|
2013-10-04 13:59:38 +02:00
|
|
|
|
2016-01-19 17:03:15 +01:00
|
|
|
* `key` : {String} - PEM encoded private key
|
|
|
|
* `passphrase` : {String} - passphrase for the private key
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-06-02 18:55:36 +02:00
|
|
|
The `output_format` can specify one of `'latin1'`, `'hex'` or `'base64'`. If
|
2015-12-27 05:54:01 +01:00
|
|
|
`output_format` is provided a string is returned; otherwise a [`Buffer`][] is
|
2012-10-22 19:37:20 +02:00
|
|
|
returned.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Sign` object can not be again used after `sign.sign()` method has been
|
|
|
|
called. Multiple calls to `sign.sign()` will result in an error being thrown.
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2016-03-01 03:03:14 +01:00
|
|
|
### sign.update(data[, input_encoding])
|
|
|
|
|
|
|
|
Updates the `Sign` content with the given `data`, the encoding of which
|
|
|
|
is given in `input_encoding` and can be `'utf8'`, `'ascii'` or
|
2016-06-02 18:55:36 +02:00
|
|
|
`'latin1'`. If `encoding` is not provided, and the `data` is a string, an
|
2016-03-01 03:03:14 +01:00
|
|
|
encoding of `'utf8'` is enforced. If `data` is a [`Buffer`][] then
|
|
|
|
`input_encoding` is ignored.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-03-01 03:03:14 +01:00
|
|
|
This can be called many times with new data as it is streamed.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2012-02-27 20:08:02 +01:00
|
|
|
## Class: Verify
|
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `Verify` class is a utility for verifying signatures. It can be used in one
|
|
|
|
of two ways:
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
- As a writable [stream][] where written data is used to validate against the
|
|
|
|
supplied signature, or
|
2016-02-15 01:40:53 +01:00
|
|
|
- Using the [`verify.update()`][] and [`verify.verify()`][] methods to verify
|
|
|
|
the signature.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`crypto.createSign()`][] method is used to create `Sign` instances.
|
|
|
|
`Sign` objects are not to be created directly using the `new` keyword.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Example: Using `Verify` objects as streams:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
2016-02-02 20:11:07 +01:00
|
|
|
const verify = crypto.createVerify('RSA-SHA256');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
verify.write('some data to sign');
|
|
|
|
verify.end();
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const public_key = getPublicKeySomehow();
|
|
|
|
const signature = getSignatureToVerify();
|
2016-06-24 23:24:09 +02:00
|
|
|
console.log(verify.verify(public_key, signature));
|
2016-01-17 18:39:07 +01:00
|
|
|
// Prints true or false
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Example: Using the [`verify.update()`][] and [`verify.verify()`][] methods:
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
2016-02-02 20:11:07 +01:00
|
|
|
const verify = crypto.createVerify('RSA-SHA256');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
verify.update('some data to sign');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const public_key = getPublicKeySomehow();
|
|
|
|
const signature = getSignatureToVerify();
|
|
|
|
console.log(verify.verify(public_key, signature));
|
|
|
|
// Prints true or false
|
|
|
|
```
|
2012-10-30 23:46:43 +01:00
|
|
|
|
2016-03-01 03:03:14 +01:00
|
|
|
### verifier.update(data[, input_encoding])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2016-03-01 03:03:14 +01:00
|
|
|
Updates the `Verify` content with the given `data`, the encoding of which
|
|
|
|
is given in `input_encoding` and can be `'utf8'`, `'ascii'` or
|
2016-06-02 18:55:36 +02:00
|
|
|
`'latin1'`. If `encoding` is not provided, and the `data` is a string, an
|
2016-03-01 03:03:14 +01:00
|
|
|
encoding of `'utf8'` is enforced. If `data` is a [`Buffer`][] then
|
|
|
|
`input_encoding` is ignored.
|
|
|
|
|
|
|
|
This can be called many times with new data as it is streamed.
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2014-09-25 00:41:31 +02:00
|
|
|
### verifier.verify(object, signature[, signature_format])
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Verifies the provided data using the given `object` and `signature`.
|
|
|
|
The `object` argument is a string containing a PEM encoded object, which can be
|
|
|
|
one an RSA public key, a DSA public key, or an X.509 certificate.
|
|
|
|
The `signature` argument is the previously calculated signature for the data, in
|
2016-06-02 18:55:36 +02:00
|
|
|
the `signature_format` which can be `'latin1'`, `'hex'` or `'base64'`.
|
2015-12-27 05:54:01 +01:00
|
|
|
If a `signature_format` is specified, the `signature` is expected to be a
|
|
|
|
string; otherwise `signature` is expected to be a [`Buffer`][].
|
2010-10-28 14:18:16 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns `true` or `false` depending on the validity of the signature for
|
2012-10-22 19:37:20 +02:00
|
|
|
the data and public key.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `verifier` object can not be used again after `verify.verify()` has been
|
|
|
|
called. Multiple calls to `verify.verify()` will result in an error being
|
|
|
|
thrown.
|
2011-07-29 20:03:58 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
## `crypto` module methods and properties
|
|
|
|
|
2016-05-02 19:27:12 +02:00
|
|
|
## crypto.constants
|
|
|
|
|
|
|
|
Returns an object containing commonly used constants for crypto and security
|
|
|
|
related operations. The specific constants currently defined are described in
|
|
|
|
[Crypto Constants][].
|
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.DEFAULT_ENCODING
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
The default encoding to use for functions that can take either strings
|
2016-02-15 01:40:53 +01:00
|
|
|
or [buffers][`Buffer`]. The default value is `'buffer'`, which makes methods
|
|
|
|
default to [`Buffer`][] objects.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
The `crypto.DEFAULT_ENCODING` mechanism is provided for backwards compatibility
|
2016-06-02 18:55:36 +02:00
|
|
|
with legacy programs that expect `'latin1'` to be the default encoding.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
New applications should expect the default to be `'buffer'`. This property may
|
|
|
|
become deprecated in a future Node.js release.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-01-23 00:10:09 +01:00
|
|
|
### crypto.fips
|
|
|
|
|
|
|
|
Property for checking and controlling whether a FIPS compliant crypto provider is
|
|
|
|
currently in use. Setting to true requires a FIPS build of Node.js.
|
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createCipher(algorithm, password)
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates and returns a `Cipher` object that uses the given `algorithm` and
|
|
|
|
`password`.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
|
2015-12-27 05:54:01 +01:00
|
|
|
recent OpenSSL releases, `openssl list-cipher-algorithms` will display the
|
|
|
|
available cipher algorithms.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `password` is used to derive the cipher key and initialization vector (IV).
|
2016-06-02 18:55:36 +02:00
|
|
|
The value must be either a `'latin1'` encoded string or a [`Buffer`][].
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The implementation of `crypto.createCipher()` derives keys using the OpenSSL
|
|
|
|
function [`EVP_BytesToKey`][] with the digest algorithm set to MD5, one
|
|
|
|
iteration, and no salt. The lack of salt allows dictionary attacks as the same
|
|
|
|
password always creates the same key. The low iteration count and
|
|
|
|
non-cryptographically secure hash algorithm allow passwords to be tested very
|
|
|
|
rapidly.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
In line with OpenSSL's recommendation to use pbkdf2 instead of
|
|
|
|
[`EVP_BytesToKey`][] it is recommended that developers derive a key and IV on
|
2016-02-15 01:40:53 +01:00
|
|
|
their own using [`crypto.pbkdf2()`][] and to use [`crypto.createCipheriv()`][]
|
2015-12-27 05:54:01 +01:00
|
|
|
to create the `Cipher` object.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createCipheriv(algorithm, key, iv)
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates and returns a `Cipher` object, with the given `algorithm`, `key` and
|
|
|
|
initialization vector (`iv`).
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
|
2015-12-27 05:54:01 +01:00
|
|
|
recent OpenSSL releases, `openssl list-cipher-algorithms` will display the
|
|
|
|
available cipher algorithms.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `key` is the raw key used by the `algorithm` and `iv` is an
|
2016-07-20 08:45:43 +02:00
|
|
|
[initialization vector][]. Both arguments must be `'utf8'` encoded strings or
|
2016-02-15 01:40:53 +01:00
|
|
|
[buffers][`Buffer`].
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createCredentials(details)
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-07-16 00:35:38 +02:00
|
|
|
> Stability: 0 - Deprecated: Use [`tls.createSecureContext()`][] instead.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `crypto.createCredentials()` method is a deprecated alias for creating
|
|
|
|
and returning a `tls.SecureContext` object. The `crypto.createCredentials()`
|
|
|
|
method should not be used.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The optional `details` argument is a hash object with keys:
|
|
|
|
|
2016-01-19 17:03:15 +01:00
|
|
|
* `pfx` : {String|Buffer} - PFX or PKCS12 encoded private
|
2015-11-04 17:23:03 +01:00
|
|
|
key, certificate and CA certificates
|
2016-01-19 17:03:15 +01:00
|
|
|
* `key` : {String} - PEM encoded private key
|
|
|
|
* `passphrase` : {String} - passphrase for the private key or PFX
|
|
|
|
* `cert` : {String} - PEM encoded certificate
|
|
|
|
* `ca` : {String|Array} - Either a string or array of strings of PEM encoded CA
|
2015-11-04 17:23:03 +01:00
|
|
|
certificates to trust.
|
2016-01-19 17:03:15 +01:00
|
|
|
* `crl` : {String|Array} - Either a string or array of strings of PEM encoded CRLs
|
2015-11-04 17:23:03 +01:00
|
|
|
(Certificate Revocation List)
|
2016-01-19 17:03:15 +01:00
|
|
|
* `ciphers`: {String} using the [OpenSSL cipher list format][] describing the
|
2015-12-27 05:54:01 +01:00
|
|
|
cipher algorithms to use or exclude.
|
|
|
|
|
|
|
|
If no 'ca' details are given, Node.js will use Mozilla's default
|
|
|
|
[publicly trusted list of CAs][].
|
|
|
|
|
|
|
|
### crypto.createDecipher(algorithm, password)
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates and returns a `Decipher` object that uses the given `algorithm` and
|
|
|
|
`password` (key).
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The implementation of `crypto.createDecipher()` derives keys using the OpenSSL
|
|
|
|
function [`EVP_BytesToKey`][] with the digest algorithm set to MD5, one
|
|
|
|
iteration, and no salt. The lack of salt allows dictionary attacks as the same
|
|
|
|
password always creates the same key. The low iteration count and
|
|
|
|
non-cryptographically secure hash algorithm allow passwords to be tested very
|
|
|
|
rapidly.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
In line with OpenSSL's recommendation to use pbkdf2 instead of
|
|
|
|
[`EVP_BytesToKey`][] it is recommended that developers derive a key and IV on
|
2016-02-15 01:40:53 +01:00
|
|
|
their own using [`crypto.pbkdf2()`][] and to use [`crypto.createDecipheriv()`][]
|
2015-12-27 05:54:01 +01:00
|
|
|
to create the `Decipher` object.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createDecipheriv(algorithm, key, iv)
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates and returns a `Decipher` object that uses the given `algorithm`, `key`
|
|
|
|
and initialization vector (`iv`).
|
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
|
2015-12-27 05:54:01 +01:00
|
|
|
recent OpenSSL releases, `openssl list-cipher-algorithms` will display the
|
|
|
|
available cipher algorithms.
|
|
|
|
|
|
|
|
The `key` is the raw key used by the `algorithm` and `iv` is an
|
2016-07-20 08:45:43 +02:00
|
|
|
[initialization vector][]. Both arguments must be `'utf8'` encoded strings or
|
2016-02-15 01:40:53 +01:00
|
|
|
[buffers][`Buffer`].
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2016-02-26 22:56:41 +01:00
|
|
|
### crypto.createDiffieHellman(prime[, prime_encoding][, generator][, generator_encoding])
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates a `DiffieHellman` key exchange object using the supplied `prime` and an
|
2014-02-18 02:57:08 +01:00
|
|
|
optional specific `generator`.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `generator` argument can be a number, string, or [`Buffer`][]. If
|
|
|
|
`generator` is not specified, the value `2` is used.
|
|
|
|
|
2016-06-02 18:55:36 +02:00
|
|
|
The `prime_encoding` and `generator_encoding` arguments can be `'latin1'`,
|
2015-12-27 05:54:01 +01:00
|
|
|
`'hex'`, or `'base64'`.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If `prime_encoding` is specified, `prime` is expected to be a string; otherwise
|
|
|
|
a [`Buffer`][] is expected.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If `generator_encoding` is specified, `generator` is expected to be a string;
|
|
|
|
otherwise either a number or [`Buffer`][] is expected.
|
2012-02-27 20:08:02 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createDiffieHellman(prime_length[, generator])
|
2014-02-18 02:57:08 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates a `DiffieHellman` key exchange object and generates a prime of
|
|
|
|
`prime_length` bits using an optional specific numeric `generator`.
|
|
|
|
If `generator` is not specified, the value `2` is used.
|
2014-02-18 02:57:08 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createECDH(curve_name)
|
2014-02-18 02:57:08 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates an Elliptic Curve Diffie-Hellman (`ECDH`) key exchange object using a
|
|
|
|
predefined curve specified by the `curve_name` string. Use
|
|
|
|
[`crypto.getCurves()`][] to obtain a list of available curve names. On recent
|
|
|
|
OpenSSL releases, `openssl ecparam -list_curves` will also display the name
|
|
|
|
and description of each available elliptic curve.
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createHash(algorithm)
|
|
|
|
|
|
|
|
Creates and returns a `Hash` object that can be used to generate hash digests
|
|
|
|
using the given `algorithm`.
|
|
|
|
|
|
|
|
The `algorithm` is dependent on the available algorithms supported by the
|
|
|
|
version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
|
|
|
|
On recent releases of OpenSSL, `openssl list-message-digest-algorithms` will
|
|
|
|
display the available digest algorithms.
|
|
|
|
|
|
|
|
Example: generating the sha256 sum of a file
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const filename = process.argv[2];
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const fs = require('fs');
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const hash = crypto.createHash('sha256');
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const input = fs.createReadStream(filename);
|
|
|
|
input.on('readable', () => {
|
|
|
|
var data = input.read();
|
|
|
|
if (data)
|
|
|
|
hash.update(data);
|
|
|
|
else {
|
|
|
|
console.log(`${hash.digest('hex')} ${filename}`);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
```
|
2015-11-04 17:23:03 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createHmac(algorithm, key)
|
|
|
|
|
|
|
|
Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `algorithm` is dependent on the available algorithms supported by the
|
|
|
|
version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
|
|
|
|
On recent releases of OpenSSL, `openssl list-message-digest-algorithms` will
|
|
|
|
display the available digest algorithms.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `key` is the HMAC key used to generate the cryptographic HMAC hash.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Example: generating the sha256 HMAC of a file
|
2012-10-22 19:37:20 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const filename = process.argv[2];
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const fs = require('fs');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const hmac = crypto.createHmac('sha256', 'a secret');
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const input = fs.createReadStream(filename);
|
|
|
|
input.on('readable', () => {
|
|
|
|
var data = input.read();
|
|
|
|
if (data)
|
|
|
|
hmac.update(data);
|
|
|
|
else {
|
|
|
|
console.log(`${hmac.digest('hex')} ${filename}`);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
```
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createSign(algorithm)
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates and returns a `Sign` object that uses the given `algorithm`. On
|
2015-11-04 17:23:03 +01:00
|
|
|
recent OpenSSL releases, `openssl list-public-key-algorithms` will
|
2015-12-27 05:54:01 +01:00
|
|
|
display the available signing algorithms. One example is `'RSA-SHA256'`.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.createVerify(algorithm)
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Creates and returns a `Verify` object that uses the given algorithm. On
|
|
|
|
recent OpenSSL releases, `openssl list-public-key-algorithms` will
|
|
|
|
display the available signing algorithms. One example is `'RSA-SHA256'`.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.getCiphers()
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Returns an array with the names of the supported cipher algorithms.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Example:
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const ciphers = crypto.getCiphers();
|
|
|
|
console.log(ciphers); // ['aes-128-cbc', 'aes-128-ccm', ...]
|
|
|
|
```
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.getCurves()
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Returns an array with the names of the supported elliptic curves.
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Example:
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const curves = crypto.getCurves();
|
|
|
|
console.log(curves); // ['secp256k1', 'secp384r1', ...]
|
|
|
|
```
|
2011-01-19 02:00:38 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.getDiffieHellman(group_name)
|
2012-01-22 19:24:37 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
Creates a predefined `DiffieHellman` key exchange object. The
|
2015-07-27 09:10:57 +02:00
|
|
|
supported groups are: `'modp1'`, `'modp2'`, `'modp5'` (defined in
|
2015-11-14 04:21:49 +01:00
|
|
|
[RFC 2412][], but see [Caveats][]) and `'modp14'`, `'modp15'`,
|
2015-12-27 05:54:01 +01:00
|
|
|
`'modp16'`, `'modp17'`, `'modp18'` (defined in [RFC 3526][]). The
|
2015-11-14 04:21:49 +01:00
|
|
|
returned object mimics the interface of objects created by
|
2016-01-05 11:49:54 +01:00
|
|
|
[`crypto.createDiffieHellman()`][], but will not allow changing
|
2015-11-28 00:30:32 +01:00
|
|
|
the keys (with [`diffieHellman.setPublicKey()`][] for example). The
|
2015-12-27 05:54:01 +01:00
|
|
|
advantage of using this method is that the parties do not have to
|
|
|
|
generate nor exchange a group modulus beforehand, saving both processor
|
2015-07-27 09:10:57 +02:00
|
|
|
and communication time.
|
2012-01-22 19:24:37 +01:00
|
|
|
|
|
|
|
Example (obtaining a shared secret):
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const alice = crypto.getDiffieHellman('modp14');
|
|
|
|
const bob = crypto.getDiffieHellman('modp14');
|
2012-01-22 19:24:37 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
alice.generateKeys();
|
|
|
|
bob.generateKeys();
|
2012-01-22 19:24:37 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
const alice_secret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
|
|
|
|
const bob_secret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
|
2014-08-27 16:01:01 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
/* alice_secret and bob_secret should be the same */
|
|
|
|
console.log(alice_secret == bob_secret);
|
|
|
|
```
|
2014-08-27 16:01:01 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.getHashes()
|
2014-08-27 16:01:01 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Returns an array with the names of the supported hash algorithms.
|
2014-08-27 16:01:01 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Example:
|
2012-01-22 19:24:37 +01:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const hashes = crypto.getHashes();
|
|
|
|
console.log(hashes); // ['sha', 'sha1', 'sha1WithRSAEncryption', ...]
|
|
|
|
```
|
2012-01-22 19:24:37 +01:00
|
|
|
|
2015-11-27 11:41:38 +01:00
|
|
|
### crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
|
2016-02-15 01:40:53 +01:00
|
|
|
implementation. A selected HMAC digest algorithm specified by `digest` is
|
2015-12-27 05:54:01 +01:00
|
|
|
applied to derive a key of the requested byte length (`keylen`) from the
|
2015-11-27 11:41:38 +01:00
|
|
|
`password`, `salt` and `iterations`.
|
2011-08-11 11:40:55 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The supplied `callback` function is called with two arguments: `err` and
|
|
|
|
`derivedKey`. If an error occurs, `err` will be set; otherwise `err` will be
|
|
|
|
null. The successfully generated `derivedKey` will be passed as a [`Buffer`][].
|
2011-09-22 22:12:10 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `iterations` argument must be a number set as high as possible. The
|
|
|
|
higher the number of iterations, the more secure the derived key will be,
|
|
|
|
but will take a longer amount of time to complete.
|
2015-10-09 14:58:44 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `salt` should also be as unique as possible. It is recommended that the
|
|
|
|
salts are random and their lengths are greater than 16 bytes. See
|
|
|
|
[NIST SP 800-132][] for details.
|
2015-10-09 14:58:44 +02:00
|
|
|
|
2013-11-21 11:29:07 +01:00
|
|
|
Example:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
|
|
|
crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, key) => {
|
|
|
|
if (err) throw err;
|
|
|
|
console.log(key.toString('hex')); // 'c5e478d...1469e50'
|
|
|
|
});
|
|
|
|
```
|
2013-11-21 11:29:07 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
An array of supported digest functions can be retrieved using
|
|
|
|
[`crypto.getHashes()`][].
|
2013-11-21 11:29:07 +01:00
|
|
|
|
2015-11-27 11:41:38 +01:00
|
|
|
### crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
|
2012-10-13 02:36:18 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
|
2016-02-15 01:40:53 +01:00
|
|
|
implementation. A selected HMAC digest algorithm specified by `digest` is
|
2015-12-27 05:54:01 +01:00
|
|
|
applied to derive a key of the requested byte length (`keylen`) from the
|
2015-11-27 11:41:38 +01:00
|
|
|
`password`, `salt` and `iterations`.
|
2012-10-13 02:36:18 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If an error occurs an Error will be thrown, otherwise the derived key will be
|
|
|
|
returned as a [`Buffer`][].
|
|
|
|
|
|
|
|
The `iterations` argument must be a number set as high as possible. The
|
|
|
|
higher the number of iterations, the more secure the derived key will be,
|
|
|
|
but will take a longer amount of time to complete.
|
|
|
|
|
|
|
|
The `salt` should also be as unique as possible. It is recommended that the
|
|
|
|
salts are random and their lengths are greater than 16 bytes. See
|
|
|
|
[NIST SP 800-132][] for details.
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
const crypto = require('crypto');
|
2016-02-18 20:12:56 +01:00
|
|
|
const key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512');
|
2016-01-17 18:39:07 +01:00
|
|
|
console.log(key.toString('hex')); // 'c5e478d...1469e50'
|
|
|
|
```
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
An array of supported digest functions can be retrieved using
|
|
|
|
[`crypto.getHashes()`][].
|
|
|
|
|
|
|
|
### crypto.privateDecrypt(private_key, buffer)
|
2013-03-03 22:11:08 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
Decrypts `buffer` with `private_key`.
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
`private_key` can be an object or a string. If `private_key` is a string, it is
|
|
|
|
treated as the key with no passphrase and will use `RSA_PKCS1_OAEP_PADDING`.
|
2015-12-27 05:54:01 +01:00
|
|
|
If `private_key` is an object, it is interpreted as a hash object with the
|
|
|
|
keys:
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2016-01-19 17:03:15 +01:00
|
|
|
* `key` : {String} - PEM encoded private key
|
|
|
|
* `passphrase` : {String} - Optional passphrase for the private key
|
2015-12-27 05:54:01 +01:00
|
|
|
* `padding` : An optional padding value, one of the following:
|
2016-05-02 19:27:12 +02:00
|
|
|
* `crypto.constants.RSA_NO_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_OAEP_PADDING`
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-05-02 19:27:12 +02:00
|
|
|
All paddings are defined in `crypto.constants`.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
### crypto.privateEncrypt(private_key, buffer)
|
|
|
|
|
|
|
|
Encrypts `buffer` with `private_key`.
|
|
|
|
|
|
|
|
`private_key` can be an object or a string. If `private_key` is a string, it is
|
|
|
|
treated as the key with no passphrase and will use `RSA_PKCS1_PADDING`.
|
|
|
|
If `private_key` is an object, it is interpreted as a hash object with the
|
|
|
|
keys:
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2016-01-19 17:03:15 +01:00
|
|
|
* `key` : {String} - PEM encoded private key
|
|
|
|
* `passphrase` : {String} - Optional passphrase for the private key
|
2015-11-04 17:23:03 +01:00
|
|
|
* `padding` : An optional padding value, one of the following:
|
2016-05-02 19:27:12 +02:00
|
|
|
* `crypto.constants.RSA_NO_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_OAEP_PADDING`
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2016-05-02 19:27:12 +02:00
|
|
|
All paddings are defined in `crypto.constants`.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
### crypto.publicDecrypt(public_key, buffer)
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Decrypts `buffer` with `public_key`.
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
`public_key` can be an object or a string. If `public_key` is a string, it is
|
|
|
|
treated as the key with no passphrase and will use `RSA_PKCS1_PADDING`.
|
|
|
|
If `public_key` is an object, it is interpreted as a hash object with the
|
|
|
|
keys:
|
|
|
|
|
2016-01-19 17:03:15 +01:00
|
|
|
* `key` : {String} - PEM encoded public key
|
|
|
|
* `passphrase` : {String} - Optional passphrase for the private key
|
2015-12-27 05:54:01 +01:00
|
|
|
* `padding` : An optional padding value, one of the following:
|
2016-05-02 19:27:12 +02:00
|
|
|
* `crypto.constants.RSA_NO_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_OAEP_PADDING`
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Because RSA public keys can be derived from private keys, a private key may
|
|
|
|
be passed instead of a public key.
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2016-05-02 19:27:12 +02:00
|
|
|
All paddings are defined in `crypto.constants`.
|
2013-10-15 16:31:14 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.publicEncrypt(public_key, buffer)
|
2014-05-05 16:35:28 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Encrypts `buffer` with `public_key`.
|
2014-05-05 16:35:28 +02:00
|
|
|
|
2014-08-23 15:38:32 +02:00
|
|
|
`public_key` can be an object or a string. If `public_key` is a string, it is
|
|
|
|
treated as the key with no passphrase and will use `RSA_PKCS1_OAEP_PADDING`.
|
2015-12-27 05:54:01 +01:00
|
|
|
If `public_key` is an object, it is interpreted as a hash object with the
|
|
|
|
keys:
|
2014-08-23 15:38:32 +02:00
|
|
|
|
2016-01-19 17:03:15 +01:00
|
|
|
* `key` : {String} - PEM encoded public key
|
|
|
|
* `passphrase` : {String} - Optional passphrase for the private key
|
2014-08-23 15:38:32 +02:00
|
|
|
* `padding` : An optional padding value, one of the following:
|
2016-05-02 19:27:12 +02:00
|
|
|
* `crypto.constants.RSA_NO_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_PADDING`
|
|
|
|
* `crypto.constants.RSA_PKCS1_OAEP_PADDING`
|
2014-08-23 15:38:32 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Because RSA public keys can be derived from private keys, a private key may
|
|
|
|
be passed instead of a public key.
|
|
|
|
|
2016-05-02 19:27:12 +02:00
|
|
|
All paddings are defined in `crypto.constants`.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
|
|
|
### crypto.randomBytes(size[, callback])
|
2014-08-23 15:38:32 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Generates cryptographically strong pseudo-random data. The `size` argument
|
|
|
|
is a number indicating the number of bytes to generate.
|
2014-05-05 16:35:28 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If a `callback` function is provided, the bytes are generated asynchronously
|
|
|
|
and the `callback` function is invoked with two arguments: `err` and `buf`.
|
|
|
|
If an error occurs, `err` will be an Error object; otherwise it is null. The
|
|
|
|
`buf` argument is a [`Buffer`][] containing the generated bytes.
|
2014-05-05 16:35:28 +02:00
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
// Asynchronous
|
|
|
|
const crypto = require('crypto');
|
|
|
|
crypto.randomBytes(256, (err, buf) => {
|
|
|
|
if (err) throw err;
|
2016-02-15 16:49:00 +01:00
|
|
|
console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
|
2016-01-17 18:39:07 +01:00
|
|
|
});
|
|
|
|
```
|
2014-05-05 16:35:28 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
If the `callback` function is not provided, the random bytes are generated
|
|
|
|
synchronously and returned as a [`Buffer`][]. An error will be thrown if
|
|
|
|
there is a problem generating the bytes.
|
|
|
|
|
2016-01-17 18:39:07 +01:00
|
|
|
```js
|
|
|
|
// Synchronous
|
|
|
|
const buf = crypto.randomBytes(256);
|
|
|
|
console.log(
|
2016-03-18 13:22:22 +01:00
|
|
|
`${buf.length} bytes of random data: ${buf.toString('hex')}`);
|
2016-01-17 18:39:07 +01:00
|
|
|
```
|
2014-08-23 15:38:32 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `crypto.randomBytes()` method will block until there is sufficient entropy.
|
|
|
|
This should normally never take longer than a few milliseconds. The only time
|
|
|
|
when generating the random bytes may conceivably block for a longer period of
|
|
|
|
time is right after boot, when the whole system is still low on entropy.
|
2014-05-05 16:35:28 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### crypto.setEngine(engine[, flags])
|
2015-01-27 20:58:14 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Load and set the `engine` for some or all OpenSSL functions (selected by flags).
|
2015-01-27 20:58:14 +01:00
|
|
|
|
2015-11-04 17:23:03 +01:00
|
|
|
`engine` could be either an id or a path to the engine's shared library.
|
2012-10-22 19:37:20 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The optional `flags` argument uses `ENGINE_METHOD_ALL` by default. The `flags`
|
2016-05-02 19:27:12 +02:00
|
|
|
is a bit field taking one of or a mix of the following flags (defined in
|
|
|
|
`crypto.constants`):
|
|
|
|
|
|
|
|
* `crypto.constants.ENGINE_METHOD_RSA`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_DSA`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_DH`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_RAND`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_ECDH`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_ECDSA`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_CIPHERS`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_DIGESTS`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_STORE`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_PKEY_METHS`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_ALL`
|
|
|
|
* `crypto.constants.ENGINE_METHOD_NONE`
|
2012-10-22 19:37:20 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
## Notes
|
|
|
|
|
|
|
|
### Legacy Streams API (pre Node.js v0.10)
|
2012-10-11 17:32:36 +02:00
|
|
|
|
2015-02-07 11:25:13 +01:00
|
|
|
The Crypto module was added to Node.js before there was the concept of a
|
2015-12-27 05:54:01 +01:00
|
|
|
unified Stream API, and before there were [`Buffer`][] objects for handling
|
|
|
|
binary data. As such, the many of the `crypto` defined classes have methods not
|
2016-02-15 01:40:53 +01:00
|
|
|
typically found on other Node.js classes that implement the [streams][stream]
|
|
|
|
API (e.g. `update()`, `final()`, or `digest()`). Also, many methods accepted
|
2016-06-02 18:55:36 +02:00
|
|
|
and returned `'latin1'` encoded strings by default rather than Buffers. This
|
2015-12-27 05:54:01 +01:00
|
|
|
default was changed after Node.js v0.8 to use [`Buffer`][] objects by default
|
|
|
|
instead.
|
|
|
|
|
|
|
|
### Recent ECDH Changes
|
2012-10-11 17:32:36 +02:00
|
|
|
|
2015-11-19 20:00:00 +01:00
|
|
|
Usage of `ECDH` with non-dynamically generated key pairs has been simplified.
|
2016-02-15 01:40:53 +01:00
|
|
|
Now, [`ecdh.setPrivateKey()`][] can be called with a preselected private key
|
|
|
|
and the associated public point (key) will be computed and stored in the object.
|
2015-12-27 05:54:01 +01:00
|
|
|
This allows code to only store and provide the private part of the EC key pair.
|
2016-02-15 01:40:53 +01:00
|
|
|
[`ecdh.setPrivateKey()`][] now also validates that the private key is valid for
|
|
|
|
the selected curve.
|
2015-12-27 05:54:01 +01:00
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
The [`ecdh.setPublicKey()`][] method is now deprecated as its inclusion in the
|
|
|
|
API is not useful. Either a previously stored private key should be set, which
|
|
|
|
automatically generates the associated public key, or [`ecdh.generateKeys()`][]
|
|
|
|
should be called. The main drawback of using [`ecdh.setPublicKey()`][] is that
|
|
|
|
it can be used to put the ECDH key pair into an inconsistent state.
|
2015-11-19 20:00:00 +01:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
### Support for weak or compromised algorithms
|
2015-07-27 09:10:57 +02:00
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
The `crypto` module still supports some algorithms which are already
|
|
|
|
compromised and are not currently recommended for use. The API also allows
|
|
|
|
the use of ciphers and hashes with a small key size that are considered to be
|
|
|
|
too weak for safe use.
|
2015-07-27 09:10:57 +02:00
|
|
|
|
|
|
|
Users should take full responsibility for selecting the crypto
|
|
|
|
algorithm and key size according to their security requirements.
|
|
|
|
|
2015-12-27 05:54:01 +01:00
|
|
|
Based on the recommendations of [NIST SP 800-131A][]:
|
2015-07-27 09:10:57 +02:00
|
|
|
|
|
|
|
- MD5 and SHA-1 are no longer acceptable where collision resistance is
|
|
|
|
required such as digital signatures.
|
|
|
|
- The key used with RSA, DSA and DH algorithms is recommended to have
|
|
|
|
at least 2048 bits and that of the curve of ECDSA and ECDH at least
|
|
|
|
224 bits, to be safe to use for several years.
|
|
|
|
- The DH groups of `modp1`, `modp2` and `modp5` have a key size
|
|
|
|
smaller than 2048 bits and are not recommended.
|
|
|
|
|
|
|
|
See the reference for other recommendations and details.
|
2012-10-11 17:32:36 +02:00
|
|
|
|
2016-05-02 19:27:12 +02:00
|
|
|
## Crypto Constants
|
|
|
|
|
|
|
|
The following constants exported by `crypto.constants` apply to various uses of
|
|
|
|
the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
|
|
|
|
|
|
|
|
### OpenSSL Options
|
|
|
|
|
|
|
|
<table>
|
|
|
|
<tr>
|
|
|
|
<th>Constant</th>
|
|
|
|
<th>Description</th>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_ALL</code></td>
|
|
|
|
<td>Applies multiple bug workarounds within OpenSSL. See
|
|
|
|
https://www.openssl.org/docs/manmaster/ssl/SSL_CTX_set_options.html for
|
|
|
|
detail.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION</code></td>
|
|
|
|
<td>Allows legacy insecure renegotiation between OpenSSL and unpatched
|
|
|
|
clients or servers. See
|
|
|
|
https://www.openssl.org/docs/manmaster/ssl/SSL_CTX_set_options.html.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_CIPHER_SERVER_PREFERENCE</code></td>
|
|
|
|
<td>Uses the server's preferences instead of the clients when selecting a
|
|
|
|
cipher. See
|
|
|
|
https://www.openssl.org/docs/manmaster/ssl/SSL_CTX_set_options.html.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_CISCO_ANYCONNECT</code></td>
|
|
|
|
<td>Instructs OpenSSL to use Cisco's "speshul" version of DTLS_BAD_VER.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_COOKIE_EXCHANGE</code></td>
|
|
|
|
<td>Instructs OpenSSL to turn on cookie exchange.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_CRYPTOPRO_TLSEXT_BUG</code></td>
|
|
|
|
<td>Instructs OpenSSL to add server-hello extension from an early version
|
|
|
|
of the cryptopro draft.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS</code></td>
|
|
|
|
<td>Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability
|
|
|
|
workaround added in OpenSSL 0.9.6d.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_EPHEMERAL_RSA</code></td>
|
|
|
|
<td>Instructs OpenSSL to always use the tmp_rsa key when performing RSA
|
|
|
|
operations.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_LEGACY_SERVER_CONNECT</code></td>
|
|
|
|
<td>Allow initial connection to servers that do not support RI.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_MICROSOFT_SESS_ID_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_MSIE_SSLV2_RSA_PADDING</code></td>
|
|
|
|
<td>Instructs OpenSSL to disable the workaround for a man-in-the-middle
|
|
|
|
protocol-version vulnerability in the SSL 2.0 server implementation.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NETSCAPE_CA_DN_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NETSCAPE_CHALLENGE_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_COMPRESSION</code></td>
|
|
|
|
<td>Instructs OpenSSL to disable support for SSL/TLS compression.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_QUERY_MTU</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION</code></td>
|
|
|
|
<td>Instructs OpenSSL to always start a new session when performing
|
|
|
|
renegotiation.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_SSLv2</code></td>
|
|
|
|
<td>Instructs OpenSSL to turn off SSL v2</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_SSLv3</code></td>
|
|
|
|
<td>Instructs OpenSSL to turn off SSL v3</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_TICKET</code></td>
|
|
|
|
<td>Instructs OpenSSL to disable use of RFC4507bis tickets.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_TLSv1</code></td>
|
|
|
|
<td>Instructs OpenSSL to turn off TLS v1</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_TLSv1_1</code></td>
|
|
|
|
<td>Instructs OpenSSL to turn off TLS v1.1</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_NO_TLSv1_2</code></td>
|
|
|
|
<td>Instructs OpenSSL to turn off TLS v1.2</td>
|
|
|
|
</tr>
|
|
|
|
<td><code>SSL_OP_PKCS1_CHECK_1</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_PKCS1_CHECK_2</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_SINGLE_DH_USE</code></td>
|
|
|
|
<td>Instructs OpenSSL to always create a new key when using
|
|
|
|
temporary/ephemeral DH parameters.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_SINGLE_ECDH_USE</code></td>
|
|
|
|
<td>Instructs OpenSSL to always create a new key when using
|
|
|
|
temporary/ephemeral ECDH parameters.</td>
|
|
|
|
</tr>
|
|
|
|
<td><code>SSL_OP_SSLEAY_080_CLIENT_DH_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_TLS_BLOCK_PADDING_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_TLS_D5_BUG</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>SSL_OP_TLS_ROLLBACK_BUG</code></td>
|
|
|
|
<td>Instructs OpenSSL to disable version rollback attack detection.</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
|
|
|
|
### OpenSSL Engine Constants
|
|
|
|
|
|
|
|
<table>
|
|
|
|
<tr>
|
|
|
|
<th>Constant</th>
|
|
|
|
<th>Description</th>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_RSA</code></td>
|
|
|
|
<td>Limit engine usage to RSA</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_DSA</code></td>
|
|
|
|
<td>Limit engine usage to DSA</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_DH</code></td>
|
|
|
|
<td>Limit engine usage to DH</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_RAND</code></td>
|
|
|
|
<td>Limit engine usage to RAND</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_ECDH</code></td>
|
|
|
|
<td>Limit engine usage to ECDH</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_ECDSA</code></td>
|
|
|
|
<td>Limit engine usage to ECDSA</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_CIPHERS</code></td>
|
|
|
|
<td>Limit engine usage to CIPHERS</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_DIGESTS</code></td>
|
|
|
|
<td>Limit engine usage to DIGESTS</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_STORE</code></td>
|
|
|
|
<td>Limit engine usage to STORE</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_PKEY_METHS</code></td>
|
|
|
|
<td>Limit engine usage to PKEY_METHDS</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_PKEY_ASN1_METHS</code></td>
|
|
|
|
<td>Limit engine usage to PKEY_ASN1_METHS</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_ALL</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ENGINE_METHOD_NONE</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
|
|
|
|
### Other OpenSSL Constants
|
|
|
|
|
|
|
|
<table>
|
|
|
|
<tr>
|
|
|
|
<th>Constant</th>
|
|
|
|
<th>Description</th>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>DH_CHECK_P_NOT_SAFE_PRIME</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>DH_CHECK_P_NOT_PRIME</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>DH_UNABLE_TO_CHECK_GENERATOR</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>DH_NOT_SUITABLE_GENERATOR</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>NPN_ENABLED</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>ALPN_ENABLED</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>RSA_PKCS1_PADDING</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>RSA_SSLV23_PADDING</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>RSA_NO_PADDING</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>RSA_PKCS1_OAEP_PADDING</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>RSA_X931_PADDING</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>RSA_PKCS1_PSS_PADDING</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>POINT_CONVERSION_COMPRESSED</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>POINT_CONVERSION_UNCOMPRESSED</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>POINT_CONVERSION_HYBRID</code></td>
|
|
|
|
<td></td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
|
|
|
|
### Node.js Crypto Constants
|
|
|
|
|
|
|
|
<table>
|
|
|
|
<tr>
|
|
|
|
<th>Constant</th>
|
|
|
|
<th>Description</th>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>defaultCoreCipherList</code></td>
|
|
|
|
<td>Specifies the built-in default cipher list used by Node.js.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><code>defaultCipherList</code></td>
|
|
|
|
<td>Specifies the active default cipher list used by the current Node.js
|
|
|
|
process.</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
|
|
|
|
|
2016-02-15 01:40:53 +01:00
|
|
|
[`Buffer`]: buffer.html
|
|
|
|
[`cipher.final()`]: #crypto_cipher_final_output_encoding
|
|
|
|
[`cipher.update()`]: #crypto_cipher_update_data_input_encoding_output_encoding
|
|
|
|
[`crypto.createCipher()`]: #crypto_crypto_createcipher_algorithm_password
|
|
|
|
[`crypto.createCipheriv()`]: #crypto_crypto_createcipheriv_algorithm_key_iv
|
|
|
|
[`crypto.createDecipher()`]: #crypto_crypto_createdecipher_algorithm_password
|
|
|
|
[`crypto.createDecipheriv()`]: #crypto_crypto_createdecipheriv_algorithm_key_iv
|
2015-11-28 00:30:32 +01:00
|
|
|
[`crypto.createDiffieHellman()`]: #crypto_crypto_creatediffiehellman_prime_prime_encoding_generator_generator_encoding
|
2016-02-15 01:40:53 +01:00
|
|
|
[`crypto.createECDH()`]: #crypto_crypto_createecdh_curve_name
|
|
|
|
[`crypto.createHash()`]: #crypto_crypto_createhash_algorithm
|
|
|
|
[`crypto.createHmac()`]: #crypto_crypto_createhmac_algorithm_key
|
|
|
|
[`crypto.createSign()`]: #crypto_crypto_createsign_algorithm
|
|
|
|
[`crypto.getCurves()`]: #crypto_crypto_getcurves
|
2015-11-28 00:30:32 +01:00
|
|
|
[`crypto.getHashes()`]: #crypto_crypto_gethashes
|
2016-02-15 01:40:53 +01:00
|
|
|
[`crypto.pbkdf2()`]: #crypto_crypto_pbkdf2_password_salt_iterations_keylen_digest_callback
|
|
|
|
[`decipher.final()`]: #crypto_decipher_final_output_encoding
|
|
|
|
[`decipher.update()`]: #crypto_decipher_update_data_input_encoding_output_encoding
|
2015-11-28 00:30:32 +01:00
|
|
|
[`diffieHellman.setPublicKey()`]: #crypto_diffiehellman_setpublickey_public_key_encoding
|
2016-02-15 01:40:53 +01:00
|
|
|
[`ecdh.generateKeys()`]: #crypto_ecdh_generatekeys_encoding_format
|
|
|
|
[`ecdh.setPrivateKey()`]: #crypto_ecdh_setprivatekey_private_key_encoding
|
|
|
|
[`ecdh.setPublicKey()`]: #crypto_ecdh_setpublickey_public_key_encoding
|
2015-11-28 00:30:32 +01:00
|
|
|
[`EVP_BytesToKey`]: https://www.openssl.org/docs/crypto/EVP_BytesToKey.html
|
2016-02-15 01:40:53 +01:00
|
|
|
[`hash.digest()`]: #crypto_hash_digest_encoding
|
|
|
|
[`hash.update()`]: #crypto_hash_update_data_input_encoding
|
|
|
|
[`hmac.digest()`]: #crypto_hmac_digest_encoding
|
2016-04-13 12:30:14 +02:00
|
|
|
[`hmac.update()`]: #crypto_hmac_update_data_input_encoding
|
2016-02-15 01:40:53 +01:00
|
|
|
[`sign.sign()`]: #crypto_sign_sign_private_key_output_format
|
2016-04-13 12:30:14 +02:00
|
|
|
[`sign.update()`]: #crypto_sign_update_data_input_encoding
|
2016-05-23 22:36:41 +02:00
|
|
|
[`tls.createSecureContext()`]: tls.html#tls_tls_createsecurecontext_options
|
2016-04-13 12:30:14 +02:00
|
|
|
[`verify.update()`]: #crypto_verifier_update_data_input_encoding
|
2016-02-15 01:40:53 +01:00
|
|
|
[`verify.verify()`]: #crypto_verifier_verify_object_signature_signature_format
|
2015-12-27 05:54:01 +01:00
|
|
|
[Caveats]: #crypto_support_for_weak_or_compromised_algorithms
|
2016-02-15 01:40:53 +01:00
|
|
|
[HTML5's `keygen` element]: http://www.w3.org/TR/html5/forms.html#the-keygen-element
|
2015-12-02 17:17:19 +01:00
|
|
|
[initialization vector]: https://en.wikipedia.org/wiki/Initialization_vector
|
2015-12-27 05:54:01 +01:00
|
|
|
[NIST SP 800-131A]: http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf
|
2015-11-28 00:30:32 +01:00
|
|
|
[NIST SP 800-132]: http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf
|
2016-05-17 19:52:54 +02:00
|
|
|
[OpenSSL cipher list format]: https://www.openssl.org/docs/apps/ciphers.html#CIPHER-LIST-FORMAT
|
2016-02-15 01:40:53 +01:00
|
|
|
[OpenSSL's SPKAC implementation]: https://www.openssl.org/docs/apps/spkac.html
|
|
|
|
[publicly trusted list of CAs]: https://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt
|
2015-12-02 17:17:19 +01:00
|
|
|
[RFC 2412]: https://www.rfc-editor.org/rfc/rfc2412.txt
|
|
|
|
[RFC 3526]: https://www.rfc-editor.org/rfc/rfc3526.txt
|
2015-11-28 00:30:32 +01:00
|
|
|
[stream]: stream.html
|
2016-02-15 01:40:53 +01:00
|
|
|
[stream-writable-write]: stream.html#stream_writable_write_chunk_encoding_callback
|
2016-05-02 19:27:12 +02:00
|
|
|
[Crypto Constants]: #crypto_crypto_constants
|