HandleScope scope;

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

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, "addRootCerts", SecureContext::AddRootCerts);

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

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

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

HandleScope scope;

SecureContext *p = new SecureContext();

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

return args.This();

HandleScope scope;

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

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

method = SSLv2_method();

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

method = SSLv2_server_method();

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

method = SSLv2_client_method();

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

// Enable session caching?

SSL_CTX_set_session_cache_mode(sc->ctx_, SSL_SESS_CACHE_SERVER);

// SSL_CTX_set_session_cache_mode(sc->ctx_,SSL_SESS_CACHE_OFF);

sc->ca_store_ = X509_STORE_new();

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

return True();

HandleScope scope;

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

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

if (!key) {

BIO_free(bio);

return False();

}

SSL_CTX_use_PrivateKey(sc->ctx_, key);

EVP_PKEY_free(key);

BIO_free(bio);

return True();

HandleScope scope;

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

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

return ThrowException(Exception::TypeError(

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

}

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

if (!x509) return False();

SSL_CTX_use_certificate(sc->ctx_, x509);

X509_free(x509);

return True();

HandleScope scope;

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

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

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

}

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

if (!x509) return False();

X509_STORE_add_cert(sc->ca_store_, x509);

X509_free(x509);

return True();

HandleScope scope;

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

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

// TODO: reuse bp ?

BIO *bp = BIO_new(BIO_s_mem());

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

BIO_free(bp);

return False();

}

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

if (x509 == NULL) {

BIO_free(bp);

return False();

}

X509_STORE_add_cert(sc->ca_store_, x509);

BIO_free(bp);

X509_free(x509);

}

return True();

HandleScope scope;

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

SSL_CTX_set_cipher_list(sc->ctx_, *ciphers);

return True();

HandleScope scope;

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

if (sc->ctx_ != NULL) {

SSL_CTX_free(sc->ctx_);

sc->ctx_ = NULL;

sc->ca_store_ = NULL;

return True();

}

return False();

if (rv >= 0) {

return rv;

}

int err = SSL_get_error(ssl, rv);

if (err != SSL_ERROR_WANT_WRITE &&

err != SSL_ERROR_WANT_READ) {

ERR_error_string_n(ERR_get_error(), &ssl_error_buf[0], sizeof(ssl_error_buf));

/* fprintf(stderr, "[%p] SSL: %s failed: (%d:%d) %s\n", ssl, func, err, rv, buf); */

return rv;

} else if (err == SSL_ERROR_WANT_WRITE) {

/* fprintf(stderr, "[%p] SSL: %s want write\n", ssl, func); */

} else if (err == SSL_ERROR_WANT_READ) {

/* fprintf(stderr, "[%p] SSL: %s want read\n", ssl, func); */

}

return 0;

HandleScope scope;

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

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

t->SetClassName(String::NewSymbol("Connection"));

NODE_SET_PROTOTYPE_METHOD(t, "encIn", Connection::EncIn);

NODE_SET_PROTOTYPE_METHOD(t, "clearOut", Connection::ClearOut);

NODE_SET_PROTOTYPE_METHOD(t, "clearIn", Connection::ClearIn);

NODE_SET_PROTOTYPE_METHOD(t, "encOut", Connection::EncOut);

NODE_SET_PROTOTYPE_METHOD(t, "clearPending", Connection::ClearPending);

NODE_SET_PROTOTYPE_METHOD(t, "encPending", Connection::EncPending);

NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", Connection::GetPeerCertificate);

NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished", Connection::IsInitFinished);

NODE_SET_PROTOTYPE_METHOD(t, "verifyError", Connection::VerifyError);

NODE_SET_PROTOTYPE_METHOD(t, "getCurrentCipher", Connection::GetCurrentCipher);

NODE_SET_PROTOTYPE_METHOD(t, "start", Connection::Start);

NODE_SET_PROTOTYPE_METHOD(t, "shutdown", Connection::Shutdown);

