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

if (!args[0]->IsString())

return ThrowException(Exception::TypeError(

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

String::Utf8Value sslmethod(args[0]->ToString());

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

method = SSLv2_method();

if (strcmp(*sslmethod, "SSLv2_server_method") == 0)

method = SSLv2_server_method();

if (strcmp(*sslmethod, "SSLv2_client_method") == 0)

method = SSLv2_client_method();

if (strcmp(*sslmethod, "SSLv3_method") == 0)

method = SSLv3_method();

if (strcmp(*sslmethod, "SSLv3_server_method") == 0)

method = SSLv3_server_method();

if (strcmp(*sslmethod, "SSLv3_client_method") == 0)

method = SSLv3_client_method();

if (strcmp(*sslmethod, "SSLv23_method") == 0)

method = SSLv23_method();

if (strcmp(*sslmethod, "SSLv23_server_method") == 0)

method = SSLv23_server_method();

if (strcmp(*sslmethod, "SSLv23_client_method") == 0)

method = SSLv23_client_method();

if (strcmp(*sslmethod, "TLSv1_method") == 0)

method = TLSv1_method();

if (strcmp(*sslmethod, "TLSv1_server_method") == 0)

method = TLSv1_server_method();

if (strcmp(*sslmethod, "TLSv1_client_method") == 0)

method = TLSv1_client_method();

}

sc->pCtx = SSL_CTX_new(method);

// Enable session caching?

SSL_CTX_set_session_cache_mode(sc->pCtx, SSL_SESS_CACHE_SERVER);

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

sc->caStore = X509_STORE_new();

SSL_CTX_set_cert_store(sc->pCtx, sc->caStore);

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 keyPem(args[0]->ToString());

BIO *bp = NULL;

EVP_PKEY* pkey;

bp = BIO_new(BIO_s_mem());

if (!BIO_write(bp, *keyPem, strlen(*keyPem)))

return False();

pkey = PEM_read_bio_PrivateKey(bp, NULL, NULL, NULL);

if (pkey == NULL)

return False();

SSL_CTX_use_PrivateKey(sc->pCtx, pkey);

BIO_free(bp);

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 certPem(args[0]->ToString());

BIO *bp = NULL;

X509 * x509;

bp = BIO_new(BIO_s_mem());

if (!BIO_write(bp, *certPem, strlen(*certPem)))

return False();

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

if (x509 == NULL)

return False();

SSL_CTX_use_certificate(sc->pCtx, 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 certPem(args[0]->ToString());

BIO *bp = NULL;

X509 *x509;

bp = BIO_new(BIO_s_mem());

if (!BIO_write(bp, *certPem, strlen(*certPem)))

return False();

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

if (x509 == NULL)

return False();

X509_STORE_add_cert(sc->caStore, 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->pCtx, *ciphers);

return True();

HandleScope scope;

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

if (sc->pCtx != NULL) {

SSL_CTX_free(sc->pCtx);

return True();

}

return False();

HandleScope scope;

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

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

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

NODE_SET_PROTOTYPE_METHOD(t, "readInject",

SecureStream::ReadInject);

NODE_SET_PROTOTYPE_METHOD(t, "readExtract",

SecureStream::ReadExtract);

NODE_SET_PROTOTYPE_METHOD(t, "writeInject",

SecureStream::WriteInject);

NODE_SET_PROTOTYPE_METHOD(t, "writeExtract",

SecureStream::WriteExtract);

NODE_SET_PROTOTYPE_METHOD(t, "readPending",

SecureStream::ReadPending);

NODE_SET_PROTOTYPE_METHOD(t, "writeCanExtract",

SecureStream::WriteCanExtract);

NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate",

SecureStream::GetPeerCertificate);

NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished",

SecureStream::IsInitFinished);

NODE_SET_PROTOTYPE_METHOD(t, "verifyPeer",

SecureStream::VerifyPeer);

NODE_SET_PROTOTYPE_METHOD(t, "getCurrentCipher",

SecureStream::GetCurrentCipher);

