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

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

}

HandleScope scope(node_isolate);

char errmsg[128];

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

return is_type_error ? ThrowTypeError(errmsg) : ThrowError(errmsg);

HandleScope scope(node_isolate);

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

secure_context_constructor = Persistent<FunctionTemplate>::New(node_isolate,

t);

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

t->SetClassName(String::NewSymbol("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, "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);

target->Set(String::NewSymbol("SecureContext"), t->GetFunction());

HandleScope scope(node_isolate);

SecureContext *p = new SecureContext();

p->Wrap(args.Holder());

return args.This();

HandleScope scope(node_isolate);

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

OPENSSL_CONST SSL_METHOD *method = SSLv23_method();

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

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

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

#ifndef OPENSSL_NO_SSL2

method = SSLv2_method();

#else

return ThrowException(Exception::Error(String::New("SSLv2 methods disabled")));

#endif

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

#ifndef OPENSSL_NO_SSL2

method = SSLv2_server_method();

#else

return ThrowException(Exception::Error(String::New("SSLv2 methods disabled")));

#endif

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

#ifndef OPENSSL_NO_SSL2

method = SSLv2_client_method();

#else

return ThrowException(Exception::Error(String::New("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 {

return ThrowException(Exception::Error(String::New("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_, GetSessionCallback);

SSL_CTX_sess_set_new_cb(sc->ctx_, NewSessionCallback);

sc->ca_store_ = NULL;

return True(node_isolate);

HandleScope scope(node_isolate);

Connection* p = static_cast<Connection*>(SSL_get_app_data(s));

// Check if session is small enough to be stored

int size = i2d_SSL_SESSION(sess, NULL);

if (size > kMaxSessionSize) return 0;

// Serialize session

char* serialized = new char[size];

unsigned char* pserialized = reinterpret_cast<unsigned char*>(serialized);

memset(serialized, 0, size);

i2d_SSL_SESSION(sess, &pserialized);

Handle<Value> argv[2] = {

Buffer::New(reinterpret_cast<char*>(sess->session_id),

sess->session_id_length)->handle_,

Buffer::New(serialized, size, SessionDataFree, NULL)->handle_

};

if (onnewsession_sym.IsEmpty()) {

onnewsession_sym = NODE_PSYMBOL("onnewsession");

}

MakeCallback(p->handle_, onnewsession_sym, ARRAY_SIZE(argv), argv);

return 0;

HandleScope scope(node_isolate);

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

unsigned int len = args.Length();

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

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

if (!bio) return False(node_isolate);

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

EVP_PKEY* key = PEM_read_bio_PrivateKey(bio, NULL, NULL,

len == 1 ? NULL : *passphrase);

if (!key) {

BIO_free_all(bio);

unsigned long err = ERR_get_error();

if (!err) {

return ThrowException(Exception::Error(

String::New("PEM_read_bio_PrivateKey")));

}

return ThrowCryptoError(err);

}

SSL_CTX_use_PrivateKey(sc->ctx_, key);

EVP_PKEY_free(key);

BIO_free_all(bio);

return True(node_isolate);

int ret = 0;

X509 *x = NULL;

x = PEM_read_bio_X509_AUX(in, NULL, NULL, 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, NULL, 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;

HandleScope scope(node_isolate);

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

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

return ThrowException(Exception::TypeError(

String::New("Bad parameter")));

}

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

if (!bio) return False(node_isolate);

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 ThrowException(Exception::Error(

String::New("SSL_CTX_use_certificate_chain")));

}

return ThrowCryptoError(err);

}

return True(node_isolate);

bool newCAStore = false;

HandleScope scope(node_isolate);

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

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

if (!sc->ca_store_) {

sc->ca_store_ = X509_STORE_new();

newCAStore = true;

}

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

if (!x509) return False(node_isolate);

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

}

return True(node_isolate);

HandleScope scope(node_isolate);

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

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

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

if (!bio) return False(node_isolate);

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

if (x509 == NULL) {

BIO_free_all(bio);

return False(node_isolate);

}

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

return True(node_isolate);

HandleScope scope(node_isolate);

SecureContext *sc = ObjectWrap::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 = BIO_new(NodeBIO::GetMethod());

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

BIO_free_all(bp);

return False(node_isolate);

}

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

if (x509 == NULL) {

BIO_free_all(bp);

return False(node_isolate);

}

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

return True(node_isolate);

HandleScope scope(node_isolate);

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

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

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

SSL_CTX_set_cipher_list(sc->ctx_, *ciphers);

return True(node_isolate);

HandleScope scope(node_isolate);

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

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

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

return True(node_isolate);

HandleScope scope(node_isolate);

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

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

return ThrowException(Exception::TypeError(String::New("Bad parameter")));

}

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

const unsigned char* sid_ctx = (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) {

Local<String> message;

BIO* bio;

BUF_MEM* mem;

if ((bio = BIO_new(BIO_s_mem()))) {

ERR_print_errors(bio);

BIO_get_mem_ptr(bio, &mem);

message = String::New(mem->data, mem->length);

BIO_free_all(bio);

} else {

message = String::New("SSL_CTX_set_session_id_context error");

}

return ThrowException(Exception::TypeError(message));

}

return True(node_isolate);

HandleScope scope;

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

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

return ThrowTypeError("Bad parameter");

}

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

SSL_CTX_set_timeout(sc->ctx_, sessionTimeout);

return True();

HandleScope scope(node_isolate);

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

sc->FreeCTXMem();

return False(node_isolate);

HandleScope scope(node_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 = ObjectWrap::Unwrap<SecureContext>(args.Holder());

if (args.Length() < 1) {

return ThrowException(Exception::TypeError(

String::New("Bad parameter")));

}

in = LoadBIO(args[0]);

if (in == NULL) {

return ThrowException(Exception::Error(

String::New("Unable to load BIO")));

}

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

ASSERT_IS_BUFFER(args[1]);

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

if (passlen < 0) {

BIO_free_all(in);

return ThrowException(Exception::TypeError(

String::New("Bad password")));

}

pass = new char[passlen + 1];

int pass_written = DecodeWrite(pass, passlen, args[1], BINARY);

assert(pass_written == 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);

}

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 ThrowException(Exception::Error(String::New(str)));

}