NODE_SET_PROTOTYPE_METHOD(t, "receivedShutdown", Connection::ReceivedShutdown);

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

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

// Quoting SSL_set_verify(3ssl):

//

// The VerifyCallback function is used to control the behaviour when

// the SSL_VERIFY_PEER flag is set. It must be supplied by the

// application and receives two arguments: preverify_ok indicates,

// whether the verification of the certificate in question was passed

// (preverify_ok=1) or not (preverify_ok=0). x509_ctx is a pointer to

// the complete context used for the certificate chain verification.

//

// The certificate chain is checked starting with the deepest nesting

// level (the root CA certificate) and worked upward to the peer's

// certificate. At each level signatures and issuer attributes are

// checked. Whenever a verification error is found, the error number is

// stored in x509_ctx and VerifyCallback is called with preverify_ok=0.

// By applying X509_CTX_store_* functions VerifyCallback can locate the

// certificate in question and perform additional steps (see EXAMPLES).

// If no error is found for a certificate, VerifyCallback is called

// with preverify_ok=1 before advancing to the next level.

//

// The return value of VerifyCallback controls the strategy of the

// further verification process. If VerifyCallback returns 0, the

// verification process is immediately stopped with "verification

// failed" state. If SSL_VERIFY_PEER is set, a verification failure

// alert is sent to the peer and the TLS/SSL handshake is terminated. If

// VerifyCallback returns 1, the verification process is continued. If

// VerifyCallback always returns 1, the TLS/SSL handshake will not be

// terminated with respect to verification failures and the connection

// will be established. The calling process can however retrieve the

// error code of the last verification error using

// SSL_get_verify_result(3) or by maintaining its own error storage

// managed by VerifyCallback.

//

// If no VerifyCallback is specified, the default callback will be

// used. Its return value is identical to preverify_ok, so that any

// verification failure will lead to a termination of the TLS/SSL

// handshake with an alert message, if SSL_VERIFY_PEER is set.

//

// Since we cannot perform I/O quickly enough in this callback, we ignore

// all preverify_ok errors and let the handshake continue. It is

// imparative that the user use Connection::VerifyError after the

// 'secure' callback has been made.

return 1;

HandleScope scope;

Connection *p = new Connection();

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

if (args.Length() < 1 || !args[0]->IsObject()) {

return ThrowException(Exception::Error(String::New(

"First argument must be a crypto module Credentials")));

}

SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args[0]->ToObject());

bool is_server = args[1]->BooleanValue();

p->ssl_ = SSL_new(sc->ctx_);

p->bio_read_ = BIO_new(BIO_s_mem());

p->bio_write_ = BIO_new(BIO_s_mem());

SSL_set_bio(p->ssl_, p->bio_read_, p->bio_write_);

#ifdef SSL_MODE_RELEASE_BUFFERS

long mode = SSL_get_mode(p->ssl_);

SSL_set_mode(p->ssl_, mode | SSL_MODE_RELEASE_BUFFERS);

#endif

int verify_mode;

if (is_server) {

bool request_cert = args[2]->BooleanValue();

if (!request_cert) {

// Note reject_unauthorized ignored.

verify_mode = SSL_VERIFY_NONE;

} else {

bool reject_unauthorized = args[3]->BooleanValue();

verify_mode = SSL_VERIFY_PEER;

if (reject_unauthorized) verify_mode |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;

}

} else {

// Note request_cert and reject_unauthorized are ignored for clients.

verify_mode = SSL_VERIFY_NONE;

}

// Always allow a connection. We'll reject in javascript.

SSL_set_verify(p->ssl_, verify_mode, VerifyCallback);

if ((p->is_server_ = is_server)) {

SSL_set_accept_state(p->ssl_);

} else {

SSL_set_connect_state(p->ssl_);

}

return args.This();

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (args.Length() < 3) {

return ThrowException(Exception::TypeError(

String::New("Takes 3 parameters")));

}

