<!--introduced_in=v0.3.6-->

Use `require('crypto')` to access this module.

```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

## 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

try {

crypto = require('crypto');

} catch (err) {

console.log('crypto support is disabled!');

}

```

<!-- YAML

added: v0.11.8

-->

Netscape and was specified formally as part of [HTML5's `keygen` element][].

Note that `<keygen>` is deprecated since [HTML 5.2][] and new projects

should not use this element anymore.

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.

### Certificate.exportChallenge(spkac)

<!-- YAML

* `spkac` {string | Buffer | TypedArray | DataView}

* Returns: {Buffer} The challenge component of the `spkac` data structure, which

```js

const { Certificate } = require('crypto');

const spkac = getSpkacSomehow();

const challenge = Certificate.exportChallenge(spkac);

console.log(challenge.toString('utf8'));

// Prints: the challenge as a UTF8 string

```

* `spkac` {string | Buffer | TypedArray | DataView}

* `encoding` {string}

* Returns: {Buffer} The public key component of the `spkac` data structure,

```js

const { Certificate } = require('crypto');

const spkac = getSpkacSomehow();

const publicKey = Certificate.exportPublicKey(spkac);

console.log(publicKey);

// Prints: the public key as <Buffer ...>

```

### Certificate.verifySpkac(spkac)

<!-- YAML

* `spkac` {Buffer | TypedArray | DataView}

* Returns: {boolean} `true` if the given `spkac` data structure is valid,

```js

const { Certificate } = require('crypto');

const spkac = getSpkacSomehow();

console.log(Certificate.verifySpkac(Buffer.from(spkac)));

// Prints: true or false

```

### Legacy API

As a still supported legacy interface, it is possible (but not recommended) to

create new instances of the `crypto.Certificate` class as illustrated in the

examples below.

#### new crypto.Certificate()

Instances of the `Certificate` class can be created using the `new` keyword

or by calling `crypto.Certificate()` as a function:

```js

const crypto = require('crypto');

const cert1 = new crypto.Certificate();

const cert2 = crypto.Certificate();

```

<!-- YAML

added: v0.11.8

-->

* `spkac` {string | Buffer | TypedArray | DataView}

* Returns: {Buffer} The challenge component of the `spkac` data structure, which

```js

const cert = require('crypto').Certificate();

const spkac = getSpkacSomehow();

const challenge = cert.exportChallenge(spkac);

console.log(challenge.toString('utf8'));

<!-- YAML

added: v0.11.8

-->

* `spkac` {string | Buffer | TypedArray | DataView}

* Returns: {Buffer} The public key component of the `spkac` data structure,

```js

const cert = require('crypto').Certificate();

const spkac = getSpkacSomehow();

const publicKey = cert.exportPublicKey(spkac);

console.log(publicKey);

<!-- YAML

added: v0.11.8

-->

* `spkac` {Buffer | TypedArray | DataView}

* Returns: {boolean} `true` if the given `spkac` data structure is valid,

```js

const cert = require('crypto').Certificate();

const spkac = getSpkacSomehow();

<!-- YAML

added: v0.1.94

-->

Instances of the `Cipher` class are used to encrypt data. The class can be

used in one of two ways:

- As a [stream][] that is both readable and writable, where plain unencrypted

data is written to produce encrypted data on the readable side, or

- Using the [`cipher.update()`][] and [`cipher.final()`][] methods to produce

the encrypted data.

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.

```js

const crypto = require('crypto');

const cipher = crypto.createCipher('aes192', 'a password');

encrypted += data.toString('hex');

});

cipher.on('end', () => {

console.log(encrypted);

// Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504

cipher.end();

```

Example: Using `Cipher` and piped streams:

```js

const crypto = require('crypto');

const fs = require('fs');

const cipher = crypto.createCipher('aes192', 'a password');

const input = fs.createReadStream('test.js');

const output = fs.createWriteStream('test.enc');

input.pipe(cipher).pipe(output);

```

```js

const crypto = require('crypto');

const cipher = crypto.createCipher('aes192', 'a password');

encrypted += cipher.final('hex');

console.log(encrypted);

<!-- YAML

added: v0.1.94

-->

* `outputEncoding` {string}

* Returns: {Buffer | string} Any remaining enciphered contents.

If `outputEncoding` is one of `'latin1'`, `'base64'` or `'hex'`, a string is

returned. If an `outputEncoding` 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.

<!-- YAML

added: v1.0.0

-->

* `buffer` {Buffer}

* `options` {Object} [`stream.transform` options][]

When using an authenticated encryption mode (`GCM`, `CCM` and `OCB` are

currently supported), the `cipher.setAAD()` method sets the value used for the

_additional authenticated data_ (AAD) input parameter.

`plaintextLength` option must be specified and its value must match the length

of the plaintext in bytes. See [CCM mode][].

The `cipher.setAAD()` method must be called before [`cipher.update()`][].

<!-- YAML

added: v1.0.0

-->

* Returns: {Buffer} When using an authenticated encryption mode (`GCM`, `CCM`

and `OCB` are 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

<!-- YAML

added: v0.7.1

-->

* `autoPadding` {boolean} **Default:** `true`

* Returns: {Cipher} for method chaining.

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)`.

Disabling automatic padding is useful for non-standard padding, for instance

using `0x0` instead of PKCS padding.

The `cipher.setAutoPadding()` method must be called before

[`cipher.final()`][].

<!-- YAML

added: v0.1.94

changes:

- version: v6.0.0

pr-url: https://github.com/nodejs/node/pull/5522

* `data` {string | Buffer | TypedArray | DataView}

* `inputEncoding` {string}

* `outputEncoding` {string}

* Returns: {Buffer | string}

The `outputEncoding` specifies the output format of the enciphered

data, and can be `'latin1'`, `'base64'` or `'hex'`. If the `outputEncoding`

[`cipher.final()`][] is called. Calling `cipher.update()` after

[`cipher.final()`][] will result in an error being thrown.

<!-- YAML

added: v0.1.94

-->

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

- Using the [`decipher.update()`][] and [`decipher.final()`][] methods to

produce the unencrypted data.

The [`crypto.createDecipher()`][] or [`crypto.createDecipheriv()`][] methods are

used to create `Decipher` instances. `Decipher` objects are not to be created

directly using the `new` keyword.

Example: Using `Decipher` objects as streams:

```js

const crypto = require('crypto');

const decipher = crypto.createDecipher('aes192', 'a password');

});

decipher.on('end', () => {

console.log(decrypted);

// Prints: some clear text data

decipher.end();

```

Example: Using `Decipher` and piped streams:

const crypto = require('crypto');

const fs = require('fs');

const decipher = crypto.createDecipher('aes192', 'a password');

const input = fs.createReadStream('test.enc');

const output = fs.createWriteStream('test.js');

input.pipe(decipher).pipe(output);

```

```js

const crypto = require('crypto');

const decipher = crypto.createDecipher('aes192', 'a password');

decrypted += decipher.final('utf8');

console.log(decrypted);

<!-- YAML

added: v0.1.94

-->

* `outputEncoding` {string}

* Returns: {Buffer | string} Any remaining deciphered contents.

If `outputEncoding` is one of `'latin1'`, `'ascii'` or `'utf8'`, a string is

returned. If an `outputEncoding` is not provided, a [`Buffer`][] is returned.

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.

<!-- YAML

added: v1.0.0

changes:

- version: v7.2.0

pr-url: https://github.com/nodejs/node/pull/9398

description: This method now returns a reference to `decipher`.

* `buffer` {Buffer | TypedArray | DataView}

* `options` {Object} [`stream.transform` options][]