// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "node.h"

#include "node_buffer.h"

#include "node_constants.h"

#include "node_crypto.h"

#include "node_crypto_bio.h"

#include "node_crypto_groups.h"

#include "node_mutex.h"

#include "tls_wrap.h" // TLSWrap

#include "async-wrap-inl.h"

#include "env-inl.h"

#include "string_bytes.h"

#include "util-inl.h"

#include "v8.h"

// CNNIC Hash WhiteList is taken from

// https://hg.mozilla.org/mozilla-central/raw-file/98820360ab66/security/

// certverifier/CNNICHashWhitelist.inc

#include "CNNICHashWhitelist.inc"

// StartCom and WoSign root CA list is taken from

// https://hg.mozilla.org/mozilla-central/file/tip/security/certverifier/

// StartComAndWoSignData.inc

#include "StartComAndWoSignData.inc"

#include <errno.h>

#include <limits.h> // INT_MAX

#include <math.h>

#include <stdlib.h>

#include <string.h>

#define THROW_AND_RETURN_IF_NOT_BUFFER(val, prefix) \

do { \

if (!Buffer::HasInstance(val)) { \

return env->ThrowTypeError(prefix " must be a buffer"); \

} \

} while (0)

#define THROW_AND_RETURN_IF_NOT_STRING(val, prefix) \

do { \

if (!val->IsString()) { \

return env->ThrowTypeError(prefix " must be a string"); \

} \

} while (0)

static const char PUBLIC_KEY_PFX[] = "-----BEGIN PUBLIC KEY-----";

static const int PUBLIC_KEY_PFX_LEN = sizeof(PUBLIC_KEY_PFX) - 1;

static const char PUBRSA_KEY_PFX[] = "-----BEGIN RSA PUBLIC KEY-----";

static const int PUBRSA_KEY_PFX_LEN = sizeof(PUBRSA_KEY_PFX) - 1;

static const char CERTIFICATE_PFX[] = "-----BEGIN CERTIFICATE-----";

static const int CERTIFICATE_PFX_LEN = sizeof(CERTIFICATE_PFX) - 1;

static const int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL

| ASN1_STRFLGS_UTF8_CONVERT

| XN_FLAG_SEP_MULTILINE

| XN_FLAG_FN_SN;

namespace node {

namespace crypto {

using v8::AccessorSignature;

using v8::Array;

using v8::Boolean;

using v8::Context;

using v8::DEFAULT;

using v8::DontDelete;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::External;

using v8::False;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::HandleScope;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Null;

using v8::Object;

using v8::ObjectTemplate;

using v8::Persistent;

using v8::PropertyAttribute;

using v8::PropertyCallbackInfo;

using v8::ReadOnly;

using v8::String;

using v8::Value;

#if OPENSSL_VERSION_NUMBER < 0x10100000L

static void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e,

const BIGNUM** d) {

if (n != nullptr) {

*n = r->n;

}

if (e != nullptr) {

*e = r->e;

}

if (d != nullptr) {

*d = r->d;

}

}

static void DH_get0_pqg(const DH* dh, const BIGNUM** p, const BIGNUM** q,

const BIGNUM** g) {

if (p != nullptr) {

*p = dh->p;

}

if (q != nullptr) {

*q = dh->q;

}

if (g != nullptr) {

*g = dh->g;

}

}

static int DH_set0_pqg(DH* dh, BIGNUM* p, BIGNUM* q, BIGNUM* g) {

if ((dh->p == nullptr && p == nullptr) ||

(dh->g == nullptr && g == nullptr)) {

return 0;

}

if (p != nullptr) {

BN_free(dh->p);

dh->p = p;

}

if (q != nullptr) {

BN_free(dh->q);

dh->q = q;

}

if (g != nullptr) {

BN_free(dh->g);

dh->g = g;

}

return 1;

}

static void DH_get0_key(const DH* dh, const BIGNUM** pub_key,

const BIGNUM** priv_key) {

if (pub_key != nullptr) {

*pub_key = dh->pub_key;

}

if (priv_key != nullptr) {

*priv_key = dh->priv_key;

}

}

static int DH_set0_key(DH* dh, BIGNUM* pub_key, BIGNUM* priv_key) {

if (pub_key != nullptr) {

BN_free(dh->pub_key);

dh->pub_key = pub_key;

}

if (priv_key != nullptr) {

BN_free(dh->priv_key);

dh->priv_key = priv_key;

}

return 1;

}

static void SSL_SESSION_get0_ticket(const SSL_SESSION* s,

const unsigned char** tick, size_t* len) {

*len = s->tlsext_ticklen;

if (tick != nullptr) {

*tick = s->tlsext_tick;

}

}

#define SSL_get_tlsext_status_type(ssl) (ssl->tlsext_status_type)

static int X509_STORE_up_ref(X509_STORE* store) {

CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE);

return 1;

}

