// 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_crypto.h"

#include "node_crypto_bio.h"

#include "node_crypto_groups.h"

#include "tls_wrap.h" // TLSCallbacks

#include "async-wrap.h"

#include "async-wrap-inl.h"

#include "env.h"

#include "env-inl.h"

#include "string_bytes.h"

#include "util.h"

#include "util-inl.h"

#include "v8.h"

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#if defined(_MSC_VER)

#define strcasecmp _stricmp

#endif

#if OPENSSL_VERSION_NUMBER >= 0x10000000L

#define OPENSSL_CONST const

#else

#define OPENSSL_CONST

#endif

#define ASSERT_IS_STRING_OR_BUFFER(val) do { \

if (!Buffer::HasInstance(val) && !val->IsString()) { \

return env->ThrowTypeError("Not a string or buffer"); \

} \

} while (0)

#define ASSERT_IS_BUFFER(val) do { \

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

return env->ThrowTypeError("Not a buffer"); \

} \

} 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 int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL

| ASN1_STRFLGS_ESC_MSB

| XN_FLAG_SEP_MULTILINE

| XN_FLAG_FN_SN;

namespace node {

namespace crypto {

using v8::Array;

using v8::Boolean;

using v8::Context;

using v8::Exception;

using v8::False;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Handle;

using v8::HandleScope;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::Null;

using v8::Object;

using v8::Persistent;

using v8::PropertyAttribute;

using v8::PropertyCallbackInfo;

using v8::String;

using v8::V8;

using v8::Value;

// Forcibly clear OpenSSL's error stack on return. This stops stale errors

// from popping up later in the lifecycle of crypto operations where they

// would cause spurious failures. It's a rather blunt method, though.

// ERR_clear_error() isn't necessarily cheap either.

struct ClearErrorOnReturn {

~ClearErrorOnReturn() { ERR_clear_error(); }

};

static uv_rwlock_t* locks;

const char* root_certs[] = {

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

NULL

};

X509_STORE* root_cert_store;

// Just to generate static methods

template class SSLWrap<TLSCallbacks>;

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

Handle<FunctionTemplate> t);

template void SSLWrap<TLSCallbacks>::InitNPN(SecureContext* sc,

TLSCallbacks* base);

template SSL_SESSION* SSLWrap<TLSCallbacks>::GetSessionCallback(

SSL* s,

unsigned char* key,

int len,

int* copy);

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

SSL_SESSION* sess);

template void SSLWrap<TLSCallbacks>::OnClientHello(

void* arg,

const ClientHelloParser::ClientHello& hello);

#ifdef OPENSSL_NPN_NEGOTIATED

template int SSLWrap<TLSCallbacks>::AdvertiseNextProtoCallback(

SSL* s,

const unsigned char** data,

unsigned int* len,

void* arg);

template int SSLWrap<TLSCallbacks>::SelectNextProtoCallback(

SSL* s,

unsigned char** out,

unsigned char* outlen,

const unsigned char* in,

unsigned int inlen,

void* arg);

#endif

static void crypto_threadid_cb(CRYPTO_THREADID* tid) {

CRYPTO_THREADID_set_numeric(tid, uv_thread_self());

}

static void crypto_lock_init(void) {

int i, n;

n = CRYPTO_num_locks();

locks = new uv_rwlock_t[n];

for (i = 0; i < n; i++)

if (uv_rwlock_init(locks + i))

abort();

}

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

assert((mode & CRYPTO_LOCK) || (mode & CRYPTO_UNLOCK));

assert((mode & CRYPTO_READ) || (mode & CRYPTO_WRITE));

if (mode & CRYPTO_LOCK) {

if (mode & CRYPTO_READ)

uv_rwlock_rdlock(locks + n);

else

uv_rwlock_wrlock(locks + n);

} else {

if (mode & CRYPTO_READ)

uv_rwlock_rdunlock(locks + n);

else

uv_rwlock_wrunlock(locks + n);

}

}

static int CryptoPemCallback(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;

}

void ThrowCryptoErrorHelper(Environment* env,

unsigned long err,

bool is_type_error) {

HandleScope scope(env->isolate());

char errmsg[128];

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

if (is_type_error)

env->ThrowTypeError(errmsg);

else

env->ThrowError(errmsg);

}

void ThrowCryptoError(Environment* env, unsigned long err) {

ThrowCryptoErrorHelper(env, err, false);

}

void ThrowCryptoTypeError(Environment* env, unsigned long err) {

ThrowCryptoErrorHelper(env, err, true);

}

// 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, Handle<Object> target) {

Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(),

SecureContext::New);

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

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