if (!Buffer::HasInstance(args[0])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[0]->ToObject();

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

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[1]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[2]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

int bytes_written = serr(ss->ssl_, "BIO_write", BIO_write(ss->bio_read_, (char*)buffer_data + off, len));

if (bytes_written < 0) {

if (errno == EAGAIN || errno == EINTR) return Null();

return ThrowException(ErrnoException(errno, "read"));

}

return scope.Close(Integer::New(bytes_written));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (args.Length() < 3) {

return ThrowException(Exception::TypeError(

String::New("Takes 3 parameters")));

}

if (!Buffer::HasInstance(args[0])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[0]->ToObject();

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

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[1]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[2]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

int bytes_read;

if (!SSL_is_init_finished(ss->ssl_)) {

if (ss->is_server_) {

bytes_read = serr(ss->ssl_, "SSL_accept:ClearOut", SSL_accept(ss->ssl_));

} else {

bytes_read = serr(ss->ssl_, "SSL_connect:ClearOut", SSL_connect(ss->ssl_));

}

if (bytes_read < 0) {

return ThrowException(Exception::Error(v8::String::New(ssl_error_buf)));

}

return scope.Close(Integer::New(0));

}

bytes_read = serr(ss->ssl_, "SSL_read:ClearOut", SSL_read(ss->ssl_, (char*)buffer_data + off, len));

if (bytes_read < 0) {

return ThrowException(Exception::Error(v8::String::New(ssl_error_buf)));

}

return scope.Close(Integer::New(bytes_read));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

int bytes_pending = BIO_pending(ss->bio_read_);

return scope.Close(Integer::New(bytes_pending));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

int bytes_pending = BIO_pending(ss->bio_write_);

return scope.Close(Integer::New(bytes_pending));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (args.Length() < 3) {

return ThrowException(Exception::TypeError(

String::New("Takes 3 parameters")));

}

if (!Buffer::HasInstance(args[0])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[0]->ToObject();

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

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[1]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[2]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

int bytes_read = serr(ss->ssl_, "BIO_read:EncOut", BIO_read(ss->bio_write_, (char*)buffer_data + off, len));

return scope.Close(Integer::New(bytes_read));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (args.Length() < 3) {

return ThrowException(Exception::TypeError(

String::New("Takes 3 parameters")));

}

if (!Buffer::HasInstance(args[0])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[0]->ToObject();

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

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[1]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[2]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

if (!SSL_is_init_finished(ss->ssl_)) {

int s;

if (ss->is_server_) {

s = serr(ss->ssl_, "SSL_accept:ClearIn", SSL_accept(ss->ssl_));

} else {

s = serr(ss->ssl_, "SSL_connect:ClearIn", SSL_connect(ss->ssl_));

}

if (s < 0) {

return ThrowException(Exception::Error(v8::String::New(ssl_error_buf)));

}

return scope.Close(Integer::New(0));

}

int bytes_written = serr(ss->ssl_, "SSL_write:ClearIn", SSL_write(ss->ssl_, (char*)buffer_data + off, len));

if (bytes_written < 0) {

return ThrowException(Exception::Error(v8::String::New(ssl_error_buf)));

}

return scope.Close(Integer::New(bytes_written));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (ss->ssl_ == NULL) return Undefined();

Local<Object> info = Object::New();

X509* peer_cert = SSL_get_peer_certificate(ss->ssl_);

if (peer_cert != NULL) {

char* subject = X509_NAME_oneline(X509_get_subject_name(peer_cert), 0, 0);

if (subject != NULL) {

info->Set(subject_symbol, String::New(subject));

OPENSSL_free(subject);

}

char* issuer = X509_NAME_oneline(X509_get_issuer_name(peer_cert), 0, 0);

if (subject != NULL) {

info->Set(issuer_symbol, String::New(issuer));

OPENSSL_free(issuer);

}

char buf[256];

BIO* bio = BIO_new(BIO_s_mem());

ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));

memset(buf, 0, sizeof(buf));

BIO_read(bio, buf, sizeof(buf) - 1);

info->Set(valid_from_symbol, String::New(buf));

ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));

memset(buf, 0, sizeof(buf));

BIO_read(bio, buf, sizeof(buf) - 1);

BIO_free(bio);

info->Set(valid_to_symbol, String::New(buf));

unsigned int md_size, i;

unsigned char md[EVP_MAX_MD_SIZE];

if (X509_digest(peer_cert, EVP_sha1(), md, &md_size)) {

const char hex[] = "0123456789ABCDEF";

char fingerprint[EVP_MAX_MD_SIZE * 3];

for (i=0; i<md_size; i++) {

fingerprint[3*i] = hex[(md[i] & 0xf0) >> 4];

fingerprint[(3*i)+1] = hex[(md[i] & 0x0f)];

fingerprint[(3*i)+2] = ':';

}

if (md_size > 0) {

fingerprint[(3*(md_size-1))+2] = '\0';

}

else {

fingerprint[0] = '\0';

}

info->Set(fingerprint_symbol, String::New(fingerprint));

}

X509_free(peer_cert);

}