static int X509_up_ref(X509* cert) {

CRYPTO_add(&cert->references, 1, CRYPTO_LOCK_X509);

return 1;

}

#endif // OPENSSL_VERSION_NUMBER < 0x10100000L

// Subject DER of CNNIC ROOT CA and CNNIC EV ROOT CA are taken from

// https://hg.mozilla.org/mozilla-central/file/98820360ab66/security/

// certverifier/NSSCertDBTrustDomain.cpp#l672

// C = CN, O = CNNIC, CN = CNNIC ROOT

static const uint8_t CNNIC_ROOT_CA_SUBJECT_DATA[] =

"\x30\x32\x31\x0B\x30\x09\x06\x03\x55\x04\x06\x13\x02\x43\x4E\x31\x0E\x30"

"\x0C\x06\x03\x55\x04\x0A\x13\x05\x43\x4E\x4E\x49\x43\x31\x13\x30\x11\x06"

"\x03\x55\x04\x03\x13\x0A\x43\x4E\x4E\x49\x43\x20\x52\x4F\x4F\x54";

static const uint8_t* cnnic_p = CNNIC_ROOT_CA_SUBJECT_DATA;

static X509_NAME* cnnic_name =

d2i_X509_NAME(nullptr, &cnnic_p, sizeof(CNNIC_ROOT_CA_SUBJECT_DATA)-1);

// C = CN, O = China Internet Network Information Center, CN = China

// Internet Network Information Center EV Certificates Root

static const uint8_t CNNIC_EV_ROOT_CA_SUBJECT_DATA[] =

"\x30\x81\x8A\x31\x0B\x30\x09\x06\x03\x55\x04\x06\x13\x02\x43\x4E\x31\x32"

"\x30\x30\x06\x03\x55\x04\x0A\x0C\x29\x43\x68\x69\x6E\x61\x20\x49\x6E\x74"

"\x65\x72\x6E\x65\x74\x20\x4E\x65\x74\x77\x6F\x72\x6B\x20\x49\x6E\x66\x6F"

"\x72\x6D\x61\x74\x69\x6F\x6E\x20\x43\x65\x6E\x74\x65\x72\x31\x47\x30\x45"

"\x06\x03\x55\x04\x03\x0C\x3E\x43\x68\x69\x6E\x61\x20\x49\x6E\x74\x65\x72"

"\x6E\x65\x74\x20\x4E\x65\x74\x77\x6F\x72\x6B\x20\x49\x6E\x66\x6F\x72\x6D"

"\x61\x74\x69\x6F\x6E\x20\x43\x65\x6E\x74\x65\x72\x20\x45\x56\x20\x43\x65"

"\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x20\x52\x6F\x6F\x74";

static const uint8_t* cnnic_ev_p = CNNIC_EV_ROOT_CA_SUBJECT_DATA;

static X509_NAME *cnnic_ev_name =

d2i_X509_NAME(nullptr, &cnnic_ev_p,

sizeof(CNNIC_EV_ROOT_CA_SUBJECT_DATA)-1);

static const char* const root_certs[] = {

#include "node_root_certs.h" // NOLINT(build/include_order)

};

static const char system_cert_path[] = NODE_OPENSSL_SYSTEM_CERT_PATH;

static std::string extra_root_certs_file; // NOLINT(runtime/string)

static X509_STORE* root_cert_store;

// Just to generate static methods

template void SSLWrap<TLSWrap>::AddMethods(Environment* env,

Local<FunctionTemplate> t);

template void SSLWrap<TLSWrap>::InitNPN(SecureContext* sc);