NODE_SET_PROTOTYPE_METHOD(t, "init", SecureContext::Init);

NODE_SET_PROTOTYPE_METHOD(t, "setKey", SecureContext::SetKey);

NODE_SET_PROTOTYPE_METHOD(t, "setCert", SecureContext::SetCert);

NODE_SET_PROTOTYPE_METHOD(t, "addCACert", SecureContext::AddCACert);

NODE_SET_PROTOTYPE_METHOD(t, "addCRL", SecureContext::AddCRL);

NODE_SET_PROTOTYPE_METHOD(t, "addRootCerts", SecureContext::AddRootCerts);

NODE_SET_PROTOTYPE_METHOD(t, "setCiphers", SecureContext::SetCiphers);

NODE_SET_PROTOTYPE_METHOD(t, "setECDHCurve", SecureContext::SetECDHCurve);

NODE_SET_PROTOTYPE_METHOD(t, "setOptions", SecureContext::SetOptions);

NODE_SET_PROTOTYPE_METHOD(t, "setSessionIdContext",

SecureContext::SetSessionIdContext);

NODE_SET_PROTOTYPE_METHOD(t, "setSessionTimeout",

SecureContext::SetSessionTimeout);

NODE_SET_PROTOTYPE_METHOD(t, "close", SecureContext::Close);

NODE_SET_PROTOTYPE_METHOD(t, "loadPKCS12", SecureContext::LoadPKCS12);

NODE_SET_PROTOTYPE_METHOD(t, "getTicketKeys", SecureContext::GetTicketKeys);

NODE_SET_PROTOTYPE_METHOD(t, "setTicketKeys", SecureContext::SetTicketKeys);

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"),

t->GetFunction());

env->set_secure_context_constructor_template(t);

}

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

HandleScope handle_scope(args.GetIsolate());

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

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

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

Environment* env = sc->env();

OPENSSL_CONST SSL_METHOD *method = SSLv23_method();

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

const String::Utf8Value sslmethod(args[0]);

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

#ifndef OPENSSL_NO_SSL2

method = SSLv2_method();

#else

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

#endif

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

#ifndef OPENSSL_NO_SSL2

method = SSLv2_server_method();

#else

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

#endif

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

#ifndef OPENSSL_NO_SSL2

method = SSLv2_client_method();

#else

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

#endif

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

method = SSLv3_method();

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

method = SSLv3_server_method();

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

method = SSLv3_client_method();

} 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 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);

sc->ca_store_ = NULL;

}

// 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, Handle<Value> v) {

BIO* bio = NodeBIO::New();

if (!bio)

return NULL;

HandleScope scope(env->isolate());

int r = -1;

if (v->IsString()) {

const String::Utf8Value s(v);

r = BIO_write(bio, *s, s.length());

} else if (Buffer::HasInstance(v)) {

char* buffer_data = Buffer::Data(v);

size_t buffer_length = Buffer::Length(v);

r = BIO_write(bio, buffer_data, buffer_length);

}

if (r <= 0) {

BIO_free_all(bio);

return NULL;

}

return bio;

}

// Takes a string or buffer and loads it into an X509

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

static X509* LoadX509(Environment* env, Handle<Value> v) {

HandleScope scope(env->isolate());

BIO *bio = LoadBIO(env, v);

if (!bio)

return NULL;

X509 * x509 = PEM_read_bio_X509(bio, NULL, CryptoPemCallback, NULL);

if (!x509) {

BIO_free_all(bio);

return NULL;

}

BIO_free_all(bio);

return x509;

}

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

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

HandleScope scope(env->isolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

unsigned int len = args.Length();

if (len != 1 && len != 2) {

return env->ThrowTypeError("Bad parameter");

}

if (len == 2 && !args[1]->IsString()) {

return env->ThrowTypeError("Bad parameter");

}

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

if (!bio)

return;

String::Utf8Value passphrase(args[1]);

EVP_PKEY* key = PEM_read_bio_PrivateKey(bio,

NULL,

CryptoPemCallback,

len == 1 ? NULL : *passphrase);

if (!key) {

BIO_free_all(bio);

unsigned long err = ERR_get_error();

if (!err) {

return env->ThrowError("PEM_read_bio_PrivateKey");

}

return ThrowCryptoError(env, err);

}

SSL_CTX_use_PrivateKey(sc->ctx_, key);

EVP_PKEY_free(key);

BIO_free_all(bio);

}

// 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 - editted for style.

int SSL_CTX_use_certificate_chain(SSL_CTX *ctx, BIO *in) {

int ret = 0;

X509 *x = NULL;

x = PEM_read_bio_X509_AUX(in, NULL, CryptoPemCallback, NULL);

if (x == NULL) {

SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);

goto end;

}