NODE_SET_PROTOTYPE_METHOD(t, "shutdown",

SecureStream::Shutdown);

NODE_SET_PROTOTYPE_METHOD(t, "close",

SecureStream::Close);

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

HandleScope scope;

SecureStream *p = new SecureStream();

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

int isServer = 0;

int shouldVerify = 0;

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

args[1]->IsNumber()) {

isServer = args[1]->Int32Value();

}

if (args.Length() >=3 &&

args[2]->IsNumber()) {

shouldVerify = args[2]->Int32Value();

}

p->pSSL = SSL_new(sc->pCtx);

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

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

SSL_set_bio(p->pSSL, p->pbioRead, p->pbioWrite);

p->shouldVerify = shouldVerify>0;

if (p->shouldVerify) {

SSL_set_verify(p->pSSL, SSL_VERIFY_PEER, verify_callback);

}

p->server = isServer>0;

if (p->server) {

SSL_set_accept_state(p->pSSL);

} else {

SSL_set_connect_state(p->pSSL);

}

return args.This();

HandleScope scope;

SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(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 = BIO_write(ss->pbioRead, (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;

SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(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->pSSL)) {

if (ss->server) {

bytes_read = SSL_accept(ss->pSSL);

} else {

bytes_read = SSL_connect(ss->pSSL);

}

if (bytes_read < 0) {

int err;

if ((err = SSL_get_error(ss->pSSL, bytes_read)) == SSL_ERROR_WANT_READ) {

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

}

}

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

}

bytes_read = SSL_read(ss->pSSL, (char*)buffer_data + off, len);

if (bytes_read < 0) {

int err = SSL_get_error(ss->pSSL, bytes_read);

if (err == SSL_ERROR_WANT_READ) {

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

}

// SSL read error

return scope.Close(Integer::New(-2));

}

if (bytes_read < 0) {

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

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

}

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

HandleScope scope;

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

int bytes_pending = BIO_pending(ss->pbioRead);

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

HandleScope scope;

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

int bytes_pending = BIO_pending(ss->pbioWrite);

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

HandleScope scope;

SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(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 = BIO_read(ss->pbioWrite, (char*)buffer_data + off, len);

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

HandleScope scope;

SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(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->pSSL)) {

int s;

if (ss->server) {

s = SSL_accept(ss->pSSL);

} else {

s = SSL_connect(ss->pSSL);

}

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

}

int bytes_written = SSL_write(ss->pSSL, (char*)buffer_data + off, len);

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

HandleScope scope;

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

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

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

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

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

X509_free(peer_cert);

}

return scope.Close(info);

HandleScope scope;

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

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

if (SSL_shutdown(ss->pSSL) == 1) {

return True();

}

return False();

HandleScope scope;

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

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

if (SSL_is_init_finished(ss->pSSL)) {

return True();

}

return False();

HandleScope scope;

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

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

if (!ss->shouldVerify) return False();

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

if (peer_cert==NULL) return False();

X509_free(peer_cert);

long x509_verify_error = SSL_get_verify_result(ss->pSSL);

// Can also check for:

// X509_V_ERR_CERT_HAS_EXPIRED

// X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT

// X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN

// X509_V_ERR_INVALID_CA

// X509_V_ERR_PATH_LENGTH_EXCEEDED

// X509_V_ERR_INVALID_PURPOSE

// X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT

// printf("%s\n", X509_verify_cert_error_string(x509_verify_error));

if (!x509_verify_error) return True();

return False();

HandleScope scope;

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

OPENSSL_CONST SSL_CIPHER *c;

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

c = SSL_get_current_cipher(ss->pSSL);

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;

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

if (ss->pSSL != NULL) {

SSL_free(ss->pSSL);

ss->pSSL = 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 *bmem, *b64;

BUF_MEM *bptr;

int len;

b64 = BIO_new(BIO_f_base64());

bmem = BIO_new(BIO_s_mem());

b64 = BIO_push(b64, bmem);

BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);

len = BIO_write(b64, input, length);

assert(len == length);

BIO_flush(b64);

BIO_get_mem_ptr(b64, &bptr);

*buf64_len = bptr->length;

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

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

char* b = *buf64;

b[bptr->length] = 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);