template void SSLWrap<TLSWrap>::SetSNIContext(SecureContext* sc);

template int SSLWrap<TLSWrap>::SetCACerts(SecureContext* sc);

#if OPENSSL_VERSION_NUMBER < 0x10100000L

template SSL_SESSION* SSLWrap<TLSWrap>::GetSessionCallback(

SSL* s,

unsigned char* key,

int len,

int* copy);

#else

template SSL_SESSION* SSLWrap<TLSWrap>::GetSessionCallback(

SSL* s,

const unsigned char* key,

int len,

int* copy);

#endif

template int SSLWrap<TLSWrap>::NewSessionCallback(SSL* s,

SSL_SESSION* sess);

template void SSLWrap<TLSWrap>::OnClientHello(

void* arg,

const ClientHelloParser::ClientHello& hello);

#ifndef OPENSSL_NO_NEXTPROTONEG

template int SSLWrap<TLSWrap>::AdvertiseNextProtoCallback(

SSL* s,

const unsigned char** data,

unsigned int* len,

void* arg);

template int SSLWrap<TLSWrap>::SelectNextProtoCallback(

SSL* s,

unsigned char** out,

unsigned char* outlen,

const unsigned char* in,

unsigned int inlen,

void* arg);

#endif

#ifdef NODE__HAVE_TLSEXT_STATUS_CB

template int SSLWrap<TLSWrap>::TLSExtStatusCallback(SSL* s, void* arg);

#endif

template void SSLWrap<TLSWrap>::DestroySSL();

template int SSLWrap<TLSWrap>::SSLCertCallback(SSL* s, void* arg);

template void SSLWrap<TLSWrap>::WaitForCertCb(CertCb cb, void* arg);

#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

template int SSLWrap<TLSWrap>::SelectALPNCallback(

SSL* s,

const unsigned char** out,

unsigned char* outlen,

const unsigned char* in,

unsigned int inlen,

void* arg);

#endif // TLSEXT_TYPE_application_layer_protocol_negotiation

#if OPENSSL_VERSION_NUMBER < 0x10100000L

static Mutex* mutexes;

static void crypto_threadid_cb(CRYPTO_THREADID* tid) {

static_assert(sizeof(uv_thread_t) <= sizeof(void*),

"uv_thread_t does not fit in a pointer");

CRYPTO_THREADID_set_pointer(tid, reinterpret_cast<void*>(uv_thread_self()));

}

static void crypto_lock_init(void) {

mutexes = new Mutex[CRYPTO_num_locks()];

}

static void crypto_lock_cb(int mode, int n, const char* file, int line) {

CHECK(!(mode & CRYPTO_LOCK) ^ !(mode & CRYPTO_UNLOCK));

CHECK(!(mode & CRYPTO_READ) ^ !(mode & CRYPTO_WRITE));

auto mutex = &mutexes[n];

if (mode & CRYPTO_LOCK)

mutex->Lock();

else

mutex->Unlock();

}

#endif

static int PasswordCallback(char *buf, int size, int rwflag, void *u) {

if (u) {

size_t buflen = static_cast<size_t>(size);

size_t len = strlen(static_cast<const char*>(u));

len = len > buflen ? buflen : len;

memcpy(buf, u, len);

return len;

}

return 0;

}

// This callback is used to avoid the default passphrase callback in OpenSSL

// which will typically prompt for the passphrase. The prompting is designed

// for the OpenSSL CLI, but works poorly for Node.js because it involves

// synchronous interaction with the controlling terminal, something we never

// want, and use this function to avoid it.

static int NoPasswordCallback(char *buf, int size, int rwflag, void *u) {

return 0;

}