return True(node_isolate);

HandleScope scope(node_isolate);

// Just accumulate data, everything will be pushed to BIO later

if (state_ == kPaused) return 0;

// Copy incoming data to the internal buffer

// (which has a size of the biggest possible TLS frame)

size_t available = sizeof(data_) - offset_;

size_t copied = len < available ? len : available;

memcpy(data_ + offset_, data, copied);

offset_ += copied;

// Vars for parsing hello

bool is_clienthello = false;

uint8_t session_size = -1;

uint8_t* session_id = NULL;

Local<Object> hello;

Handle<Value> argv[1];

switch (state_) {

case kWaiting:

// >= 5 bytes for header parsing

if (offset_ < 5) break;

if (data_[0] == kChangeCipherSpec || data_[0] == kAlert ||

data_[0] == kHandshake || data_[0] == kApplicationData) {

frame_len_ = (data_[3] << 8) + data_[4];

state_ = kTLSHeader;

body_offset_ = 5;

} else {

frame_len_ = (data_[0] << 8) + data_[1];

state_ = kSSLHeader;

if (*data_ & 0x40) {

// header with padding

body_offset_ = 3;

} else {

// without padding

body_offset_ = 2;

}

}

// Sanity check (too big frame, or too small)

if (frame_len_ >= sizeof(data_)) {

// Let OpenSSL handle it

Finish();

return copied;

}

case kTLSHeader:

case kSSLHeader:

// >= 5 + frame size bytes for frame parsing

if (offset_ < body_offset_ + frame_len_) break;

// Skip unsupported frames and gather some data from frame

// TODO: Check protocol version

if (data_[body_offset_] == kClientHello) {

is_clienthello = true;

uint8_t* body;

size_t session_offset;

if (state_ == kTLSHeader) {

// Skip frame header, hello header, protocol version and random data

session_offset = body_offset_ + 4 + 2 + 32;

if (session_offset + 1 < offset_) {

body = data_ + session_offset;

session_size = *body;

session_id = body + 1;

}

} else if (state_ == kSSLHeader) {

// Skip header, version

session_offset = body_offset_ + 3;

if (session_offset + 4 < offset_) {

body = data_ + session_offset;

int ciphers_size = (body[0] << 8) + body[1];

if (body + 4 + ciphers_size < data_ + offset_) {

session_size = (body[2] << 8) + body[3];

session_id = body + 4 + ciphers_size;

}

}

} else {

// Whoa? How did we get here?

abort();

}

// Check if we overflowed (do not reply with any private data)

if (session_id == NULL ||

session_size > 32 ||

session_id + session_size > data_ + offset_) {

Finish();

return copied;

}

// TODO: Parse other things?

}

// Not client hello - let OpenSSL handle it

if (!is_clienthello) {

Finish();

return copied;

}

// Parse frame, call javascript handler and

// move parser into the paused state

if (onclienthello_sym.IsEmpty()) {

onclienthello_sym = NODE_PSYMBOL("onclienthello");

}

if (sessionid_sym.IsEmpty()) {

sessionid_sym = NODE_PSYMBOL("sessionId");

}

state_ = kPaused;

hello = Object::New();

hello->Set(sessionid_sym,

Buffer::New(reinterpret_cast<char*>(session_id),

session_size)->handle_);

argv[0] = hello;

MakeCallback(conn_->handle_, onclienthello_sym, 1, argv);

break;

case kEnded:

default:

break;

}