bmem = BIO_push(b64, bmem);

*buffer_len = BIO_read(bmem, *buffer, length);

BIO_free_all(bmem);

int answer = len;

// 1-byte encoding.

static const int kUtf8SingleByteMask = 0x80;

static const int kUtf8SingleByteValue = 0x00;

// 2-byte encoding.

static const int kUtf8TwoByteMask = 0xe0;

static const int kUtf8TwoByteValue = 0xc0;

// 3-byte encoding.

static const int kUtf8ThreeByteMask = 0xf0;

static const int kUtf8ThreeByteValue = 0xe0;

// 4-byte encoding.

static const int kUtf8FourByteMask = 0xf8;

static const int kUtf8FourByteValue = 0xf0;

// Subsequent bytes of a multi-byte encoding.

static const int kMultiByteMask = 0xc0;

static const int kMultiByteValue = 0x80;

int multi_byte_bytes_seen = 0;

while (answer > 0) {

int c = buffer[answer - 1];

// Ends in valid single-byte sequence?

if ((c & kUtf8SingleByteMask) == kUtf8SingleByteValue) return answer;

// Ends in one or more subsequent bytes of a multi-byte value?

if ((c & kMultiByteMask) == kMultiByteValue) {

multi_byte_bytes_seen++;

answer--;

} else {

if ((c & kUtf8TwoByteMask) == kUtf8TwoByteValue) {

if (multi_byte_bytes_seen >= 1) {

return answer + 2;

}

return answer - 1;

} else if ((c & kUtf8ThreeByteMask) == kUtf8ThreeByteValue) {

if (multi_byte_bytes_seen >= 2) {

return answer + 3;

}

return answer - 1;

} else if ((c & kUtf8FourByteMask) == kUtf8FourByteValue) {

if (multi_byte_bytes_seen >= 3) {

return answer + 4;

}

return answer - 1;

} else {

return answer; // Malformed UTF-8.

}

}

}

return 0;

unsigned char *out,

int *outl) {

int i,b;

int n;

*outl=0;

b=ctx->cipher->block_size;

if (ctx->flags & EVP_CIPH_NO_PADDING) {

if(ctx->buf_len) {

EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);

return 0;

}

*outl = 0;

return 1;

}

if (b > 1) {

if (ctx->buf_len || !ctx->final_used) {

EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_WRONG_FINAL_BLOCK_LENGTH);

return(0);

}

if (b > (sizeof(ctx->final) / sizeof(ctx->final[0]))) {

EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT);

return(0);

}

n=ctx->final[b-1];

if (n > b) {

EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT);

return(0);

}

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

if (ctx->final[--b] != n) {

EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT);

return(0);

}

}

n=ctx->cipher->block_size-n;

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

out[i]=ctx->final[i];

}

*outl=n;

} else {

*outl=0;

}

return(1);

public:

static void Initialize (v8::Handle<v8::Object> target) {

HandleScope scope;

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

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

NODE_SET_PROTOTYPE_METHOD(t, "init", CipherInit);

NODE_SET_PROTOTYPE_METHOD(t, "initiv", CipherInitIv);

NODE_SET_PROTOTYPE_METHOD(t, "update", CipherUpdate);

NODE_SET_PROTOTYPE_METHOD(t, "final", CipherFinal);

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

}

bool CipherInit(char* cipherType, char* key_buf, int key_buf_len) {

cipher = EVP_get_cipherbyname(cipherType);

if(!cipher) {

fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);

return false;

}

unsigned char key[EVP_MAX_KEY_LENGTH],iv[EVP_MAX_IV_LENGTH];

int key_len = EVP_BytesToKey(cipher, EVP_md5(), NULL, (unsigned char*) key_buf, key_buf_len, 1, key, iv);