void ThrowCryptoError(Environment* env,

unsigned long err, // NOLINT(runtime/int)

const char* default_message = nullptr) {

HandleScope scope(env->isolate());

Local<String> message;

if (err != 0 || default_message == nullptr) {

char errmsg[128] = { 0 };

ERR_error_string_n(err, errmsg, sizeof(errmsg));

message = String::NewFromUtf8(env->isolate(), errmsg,

v8::NewStringType::kNormal)

.ToLocalChecked();

} else {

message = String::NewFromUtf8(env->isolate(), default_message,

v8::NewStringType::kNormal)

.ToLocalChecked();

}

Local<Value> exception_v = Exception::Error(message);

CHECK(!exception_v.IsEmpty());

Local<Object> exception = exception_v.As<Object>();

ERR_STATE* es = ERR_get_state();

if (es->bottom != es->top) {

Local<Array> error_stack = Array::New(env->isolate());

int top = es->top;

// Build the error_stack array to be added to opensslErrorStack property.

for (unsigned int i = 0; es->bottom != es->top;) {

unsigned long err_buf = es->err_buffer[es->top]; // NOLINT(runtime/int)

// Only add error string if there is valid err_buffer.

if (err_buf) {

char tmp_str[256];

ERR_error_string_n(err_buf, tmp_str, sizeof(tmp_str));

error_stack->Set(env->context(), i,

String::NewFromUtf8(env->isolate(), tmp_str,

v8::NewStringType::kNormal)

.ToLocalChecked()).FromJust();

// Only increment if we added to error_stack.

i++;

}

// Since the ERR_STATE is a ring buffer, we need to use modular

// arithmetic to loop back around in the case where bottom is after top.

// Using ERR_NUM_ERRORS macro defined in openssl.

es->top = (((es->top - 1) % ERR_NUM_ERRORS) + ERR_NUM_ERRORS) %

ERR_NUM_ERRORS;

}

// Restore top.

es->top = top;

// Add the opensslErrorStack property to the exception object.

// The new property will look like the following:

// opensslErrorStack: [

// 'error:0906700D:PEM routines:PEM_ASN1_read_bio:ASN1 lib',

// 'error:0D07803A:asn1 encoding routines:ASN1_ITEM_EX_D2I:nested asn1 err'

// ]

exception->Set(env->context(), env->openssl_error_stack(), error_stack)

.FromJust();

}

env->isolate()->ThrowException(exception);

}

// Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG.

// The entropy pool starts out empty and needs to fill up before the PRNG

// can be used securely. Once the pool is filled, it never dries up again;

// its contents is stirred and reused when necessary.

//

// OpenSSL normally fills the pool automatically but not when someone starts

// generating random numbers before the pool is full: in that case OpenSSL

// keeps lowering the entropy estimate to thwart attackers trying to guess

// the initial state of the PRNG.

//

// When that happens, we will have to wait until enough entropy is available.

// That should normally never take longer than a few milliseconds.

//

// OpenSSL draws from /dev/random and /dev/urandom. While /dev/random may

// block pending "true" randomness, /dev/urandom is a CSPRNG that doesn't

// block under normal circumstances.

//

// The only time when /dev/urandom may conceivably block is right after boot,

// when the whole system is still low on entropy. That's not something we can

// do anything about.

inline void CheckEntropy() {

for (;;) {

int status = RAND_status();

CHECK_GE(status, 0); // Cannot fail.

if (status != 0)

break;

// Give up, RAND_poll() not supported.

if (RAND_poll() == 0)

break;

}

}

bool EntropySource(unsigned char* buffer, size_t length) {

// Ensure that OpenSSL's PRNG is properly seeded.

CheckEntropy();

// RAND_bytes() can return 0 to indicate that the entropy data is not truly

// random. That's okay, it's still better than V8's stock source of entropy,

// which is /dev/urandom on UNIX platforms and the current time on Windows.

return RAND_bytes(buffer, length) != -1;

}