return scope.Close(info);

HandleScope scope;

int rv;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (!SSL_is_init_finished(ss->ssl_)) {

if (ss->is_server_) {

rv = serr(ss->ssl_, "SSL_accept:Start", SSL_accept(ss->ssl_));

} else {

rv = serr(ss->ssl_, "SSL_connect:Start", SSL_connect(ss->ssl_));

}

if (rv < 0) {

return ThrowException(Exception::Error(v8::String::New(ssl_error_buf)));

}

if (rv == 1) {

return True();

} else {

return False();

}

}

return True();

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (ss->ssl_ == NULL) return False();

int r = SSL_shutdown(ss->ssl_);

return scope.Close(Integer::New(r));

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (ss->ssl_ == NULL) return False();

int r = SSL_get_shutdown(ss->ssl_);

if (r | SSL_RECEIVED_SHUTDOWN) return True();

return False();

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (ss->ssl_ == NULL) return False();

return SSL_is_init_finished(ss->ssl_) ? True() : False();

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (ss->ssl_ == NULL) return Null();

// XXX Do this check in JS land?

X509* peer_cert = SSL_get_peer_certificate(ss->ssl_);

if (peer_cert == NULL) {

// We requested a certificate and they did not send us one.

// Definitely an error.

// XXX is this the right error message?

return scope.Close(String::New("UNABLE_TO_GET_ISSUER_CERT"));

}

X509_free(peer_cert);

long x509_verify_error = SSL_get_verify_result(ss->ssl_);

Local<String> s;