ret = SSL_CTX_use_certificate(ctx, x);

if (ERR_peek_error() != 0) {

// Key/certificate mismatch doesn't imply ret==0 ...

ret = 0;

}

if (ret) {

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

// the CA certificates.

X509 *ca;

int r;

unsigned long err;

if (ctx->extra_certs != NULL) {

sk_X509_pop_free(ctx->extra_certs, X509_free);

ctx->extra_certs = NULL;

}

while ((ca = PEM_read_bio_X509(in, NULL, CryptoPemCallback, NULL))) {

r = SSL_CTX_add_extra_chain_cert(ctx, ca);

if (!r) {

X509_free(ca);

ret = 0;

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

}

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

ret = 0;

}

}

end:

if (x != NULL)

X509_free(x);

return ret;

}

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

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

HandleScope scope(env->isolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

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

return env->ThrowTypeError("Bad parameter");

}

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

if (!bio)

return;

int rv = SSL_CTX_use_certificate_chain(sc->ctx_, bio);

BIO_free_all(bio);

if (!rv) {

unsigned long err = ERR_get_error();

if (!err) {

return env->ThrowError("SSL_CTX_use_certificate_chain");

}

return ThrowCryptoError(env, err);

}

}

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

bool newCAStore = false;

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

HandleScope scope(env->isolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

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

return env->ThrowTypeError("Bad parameter");

}

if (!sc->ca_store_) {

sc->ca_store_ = X509_STORE_new();

newCAStore = true;

}

X509* x509 = LoadX509(env, args[0]);

if (!x509)

return;

X509_STORE_add_cert(sc->ca_store_, x509);

SSL_CTX_add_client_CA(sc->ctx_, x509);

X509_free(x509);

if (newCAStore) {

SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);

}

}

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

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

HandleScope scope(env->isolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

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

return env->ThrowTypeError("Bad parameter");

}

ClearErrorOnReturn clear_error_on_return;

(void) &clear_error_on_return; // Silence compiler warning.

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

if (!bio)

return;

X509_CRL *x509 = PEM_read_bio_X509_CRL(bio, NULL, CryptoPemCallback, NULL);

if (x509 == NULL) {

BIO_free_all(bio);

return;

}

X509_STORE_add_crl(sc->ca_store_, x509);

X509_STORE_set_flags(sc->ca_store_, X509_V_FLAG_CRL_CHECK |

X509_V_FLAG_CRL_CHECK_ALL);

BIO_free_all(bio);

X509_CRL_free(x509);

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

assert(sc->ca_store_ == NULL);

if (!root_cert_store) {

root_cert_store = X509_STORE_new();

for (int i = 0; root_certs[i]; i++) {

BIO* bp = NodeBIO::New();

if (!BIO_write(bp, root_certs[i], strlen(root_certs[i]))) {

BIO_free_all(bp);

return;

}

X509 *x509 = PEM_read_bio_X509(bp, NULL, CryptoPemCallback, NULL);

if (x509 == NULL) {

BIO_free_all(bp);

return;

}

X509_STORE_add_cert(root_cert_store, x509);

BIO_free_all(bp);

X509_free(x509);

}

}

sc->ca_store_ = root_cert_store;

SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

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

return sc->env()->ThrowTypeError("Bad parameter");

}

const String::Utf8Value ciphers(args[0]);

SSL_CTX_set_cipher_list(sc->ctx_, *ciphers);

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

Environment* env = sc->env();

if (args.Length() != 1 || !args[0]->IsString())

return env->ThrowTypeError("First argument should be a string");

String::Utf8Value curve(args[0]);

int nid = OBJ_sn2nid(*curve);

if (nid == NID_undef)

return env->ThrowTypeError("First argument should be a valid curve name");

EC_KEY* ecdh = EC_KEY_new_by_curve_name(nid);

if (ecdh == NULL)

return env->ThrowTypeError("First argument should be a valid curve name");

SSL_CTX_set_options(sc->ctx_, SSL_OP_SINGLE_ECDH_USE);

SSL_CTX_set_tmp_ecdh(sc->ctx_, ecdh);

EC_KEY_free(ecdh);

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

if (args.Length() != 1 || !args[0]->IntegerValue()) {

return sc->env()->ThrowTypeError("Bad parameter");

}

SSL_CTX_set_options(sc->ctx_, args[0]->IntegerValue());

}

void SecureContext::SetSessionIdContext(

const FunctionCallbackInfo<Value>& args) {

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

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

return sc->env()->ThrowTypeError("Bad parameter");

}