void SecureContext::Initialize(Environment* env, Local<Object> target) {

Local<FunctionTemplate> t = env->NewFunctionTemplate(SecureContext::New);

t->InstanceTemplate()->SetInternalFieldCount(1);

Local<String> secureContextString =

FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext");

t->SetClassName(secureContextString);

env->SetProtoMethod(t, "init", SecureContext::Init);

env->SetProtoMethod(t, "setKey", SecureContext::SetKey);

env->SetProtoMethod(t, "setCert", SecureContext::SetCert);

env->SetProtoMethod(t, "addCACert", SecureContext::AddCACert);

env->SetProtoMethod(t, "addCRL", SecureContext::AddCRL);

env->SetProtoMethod(t, "addRootCerts", SecureContext::AddRootCerts);

env->SetProtoMethod(t, "setCiphers", SecureContext::SetCiphers);

env->SetProtoMethod(t, "setECDHCurve", SecureContext::SetECDHCurve);

env->SetProtoMethod(t, "setDHParam", SecureContext::SetDHParam);

env->SetProtoMethod(t, "setOptions", SecureContext::SetOptions);

env->SetProtoMethod(t, "setSessionIdContext",

SecureContext::SetSessionIdContext);

env->SetProtoMethod(t, "setSessionTimeout",

SecureContext::SetSessionTimeout);

env->SetProtoMethod(t, "close", SecureContext::Close);

env->SetProtoMethod(t, "loadPKCS12", SecureContext::LoadPKCS12);

env->SetProtoMethod(t, "getTicketKeys", SecureContext::GetTicketKeys);

env->SetProtoMethod(t, "setTicketKeys", SecureContext::SetTicketKeys);

env->SetProtoMethod(t, "setFreeListLength", SecureContext::SetFreeListLength);

env->SetProtoMethod(t,

"enableTicketKeyCallback",

SecureContext::EnableTicketKeyCallback);

env->SetProtoMethod(t, "getCertificate", SecureContext::GetCertificate<true>);

env->SetProtoMethod(t, "getIssuer", SecureContext::GetCertificate<false>);

t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyReturnIndex"),

Integer::NewFromUnsigned(env->isolate(), kTicketKeyReturnIndex));

t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyHMACIndex"),

Integer::NewFromUnsigned(env->isolate(), kTicketKeyHMACIndex));

t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyAESIndex"),

Integer::NewFromUnsigned(env->isolate(), kTicketKeyAESIndex));

t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyNameIndex"),

Integer::NewFromUnsigned(env->isolate(), kTicketKeyNameIndex));

t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyIVIndex"),

Integer::NewFromUnsigned(env->isolate(), kTicketKeyIVIndex));

t->PrototypeTemplate()->SetAccessor(

FIXED_ONE_BYTE_STRING(env->isolate(), "_external"),

CtxGetter,

nullptr,

env->as_external(),

DEFAULT,

static_cast<PropertyAttribute>(ReadOnly | DontDelete),

AccessorSignature::New(env->isolate(), t));

target->Set(secureContextString, t->GetFunction());

env->set_secure_context_constructor_template(t);

}

void SecureContext::New(const FunctionCallbackInfo<Value>& args) {

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

new SecureContext(env, args.This());

}

void SecureContext::Init(const FunctionCallbackInfo<Value>& args) {

SecureContext* sc;

ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());

Environment* env = sc->env();

const SSL_METHOD* method = SSLv23_method();

if (args.Length() == 1 && args[0]->IsString()) {

const node::Utf8Value sslmethod(env->isolate(), args[0]);

// Note that SSLv2 and SSLv3 are disallowed but SSLv2_method and friends

// are still accepted. They are OpenSSL's way of saying that all known

// protocols are supported unless explicitly disabled (which we do below

// for SSLv2 and SSLv3.)

if (strcmp(*sslmethod, "SSLv2_method") == 0) {

return env->ThrowError("SSLv2 methods disabled");

} else if (strcmp(*sslmethod, "SSLv2_server_method") == 0) {

return env->ThrowError("SSLv2 methods disabled");

} else if (strcmp(*sslmethod, "SSLv2_client_method") == 0) {

return env->ThrowError("SSLv2 methods disabled");

} else if (strcmp(*sslmethod, "SSLv3_method") == 0) {

return env->ThrowError("SSLv3 methods disabled");

} else if (strcmp(*sslmethod, "SSLv3_server_method") == 0) {

return env->ThrowError("SSLv3 methods disabled");

} else if (strcmp(*sslmethod, "SSLv3_client_method") == 0) {

return env->ThrowError("SSLv3 methods disabled");

} else if (strcmp(*sslmethod, "SSLv23_method") == 0) {

method = SSLv23_method();

} else if (strcmp(*sslmethod, "SSLv23_server_method") == 0) {

method = SSLv23_server_method();

} else if (strcmp(*sslmethod, "SSLv23_client_method") == 0) {

method = SSLv23_client_method();

} else if (strcmp(*sslmethod, "TLSv1_method") == 0) {

method = TLSv1_method();

} else if (strcmp(*sslmethod, "TLSv1_server_method") == 0) {

method = TLSv1_server_method();

} else if (strcmp(*sslmethod, "TLSv1_client_method") == 0) {

method = TLSv1_client_method();

} else if (strcmp(*sslmethod, "TLSv1_1_method") == 0) {

method = TLSv1_1_method();

} else if (strcmp(*sslmethod, "TLSv1_1_server_method") == 0) {

method = TLSv1_1_server_method();

} else if (strcmp(*sslmethod, "TLSv1_1_client_method") == 0) {

method = TLSv1_1_client_method();

} else if (strcmp(*sslmethod, "TLSv1_2_method") == 0) {

method = TLSv1_2_method();

} else if (strcmp(*sslmethod, "TLSv1_2_server_method") == 0) {

method = TLSv1_2_server_method();

} else if (strcmp(*sslmethod, "TLSv1_2_client_method") == 0) {

method = TLSv1_2_client_method();

} else {

return env->ThrowError("Unknown method");

}

}