switch (x509_verify_error) {

case X509_V_OK:

return Null();

case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:

s = String::New("UNABLE_TO_GET_ISSUER_CERT");

break;

case X509_V_ERR_UNABLE_TO_GET_CRL:

s = String::New("UNABLE_TO_GET_CRL");

break;

case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:

s = String::New("UNABLE_TO_DECRYPT_CERT_SIGNATURE");

break;

case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:

s = String::New("UNABLE_TO_DECRYPT_CRL_SIGNATURE");

break;

case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:

s = String::New("UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");

break;

case X509_V_ERR_CERT_SIGNATURE_FAILURE:

s = String::New("CERT_SIGNATURE_FAILURE");

break;

case X509_V_ERR_CRL_SIGNATURE_FAILURE:

s = String::New("CRL_SIGNATURE_FAILURE");

break;

case X509_V_ERR_CERT_NOT_YET_VALID:

s = String::New("CERT_NOT_YET_VALID");

break;

case X509_V_ERR_CERT_HAS_EXPIRED:

s = String::New("CERT_HAS_EXPIRED");

break;

case X509_V_ERR_CRL_NOT_YET_VALID:

s = String::New("CRL_NOT_YET_VALID");

break;

case X509_V_ERR_CRL_HAS_EXPIRED:

s = String::New("CRL_HAS_EXPIRED");

break;

case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:

s = String::New("ERROR_IN_CERT_NOT_BEFORE_FIELD");

break;

case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:

s = String::New("ERROR_IN_CERT_NOT_AFTER_FIELD");

break;

case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:

s = String::New("ERROR_IN_CRL_LAST_UPDATE_FIELD");

break;

case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:

s = String::New("ERROR_IN_CRL_NEXT_UPDATE_FIELD");

break;

case X509_V_ERR_OUT_OF_MEM:

s = String::New("OUT_OF_MEM");

break;

case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:

s = String::New("DEPTH_ZERO_SELF_SIGNED_CERT");

break;

case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:

s = String::New("SELF_SIGNED_CERT_IN_CHAIN");

break;

case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:

s = String::New("UNABLE_TO_GET_ISSUER_CERT_LOCALLY");

break;

case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:

s = String::New("UNABLE_TO_VERIFY_LEAF_SIGNATURE");

break;

case X509_V_ERR_CERT_CHAIN_TOO_LONG:

s = String::New("CERT_CHAIN_TOO_LONG");

break;

case X509_V_ERR_CERT_REVOKED:

s = String::New("CERT_REVOKED");

break;

case X509_V_ERR_INVALID_CA:

s = String::New("INVALID_CA");

break;

case X509_V_ERR_PATH_LENGTH_EXCEEDED:

s = String::New("PATH_LENGTH_EXCEEDED");

break;

case X509_V_ERR_INVALID_PURPOSE:

s = String::New("INVALID_PURPOSE");

break;

case X509_V_ERR_CERT_UNTRUSTED:

s = String::New("CERT_UNTRUSTED");

break;

case X509_V_ERR_CERT_REJECTED:

s = String::New("CERT_REJECTED");

break;

default:

s = String::New(X509_verify_cert_error_string(x509_verify_error));

break;

}

return scope.Close(s);

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

OPENSSL_CONST SSL_CIPHER *c;

if ( ss->ssl_ == NULL ) return Undefined();

c = SSL_get_current_cipher(ss->ssl_);

if ( c == NULL ) return Undefined();

Local<Object> info = Object::New();

const char *cipher_name = SSL_CIPHER_get_name(c);

info->Set(name_symbol, String::New(cipher_name));

const char *cipher_version = SSL_CIPHER_get_version(c);

info->Set(version_symbol, String::New(cipher_version));

return scope.Close(info);

HandleScope scope;

Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());

if (ss->ssl_ != NULL) {

SSL_free(ss->ssl_);

ss->ssl_ = NULL;

}

return True();

int md_len,

char** md_hexdigest,

int* md_hex_len) {

*md_hex_len = (2*(md_len));

*md_hexdigest = new char[*md_hex_len + 1];

for (int i = 0; i < md_len; i++) {

snprintf((char *)(*md_hexdigest + (i*2)), 3, "%02x", md_value[i]);

}

int length,

char** buf64,

int* buf64_len) {

*buf64_len = (length/2);

*buf64 = new char[length/2 + 1];

char *b = *buf64;

for(int i = 0; i < length-1; i+=2) {

b[i/2] = (hex2i(input[i])<<4) | (hex2i(input[i+1]));

}

BIO *b64 = BIO_new(BIO_f_base64());

BIO *bmem = BIO_new(BIO_s_mem());

b64 = BIO_push(b64, bmem);

BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

int len = BIO_write(b64, input, length);

assert(len == length);

int r = BIO_flush(b64);

assert(r == 1);

BUF_MEM *bptr;

BIO_get_mem_ptr(b64, &bptr);

*buf64_len = bptr->length;

*buf64 = new char[*buf64_len+1];

memcpy(*buf64, bptr->data, *buf64_len);

char* b = *buf64;

b[*buf64_len] = 0;

BIO_free_all(b64);

int length,

char** buffer,

int* buffer_len) {

BIO *b64, *bmem;

*buffer = new char[length];

memset(*buffer, 0, length);

b64 = BIO_new(BIO_f_base64());

BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

bmem = BIO_new_mem_buf(input, length);