return copied;

assert(state_ != kEnded);

state_ = kEnded;

// Write all accumulated data

int r = BIO_write(conn_->bio_read_, reinterpret_cast<char*>(data_), offset_);

conn_->HandleBIOError(conn_->bio_read_, "BIO_write", r);

conn_->SetShutdownFlags();

if (rv >= 0) return rv;

int retry = BIO_should_retry(bio);

(void) retry; // unused if !defined(SSL_PRINT_DEBUG)

if (BIO_should_write(bio)) {

DEBUG_PRINT("[%p] BIO: %s want write. should retry %d\n", ssl_, func, retry);

return 0;

} else if (BIO_should_read(bio)) {

DEBUG_PRINT("[%p] BIO: %s want read. should retry %d\n", ssl_, func, retry);

return 0;

} else {

static char ssl_error_buf[512];

ERR_error_string_n(rv, ssl_error_buf, sizeof(ssl_error_buf));

HandleScope scope(node_isolate);

Local<Value> e = Exception::Error(String::New(ssl_error_buf));

handle_->Set(String::New("error"), e);

DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n", ssl_, func, rv, ssl_error_buf);

return rv;

}

return 0;

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

// from popping up later in the lifecycle of the SSL connection 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(); }

};

ClearErrorOnReturn clear_error_on_return;

(void) &clear_error_on_return; // Silence unused variable warning.

if (rv > 0) return rv;

if ((rv == 0) && (zs == kZeroIsNotAnError)) return rv;

int err = SSL_get_error(ssl_, rv);

if (err == SSL_ERROR_NONE) {

return 0;

} else if (err == SSL_ERROR_WANT_WRITE) {

DEBUG_PRINT("[%p] SSL: %s want write\n", ssl_, func);

return 0;

} else if (err == SSL_ERROR_WANT_READ) {

DEBUG_PRINT("[%p] SSL: %s want read\n", ssl_, func);

return 0;

} else if (err == SSL_ERROR_ZERO_RETURN) {

handle_->Set(String::New("error"),

Exception::Error(String::New("ZERO_RETURN")));

return rv;

} else {

HandleScope scope(node_isolate);

BUF_MEM* mem;

BIO *bio;

assert(err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL);

// XXX We need to drain the error queue for this thread or else OpenSSL

// has the possibility of blocking connections? This problem is not well

// understood. And we should be somehow propagating these errors up

// into JavaScript. There is no test which demonstrates this problem.

// https://github.com/joyent/node/issues/1719

if ((bio = BIO_new(BIO_s_mem()))) {

ERR_print_errors(bio);

BIO_get_mem_ptr(bio, &mem);

Local<Value> e = Exception::Error(String::New(mem->data, mem->length));

handle_->Set(String::New("error"), e);

BIO_free_all(bio);

}

return rv;

}

return 0;

#ifndef NDEBUG

HandleScope scope(node_isolate);

// We should clear the error in JS-land

assert(handle_->Get(String::New("error"))->BooleanValue() == false);

#endif // NDEBUG

HandleScope scope(node_isolate);

int flags = SSL_get_shutdown(ssl_);

if (flags & SSL_SENT_SHUTDOWN) {

handle_->Set(String::New("sentShutdown"), True(node_isolate));

}

if (flags & SSL_RECEIVED_SHUTDOWN) {