sc->ctx_ = SSL_CTX_new(method);

SSL_CTX_set_app_data(sc->ctx_, sc);

// Disable SSLv2 in the case when method == SSLv23_method() and the

// cipher list contains SSLv2 ciphers (not the default, should be rare.)

// The bundled OpenSSL doesn't have SSLv2 support but the system OpenSSL may.

// SSLv3 is disabled because it's susceptible to downgrade attacks (POODLE.)

SSL_CTX_set_options(sc->ctx_, SSL_OP_NO_SSLv2);

SSL_CTX_set_options(sc->ctx_, SSL_OP_NO_SSLv3);

// SSL session cache configuration

SSL_CTX_set_session_cache_mode(sc->ctx_,

SSL_SESS_CACHE_SERVER |

SSL_SESS_CACHE_NO_INTERNAL |

SSL_SESS_CACHE_NO_AUTO_CLEAR);

SSL_CTX_sess_set_get_cb(sc->ctx_, SSLWrap<Connection>::GetSessionCallback);

SSL_CTX_sess_set_new_cb(sc->ctx_, SSLWrap<Connection>::NewSessionCallback);

}

// Takes a string or buffer and loads it into a BIO.

// Caller responsible for BIO_free_all-ing the returned object.

static BIO* LoadBIO(Environment* env, Local<Value> v) {

HandleScope scope(env->isolate());

if (v->IsString()) {

const node::Utf8Value s(env->isolate(), v);

return NodeBIO::NewFixed(*s, s.length());

}

if (Buffer::HasInstance(v)) {

return NodeBIO::NewFixed(Buffer::Data(v), Buffer::Length(v));

}

return nullptr;

}

void SecureContext::SetKey(const FunctionCallbackInfo<Value>& args) {

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

SecureContext* sc;

ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());

unsigned int len = args.Length();

if (len < 1) {

return env->ThrowError("Private key argument is mandatory");

}

if (len > 2) {

return env->ThrowError("Only private key and pass phrase are expected");

}

if (len == 2) {

if (args[1]->IsUndefined() || args[1]->IsNull())

len = 1;

else

THROW_AND_RETURN_IF_NOT_STRING(args[1], "Pass phrase");

}

BIO *bio = LoadBIO(env, args[0]);

if (!bio)

return;

node::Utf8Value passphrase(env->isolate(), args[1]);

EVP_PKEY* key = PEM_read_bio_PrivateKey(bio,

nullptr,

PasswordCallback,

len == 1 ? nullptr : *passphrase);

if (!key) {

BIO_free_all(bio);

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

if (!err) {

return env->ThrowError("PEM_read_bio_PrivateKey");

}

return ThrowCryptoError(env, err);

}

int rv = SSL_CTX_use_PrivateKey(sc->ctx_, key);

EVP_PKEY_free(key);

BIO_free_all(bio);

if (!rv) {

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

if (!err)

return env->ThrowError("SSL_CTX_use_PrivateKey");

return ThrowCryptoError(env, err);

}

}