const String::Utf8Value sessionIdContext(args[0]);

const unsigned char* sid_ctx =

reinterpret_cast<const unsigned char*>(*sessionIdContext);

unsigned int sid_ctx_len = sessionIdContext.length();

int r = SSL_CTX_set_session_id_context(sc->ctx_, sid_ctx, sid_ctx_len);

if (r == 1)

return;

BIO* bio;

BUF_MEM* mem;

Local<String> message;

bio = BIO_new(BIO_s_mem());

if (bio == NULL) {

message = FIXED_ONE_BYTE_STRING(args.GetIsolate(),

"SSL_CTX_set_session_id_context error");

} else {

ERR_print_errors(bio);

BIO_get_mem_ptr(bio, &mem);

message = OneByteString(args.GetIsolate(), mem->data, mem->length);

BIO_free_all(bio);

}

args.GetIsolate()->ThrowException(Exception::TypeError(message));

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

if (args.Length() != 1 || !args[0]->IsInt32()) {

return sc->env()->ThrowTypeError("Bad parameter");

}

int32_t sessionTimeout = args[0]->Int32Value();

SSL_CTX_set_timeout(sc->ctx_, sessionTimeout);

}

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

HandleScope scope(args.GetIsolate());

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

sc->FreeCTXMem();

}

// Takes .pfx or .p12 and password in string or buffer format

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

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

HandleScope scope(env->isolate());

BIO* in = NULL;

PKCS12* p12 = NULL;

EVP_PKEY* pkey = NULL;

X509* cert = NULL;

STACK_OF(X509)* extraCerts = NULL;

char* pass = NULL;

bool ret = false;

SecureContext* sc = Unwrap<SecureContext>(args.Holder());

if (args.Length() < 1) {

return env->ThrowTypeError("Bad parameter");

}

in = LoadBIO(env, args[0]);

if (in == NULL) {

return env->ThrowError("Unable to load BIO");

}

if (args.Length() >= 2) {

ASSERT_IS_BUFFER(args[1]);

size_t passlen = Buffer::Length(args[1]);

pass = new char[passlen + 1];

memcpy(pass, Buffer::Data(args[1]), passlen);

pass[passlen] = '\0';

}

if (d2i_PKCS12_bio(in, &p12) &&

PKCS12_parse(p12, pass, &pkey, &cert, &extraCerts) &&

SSL_CTX_use_certificate(sc->ctx_, cert) &&

SSL_CTX_use_PrivateKey(sc->ctx_, pkey)) {

// set extra certs

while (X509* x509 = sk_X509_pop(extraCerts)) {

if (!sc->ca_store_) {

sc->ca_store_ = X509_STORE_new();

SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);

}

X509_STORE_add_cert(sc->ca_store_, x509);

SSL_CTX_add_client_CA(sc->ctx_, x509);

X509_free(x509);

}

EVP_PKEY_free(pkey);

X509_free(cert);

sk_X509_free(extraCerts);

ret = true;

}

PKCS12_free(p12);

BIO_free_all(in);

delete[] pass;

if (!ret) {

unsigned long err = ERR_get_error();

const char* str = ERR_reason_error_string(err);

return env->ThrowError(str);

}

}

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

#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_get_tlsext_ticket_keys)

HandleScope handle_scope(args.GetIsolate());

SecureContext* wrap = Unwrap<SecureContext>(args.Holder());

Local<Object> buff = Buffer::New(wrap->env(), 48);

if (SSL_CTX_get_tlsext_ticket_keys(wrap->ctx_,

Buffer::Data(buff),

Buffer::Length(buff)) != 1) {

return wrap->env()->ThrowError("Failed to fetch tls ticket keys");

}

args.GetReturnValue().Set(buff);

#endif // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)

}

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

#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_get_tlsext_ticket_keys)

HandleScope scope(args.GetIsolate());

SecureContext* wrap = Unwrap<SecureContext>(args.Holder());

if (args.Length() < 1 ||

!Buffer::HasInstance(args[0]) ||

Buffer::Length(args[0]) != 48) {

return wrap->env()->ThrowTypeError("Bad argument");

}

if (SSL_CTX_set_tlsext_ticket_keys(wrap->ctx_,

Buffer::Data(args[0]),

Buffer::Length(args[0])) != 1) {

return wrap->env()->ThrowError("Failed to fetch tls ticket keys");

}

args.GetReturnValue().Set(true);

#endif // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)

}

template <class Base>

