console.log(key2.toString('hex')); // '3745e48...aa39b34'

* Returns: {Object}

* `total` {number} The total allocated secure heap size as specified

using the `--secure-heap=n` command-line flag.

* `min` {number} The minimum allocation from the secure heap as

specified using the `--secure-heap-min` command-line flag.

* `used` {number} The total number of bytes currently allocated from

the secure heap.

* `utilization` {number} The calculated ratio of `used` to `total`

allocated bytes.

to be generated on un-caught exceptions. Useful when inspecting JavaScript

stack in conjunction with native stack and other runtime environment data.

.It Fl -secure-heap Ns = Ns Ar n

Specify the size of the OpenSSL secure heap. Any value less than 2 disables

the secure heap. The default is 0. The value must be a power of two.

.It Fl -secure-heap-min Ns = Ns Ar n

Specify the minimum allocation from the OpenSSL secure heap. The default is 2. The value must be a power of two.

.It Fl -throw-deprecation

Throw errors for deprecations.

setDefaultEncoding,

setEngine,

lazyRequire,

secureHeapUsed,

} = require('internal/crypto/util');

const Certificate = require('internal/crypto/certificate');

Sign,

Verify,

X509Certificate,

secureHeapUsed,

function setFipsDisabled() {

ArrayPrototypeIncludes,

ArrayPrototypePush,

FunctionPrototypeBind,

Number,

Promise,

StringPrototypeToLowerCase,

StringPrototypeToUpperCase,

getCurves: _getCurves,

getHashes: _getHashes,

setEngine: _setEngine,

secureHeapUsed: _secureHeapUsed,

} = internalBinding('crypto');

const { getOptionValue } = require('internal/options');

const {

crypto: {

ENGINE_METHOD_ALL

}

function secureHeapUsed() {

const val = _secureHeapUsed();

if (val === undefined)

return { total: 0, used: 0, utilization: 0, min: 0 };

const used = Number(_secureHeapUsed());

const total = Number(getOptionValue('--secure-heap'));

const min = Number(getOptionValue('--secure-heap-min'));

const utilization = used / total;

return { total, used, utilization, min };

module.exports = {

getArrayBufferOrView,

getCiphers,

getStringOption,

getUsagesUnion,

getHashLength,

secureHeapUsed,

using v8::ArrayBuffer;

using v8::BackingStore;

using v8::BigInt;

using v8::Context;

using v8::Exception;

using v8::FunctionCallbackInfo;

settings = nullptr;

#endif

#ifndef _WIN32

if (per_process::cli_options->secure_heap != 0) {

switch (CRYPTO_secure_malloc_init(

per_process::cli_options->secure_heap,

static_cast<int>(per_process::cli_options->secure_heap_min))) {

case 0:

fprintf(stderr, "Unable to initialize openssl secure heap.\n");

break;

case 2:

// Not a fatal error but worthy of a warning.

fprintf(stderr, "Unable to memory map openssl secure heap.\n");

break;

case 1:

// OK!

break;

}

}

#endif

#ifdef NODE_FIPS_MODE

/* Override FIPS settings in cnf file, if needed. */

unsigned long err = 0; // NOLINT(runtime/int)

Local<ArrayBuffer> buffer = ArrayBuffer::New(env->isolate(), store);

args.GetReturnValue().Set(Uint8Array::New(buffer, 0, len));

}

void SecureHeapUsed(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

if (CRYPTO_secure_malloc_initialized())

args.GetReturnValue().Set(

BigInt::New(env->isolate(), CRYPTO_secure_used()));

}

} // namespace

namespace Util {

NODE_DEFINE_CONSTANT(target, kCryptoJobSync);

env->SetMethod(target, "secureBuffer", SecureBuffer);

env->SetMethod(target, "secureHeapUsed", SecureHeapUsed);

}

} // namespace Util

#include <errno.h>

#include <sstream>

#include <limits>

#include <algorithm>

#include <cstdlib> // strtoul, errno

using v8::Boolean;