int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer) {

X509_STORE* store = SSL_CTX_get_cert_store(ctx);

X509_STORE_CTX* store_ctx = X509_STORE_CTX_new();

int ret = store_ctx != nullptr &&

X509_STORE_CTX_init(store_ctx, store, nullptr, nullptr) == 1 &&

X509_STORE_CTX_get1_issuer(issuer, store_ctx, cert) == 1;

X509_STORE_CTX_free(store_ctx);

return ret;

}

int SSL_CTX_use_certificate_chain(SSL_CTX* ctx,

X509* x,

STACK_OF(X509)* extra_certs,

X509** cert,

X509** issuer) {

CHECK_EQ(*issuer, nullptr);

CHECK_EQ(*cert, nullptr);

int ret = SSL_CTX_use_certificate(ctx, x);

if (ret) {

// If we could set up our certificate, now proceed to

// the CA certificates.

int r;

SSL_CTX_clear_extra_chain_certs(ctx);

for (int i = 0; i < sk_X509_num(extra_certs); i++) {

X509* ca = sk_X509_value(extra_certs, i);

// NOTE: Increments reference count on `ca`

r = SSL_CTX_add1_chain_cert(ctx, ca);

if (!r) {

ret = 0;

*issuer = nullptr;

goto end;

}

// Note that we must not free r if it was successfully

// added to the chain (while we must free the main

// certificate, since its reference count is increased

// by SSL_CTX_use_certificate).

// Find issuer

if (*issuer != nullptr || X509_check_issued(ca, x) != X509_V_OK)

continue;

*issuer = ca;

}

}

// Try getting issuer from a cert store

if (ret) {

if (*issuer == nullptr) {

ret = SSL_CTX_get_issuer(ctx, x, issuer);

ret = ret < 0 ? 0 : 1;

// NOTE: get_cert_store doesn't increment reference count,

// no need to free `store`

} else {

// Increment issuer reference count

*issuer = X509_dup(*issuer);

if (*issuer == nullptr) {

ret = 0;

goto end;

}

}

}

end:

if (ret && x != nullptr) {

*cert = X509_dup(x);

if (*cert == nullptr)

ret = 0;

}

return ret;

}

// Read a file that contains our certificate in "PEM" format,

// possibly followed by a sequence of CA certificates that should be

// sent to the peer in the Certificate message.

//

// Taken from OpenSSL - edited for style.

int SSL_CTX_use_certificate_chain(SSL_CTX* ctx,

BIO* in,

X509** cert,

X509** issuer) {

X509* x = nullptr;

// Just to ensure that `ERR_peek_last_error` below will return only errors

// that we are interested in

ERR_clear_error();

x = PEM_read_bio_X509_AUX(in, nullptr, NoPasswordCallback, nullptr);

if (x == nullptr) {

return 0;

}

X509* extra = nullptr;

int ret = 0;

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

// Read extra certs

STACK_OF(X509)* extra_certs = sk_X509_new_null();

if (extra_certs == nullptr) {

goto done;

}

while ((extra = PEM_read_bio_X509(in,

nullptr,

NoPasswordCallback,

nullptr))) {

if (sk_X509_push(extra_certs, extra))

continue;

// Failure, free all certs

goto done;

}

extra = nullptr;

// When the while loop ends, it's usually just EOF.

err = ERR_peek_last_error();

if (ERR_GET_LIB(err) == ERR_LIB_PEM &&

ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {

ERR_clear_error();

} else {

// some real error

goto done;

}

ret = SSL_CTX_use_certificate_chain(ctx, x, extra_certs, cert, issuer);

if (!ret)

goto done;

done:

if (extra_certs != nullptr)

sk_X509_pop_free(extra_certs, X509_free);

if (extra != nullptr)

X509_free(extra);

if (x != nullptr)

X509_free(x);

return ret;

}

void SecureContext::SetCert(const FunctionCallbackInfo<Value>& args) {

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

SecureContext* sc;

ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());

if (args.Length() != 1) {

return env->ThrowTypeError("Certificate argument is mandatory");

}

BIO* bio = LoadBIO(env, args[0]);

if (!bio)

return;

// Free previous certs

if (sc->issuer_ != nullptr) {

X509_free(sc->issuer_);

sc->issuer_ = nullptr;

}

if (sc->cert_ != nullptr) {

X509_free(sc->cert_);

sc->cert_ = nullptr;

}

int rv = SSL_CTX_use_certificate_chain(sc->ctx_,

bio,

&sc->cert_,

&sc->issuer_);

BIO_free_all(bio);

if (!rv) {

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

if (!err) {

return env->ThrowError("SSL_CTX_use_certificate_chain");

}

return ThrowCryptoError(env, err);

}

}