EVP_CIPHER_CTX_init(&ctx);

EVP_CipherInit(&ctx,cipher,(unsigned char *)key,(unsigned char *)iv, true);

if (!EVP_CIPHER_CTX_set_key_length(&ctx,key_len)) {

fprintf(stderr, "node-crypto : Invalid key length %d\n", key_len);

EVP_CIPHER_CTX_cleanup(&ctx);

return false;

}

initialised_ = true;

return true;

}

bool CipherInitIv(char* cipherType,

char* key,

int key_len,

char *iv,

int iv_len) {

cipher = EVP_get_cipherbyname(cipherType);

if(!cipher) {

fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);

return false;

}

if (EVP_CIPHER_iv_length(cipher)!=iv_len) {

fprintf(stderr, "node-crypto : Invalid IV length %d\n", iv_len);

return false;

}

EVP_CIPHER_CTX_init(&ctx);

EVP_CipherInit(&ctx,cipher,(unsigned char *)key,(unsigned char *)iv, true);

if (!EVP_CIPHER_CTX_set_key_length(&ctx,key_len)) {

fprintf(stderr, "node-crypto : Invalid key length %d\n", key_len);

EVP_CIPHER_CTX_cleanup(&ctx);

return false;

}

initialised_ = true;

return true;

}

int CipherUpdate(char* data, int len, unsigned char** out, int* out_len) {

if (!initialised_) return 0;

*out_len=len+EVP_CIPHER_CTX_block_size(&ctx);

*out= new unsigned char[*out_len];

EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len);

return 1;

}

int CipherFinal(unsigned char** out, int *out_len) {

if (!initialised_) return 0;

*out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)];

EVP_CipherFinal(&ctx,*out,out_len);

EVP_CIPHER_CTX_cleanup(&ctx);

initialised_ = false;

return 1;

}

protected:

static Handle<Value> New (const Arguments& args) {

HandleScope scope;

Cipher *cipher = new Cipher();

cipher->Wrap(args.This());

return args.This();

}

static Handle<Value> CipherInit(const Arguments& args) {

HandleScope scope;

Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());

cipher->incomplete_base64=NULL;

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

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

"Must give cipher-type, key")));

}

ssize_t key_buf_len = DecodeBytes(args[1], BINARY);

if (key_buf_len < 0) {

Local<Value> exception = Exception::TypeError(String::New("Bad argument"));

return ThrowException(exception);

}

char* key_buf = new char[key_buf_len];

ssize_t key_written = DecodeWrite(key_buf, key_buf_len, args[1], BINARY);

assert(key_written == key_buf_len);

String::Utf8Value cipherType(args[0]->ToString());

bool r = cipher->CipherInit(*cipherType, key_buf, key_buf_len);

delete [] key_buf;

return args.This();

}

static Handle<Value> CipherInitIv(const Arguments& args) {

Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());

HandleScope scope;

cipher->incomplete_base64=NULL;

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

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

"Must give cipher-type, key, and iv as argument")));

}

ssize_t key_len = DecodeBytes(args[1], BINARY);

if (key_len < 0) {

Local<Value> exception = Exception::TypeError(String::New("Bad argument"));

return ThrowException(exception);

}

ssize_t iv_len = DecodeBytes(args[2], BINARY);

if (iv_len < 0) {

Local<Value> exception = Exception::TypeError(String::New("Bad argument"));

return ThrowException(exception);

}

char* key_buf = new char[key_len];

ssize_t key_written = DecodeWrite(key_buf, key_len, args[1], BINARY);

assert(key_written == key_len);

char* iv_buf = new char[iv_len];

ssize_t iv_written = DecodeWrite(iv_buf, iv_len, args[2], BINARY);

assert(iv_written == iv_len);

String::Utf8Value cipherType(args[0]->ToString());

bool r = cipher->CipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len);

delete [] key_buf;

delete [] iv_buf;

return args.This();

}

static Handle<Value> CipherUpdate(const Arguments& args) {

Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());

HandleScope scope;