errors->push_back("either --use-openssl-ca or --use-bundled-ca can be "

"used, not both");

}

// Any value less than 2 disables use of the secure heap.

if (secure_heap >= 2) {

if ((secure_heap & (secure_heap - 1)) != 0)

errors->push_back("--secure-heap must be a power of 2");

secure_heap_min =

std::min({

secure_heap,

secure_heap_min,

static_cast<int64_t>(std::numeric_limits<int>::max())});

secure_heap_min = std::max(static_cast<int64_t>(2), secure_heap_min);

if ((secure_heap_min & (secure_heap_min - 1)) != 0)

errors->push_back("--secure-heap-min must be a power of 2");

}

#endif

if (use_largepages != "off" &&

use_largepages != "on" &&

&PerProcessOptions::force_fips_crypto,

kAllowedInEnvironment);

#endif

AddOption("--secure-heap",

"total size of the OpenSSL secure heap",

&PerProcessOptions::secure_heap,

kAllowedInEnvironment);

AddOption("--secure-heap-min",

"minimum allocation size from the OpenSSL secure heap",

&PerProcessOptions::secure_heap_min,

kAllowedInEnvironment);

#endif

AddOption("--use-largepages",

"Map the Node.js static code to large pages. Options are "

#if HAVE_OPENSSL

std::string openssl_config;

std::string tls_cipher_list = DEFAULT_CIPHER_LIST_CORE;

int64_t secure_heap = 0;

int64_t secure_heap_min = 2;

#ifdef NODE_OPENSSL_CERT_STORE

bool ssl_openssl_cert_store = true;

#else

const common = require('../common');

if (!common.hasCrypto)

common.skip('missing crypto');

if (common.isWindows)

common.skip('Not supported on Windows');

const assert = require('assert');

const { fork } = require('child_process');

const fixtures = require('../common/fixtures');

const {

secureHeapUsed,

createDiffieHellman,

} = require('crypto');

if (process.argv[2] === 'child') {

const a = secureHeapUsed();

assert(a);

assert.strictEqual(typeof a, 'object');

assert.strictEqual(a.total, 65536);

assert.strictEqual(a.min, 4);

assert.strictEqual(a.used, 0);

{

const dh1 = createDiffieHellman(common.hasFipsCrypto ? 1024 : 256);

const p1 = dh1.getPrime('buffer');

const dh2 = createDiffieHellman(p1, 'buffer');

const key1 = dh1.generateKeys();

const key2 = dh2.generateKeys('hex');

dh1.computeSecret(key2, 'hex', 'base64');

dh2.computeSecret(key1, 'latin1', 'buffer');

const b = secureHeapUsed();

assert(b);

assert.strictEqual(typeof b, 'object');

assert.strictEqual(b.total, 65536);

assert.strictEqual(b.min, 4);

// The amount used can vary on a number of factors

assert(b.used > 0);

assert(b.utilization > 0.0);

}

return;

const child = fork(

process.argv[1],

['child'],

{ execArgv: ['--secure-heap=65536', '--secure-heap-min=4'] });

child.on('exit', common.mustCall((code) => {

assert.strictEqual(code, 0);

const child = fork(fixtures.path('a.js'), {

execArgv: ['--secure-heap=3', '--secure-heap-min=3'],

stdio: 'pipe'

});

let res = '';

child.on('exit', common.mustCall((code) => {

assert.notStrictEqual(code, 0);

assert.match(res, /--secure-heap must be a power of 2/);

assert.match(res, /--secure-heap-min must be a power of 2/);

}));

child.stderr.setEncoding('utf8');

child.stderr.on('data', (chunk) => res += chunk);

const conditionalOpts = [

{ include: common.hasCrypto,

filter: (opt) => {

return [

'--openssl-config',

'--tls-cipher-list',

'--use-bundled-ca',

'--use-openssl-ca',

'--secure-heap',

'--secure-heap-min',

].includes(opt);

} },

{

// We are using openssl_is_fips from the configuration because it could be