static X509_STORE* NewRootCertStore() {

static std::vector<X509*> root_certs_vector;

if (root_certs_vector.empty()) {

for (size_t i = 0; i < arraysize(root_certs); i++) {

BIO* bp = NodeBIO::NewFixed(root_certs[i], strlen(root_certs[i]));

X509 *x509 = PEM_read_bio_X509(bp, nullptr, NoPasswordCallback, nullptr);

BIO_free(bp);

// Parse errors from the built-in roots are fatal.

CHECK_NE(x509, nullptr);

root_certs_vector.push_back(x509);

}

}

X509_STORE* store = X509_STORE_new();

if (*system_cert_path != '\0') {

X509_STORE_load_locations(store, system_cert_path, nullptr);

}

if (ssl_openssl_cert_store) {

X509_STORE_set_default_paths(store);

} else {

for (X509 *cert : root_certs_vector) {

X509_up_ref(cert);

X509_STORE_add_cert(store, cert);

}

}

return store;

}

void SecureContext::AddCACert(const FunctionCallbackInfo<Value>& args) {

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

SecureContext* sc;

ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());

ClearErrorOnReturn clear_error_on_return;

if (args.Length() != 1) {

return env->ThrowTypeError("CA certificate argument is mandatory");

}

BIO* bio = LoadBIO(env, args[0]);

if (!bio) {

return;

}

X509_STORE* cert_store = SSL_CTX_get_cert_store(sc->ctx_);

while (X509* x509 =

PEM_read_bio_X509(bio, nullptr, NoPasswordCallback, nullptr)) {

if (cert_store == root_cert_store) {

cert_store = NewRootCertStore();

SSL_CTX_set_cert_store(sc->ctx_, cert_store);

}

X509_STORE_add_cert(cert_store, x509);

SSL_CTX_add_client_CA(sc->ctx_, x509);

X509_free(x509);

}

BIO_free_all(bio);

}

void SecureContext::AddCRL(const FunctionCallbackInfo<Value>& args) {

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

SecureContext* sc;

ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());

if (args.Length() != 1) {

return env->ThrowTypeError("CRL argument is mandatory");

}

ClearErrorOnReturn clear_error_on_return;

BIO *bio = LoadBIO(env, args[0]);

if (!bio)

return;

X509_CRL* crl =

PEM_read_bio_X509_CRL(bio, nullptr, NoPasswordCallback, nullptr);

if (crl == nullptr) {

BIO_free_all(bio);

return env->ThrowError("Failed to parse CRL");

}

X509_STORE* cert_store = SSL_CTX_get_cert_store(sc->ctx_);

if (cert_store == root_cert_store) {

cert_store = NewRootCertStore();

SSL_CTX_set_cert_store(sc->ctx_, cert_store);

}

X509_STORE_add_crl(cert_store, crl);

X509_STORE_set_flags(cert_store,

X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);

BIO_free_all(bio);

X509_CRL_free(crl);

}

void UseExtraCaCerts(const std::string& file) {

extra_root_certs_file = file;

}

static unsigned long AddCertsFromFile( // NOLINT(runtime/int)

X509_STORE* store,

const char* file) {

ERR_clear_error();

MarkPopErrorOnReturn mark_pop_error_on_return;

BIO* bio = BIO_new_file(file, "r");

if (!bio) {

return ERR_get_error();

}

while (X509* x509 =

PEM_read_bio_X509(bio, nullptr, NoPasswordCallback, nullptr)) {

X509_STORE_add_cert(store, x509);

X509_free(x509);

}

BIO_free_all(bio);

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

// Ignore error if its EOF/no start line found.

if (ERR_GET_LIB(err) == ERR_LIB_PEM &&

ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {

return 0;

}

return err;

}

void SecureContext::AddRootCerts(const FunctionCallbackInfo<Value>& args) {

SecureContext* sc;

ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());

ClearErrorOnReturn clear_error_on_return;

if (!root_cert_store) {