#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::ThrowException;

using v8::V8;

using v8::Value;

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;

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

}

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

}

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

}

void ThrowCryptoErrorHelper(Environment* env,

}

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

ThrowCryptoErrorHelper(env, err, false);

}

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

ThrowCryptoErrorHelper(env, err, true);

}

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

}

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

}

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

}

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

}

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;

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

void SecureContext::SetSessionIdContext(

}

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

}

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

}

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

}

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

}

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

}

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

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

}

hello_obj->Set(env->tls_ticket_string(), Boolean::New(hello.has_ticket()));

Local<Value> argv[] = { hello_obj };

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

}

template <class Base>

void SSLWrap<Base>::GetPeerCertificate(

const FunctionCallbackInfo<Value>& args) {

HandleScope scope(args.GetIsolate());

Base* w = Unwrap<Base>(args.This());

Environment* env = w->ssl_env();

ClearErrorOnReturn clear_error_on_return;

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

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

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

if (peer_cert != NULL) {

BIO* bio = BIO_new(BIO_s_mem());

BUF_MEM* mem;