void SSLWrap<Base>::AddMethods(Environment* env, Handle<FunctionTemplate> t) {

HandleScope scope(env->isolate());

NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", GetPeerCertificate);

NODE_SET_PROTOTYPE_METHOD(t, "getSession", GetSession);

NODE_SET_PROTOTYPE_METHOD(t, "setSession", SetSession);

NODE_SET_PROTOTYPE_METHOD(t, "loadSession", LoadSession);

NODE_SET_PROTOTYPE_METHOD(t, "isSessionReused", IsSessionReused);

NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished", IsInitFinished);

NODE_SET_PROTOTYPE_METHOD(t, "verifyError", VerifyError);

NODE_SET_PROTOTYPE_METHOD(t, "getCurrentCipher", GetCurrentCipher);

NODE_SET_PROTOTYPE_METHOD(t, "endParser", EndParser);

NODE_SET_PROTOTYPE_METHOD(t, "renegotiate", Renegotiate);

NODE_SET_PROTOTYPE_METHOD(t, "shutdown", Shutdown);

NODE_SET_PROTOTYPE_METHOD(t, "getTLSTicket", GetTLSTicket);

NODE_SET_PROTOTYPE_METHOD(t, "newSessionDone", NewSessionDone);

#ifdef SSL_set_max_send_fragment

NODE_SET_PROTOTYPE_METHOD(t, "setMaxSendFragment", SetMaxSendFragment);

#endif // SSL_set_max_send_fragment

#ifdef OPENSSL_NPN_NEGOTIATED

NODE_SET_PROTOTYPE_METHOD(t, "getNegotiatedProtocol", GetNegotiatedProto);

NODE_SET_PROTOTYPE_METHOD(t, "setNPNProtocols", SetNPNProtocols);

#endif // OPENSSL_NPN_NEGOTIATED

}

template <class Base>

void SSLWrap<Base>::InitNPN(SecureContext* sc, Base* base) {

if (base->is_server()) {

#ifdef OPENSSL_NPN_NEGOTIATED

// Server should advertise NPN protocols

SSL_CTX_set_next_protos_advertised_cb(sc->ctx_,

AdvertiseNextProtoCallback,

base);

#endif // OPENSSL_NPN_NEGOTIATED

} else {

#ifdef OPENSSL_NPN_NEGOTIATED

// Client should select protocol from list of advertised

// If server supports NPN

SSL_CTX_set_next_proto_select_cb(sc->ctx_, SelectNextProtoCallback, base);

#endif // OPENSSL_NPN_NEGOTIATED

}

}

template <class Base>

SSL_SESSION* SSLWrap<Base>::GetSessionCallback(SSL* s,

unsigned char* key,

int len,

int* copy) {

Base* w = static_cast<Base*>(SSL_get_app_data(s));

*copy = 0;

SSL_SESSION* sess = w->next_sess_;

w->next_sess_ = NULL;

return sess;

}

template <class Base>

int SSLWrap<Base>::NewSessionCallback(SSL* s, SSL_SESSION* sess) {

Base* w = static_cast<Base*>(SSL_get_app_data(s));

Environment* env = w->ssl_env();

HandleScope handle_scope(env->isolate());

Context::Scope context_scope(env->context());

if (!w->session_callbacks_)

return 0;

// Check if session is small enough to be stored

int size = i2d_SSL_SESSION(sess, NULL);

if (size > SecureContext::kMaxSessionSize)

return 0;

// Serialize session

Local<Object> buff = Buffer::New(env, size);

unsigned char* serialized = reinterpret_cast<unsigned char*>(

Buffer::Data(buff));

memset(serialized, 0, size);

i2d_SSL_SESSION(sess, &serialized);

Local<Object> session = Buffer::New(env,

reinterpret_cast<char*>(sess->session_id),

sess->session_id_length);

Local<Value> argv[] = { session, buff };

w->new_session_wait_ = true;

w->MakeCallback(env->onnewsession_string(), ARRAY_SIZE(argv), argv);

return 0;

}

template <class Base>

void SSLWrap<Base>::OnClientHello(void* arg,

const ClientHelloParser::ClientHello& hello) {

Base* w = static_cast<Base*>(arg);

Environment* env = w->ssl_env();

HandleScope handle_scope(env->isolate());

Context::Scope context_scope(env->context());

Local<Object> hello_obj = Object::New(env->isolate());

Local<Object> buff = Buffer::New(

env,

reinterpret_cast<const char*>(hello.session_id()),

hello.session_size());

hello_obj->Set(env->session_id_string(), buff);

if (hello.servername() == NULL) {

hello_obj->Set(env->servername_string(), String::Empty(env->isolate()));

} else {

Local<String> servername = OneByteString(env->isolate(),

hello.servername(),

hello.servername_size());

hello_obj->Set(env->servername_string(), servername);