src/node_crypto.cc

   1 // Copyright Joyent, Inc. and other Node contributors.
   2 //
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the
   5 // "Software"), to deal in the Software without restriction, including
   6 // without limitation the rights to use, copy, modify, merge, publish,
   7 // distribute, sublicense, and/or sell copies of the Software, and to permit
   8 // persons to whom the Software is furnished to do so, subject to the
   9 // following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be included
  12 // in all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  17 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  18 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  19 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20 // USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22 #include "node_crypto.h"
  23 #include "node_crypto_groups.h"
  24 #include "v8.h"
  25
  26 #include "node.h"
  27 #include "node_buffer.h"
  28 #include "node_root_certs.h"
  29
  30 #include <string.h>
  31 #ifdef _MSC_VER
  32 #define strcasecmp _stricmp
  33 #endif
  34
  35 #include <stdlib.h>
  36
  37 #include <errno.h>
  38
  39 /* Sigh. */
  40 #ifdef _WIN32
  41 # include <windows.h>
  42 #else
  43 # include <pthread.h>
  44 #endif
  45
  46
  47 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  48 # define OPENSSL_CONST const
  49 #else
  50 # define OPENSSL_CONST
  51 #endif
  52
  53 #define ASSERT_IS_STRING_OR_BUFFER(val) \
  54   if (!val->IsString() && !Buffer::HasInstance(val)) { \
  55     return ThrowException(Exception::TypeError(String::New("Not a string or buffer"))); \
  56   }
  57
  58 static const char PUBLIC_KEY_PFX[] =  "-----BEGIN PUBLIC KEY-----";
  59 static const int PUBLIC_KEY_PFX_LEN = sizeof(PUBLIC_KEY_PFX) - 1;
  60 static const char PUBRSA_KEY_PFX[] =  "-----BEGIN RSA PUBLIC KEY-----";
  61 static const int PUBRSA_KEY_PFX_LEN = sizeof(PUBRSA_KEY_PFX) - 1;
  62 static const int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL
  63                                  | ASN1_STRFLGS_ESC_MSB
  64                                  | XN_FLAG_SEP_MULTILINE
  65                                  | XN_FLAG_FN_SN;
  66
  67 namespace node {
  68 namespace crypto {
  69
  70 using namespace v8;
  71
  72 static Persistent<String> errno_symbol;
  73 static Persistent<String> syscall_symbol;
  74 static Persistent<String> subject_symbol;
  75 static Persistent<String> subjectaltname_symbol;
  76 static Persistent<String> modulus_symbol;
  77 static Persistent<String> exponent_symbol;
  78 static Persistent<String> issuer_symbol;
  79 static Persistent<String> valid_from_symbol;
  80 static Persistent<String> valid_to_symbol;
  81 static Persistent<String> fingerprint_symbol;
  82 static Persistent<String> name_symbol;
  83 static Persistent<String> version_symbol;
  84 static Persistent<String> ext_key_usage_symbol;
  85 static Persistent<String> onhandshakestart_sym;
  86 static Persistent<String> onhandshakedone_sym;
  87
  88 static Persistent<FunctionTemplate> secure_context_constructor;
  89
  90 static uv_rwlock_t* locks;
  91
  92
  93 static unsigned long crypto_id_cb(void) {
  94 #ifdef _WIN32
  95   return (unsigned long) GetCurrentThreadId();
  96 #else /* !_WIN32 */
  97   return (unsigned long) pthread_self();
  98 #endif /* !_WIN32 */
  99 }
 100
 101
 102 static void crypto_lock_init(void) {
 103   int i, n;
 104
 105   n = CRYPTO_num_locks();
 106   locks = new uv_rwlock_t[n];
 107
 108   for (i = 0; i < n; i++)
 109     if (uv_rwlock_init(locks + i))
 110       abort();
 111 }
 112
 113
 114 static void crypto_lock_cb(int mode, int n, const char* file, int line) {
 115   assert((mode & CRYPTO_LOCK) || (mode & CRYPTO_UNLOCK));
 116   assert((mode & CRYPTO_READ) || (mode & CRYPTO_WRITE));
 117
 118   if (mode & CRYPTO_LOCK) {
 119     if (mode & CRYPTO_READ)
 120       uv_rwlock_rdlock(locks + n);
 121     else
 122       uv_rwlock_wrlock(locks + n);
 123   } else {
 124     if (mode & CRYPTO_READ)
 125       uv_rwlock_rdunlock(locks + n);
 126     else
 127       uv_rwlock_wrunlock(locks + n);
 128   }
 129 }
 130
 131
 132
 133
 134 void SecureContext::Initialize(Handle<Object> target) {
 135   HandleScope scope;
 136
 137   Local<FunctionTemplate> t = FunctionTemplate::New(SecureContext::New);
 138   secure_context_constructor = Persistent<FunctionTemplate>::New(t);
 139
 140   t->InstanceTemplate()->SetInternalFieldCount(1);
 141   t->SetClassName(String::NewSymbol("SecureContext"));
 142
 143   NODE_SET_PROTOTYPE_METHOD(t, "init", SecureContext::Init);
 144   NODE_SET_PROTOTYPE_METHOD(t, "setKey", SecureContext::SetKey);
 145   NODE_SET_PROTOTYPE_METHOD(t, "setCert", SecureContext::SetCert);
 146   NODE_SET_PROTOTYPE_METHOD(t, "addCACert", SecureContext::AddCACert);
 147   NODE_SET_PROTOTYPE_METHOD(t, "addCRL", SecureContext::AddCRL);
 148   NODE_SET_PROTOTYPE_METHOD(t, "addRootCerts", SecureContext::AddRootCerts);
 149   NODE_SET_PROTOTYPE_METHOD(t, "setCiphers", SecureContext::SetCiphers);
 150   NODE_SET_PROTOTYPE_METHOD(t, "setOptions", SecureContext::SetOptions);
 151   NODE_SET_PROTOTYPE_METHOD(t, "setSessionIdContext",
 152                                SecureContext::SetSessionIdContext);
 153   NODE_SET_PROTOTYPE_METHOD(t, "close", SecureContext::Close);
 154   NODE_SET_PROTOTYPE_METHOD(t, "loadPKCS12", SecureContext::LoadPKCS12);
 155
 156   target->Set(String::NewSymbol("SecureContext"), t->GetFunction());
 157 }
 158
 159
 160 Handle<Value> SecureContext::New(const Arguments& args) {
 161   HandleScope scope;
 162   SecureContext *p = new SecureContext();
 163   p->Wrap(args.Holder());
 164   return args.This();
 165 }
 166
 167
 168 Handle<Value> SecureContext::Init(const Arguments& args) {
 169   HandleScope scope;
 170
 171   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 172
 173   OPENSSL_CONST SSL_METHOD *method = SSLv23_method();
 174
 175   if (args.Length() == 1 && args[0]->IsString()) {
 176     String::Utf8Value sslmethod(args[0]);
 177
 178     if (strcmp(*sslmethod, "SSLv2_method") == 0) {
 179 #ifndef OPENSSL_NO_SSL2
 180       method = SSLv2_method();
 181 #else
 182       return ThrowException(Exception::Error(String::New("SSLv2 methods disabled")));
 183 #endif
 184     } else if (strcmp(*sslmethod, "SSLv2_server_method") == 0) {
 185 #ifndef OPENSSL_NO_SSL2
 186       method = SSLv2_server_method();
 187 #else
 188       return ThrowException(Exception::Error(String::New("SSLv2 methods disabled")));
 189 #endif
 190     } else if (strcmp(*sslmethod, "SSLv2_client_method") == 0) {
 191 #ifndef OPENSSL_NO_SSL2
 192       method = SSLv2_client_method();
 193 #else
 194       return ThrowException(Exception::Error(String::New("SSLv2 methods disabled")));
 195 #endif
 196     } else if (strcmp(*sslmethod, "SSLv3_method") == 0) {
 197       method = SSLv3_method();
 198     } else if (strcmp(*sslmethod, "SSLv3_server_method") == 0) {
 199       method = SSLv3_server_method();
 200     } else if (strcmp(*sslmethod, "SSLv3_client_method") == 0) {
 201       method = SSLv3_client_method();
 202     } else if (strcmp(*sslmethod, "SSLv23_method") == 0) {
 203       method = SSLv23_method();
 204     } else if (strcmp(*sslmethod, "SSLv23_server_method") == 0) {
 205       method = SSLv23_server_method();
 206     } else if (strcmp(*sslmethod, "SSLv23_client_method") == 0) {
 207       method = SSLv23_client_method();
 208     } else if (strcmp(*sslmethod, "TLSv1_method") == 0) {
 209       method = TLSv1_method();
 210     } else if (strcmp(*sslmethod, "TLSv1_server_method") == 0) {
 211       method = TLSv1_server_method();
 212     } else if (strcmp(*sslmethod, "TLSv1_client_method") == 0) {
 213       method = TLSv1_client_method();
 214     } else {
 215       return ThrowException(Exception::Error(String::New("Unknown method")));
 216     }
 217   }
 218
 219   sc->ctx_ = SSL_CTX_new(method);
 220   // Enable session caching?
 221   SSL_CTX_set_session_cache_mode(sc->ctx_, SSL_SESS_CACHE_SERVER);
 222   // SSL_CTX_set_session_cache_mode(sc->ctx_,SSL_SESS_CACHE_OFF);
 223
 224   sc->ca_store_ = NULL;
 225   return True();
 226 }
 227
 228
 229 // Takes a string or buffer and loads it into a BIO.
 230 // Caller responsible for BIO_free-ing the returned object.
 231 static BIO* LoadBIO (Handle<Value> v) {
 232   BIO *bio = BIO_new(BIO_s_mem());
 233   if (!bio) return NULL;
 234
 235   HandleScope scope;
 236
 237   int r = -1;
 238
 239   if (v->IsString()) {
 240     String::Utf8Value s(v);
 241     r = BIO_write(bio, *s, s.length());
 242   } else if (Buffer::HasInstance(v)) {
 243     Local<Object> buffer_obj = v->ToObject();
 244     char *buffer_data = Buffer::Data(buffer_obj);
 245     size_t buffer_length = Buffer::Length(buffer_obj);
 246     r = BIO_write(bio, buffer_data, buffer_length);
 247   }
 248
 249   if (r <= 0) {
 250     BIO_free(bio);
 251     return NULL;
 252   }
 253
 254   return bio;
 255 }
 256
 257
 258 // Takes a string or buffer and loads it into an X509
 259 // Caller responsible for X509_free-ing the returned object.
 260 static X509* LoadX509 (Handle<Value> v) {
 261   HandleScope scope; // necessary?
 262
 263   BIO *bio = LoadBIO(v);
 264   if (!bio) return NULL;
 265
 266   X509 * x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
 267   if (!x509) {
 268     BIO_free(bio);
 269     return NULL;
 270   }
 271
 272   BIO_free(bio);
 273   return x509;
 274 }
 275
 276
 277 Handle<Value> SecureContext::SetKey(const Arguments& args) {
 278   HandleScope scope;
 279
 280   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 281
 282   unsigned int len = args.Length();
 283   if (len != 1 && len != 2) {
 284     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 285   }
 286   if (len == 2 && !args[1]->IsString()) {
 287     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 288   }
 289
 290   BIO *bio = LoadBIO(args[0]);
 291   if (!bio) return False();
 292
 293   String::Utf8Value passphrase(args[1]);
 294
 295   EVP_PKEY* key = PEM_read_bio_PrivateKey(bio, NULL, NULL,
 296                                           len == 1 ? NULL : *passphrase);
 297
 298   if (!key) {
 299     BIO_free(bio);
 300     unsigned long err = ERR_get_error();
 301     if (!err) {
 302       return ThrowException(Exception::Error(
 303           String::New("PEM_read_bio_PrivateKey")));
 304     }
 305     char string[120];
 306     ERR_error_string_n(err, string, sizeof string);
 307     return ThrowException(Exception::Error(String::New(string)));
 308   }
 309
 310   SSL_CTX_use_PrivateKey(sc->ctx_, key);
 311   EVP_PKEY_free(key);
 312   BIO_free(bio);
 313
 314   return True();
 315 }
 316
 317
 318 // Read a file that contains our certificate in "PEM" format,
 319 // possibly followed by a sequence of CA certificates that should be
 320 // sent to the peer in the Certificate message.
 321 //
 322 // Taken from OpenSSL - editted for style.
 323 int SSL_CTX_use_certificate_chain(SSL_CTX *ctx, BIO *in) {
 324   int ret = 0;
 325   X509 *x = NULL;
 326
 327   x = PEM_read_bio_X509_AUX(in, NULL, NULL, NULL);
 328
 329   if (x == NULL) {
 330     SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);
 331     goto end;
 332   }
 333
 334   ret = SSL_CTX_use_certificate(ctx, x);
 335
 336   if (ERR_peek_error() != 0) {
 337     // Key/certificate mismatch doesn't imply ret==0 ...
 338     ret = 0;
 339   }
 340
 341   if (ret) {
 342     // If we could set up our certificate, now proceed to
 343     // the CA certificates.
 344     X509 *ca;
 345     int r;
 346     unsigned long err;
 347
 348     if (ctx->extra_certs != NULL) {
 349       sk_X509_pop_free(ctx->extra_certs, X509_free);
 350       ctx->extra_certs = NULL;
 351     }
 352
 353     while ((ca = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
 354       r = SSL_CTX_add_extra_chain_cert(ctx, ca);
 355
 356       if (!r) {
 357         X509_free(ca);
 358         ret = 0;
 359         goto end;
 360       }
 361       // Note that we must not free r if it was successfully
 362       // added to the chain (while we must free the main
 363       // certificate, since its reference count is increased
 364       // by SSL_CTX_use_certificate).
 365     }
 366
 367     // When the while loop ends, it's usually just EOF.
 368     err = ERR_peek_last_error();
 369     if (ERR_GET_LIB(err) == ERR_LIB_PEM &&
 370         ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {
 371       ERR_clear_error();
 372     } else  {
 373       // some real error
 374       ret = 0;
 375     }
 376   }
 377
 378 end:
 379   if (x != NULL) X509_free(x);
 380   return ret;
 381 }
 382
 383
 384 Handle<Value> SecureContext::SetCert(const Arguments& args) {
 385   HandleScope scope;
 386
 387   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 388
 389   if (args.Length() != 1) {
 390     return ThrowException(Exception::TypeError(
 391           String::New("Bad parameter")));
 392   }
 393
 394   BIO* bio = LoadBIO(args[0]);
 395   if (!bio) return False();
 396
 397   int rv = SSL_CTX_use_certificate_chain(sc->ctx_, bio);
 398
 399   BIO_free(bio);
 400
 401   if (!rv) {
 402     unsigned long err = ERR_get_error();
 403     if (!err) {
 404       return ThrowException(Exception::Error(
 405           String::New("SSL_CTX_use_certificate_chain")));
 406     }
 407     char string[120];
 408     ERR_error_string_n(err, string, sizeof string);
 409     return ThrowException(Exception::Error(String::New(string)));
 410   }
 411
 412   return True();
 413 }
 414
 415
 416 Handle<Value> SecureContext::AddCACert(const Arguments& args) {
 417   bool newCAStore = false;
 418   HandleScope scope;
 419
 420   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 421
 422   if (args.Length() != 1) {
 423     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 424   }
 425
 426   if (!sc->ca_store_) {
 427     sc->ca_store_ = X509_STORE_new();
 428     newCAStore = true;
 429   }
 430
 431   X509* x509 = LoadX509(args[0]);
 432   if (!x509) return False();
 433
 434   X509_STORE_add_cert(sc->ca_store_, x509);
 435   SSL_CTX_add_client_CA(sc->ctx_, x509);
 436
 437   X509_free(x509);
 438
 439   if (newCAStore) {
 440     SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);
 441   }
 442
 443   return True();
 444 }
 445
 446
 447 Handle<Value> SecureContext::AddCRL(const Arguments& args) {
 448   HandleScope scope;
 449
 450   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 451
 452   if (args.Length() != 1) {
 453     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 454   }
 455
 456   BIO *bio = LoadBIO(args[0]);
 457   if (!bio) return False();
 458
 459   X509_CRL *x509 = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL);
 460
 461   if (x509 == NULL) {
 462     BIO_free(bio);
 463     return False();
 464   }
 465
 466   X509_STORE_add_crl(sc->ca_store_, x509);
 467
 468   X509_STORE_set_flags(sc->ca_store_, X509_V_FLAG_CRL_CHECK |
 469                                       X509_V_FLAG_CRL_CHECK_ALL);
 470
 471   BIO_free(bio);
 472   X509_CRL_free(x509);
 473
 474   return True();
 475 }
 476
 477
 478
 479 Handle<Value> SecureContext::AddRootCerts(const Arguments& args) {
 480   HandleScope scope;
 481
 482   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 483
 484   assert(sc->ca_store_ == NULL);
 485
 486   if (!root_cert_store) {
 487     root_cert_store = X509_STORE_new();
 488
 489     for (int i = 0; root_certs[i]; i++) {
 490       BIO *bp = BIO_new(BIO_s_mem());
 491
 492       if (!BIO_write(bp, root_certs[i], strlen(root_certs[i]))) {
 493         BIO_free(bp);
 494         return False();
 495       }
 496
 497       X509 *x509 = PEM_read_bio_X509(bp, NULL, NULL, NULL);
 498
 499       if (x509 == NULL) {
 500         BIO_free(bp);
 501         return False();
 502       }
 503
 504       X509_STORE_add_cert(root_cert_store, x509);
 505
 506       BIO_free(bp);
 507       X509_free(x509);
 508     }
 509   }
 510
 511   sc->ca_store_ = root_cert_store;
 512   SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);
 513
 514   return True();
 515 }
 516
 517
 518 Handle<Value> SecureContext::SetCiphers(const Arguments& args) {
 519   HandleScope scope;
 520
 521   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 522
 523   if (args.Length() != 1 || !args[0]->IsString()) {
 524     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 525   }
 526
 527   String::Utf8Value ciphers(args[0]);
 528   SSL_CTX_set_cipher_list(sc->ctx_, *ciphers);
 529
 530   return True();
 531 }
 532
 533 Handle<Value> SecureContext::SetOptions(const Arguments& args) {
 534   HandleScope scope;
 535
 536   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 537
 538   if (args.Length() != 1 || !args[0]->IsUint32()) {
 539     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 540   }
 541
 542   unsigned int opts = args[0]->Uint32Value();
 543
 544   SSL_CTX_set_options(sc->ctx_, opts);
 545
 546   return True();
 547 }
 548
 549 Handle<Value> SecureContext::SetSessionIdContext(const Arguments& args) {
 550   HandleScope scope;
 551
 552   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 553
 554   if (args.Length() != 1 || !args[0]->IsString()) {
 555     return ThrowException(Exception::TypeError(String::New("Bad parameter")));
 556   }
 557
 558   String::Utf8Value sessionIdContext(args[0]);
 559   const unsigned char* sid_ctx = (const unsigned char*) *sessionIdContext;
 560   unsigned int sid_ctx_len = sessionIdContext.length();
 561
 562   int r = SSL_CTX_set_session_id_context(sc->ctx_, sid_ctx, sid_ctx_len);
 563   if (r != 1) {
 564     Local<String> message;
 565     BIO* bio;
 566     BUF_MEM* mem;
 567     if ((bio = BIO_new(BIO_s_mem()))) {
 568       ERR_print_errors(bio);
 569       BIO_get_mem_ptr(bio, &mem);
 570       message = String::New(mem->data, mem->length);
 571       BIO_free(bio);
 572     } else {
 573       message = String::New("SSL_CTX_set_session_id_context error");
 574     }
 575     return ThrowException(Exception::TypeError(message));
 576   }
 577
 578   return True();
 579 }
 580
 581 Handle<Value> SecureContext::Close(const Arguments& args) {
 582   HandleScope scope;
 583   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 584   sc->FreeCTXMem();
 585   return False();
 586 }
 587
 588 //Takes .pfx or .p12 and password in string or buffer format
 589 Handle<Value> SecureContext::LoadPKCS12(const Arguments& args) {
 590   HandleScope scope;
 591
 592   BIO* in = NULL;
 593   PKCS12* p12 = NULL;
 594   EVP_PKEY* pkey = NULL;
 595   X509* cert = NULL;
 596   STACK_OF(X509)* extraCerts = NULL;
 597   char* pass = NULL;
 598   bool ret = false;
 599
 600   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args.Holder());
 601
 602   if (args.Length() < 1) {
 603     return ThrowException(Exception::TypeError(
 604           String::New("Bad parameter")));
 605   }
 606
 607   in = LoadBIO(args[0]);
 608   if (in == NULL) {
 609     return ThrowException(Exception::Error(
 610           String::New("Unable to load BIO")));
 611   }
 612
 613   if (args.Length() >= 2) {
 614     ASSERT_IS_STRING_OR_BUFFER(args[1]);
 615
 616     int passlen = DecodeBytes(args[1], BINARY);
 617     if (passlen < 0) {
 618       BIO_free(in);
 619       return ThrowException(Exception::TypeError(
 620             String::New("Bad password")));
 621     }
 622     pass = new char[passlen + 1];
 623     int pass_written = DecodeWrite(pass, passlen, args[1], BINARY);
 624
 625     assert(pass_written == passlen);
 626     pass[passlen] = '\0';
 627   }
 628
 629   if (d2i_PKCS12_bio(in, &p12) &&
 630       PKCS12_parse(p12, pass, &pkey, &cert, &extraCerts) &&
 631       SSL_CTX_use_certificate(sc->ctx_, cert) &&
 632       SSL_CTX_use_PrivateKey(sc->ctx_, pkey))
 633   {
 634     // set extra certs
 635     while (X509* x509 = sk_X509_pop(extraCerts)) {
 636       if (!sc->ca_store_) {
 637         sc->ca_store_ = X509_STORE_new();
 638         SSL_CTX_set_cert_store(sc->ctx_, sc->ca_store_);
 639       }
 640
 641       X509_STORE_add_cert(sc->ca_store_, x509);
 642       SSL_CTX_add_client_CA(sc->ctx_, x509);
 643     }
 644
 645     EVP_PKEY_free(pkey);
 646     X509_free(cert);
 647     sk_X509_free(extraCerts);
 648
 649     ret = true;
 650   }
 651
 652   PKCS12_free(p12);
 653   BIO_free(in);
 654   delete[] pass;
 655
 656   if (!ret) {
 657     unsigned long err = ERR_get_error();
 658     const char *str = ERR_reason_error_string(err);
 659     return ThrowException(Exception::Error(String::New(str)));
 660   }
 661
 662   return True();
 663 }
 664
 665
 666 #ifdef SSL_PRINT_DEBUG
 667 # define DEBUG_PRINT(...) fprintf (stderr, __VA_ARGS__)
 668 #else
 669 # define DEBUG_PRINT(...)
 670 #endif
 671
 672
 673 int Connection::HandleBIOError(BIO *bio, const char* func, int rv) {
 674   if (rv >= 0) return rv;
 675
 676   int retry = BIO_should_retry(bio);
 677   (void) retry; // unused if !defined(SSL_PRINT_DEBUG)
 678
 679   if (BIO_should_write(bio)) {
 680     DEBUG_PRINT("[%p] BIO: %s want write. should retry %d\n", ssl_, func, retry);
 681     return 0;
 682
 683   } else if (BIO_should_read(bio)) {
 684     DEBUG_PRINT("[%p] BIO: %s want read. should retry %d\n", ssl_, func, retry);
 685     return 0;
 686
 687   } else {
 688    static char ssl_error_buf[512];
 689     ERR_error_string_n(rv, ssl_error_buf, sizeof(ssl_error_buf));
 690
 691     HandleScope scope;
 692     Local<Value> e = Exception::Error(String::New(ssl_error_buf));
 693     handle_->Set(String::New("error"), e);
 694
 695     DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n", ssl_, func, rv, ssl_error_buf);
 696
 697     return rv;
 698   }
 699
 700   return 0;
 701 }
 702
 703
 704 int Connection::HandleSSLError(const char* func, int rv) {
 705   if (rv >= 0) return rv;
 706
 707   int err = SSL_get_error(ssl_, rv);
 708
 709   if (err == SSL_ERROR_NONE) {
 710     return 0;
 711
 712   } else if (err == SSL_ERROR_WANT_WRITE) {
 713     DEBUG_PRINT("[%p] SSL: %s want write\n", ssl_, func);
 714     return 0;
 715
 716   } else if (err == SSL_ERROR_WANT_READ) {
 717     DEBUG_PRINT("[%p] SSL: %s want read\n", ssl_, func);
 718     return 0;
 719
 720   } else {
 721     HandleScope scope;
 722     BUF_MEM* mem;
 723     BIO *bio;
 724
 725     assert(err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL);
 726
 727     // XXX We need to drain the error queue for this thread or else OpenSSL
 728     // has the possibility of blocking connections? This problem is not well
 729     // understood. And we should be somehow propagating these errors up
 730     // into JavaScript. There is no test which demonstrates this problem.
 731     // https://github.com/joyent/node/issues/1719
 732     if ((bio = BIO_new(BIO_s_mem()))) {
 733       ERR_print_errors(bio);
 734       BIO_get_mem_ptr(bio, &mem);
 735       Local<Value> e = Exception::Error(String::New(mem->data, mem->length));
 736       handle_->Set(String::New("error"), e);
 737       BIO_free(bio);
 738     }
 739
 740     return rv;
 741   }
 742
 743   return 0;
 744 }
 745
 746
 747 void Connection::ClearError() {
 748 #ifndef NDEBUG
 749   HandleScope scope;
 750
 751   // We should clear the error in JS-land
 752   assert(handle_->Get(String::New("error"))->BooleanValue() == false);
 753 #endif // NDEBUG
 754 }
 755
 756
 757 void Connection::SetShutdownFlags() {
 758   HandleScope scope;
 759
 760   int flags = SSL_get_shutdown(ssl_);
 761
 762   if (flags & SSL_SENT_SHUTDOWN) {
 763     handle_->Set(String::New("sentShutdown"), True());
 764   }
 765
 766   if (flags & SSL_RECEIVED_SHUTDOWN) {
 767     handle_->Set(String::New("receivedShutdown"), True());
 768   }
 769 }
 770
 771
 772 void Connection::Initialize(Handle<Object> target) {
 773   HandleScope scope;
 774
 775   Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
 776   t->InstanceTemplate()->SetInternalFieldCount(1);
 777   t->SetClassName(String::NewSymbol("Connection"));
 778
 779   NODE_SET_PROTOTYPE_METHOD(t, "encIn", Connection::EncIn);
 780   NODE_SET_PROTOTYPE_METHOD(t, "clearOut", Connection::ClearOut);
 781   NODE_SET_PROTOTYPE_METHOD(t, "clearIn", Connection::ClearIn);
 782   NODE_SET_PROTOTYPE_METHOD(t, "encOut", Connection::EncOut);
 783   NODE_SET_PROTOTYPE_METHOD(t, "clearPending", Connection::ClearPending);
 784   NODE_SET_PROTOTYPE_METHOD(t, "encPending", Connection::EncPending);
 785   NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", Connection::GetPeerCertificate);
 786   NODE_SET_PROTOTYPE_METHOD(t, "getSession", Connection::GetSession);
 787   NODE_SET_PROTOTYPE_METHOD(t, "setSession", Connection::SetSession);
 788   NODE_SET_PROTOTYPE_METHOD(t, "isSessionReused", Connection::IsSessionReused);
 789   NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished", Connection::IsInitFinished);
 790   NODE_SET_PROTOTYPE_METHOD(t, "verifyError", Connection::VerifyError);
 791   NODE_SET_PROTOTYPE_METHOD(t, "getCurrentCipher", Connection::GetCurrentCipher);
 792   NODE_SET_PROTOTYPE_METHOD(t, "start", Connection::Start);
 793   NODE_SET_PROTOTYPE_METHOD(t, "shutdown", Connection::Shutdown);
 794   NODE_SET_PROTOTYPE_METHOD(t, "receivedShutdown", Connection::ReceivedShutdown);
 795   NODE_SET_PROTOTYPE_METHOD(t, "close", Connection::Close);
 796
 797 #ifdef OPENSSL_NPN_NEGOTIATED
 798   NODE_SET_PROTOTYPE_METHOD(t, "getNegotiatedProtocol", Connection::GetNegotiatedProto);
 799   NODE_SET_PROTOTYPE_METHOD(t, "setNPNProtocols", Connection::SetNPNProtocols);
 800 #endif
 801
 802
 803 #ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
 804   NODE_SET_PROTOTYPE_METHOD(t, "getServername", Connection::GetServername);
 805   NODE_SET_PROTOTYPE_METHOD(t, "setSNICallback",  Connection::SetSNICallback);
 806 #endif
 807
 808   target->Set(String::NewSymbol("Connection"), t->GetFunction());
 809 }
 810
 811
 812 static int VerifyCallback(int preverify_ok, X509_STORE_CTX *ctx) {
 813   // Quoting SSL_set_verify(3ssl):
 814   //
 815   //   The VerifyCallback function is used to control the behaviour when
 816   //   the SSL_VERIFY_PEER flag is set. It must be supplied by the
 817   //   application and receives two arguments: preverify_ok indicates,
 818   //   whether the verification of the certificate in question was passed
 819   //   (preverify_ok=1) or not (preverify_ok=0). x509_ctx is a pointer to
 820   //   the complete context used for the certificate chain verification.
 821   //
 822   //   The certificate chain is checked starting with the deepest nesting
 823   //   level (the root CA certificate) and worked upward to the peer's
 824   //   certificate.  At each level signatures and issuer attributes are
 825   //   checked.  Whenever a verification error is found, the error number is
 826   //   stored in x509_ctx and VerifyCallback is called with preverify_ok=0.
 827   //   By applying X509_CTX_store_* functions VerifyCallback can locate the
 828   //   certificate in question and perform additional steps (see EXAMPLES).
 829   //   If no error is found for a certificate, VerifyCallback is called
 830   //   with preverify_ok=1 before advancing to the next level.
 831   //
 832   //   The return value of VerifyCallback controls the strategy of the
 833   //   further verification process. If VerifyCallback returns 0, the
 834   //   verification process is immediately stopped with "verification
 835   //   failed" state. If SSL_VERIFY_PEER is set, a verification failure
 836   //   alert is sent to the peer and the TLS/SSL handshake is terminated. If
 837   //   VerifyCallback returns 1, the verification process is continued. If
 838   //   VerifyCallback always returns 1, the TLS/SSL handshake will not be
 839   //   terminated with respect to verification failures and the connection
 840   //   will be established. The calling process can however retrieve the
 841   //   error code of the last verification error using
 842   //   SSL_get_verify_result(3) or by maintaining its own error storage
 843   //   managed by VerifyCallback.
 844   //
 845   //   If no VerifyCallback is specified, the default callback will be
 846   //   used.  Its return value is identical to preverify_ok, so that any
 847   //   verification failure will lead to a termination of the TLS/SSL
 848   //   handshake with an alert message, if SSL_VERIFY_PEER is set.
 849   //
 850   // Since we cannot perform I/O quickly enough in this callback, we ignore
 851   // all preverify_ok errors and let the handshake continue. It is
 852   // imparative that the user use Connection::VerifyError after the
 853   // 'secure' callback has been made.
 854   return 1;
 855 }
 856
 857 #ifdef OPENSSL_NPN_NEGOTIATED
 858
 859 int Connection::AdvertiseNextProtoCallback_(SSL *s,
 860                                             const unsigned char **data,
 861                                             unsigned int *len,
 862                                             void *arg) {
 863
 864   Connection *p = static_cast<Connection*>(SSL_get_app_data(s));
 865
 866   if (p->npnProtos_.IsEmpty()) {
 867     // No initialization - no NPN protocols
 868     *data = reinterpret_cast<const unsigned char*>("");
 869     *len = 0;
 870   } else {
 871     *data = reinterpret_cast<const unsigned char*>(Buffer::Data(p->npnProtos_));
 872     *len = Buffer::Length(p->npnProtos_);
 873   }
 874
 875   return SSL_TLSEXT_ERR_OK;
 876 }
 877
 878 int Connection::SelectNextProtoCallback_(SSL *s,
 879                              unsigned char **out, unsigned char *outlen,
 880                              const unsigned char* in,
 881                              unsigned int inlen, void *arg) {
 882   Connection *p = static_cast<Connection*> SSL_get_app_data(s);
 883
 884   // Release old protocol handler if present
 885   if (!p->selectedNPNProto_.IsEmpty()) {
 886     p->selectedNPNProto_.Dispose();
 887   }
 888
 889   if (p->npnProtos_.IsEmpty()) {
 890     // We should at least select one protocol
 891     // If server is using NPN
 892     *out = reinterpret_cast<unsigned char*>(const_cast<char*>("http/1.1"));
 893     *outlen = 8;
 894
 895     // set status unsupported
 896     p->selectedNPNProto_ = Persistent<Value>::New(False());
 897
 898     return SSL_TLSEXT_ERR_OK;
 899   }
 900
 901   const unsigned char* npnProtos =
 902       reinterpret_cast<const unsigned char*>(Buffer::Data(p->npnProtos_));
 903
 904   int status = SSL_select_next_proto(out, outlen, in, inlen, npnProtos,
 905                                      Buffer::Length(p->npnProtos_));
 906
 907   switch (status) {
 908     case OPENSSL_NPN_UNSUPPORTED:
 909       p->selectedNPNProto_ = Persistent<Value>::New(Null());
 910       break;
 911     case OPENSSL_NPN_NEGOTIATED:
 912       p->selectedNPNProto_ = Persistent<Value>::New(String::New(
 913                                  reinterpret_cast<const char*>(*out), *outlen
 914                              ));
 915       break;
 916     case OPENSSL_NPN_NO_OVERLAP:
 917       p->selectedNPNProto_ = Persistent<Value>::New(False());
 918       break;
 919     default:
 920       break;
 921   }
 922
 923   return SSL_TLSEXT_ERR_OK;
 924 }
 925 #endif
 926
 927 #ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
 928 int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) {
 929   HandleScope scope;
 930
 931   Connection *p = static_cast<Connection*> SSL_get_app_data(s);
 932
 933   const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 934
 935   if (servername) {
 936     if (!p->servername_.IsEmpty()) {
 937       p->servername_.Dispose();
 938     }
 939     p->servername_ = Persistent<String>::New(String::New(servername));
 940
 941     // Call the SNI callback and use its return value as context
 942     if (!p->sniObject_.IsEmpty()) {
 943       if (!p->sniContext_.IsEmpty()) {
 944         p->sniContext_.Dispose();
 945       }
 946
 947       // Get callback init args
 948       Local<Value> argv[1] = {*p->servername_};
 949
 950       // Call it
 951       Local<Value> ret = Local<Value>::New(MakeCallback(p->sniObject_,
 952                                                         "onselect",
 953                                                         ARRAY_SIZE(argv),
 954                                                         argv));
 955
 956       // If ret is SecureContext
 957       if (secure_context_constructor->HasInstance(ret)) {
 958         p->sniContext_ = Persistent<Value>::New(ret);
 959         SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(
 960                                 Local<Object>::Cast(ret));
 961         SSL_set_SSL_CTX(s, sc->ctx_);
 962       } else {
 963         return SSL_TLSEXT_ERR_NOACK;
 964       }
 965     }
 966   }
 967
 968   return SSL_TLSEXT_ERR_OK;
 969 }
 970 #endif
 971
 972 Handle<Value> Connection::New(const Arguments& args) {
 973   HandleScope scope;
 974
 975   Connection *p = new Connection();
 976   p->Wrap(args.Holder());
 977
 978   if (args.Length() < 1 || !args[0]->IsObject()) {
 979     return ThrowException(Exception::Error(String::New(
 980       "First argument must be a crypto module Credentials")));
 981   }
 982
 983   SecureContext *sc = ObjectWrap::Unwrap<SecureContext>(args[0]->ToObject());
 984
 985   bool is_server = args[1]->BooleanValue();
 986
 987   p->ssl_ = SSL_new(sc->ctx_);
 988   p->bio_read_ = BIO_new(BIO_s_mem());
 989   p->bio_write_ = BIO_new(BIO_s_mem());
 990
 991   SSL_set_app_data(p->ssl_, p);
 992
 993   if (is_server) SSL_set_info_callback(p->ssl_, SSLInfoCallback);
 994
 995 #ifdef OPENSSL_NPN_NEGOTIATED
 996   if (is_server) {
 997     // Server should advertise NPN protocols
 998     SSL_CTX_set_next_protos_advertised_cb(sc->ctx_,
 999                                           AdvertiseNextProtoCallback_,
1000                                           NULL);
1001   } else {
1002     // Client should select protocol from advertised
1003     // If server supports NPN
1004     SSL_CTX_set_next_proto_select_cb(sc->ctx_,
1005                                      SelectNextProtoCallback_,
1006                                      NULL);
1007   }
1008 #endif
1009
1010 #ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
1011   if (is_server) {
1012     SSL_CTX_set_tlsext_servername_callback(sc->ctx_, SelectSNIContextCallback_);
1013   } else {
1014     String::Utf8Value servername(args[2]);
1015     SSL_set_tlsext_host_name(p->ssl_, *servername);
1016   }
1017 #endif
1018
1019   SSL_set_bio(p->ssl_, p->bio_read_, p->bio_write_);
1020
1021 #ifdef SSL_MODE_RELEASE_BUFFERS
1022   long mode = SSL_get_mode(p->ssl_);
1023   SSL_set_mode(p->ssl_, mode | SSL_MODE_RELEASE_BUFFERS);
1024 #endif
1025
1026
1027   int verify_mode;
1028   if (is_server) {
1029     bool request_cert = args[2]->BooleanValue();
1030     if (!request_cert) {
1031       // Note reject_unauthorized ignored.
1032       verify_mode = SSL_VERIFY_NONE;
1033     } else {
1034       bool reject_unauthorized = args[3]->BooleanValue();
1035       verify_mode = SSL_VERIFY_PEER;
1036       if (reject_unauthorized) verify_mode |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
1037     }
1038   } else {
1039     // Note request_cert and reject_unauthorized are ignored for clients.
1040     verify_mode = SSL_VERIFY_NONE;
1041   }
1042
1043
1044   // Always allow a connection. We'll reject in javascript.
1045   SSL_set_verify(p->ssl_, verify_mode, VerifyCallback);
1046
1047   if ((p->is_server_ = is_server)) {
1048     SSL_set_accept_state(p->ssl_);
1049   } else {
1050     SSL_set_connect_state(p->ssl_);
1051   }
1052
1053   return args.This();
1054 }
1055
1056
1057 void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) {
1058   // Be compatible with older versions of OpenSSL. SSL_get_app_data() wants
1059   // a non-const SSL* in OpenSSL <= 0.9.7e.
1060   SSL* ssl = const_cast<SSL*>(ssl_);
1061   if (where & SSL_CB_HANDSHAKE_START) {
1062     HandleScope scope;
1063     Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
1064     if (onhandshakestart_sym.IsEmpty()) {
1065       onhandshakestart_sym = NODE_PSYMBOL("onhandshakestart");
1066     }
1067     MakeCallback(c->handle_, onhandshakestart_sym, 0, NULL);
1068   }
1069   if (where & SSL_CB_HANDSHAKE_DONE) {
1070     HandleScope scope;
1071     Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
1072     if (onhandshakedone_sym.IsEmpty()) {
1073       onhandshakedone_sym = NODE_PSYMBOL("onhandshakedone");
1074     }
1075     MakeCallback(c->handle_, onhandshakedone_sym, 0, NULL);
1076   }
1077 }
1078
1079
1080 Handle<Value> Connection::EncIn(const Arguments& args) {
1081   HandleScope scope;
1082
1083   Connection *ss = Connection::Unwrap(args);
1084
1085   if (args.Length() < 3) {
1086     return ThrowException(Exception::TypeError(
1087           String::New("Takes 3 parameters")));
1088   }
1089
1090   if (!Buffer::HasInstance(args[0])) {
1091     return ThrowException(Exception::TypeError(
1092           String::New("Second argument should be a buffer")));
1093   }
1094
1095   Local<Object> buffer_obj = args[0]->ToObject();
1096   char *buffer_data = Buffer::Data(buffer_obj);
1097   size_t buffer_length = Buffer::Length(buffer_obj);
1098
1099   size_t off = args[1]->Int32Value();
1100   if (off >= buffer_length) {
1101     return ThrowException(Exception::Error(
1102           String::New("Offset is out of bounds")));
1103   }
1104
1105   size_t len = args[2]->Int32Value();
1106   if (off + len > buffer_length) {
1107     return ThrowException(Exception::Error(
1108           String::New("off + len > buffer.length")));
1109   }
1110
1111   int bytes_written = BIO_write(ss->bio_read_, buffer_data + off, len);
1112   ss->HandleBIOError(ss->bio_read_, "BIO_write", bytes_written);
1113   ss->SetShutdownFlags();
1114
1115   return scope.Close(Integer::New(bytes_written));
1116 }
1117
1118
1119 Handle<Value> Connection::ClearOut(const Arguments& args) {
1120   HandleScope scope;
1121
1122   Connection *ss = Connection::Unwrap(args);
1123
1124   if (args.Length() < 3) {
1125     return ThrowException(Exception::TypeError(
1126           String::New("Takes 3 parameters")));
1127   }
1128
1129   if (!Buffer::HasInstance(args[0])) {
1130     return ThrowException(Exception::TypeError(
1131           String::New("Second argument should be a buffer")));
1132   }
1133
1134   Local<Object> buffer_obj = args[0]->ToObject();
1135   char *buffer_data = Buffer::Data(buffer_obj);
1136   size_t buffer_length = Buffer::Length(buffer_obj);
1137
1138   size_t off = args[1]->Int32Value();
1139   if (off >= buffer_length) {
1140     return ThrowException(Exception::Error(
1141           String::New("Offset is out of bounds")));
1142   }
1143
1144   size_t len = args[2]->Int32Value();
1145   if (off + len > buffer_length) {
1146     return ThrowException(Exception::Error(
1147           String::New("off + len > buffer.length")));
1148   }
1149
1150   if (!SSL_is_init_finished(ss->ssl_)) {
1151     int rv;
1152
1153     if (ss->is_server_) {
1154       rv = SSL_accept(ss->ssl_);
1155       ss->HandleSSLError("SSL_accept:ClearOut", rv);
1156     } else {
1157       rv = SSL_connect(ss->ssl_);
1158       ss->HandleSSLError("SSL_connect:ClearOut", rv);
1159     }
1160
1161     if (rv < 0) return scope.Close(Integer::New(rv));
1162   }
1163
1164   int bytes_read = SSL_read(ss->ssl_, buffer_data + off, len);
1165   ss->HandleSSLError("SSL_read:ClearOut", bytes_read);
1166   ss->SetShutdownFlags();
1167
1168   return scope.Close(Integer::New(bytes_read));
1169 }
1170
1171
1172 Handle<Value> Connection::ClearPending(const Arguments& args) {
1173   HandleScope scope;
1174
1175   Connection *ss = Connection::Unwrap(args);
1176
1177   int bytes_pending = BIO_pending(ss->bio_read_);
1178   return scope.Close(Integer::New(bytes_pending));
1179 }
1180
1181
1182 Handle<Value> Connection::EncPending(const Arguments& args) {
1183   HandleScope scope;
1184
1185   Connection *ss = Connection::Unwrap(args);
1186
1187   int bytes_pending = BIO_pending(ss->bio_write_);
1188   return scope.Close(Integer::New(bytes_pending));
1189 }
1190
1191
1192 Handle<Value> Connection::EncOut(const Arguments& args) {
1193   HandleScope scope;
1194
1195   Connection *ss = Connection::Unwrap(args);
1196
1197   if (args.Length() < 3) {
1198     return ThrowException(Exception::TypeError(
1199           String::New("Takes 3 parameters")));
1200   }
1201
1202   if (!Buffer::HasInstance(args[0])) {
1203     return ThrowException(Exception::TypeError(
1204           String::New("Second argument should be a buffer")));
1205   }
1206
1207   Local<Object> buffer_obj = args[0]->ToObject();
1208   char *buffer_data = Buffer::Data(buffer_obj);
1209   size_t buffer_length = Buffer::Length(buffer_obj);
1210
1211   size_t off = args[1]->Int32Value();
1212   if (off >= buffer_length) {
1213     return ThrowException(Exception::Error(
1214           String::New("Offset is out of bounds")));
1215   }
1216
1217   size_t len = args[2]->Int32Value();
1218   if (off + len > buffer_length) {
1219     return ThrowException(Exception::Error(
1220           String::New("off + len > buffer.length")));
1221   }
1222
1223   int bytes_read = BIO_read(ss->bio_write_, buffer_data + off, len);
1224
1225   ss->HandleBIOError(ss->bio_write_, "BIO_read:EncOut", bytes_read);
1226   ss->SetShutdownFlags();
1227
1228   return scope.Close(Integer::New(bytes_read));
1229 }
1230
1231
1232 Handle<Value> Connection::ClearIn(const Arguments& args) {
1233   HandleScope scope;
1234
1235   Connection *ss = Connection::Unwrap(args);
1236
1237   if (args.Length() < 3) {
1238     return ThrowException(Exception::TypeError(
1239           String::New("Takes 3 parameters")));
1240   }
1241
1242   if (!Buffer::HasInstance(args[0])) {
1243     return ThrowException(Exception::TypeError(
1244           String::New("Second argument should be a buffer")));
1245   }
1246
1247   Local<Object> buffer_obj = args[0]->ToObject();
1248   char *buffer_data = Buffer::Data(buffer_obj);
1249   size_t buffer_length = Buffer::Length(buffer_obj);
1250
1251   size_t off = args[1]->Int32Value();
1252   if (off > buffer_length) {
1253     return ThrowException(Exception::Error(
1254           String::New("Offset is out of bounds")));
1255   }
1256
1257   size_t len = args[2]->Int32Value();
1258   if (off + len > buffer_length) {
1259     return ThrowException(Exception::Error(
1260           String::New("off + len > buffer.length")));
1261   }
1262
1263   if (!SSL_is_init_finished(ss->ssl_)) {
1264     int rv;
1265     if (ss->is_server_) {
1266       rv = SSL_accept(ss->ssl_);
1267       ss->HandleSSLError("SSL_accept:ClearIn", rv);
1268     } else {
1269       rv = SSL_connect(ss->ssl_);
1270       ss->HandleSSLError("SSL_connect:ClearIn", rv);
1271     }
1272
1273     if (rv < 0) return scope.Close(Integer::New(rv));
1274   }
1275
1276   int bytes_written = SSL_write(ss->ssl_, buffer_data + off, len);
1277
1278   ss->HandleSSLError("SSL_write:ClearIn", bytes_written);
1279   ss->SetShutdownFlags();
1280
1281   return scope.Close(Integer::New(bytes_written));
1282 }
1283
1284
1285 Handle<Value> Connection::GetPeerCertificate(const Arguments& args) {
1286   HandleScope scope;
1287
1288   Connection *ss = Connection::Unwrap(args);
1289
1290   if (ss->ssl_ == NULL) return Undefined();
1291   Local<Object> info = Object::New();
1292   X509* peer_cert = SSL_get_peer_certificate(ss->ssl_);
1293   if (peer_cert != NULL) {
1294     BIO* bio = BIO_new(BIO_s_mem());
1295     BUF_MEM* mem;
1296     if (X509_NAME_print_ex(bio, X509_get_subject_name(peer_cert), 0,
1297                            X509_NAME_FLAGS) > 0) {
1298       BIO_get_mem_ptr(bio, &mem);
1299       info->Set(subject_symbol, String::New(mem->data, mem->length));
1300     }
1301     (void) BIO_reset(bio);
1302
1303     if (X509_NAME_print_ex(bio, X509_get_issuer_name(peer_cert), 0,
1304                            X509_NAME_FLAGS) > 0) {
1305       BIO_get_mem_ptr(bio, &mem);
1306       info->Set(issuer_symbol, String::New(mem->data, mem->length));
1307     }
1308     (void) BIO_reset(bio);
1309
1310     int index = X509_get_ext_by_NID(peer_cert, NID_subject_alt_name, -1);
1311     if (index >= 0) {
1312       X509_EXTENSION* ext;
1313       int rv;
1314
1315       ext = X509_get_ext(peer_cert, index);
1316       assert(ext != NULL);
1317
1318       rv = X509V3_EXT_print(bio, ext, 0, 0);
1319       assert(rv == 1);
1320
1321       BIO_get_mem_ptr(bio, &mem);
1322       info->Set(subjectaltname_symbol, String::New(mem->data, mem->length));
1323
1324       (void) BIO_reset(bio);
1325     }
1326
1327     EVP_PKEY *pkey = NULL;
1328     RSA *rsa = NULL;
1329     if( NULL != (pkey = X509_get_pubkey(peer_cert))
1330         && NULL != (rsa = EVP_PKEY_get1_RSA(pkey)) ) {
1331         BN_print(bio, rsa->n);
1332         BIO_get_mem_ptr(bio, &mem);
1333         info->Set(modulus_symbol, String::New(mem->data, mem->length) );
1334         (void) BIO_reset(bio);
1335
1336         BN_print(bio, rsa->e);
1337         BIO_get_mem_ptr(bio, &mem);
1338         info->Set(exponent_symbol, String::New(mem->data, mem->length) );
1339         (void) BIO_reset(bio);
1340     }
1341
1342     ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
1343     BIO_get_mem_ptr(bio, &mem);
1344     info->Set(valid_from_symbol, String::New(mem->data, mem->length));
1345     (void) BIO_reset(bio);
1346
1347     ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
1348     BIO_get_mem_ptr(bio, &mem);
1349     info->Set(valid_to_symbol, String::New(mem->data, mem->length));
1350     BIO_free(bio);
1351
1352     unsigned int md_size, i;
1353     unsigned char md[EVP_MAX_MD_SIZE];
1354     if (X509_digest(peer_cert, EVP_sha1(), md, &md_size)) {
1355       const char hex[] = "0123456789ABCDEF";
1356       char fingerprint[EVP_MAX_MD_SIZE * 3];
1357
1358       for (i=0; i<md_size; i++) {
1359         fingerprint[3*i] = hex[(md[i] & 0xf0) >> 4];
1360         fingerprint[(3*i)+1] = hex[(md[i] & 0x0f)];
1361         fingerprint[(3*i)+2] = ':';
1362       }
1363
1364       if (md_size > 0) {
1365         fingerprint[(3*(md_size-1))+2] = '\0';
1366       }
1367       else {
1368         fingerprint[0] = '\0';
1369       }
1370
1371       info->Set(fingerprint_symbol, String::New(fingerprint));
1372     }
1373
1374     STACK_OF(ASN1_OBJECT) *eku = (STACK_OF(ASN1_OBJECT) *)X509_get_ext_d2i(
1375         peer_cert, NID_ext_key_usage, NULL, NULL);
1376     if (eku != NULL) {
1377       Local<Array> ext_key_usage = Array::New();
1378       char buf[256];
1379
1380       for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
1381         memset(buf, 0, sizeof(buf));
1382         OBJ_obj2txt(buf, sizeof(buf) - 1, sk_ASN1_OBJECT_value(eku, i), 1);
1383         ext_key_usage->Set(Integer::New(i), String::New(buf));
1384       }
1385
1386       sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
1387       info->Set(ext_key_usage_symbol, ext_key_usage);
1388     }
1389
1390     X509_free(peer_cert);
1391   }
1392   return scope.Close(info);
1393 }
1394
1395 Handle<Value> Connection::GetSession(const Arguments& args) {
1396   HandleScope scope;
1397
1398   Connection *ss = Connection::Unwrap(args);
1399
1400   if (ss->ssl_ == NULL) return Undefined();
1401
1402   SSL_SESSION* sess = SSL_get_session(ss->ssl_);
1403   if (!sess) return Undefined();
1404
1405   int slen = i2d_SSL_SESSION(sess, NULL);
1406   assert(slen > 0);
1407
1408   if (slen > 0) {
1409     unsigned char* sbuf = new unsigned char[slen];
1410     unsigned char* p = sbuf;
1411     i2d_SSL_SESSION(sess, &p);
1412     Local<Value> s = Encode(sbuf, slen, BINARY);
1413     delete[] sbuf;
1414     return scope.Close(s);
1415   }
1416
1417   return Null();
1418 }
1419
1420 Handle<Value> Connection::SetSession(const Arguments& args) {
1421   HandleScope scope;
1422
1423   Connection *ss = Connection::Unwrap(args);
1424
1425   if (args.Length() < 1 || !args[0]->IsString()) {
1426     Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
1427     return ThrowException(exception);
1428   }
1429
1430   ASSERT_IS_STRING_OR_BUFFER(args[0]);
1431   ssize_t slen = DecodeBytes(args[0], BINARY);
1432
1433   if (slen < 0) {
1434     Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
1435     return ThrowException(exception);
1436   }
1437
1438   char* sbuf = new char[slen];
1439
1440   ssize_t wlen = DecodeWrite(sbuf, slen, args[0], BINARY);
1441   assert(wlen == slen);
1442
1443   const unsigned char* p = (unsigned char*) sbuf;
1444   SSL_SESSION* sess = d2i_SSL_SESSION(NULL, &p, wlen);
1445
1446   delete [] sbuf;
1447
1448   if (!sess)
1449     return Undefined();
1450
1451   int r = SSL_set_session(ss->ssl_, sess);
1452   SSL_SESSION_free(sess);
1453
1454   if (!r) {
1455     Local<String> eStr = String::New("SSL_set_session error");
1456     return ThrowException(Exception::Error(eStr));
1457   }
1458
1459   return True();
1460 }
1461
1462 Handle<Value> Connection::IsSessionReused(const Arguments& args) {
1463   HandleScope scope;
1464
1465   Connection *ss = Connection::Unwrap(args);
1466
1467   if (ss->ssl_ == NULL) return False();
1468   return SSL_session_reused(ss->ssl_) ? True() : False();
1469 }
1470
1471
1472 Handle<Value> Connection::Start(const Arguments& args) {
1473   HandleScope scope;
1474
1475   Connection *ss = Connection::Unwrap(args);
1476
1477   if (!SSL_is_init_finished(ss->ssl_)) {
1478     int rv;
1479     if (ss->is_server_) {
1480       rv = SSL_accept(ss->ssl_);
1481       ss->HandleSSLError("SSL_accept:Start", rv);
1482     } else {
1483       rv = SSL_connect(ss->ssl_);
1484       ss->HandleSSLError("SSL_connect:Start", rv);
1485     }
1486
1487     return scope.Close(Integer::New(rv));
1488   }
1489
1490   return scope.Close(Integer::New(0));
1491 }
1492
1493
1494 Handle<Value> Connection::Shutdown(const Arguments& args) {
1495   HandleScope scope;
1496
1497   Connection *ss = Connection::Unwrap(args);
1498
1499   if (ss->ssl_ == NULL) return False();
1500   int rv = SSL_shutdown(ss->ssl_);
1501
1502   ss->HandleSSLError("SSL_shutdown", rv);
1503   ss->SetShutdownFlags();
1504
1505   return scope.Close(Integer::New(rv));
1506 }
1507
1508
1509 Handle<Value> Connection::ReceivedShutdown(const Arguments& args) {
1510   HandleScope scope;
1511
1512   Connection *ss = Connection::Unwrap(args);
1513
1514   if (ss->ssl_ == NULL) return False();
1515   int r = SSL_get_shutdown(ss->ssl_);
1516
1517   if (r & SSL_RECEIVED_SHUTDOWN) return True();
1518
1519   return False();
1520 }
1521
1522
1523 Handle<Value> Connection::IsInitFinished(const Arguments& args) {
1524   HandleScope scope;
1525
1526   Connection *ss = Connection::Unwrap(args);
1527
1528   if (ss->ssl_ == NULL) return False();
1529   return SSL_is_init_finished(ss->ssl_) ? True() : False();
1530 }
1531
1532
1533 Handle<Value> Connection::VerifyError(const Arguments& args) {
1534   HandleScope scope;
1535
1536   Connection *ss = Connection::Unwrap(args);
1537
1538   if (ss->ssl_ == NULL) return Null();
1539
1540
1541   // XXX Do this check in JS land?
1542   X509* peer_cert = SSL_get_peer_certificate(ss->ssl_);
1543   if (peer_cert == NULL) {
1544     // We requested a certificate and they did not send us one.
1545     // Definitely an error.
1546     // XXX is this the right error message?
1547     return scope.Close(Exception::Error(
1548           String::New("UNABLE_TO_GET_ISSUER_CERT")));
1549   }
1550   X509_free(peer_cert);
1551
1552
1553   long x509_verify_error = SSL_get_verify_result(ss->ssl_);
1554
1555   Local<String> s;
1556
1557   switch (x509_verify_error) {
1558     case X509_V_OK:
1559       return Null();
1560
1561     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
1562       s = String::New("UNABLE_TO_GET_ISSUER_CERT");
1563       break;
1564
1565     case X509_V_ERR_UNABLE_TO_GET_CRL:
1566       s = String::New("UNABLE_TO_GET_CRL");
1567       break;
1568
1569     case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
1570       s = String::New("UNABLE_TO_DECRYPT_CERT_SIGNATURE");
1571       break;
1572
1573     case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
1574       s = String::New("UNABLE_TO_DECRYPT_CRL_SIGNATURE");
1575       break;
1576
1577     case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
1578       s = String::New("UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");
1579       break;
1580
1581     case X509_V_ERR_CERT_SIGNATURE_FAILURE:
1582       s = String::New("CERT_SIGNATURE_FAILURE");
1583       break;
1584
1585     case X509_V_ERR_CRL_SIGNATURE_FAILURE:
1586       s = String::New("CRL_SIGNATURE_FAILURE");
1587       break;
1588
1589     case X509_V_ERR_CERT_NOT_YET_VALID:
1590       s = String::New("CERT_NOT_YET_VALID");
1591       break;
1592
1593     case X509_V_ERR_CERT_HAS_EXPIRED:
1594       s = String::New("CERT_HAS_EXPIRED");
1595       break;
1596
1597     case X509_V_ERR_CRL_NOT_YET_VALID:
1598       s = String::New("CRL_NOT_YET_VALID");
1599       break;
1600
1601     case X509_V_ERR_CRL_HAS_EXPIRED:
1602       s = String::New("CRL_HAS_EXPIRED");
1603       break;
1604
1605     case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
1606       s = String::New("ERROR_IN_CERT_NOT_BEFORE_FIELD");
1607       break;
1608
1609     case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
1610       s = String::New("ERROR_IN_CERT_NOT_AFTER_FIELD");
1611       break;
1612
1613     case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
1614       s = String::New("ERROR_IN_CRL_LAST_UPDATE_FIELD");
1615       break;
1616
1617     case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
1618       s = String::New("ERROR_IN_CRL_NEXT_UPDATE_FIELD");
1619       break;
1620
1621     case X509_V_ERR_OUT_OF_MEM:
1622       s = String::New("OUT_OF_MEM");
1623       break;
1624
1625     case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
1626       s = String::New("DEPTH_ZERO_SELF_SIGNED_CERT");
1627       break;
1628
1629     case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
1630       s = String::New("SELF_SIGNED_CERT_IN_CHAIN");
1631       break;
1632
1633     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
1634       s = String::New("UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
1635       break;
1636
1637     case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
1638       s = String::New("UNABLE_TO_VERIFY_LEAF_SIGNATURE");
1639       break;
1640
1641     case X509_V_ERR_CERT_CHAIN_TOO_LONG:
1642       s = String::New("CERT_CHAIN_TOO_LONG");
1643       break;
1644
1645     case X509_V_ERR_CERT_REVOKED:
1646       s = String::New("CERT_REVOKED");
1647       break;
1648
1649     case X509_V_ERR_INVALID_CA:
1650       s = String::New("INVALID_CA");
1651       break;
1652
1653     case X509_V_ERR_PATH_LENGTH_EXCEEDED:
1654       s = String::New("PATH_LENGTH_EXCEEDED");
1655       break;
1656
1657     case X509_V_ERR_INVALID_PURPOSE:
1658       s = String::New("INVALID_PURPOSE");
1659       break;
1660
1661     case X509_V_ERR_CERT_UNTRUSTED:
1662       s = String::New("CERT_UNTRUSTED");
1663       break;
1664
1665     case X509_V_ERR_CERT_REJECTED:
1666       s = String::New("CERT_REJECTED");
1667       break;
1668
1669     default:
1670       s = String::New(X509_verify_cert_error_string(x509_verify_error));
1671       break;
1672   }
1673
1674   return scope.Close(Exception::Error(s));
1675 }
1676
1677
1678 Handle<Value> Connection::GetCurrentCipher(const Arguments& args) {
1679   HandleScope scope;
1680
1681   Connection *ss = Connection::Unwrap(args);
1682
1683   OPENSSL_CONST SSL_CIPHER *c;
1684
1685   if ( ss->ssl_ == NULL ) return Undefined();
1686   c = SSL_get_current_cipher(ss->ssl_);
1687   if ( c == NULL ) return Undefined();
1688   Local<Object> info = Object::New();
1689   const char *cipher_name = SSL_CIPHER_get_name(c);
1690   info->Set(name_symbol, String::New(cipher_name));
1691   const char *cipher_version = SSL_CIPHER_get_version(c);
1692   info->Set(version_symbol, String::New(cipher_version));
1693   return scope.Close(info);
1694 }
1695
1696 Handle<Value> Connection::Close(const Arguments& args) {
1697   HandleScope scope;
1698
1699   Connection *ss = Connection::Unwrap(args);
1700
1701   if (ss->ssl_ != NULL) {
1702     SSL_free(ss->ssl_);
1703     ss->ssl_ = NULL;
1704   }
1705   return True();
1706 }
1707
1708 #ifdef OPENSSL_NPN_NEGOTIATED
1709 Handle<Value> Connection::GetNegotiatedProto(const Arguments& args) {
1710   HandleScope scope;
1711
1712   Connection *ss = Connection::Unwrap(args);
1713
1714   if (ss->is_server_) {
1715     const unsigned char *npn_proto;
1716     unsigned int npn_proto_len;
1717
1718     SSL_get0_next_proto_negotiated(ss->ssl_, &npn_proto, &npn_proto_len);
1719
1720     if (!npn_proto) {
1721       return False();
1722     }
1723
1724     return String::New((const char*) npn_proto, npn_proto_len);
1725   } else {
1726     return ss->selectedNPNProto_;
1727   }
1728 }
1729
1730 Handle<Value> Connection::SetNPNProtocols(const Arguments& args) {
1731   HandleScope scope;
1732
1733   Connection *ss = Connection::Unwrap(args);
1734
1735   if (args.Length() < 1 || !Buffer::HasInstance(args[0])) {
1736     return ThrowException(Exception::Error(String::New(
1737            "Must give a Buffer as first argument")));
1738   }
1739
1740   // Release old handle
1741   if (!ss->npnProtos_.IsEmpty()) {
1742     ss->npnProtos_.Dispose();
1743   }
1744   ss->npnProtos_ = Persistent<Object>::New(args[0]->ToObject());
1745
1746   return True();
1747 };
1748 #endif
1749
1750 #ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
1751 Handle<Value> Connection::GetServername(const Arguments& args) {
1752   HandleScope scope;
1753
1754   Connection *ss = Connection::Unwrap(args);
1755
1756   if (ss->is_server_ && !ss->servername_.IsEmpty()) {
1757     return ss->servername_;
1758   } else {
1759     return False();
1760   }
1761 }
1762
1763 Handle<Value> Connection::SetSNICallback(const Arguments& args) {
1764   HandleScope scope;
1765
1766   Connection *ss = Connection::Unwrap(args);
1767
1768   if (args.Length() < 1 || !args[0]->IsFunction()) {
1769     return ThrowException(Exception::Error(String::New(
1770            "Must give a Function as first argument")));
1771   }
1772
1773   // Release old handle
1774   if (!ss->sniObject_.IsEmpty()) {
1775     ss->sniObject_.Dispose();
1776   }
1777   ss->sniObject_ = Persistent<Object>::New(Object::New());
1778   ss->sniObject_->Set(String::New("onselect"), args[0]);
1779
1780   return True();
1781 }
1782 #endif
1783
1784 static void HexEncode(unsigned char *md_value,
1785                       int md_len,
1786                       char** md_hexdigest,
1787                       int* md_hex_len) {
1788   *md_hex_len = (2*(md_len));
1789   *md_hexdigest = new char[*md_hex_len + 1];
1790
1791   char* buff = *md_hexdigest;
1792   const int len = *md_hex_len;
1793   for (int i = 0; i < len; i += 2) {
1794     // nibble nibble
1795     const int index = i / 2;
1796     const char msb = (md_value[index] >> 4) & 0x0f;
1797     const char lsb = md_value[index] & 0x0f;
1798
1799     buff[i] = (msb < 10) ? msb + '0' : (msb - 10) + 'a';
1800     buff[i + 1] = (lsb < 10) ? lsb + '0' : (lsb - 10) + 'a';
1801   }
1802   // null terminator
1803   buff[*md_hex_len] = '\0';
1804 }
1805
1806 #define hex2i(c) ((c) <= '9' ? ((c) - '0') : (c) <= 'Z' ? ((c) - 'A' + 10) \
1807                  : ((c) - 'a' + 10))
1808
1809 static void HexDecode(unsigned char *input,
1810                       int length,
1811                       char** buf64,
1812                       int* buf64_len) {
1813   *buf64_len = (length/2);
1814   *buf64 = new char[length/2 + 1];
1815   char *b = *buf64;
1816   for(int i = 0; i < length-1; i+=2) {
1817     b[i/2]  = (hex2i(input[i])<<4) | (hex2i(input[i+1]));
1818   }
1819 }
1820
1821
1822 void base64(unsigned char *input, int length, char** buf64, int* buf64_len) {
1823   BIO *b64 = BIO_new(BIO_f_base64());
1824   BIO *bmem = BIO_new(BIO_s_mem());
1825   b64 = BIO_push(b64, bmem);
1826   BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
1827   int len = BIO_write(b64, input, length);
1828   assert(len == length);
1829   int r = BIO_flush(b64);
1830   assert(r == 1);
1831
1832   BUF_MEM *bptr;
1833   BIO_get_mem_ptr(b64, &bptr);
1834
1835   *buf64_len = bptr->length;
1836   *buf64 = new char[*buf64_len+1];
1837   memcpy(*buf64, bptr->data, *buf64_len);
1838   char* b = *buf64;
1839   b[*buf64_len] = 0;
1840
1841   BIO_free_all(b64);
1842 }
1843
1844
1845 void unbase64(unsigned char *input,
1846                int length,
1847                char** buffer,
1848                int* buffer_len) {
1849   BIO *b64, *bmem;
1850   *buffer = new char[length];
1851   memset(*buffer, 0, length);
1852
1853   b64 = BIO_new(BIO_f_base64());
1854   BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
1855   bmem = BIO_new_mem_buf(input, length);
1856   bmem = BIO_push(b64, bmem);
1857
1858   *buffer_len = BIO_read(bmem, *buffer, length);
1859   BIO_free_all(bmem);
1860 }
1861
1862
1863 // LengthWithoutIncompleteUtf8 from V8 d8-posix.cc
1864 // see http://v8.googlecode.com/svn/trunk/src/d8-posix.cc
1865 static int LengthWithoutIncompleteUtf8(char* buffer, int len) {
1866   int answer = len;
1867   // 1-byte encoding.
1868   static const int kUtf8SingleByteMask = 0x80;
1869   static const int kUtf8SingleByteValue = 0x00;
1870   // 2-byte encoding.
1871   static const int kUtf8TwoByteMask = 0xe0;
1872   static const int kUtf8TwoByteValue = 0xc0;
1873   // 3-byte encoding.
1874   static const int kUtf8ThreeByteMask = 0xf0;
1875   static const int kUtf8ThreeByteValue = 0xe0;
1876   // 4-byte encoding.
1877   static const int kUtf8FourByteMask = 0xf8;
1878   static const int kUtf8FourByteValue = 0xf0;
1879   // Subsequent bytes of a multi-byte encoding.
1880   static const int kMultiByteMask = 0xc0;
1881   static const int kMultiByteValue = 0x80;
1882   int multi_byte_bytes_seen = 0;
1883   while (answer > 0) {
1884     int c = buffer[answer - 1];
1885     // Ends in valid single-byte sequence?
1886     if ((c & kUtf8SingleByteMask) == kUtf8SingleByteValue) return answer;
1887     // Ends in one or more subsequent bytes of a multi-byte value?
1888     if ((c & kMultiByteMask) == kMultiByteValue) {
1889       multi_byte_bytes_seen++;
1890       answer--;
1891     } else {
1892       if ((c & kUtf8TwoByteMask) == kUtf8TwoByteValue) {
1893         if (multi_byte_bytes_seen >= 1) {
1894           return answer + 2;
1895         }
1896         return answer - 1;
1897       } else if ((c & kUtf8ThreeByteMask) == kUtf8ThreeByteValue) {
1898         if (multi_byte_bytes_seen >= 2) {
1899           return answer + 3;
1900         }
1901         return answer - 1;
1902       } else if ((c & kUtf8FourByteMask) == kUtf8FourByteValue) {
1903         if (multi_byte_bytes_seen >= 3) {
1904           return answer + 4;
1905         }
1906         return answer - 1;
1907       } else {
1908         return answer;  // Malformed UTF-8.
1909       }
1910     }
1911   }
1912   return 0;
1913 }
1914
1915
1916 // local decrypt final without strict padding check
1917 // to work with php mcrypt
1918 // see http://www.mail-archive.com/openssl-dev@openssl.org/msg19927.html
1919 int local_EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx,
1920                               unsigned char *out,
1921                               int *outl) {
1922   int i,b;
1923   int n;
1924
1925   *outl=0;
1926   b=ctx->cipher->block_size;
1927
1928   if (ctx->flags & EVP_CIPH_NO_PADDING) {
1929     if(ctx->buf_len) {
1930       EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH);
1931       return 0;
1932     }
1933     *outl = 0;
1934     return 1;
1935   }
1936
1937   if (b > 1) {
1938     if (ctx->buf_len || !ctx->final_used) {
1939       EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_WRONG_FINAL_BLOCK_LENGTH);
1940       return(0);
1941     }
1942
1943     if (b > (int)(sizeof(ctx->final) / sizeof(ctx->final[0]))) {
1944       EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT);
1945       return(0);
1946     }
1947
1948     n=ctx->final[b-1];
1949
1950     if (n > b) {
1951       EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT);
1952       return(0);
1953     }
1954
1955     for (i=0; i<n; i++) {
1956       if (ctx->final[--b] != n) {
1957         EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT);
1958         return(0);
1959       }
1960     }
1961
1962     n=ctx->cipher->block_size-n;
1963
1964     for (i=0; i<n; i++) {
1965       out[i]=ctx->final[i];
1966     }
1967     *outl=n;
1968   } else {
1969     *outl=0;
1970   }
1971
1972   return(1);
1973 }
1974
1975
1976 class Cipher : public ObjectWrap {
1977  public:
1978   static void Initialize (v8::Handle<v8::Object> target) {
1979     HandleScope scope;
1980
1981     Local<FunctionTemplate> t = FunctionTemplate::New(New);
1982
1983     t->InstanceTemplate()->SetInternalFieldCount(1);
1984
1985     NODE_SET_PROTOTYPE_METHOD(t, "init", CipherInit);
1986     NODE_SET_PROTOTYPE_METHOD(t, "initiv", CipherInitIv);
1987     NODE_SET_PROTOTYPE_METHOD(t, "update", CipherUpdate);
1988     NODE_SET_PROTOTYPE_METHOD(t, "setAutoPadding", SetAutoPadding);
1989     NODE_SET_PROTOTYPE_METHOD(t, "final", CipherFinal);
1990
1991     target->Set(String::NewSymbol("Cipher"), t->GetFunction());
1992   }
1993
1994
1995   bool CipherInit(char* cipherType, char* key_buf, int key_buf_len) {
1996     cipher = EVP_get_cipherbyname(cipherType);
1997     if(!cipher) {
1998       fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);
1999       return false;
2000     }
2001
2002     unsigned char key[EVP_MAX_KEY_LENGTH],iv[EVP_MAX_IV_LENGTH];
2003     int key_len = EVP_BytesToKey(cipher, EVP_md5(), NULL,
2004       (unsigned char*) key_buf, key_buf_len, 1, key, iv);
2005
2006     EVP_CIPHER_CTX_init(&ctx);
2007     EVP_CipherInit_ex(&ctx, cipher, NULL, NULL, NULL, true);
2008     if (!EVP_CIPHER_CTX_set_key_length(&ctx, key_len)) {
2009       fprintf(stderr, "node-crypto : Invalid key length %d\n", key_len);
2010       EVP_CIPHER_CTX_cleanup(&ctx);
2011       return false;
2012     }
2013     EVP_CipherInit_ex(&ctx, NULL, NULL,
2014       (unsigned char *)key,
2015       (unsigned char *)iv, true);
2016     initialised_ = true;
2017     return true;
2018   }
2019
2020
2021   bool CipherInitIv(char* cipherType,
2022                     char* key,
2023                     int key_len,
2024                     char *iv,
2025                     int iv_len) {
2026     cipher = EVP_get_cipherbyname(cipherType);
2027     if(!cipher) {
2028       fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);
2029       return false;
2030     }
2031     /* OpenSSL versions up to 0.9.8l failed to return the correct
2032        iv_length (0) for ECB ciphers */
2033     if (EVP_CIPHER_iv_length(cipher) != iv_len &&
2034       !(EVP_CIPHER_mode(cipher) == EVP_CIPH_ECB_MODE && iv_len == 0)) {
2035       fprintf(stderr, "node-crypto : Invalid IV length %d\n", iv_len);
2036       return false;
2037     }
2038     EVP_CIPHER_CTX_init(&ctx);
2039     EVP_CipherInit_ex(&ctx, cipher, NULL, NULL, NULL, true);
2040     if (!EVP_CIPHER_CTX_set_key_length(&ctx, key_len)) {
2041       fprintf(stderr, "node-crypto : Invalid key length %d\n", key_len);
2042       EVP_CIPHER_CTX_cleanup(&ctx);
2043       return false;
2044     }
2045     EVP_CipherInit_ex(&ctx, NULL, NULL,
2046       (unsigned char *)key,
2047       (unsigned char *)iv, true);
2048     initialised_ = true;
2049     return true;
2050   }
2051
2052   int CipherUpdate(char* data, int len, unsigned char** out, int* out_len) {
2053     if (!initialised_) return 0;
2054     *out_len=len+EVP_CIPHER_CTX_block_size(&ctx);
2055     *out= new unsigned char[*out_len];
2056
2057     EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len);
2058     return 1;
2059   }
2060
2061   int SetAutoPadding(bool auto_padding) {
2062     if (!initialised_) return 0;
2063     return EVP_CIPHER_CTX_set_padding(&ctx, auto_padding ? 1 : 0);
2064   }
2065
2066   int CipherFinal(unsigned char** out, int *out_len) {
2067     if (!initialised_) return 0;
2068     *out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)];
2069     int r = EVP_CipherFinal_ex(&ctx,*out, out_len);
2070     EVP_CIPHER_CTX_cleanup(&ctx);
2071     initialised_ = false;
2072     return r;
2073   }
2074
2075
2076  protected:
2077
2078   static Handle<Value> New(const Arguments& args) {
2079     HandleScope scope;
2080
2081     Cipher *cipher = new Cipher();
2082     cipher->Wrap(args.This());
2083     return args.This();
2084   }
2085
2086   static Handle<Value> CipherInit(const Arguments& args) {
2087     HandleScope scope;
2088
2089     Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
2090
2091     cipher->incomplete_base64 = NULL;
2092
2093     if (args.Length() <= 1
2094         || !args[0]->IsString()
2095         || !(args[1]->IsString() || Buffer::HasInstance(args[1])))
2096     {
2097       return ThrowException(Exception::Error(String::New(
2098         "Must give cipher-type, key")));
2099     }
2100
2101     ASSERT_IS_STRING_OR_BUFFER(args[1]);
2102     ssize_t key_buf_len = DecodeBytes(args[1], BINARY);
2103
2104     if (key_buf_len < 0) {
2105       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2106       return ThrowException(exception);
2107     }
2108
2109     char* key_buf = new char[key_buf_len];
2110     ssize_t key_written = DecodeWrite(key_buf, key_buf_len, args[1], BINARY);
2111     assert(key_written == key_buf_len);
2112
2113     String::Utf8Value cipherType(args[0]);
2114
2115     bool r = cipher->CipherInit(*cipherType, key_buf, key_buf_len);
2116
2117     delete [] key_buf;
2118
2119     if (!r) {
2120       return ThrowException(Exception::Error(String::New("CipherInit error")));
2121     }
2122
2123     return args.This();
2124   }
2125
2126
2127   static Handle<Value> CipherInitIv(const Arguments& args) {
2128     Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
2129
2130     HandleScope scope;
2131
2132     cipher->incomplete_base64 = NULL;
2133
2134     if (args.Length() <= 2
2135         || !args[0]->IsString()
2136         || !(args[1]->IsString() || Buffer::HasInstance(args[1]))
2137         || !(args[2]->IsString() || Buffer::HasInstance(args[2])))
2138     {
2139       return ThrowException(Exception::Error(String::New(
2140         "Must give cipher-type, key, and iv as argument")));
2141     }
2142
2143     ASSERT_IS_STRING_OR_BUFFER(args[1]);
2144     ssize_t key_len = DecodeBytes(args[1], BINARY);
2145
2146     if (key_len < 0) {
2147       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2148       return ThrowException(exception);
2149     }
2150
2151     ASSERT_IS_STRING_OR_BUFFER(args[2]);
2152     ssize_t iv_len = DecodeBytes(args[2], BINARY);
2153
2154     if (iv_len < 0) {
2155       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2156       return ThrowException(exception);
2157     }
2158
2159     char* key_buf = new char[key_len];
2160     ssize_t key_written = DecodeWrite(key_buf, key_len, args[1], BINARY);
2161     assert(key_written == key_len);
2162
2163     char* iv_buf = new char[iv_len];
2164     ssize_t iv_written = DecodeWrite(iv_buf, iv_len, args[2], BINARY);
2165     assert(iv_written == iv_len);
2166
2167     String::Utf8Value cipherType(args[0]);
2168
2169     bool r = cipher->CipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len);
2170
2171     delete [] key_buf;
2172     delete [] iv_buf;
2173
2174     if (!r) {
2175       return ThrowException(Exception::Error(String::New("CipherInitIv error")));
2176     }
2177
2178     return args.This();
2179   }
2180
2181   static Handle<Value> CipherUpdate(const Arguments& args) {
2182     Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
2183
2184     HandleScope scope;
2185
2186     ASSERT_IS_STRING_OR_BUFFER(args[0]);
2187
2188     enum encoding enc = ParseEncoding(args[1]);
2189     ssize_t len = DecodeBytes(args[0], enc);
2190
2191     if (len < 0) {
2192       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2193       return ThrowException(exception);
2194     }
2195
2196     unsigned char *out=0;
2197     int out_len=0, r;
2198     if (Buffer::HasInstance(args[0])) {
2199       Local<Object> buffer_obj = args[0]->ToObject();
2200       char *buffer_data = Buffer::Data(buffer_obj);
2201       size_t buffer_length = Buffer::Length(buffer_obj);
2202
2203       r = cipher->CipherUpdate(buffer_data, buffer_length, &out, &out_len);
2204     } else {
2205       char* buf = new char[len];
2206       ssize_t written = DecodeWrite(buf, len, args[0], enc);
2207       assert(written == len);
2208       r = cipher->CipherUpdate(buf, len,&out,&out_len);
2209       delete [] buf;
2210     }
2211
2212     if (!r) {
2213       delete [] out;
2214       Local<Value> exception = Exception::TypeError(String::New("DecipherUpdate fail"));
2215       return ThrowException(exception);
2216     }
2217
2218     Local<Value> outString;
2219     if (out_len==0) {
2220       outString=String::New("");
2221     } else {
2222       char* out_hexdigest;
2223       int out_hex_len;
2224       enum encoding enc = ParseEncoding(args[2], BINARY);
2225       if (enc == HEX) {
2226         // Hex encoding
2227         HexEncode(out, out_len, &out_hexdigest, &out_hex_len);
2228         outString = Encode(out_hexdigest, out_hex_len, BINARY);
2229         delete [] out_hexdigest;
2230       } else if (enc == BASE64) {
2231         // Base64 encoding
2232         // Check to see if we need to add in previous base64 overhang
2233         if (cipher->incomplete_base64!=NULL){
2234           unsigned char* complete_base64 = new unsigned char[out_len+cipher->incomplete_base64_len+1];
2235           memcpy(complete_base64, cipher->incomplete_base64, cipher->incomplete_base64_len);
2236           memcpy(&complete_base64[cipher->incomplete_base64_len], out, out_len);
2237           delete [] out;
2238
2239           delete [] cipher->incomplete_base64;
2240           cipher->incomplete_base64=NULL;
2241
2242           out=complete_base64;
2243           out_len += cipher->incomplete_base64_len;
2244         }
2245
2246         // Check to see if we need to trim base64 stream
2247         if (out_len%3!=0){
2248           cipher->incomplete_base64_len = out_len%3;
2249           cipher->incomplete_base64 = new char[cipher->incomplete_base64_len+1];
2250           memcpy(cipher->incomplete_base64,
2251                  &out[out_len-cipher->incomplete_base64_len],
2252                  cipher->incomplete_base64_len);
2253           out_len -= cipher->incomplete_base64_len;
2254           out[out_len]=0;
2255         }
2256
2257         base64(out, out_len, &out_hexdigest, &out_hex_len);
2258         outString = Encode(out_hexdigest, out_hex_len, BINARY);
2259         delete [] out_hexdigest;
2260       } else if (enc == BINARY) {
2261         outString = Encode(out, out_len, BINARY);
2262       } else {
2263         fprintf(stderr, "node-crypto : Cipher .update encoding "
2264                         "can be binary, hex or base64\n");
2265       }
2266     }
2267
2268     if (out) delete [] out;
2269
2270     return scope.Close(outString);
2271   }
2272
2273   static Handle<Value> SetAutoPadding(const Arguments& args) {
2274     HandleScope scope;
2275     Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
2276
2277     cipher->SetAutoPadding(args.Length() < 1 || args[0]->BooleanValue());
2278
2279     return Undefined();
2280   }
2281
2282   static Handle<Value> CipherFinal(const Arguments& args) {
2283     Cipher *cipher = ObjectWrap::Unwrap<Cipher>(args.This());
2284
2285     HandleScope scope;
2286
2287     unsigned char* out_value = NULL;
2288     int out_len = -1;
2289     char* out_hexdigest;
2290     int out_hex_len;
2291     Local<Value> outString ;
2292
2293     int r = cipher->CipherFinal(&out_value, &out_len);
2294
2295     assert(out_value != NULL);
2296     assert(out_len != -1 || r == 0);
2297
2298     if (out_len == 0 || r == 0) {
2299       // out_value always get allocated.
2300       delete[] out_value;
2301       if (r == 0) {
2302         Local<Value> exception = Exception::TypeError(
2303           String::New("CipherFinal fail"));
2304         return ThrowException(exception);
2305       } else {
2306         return scope.Close(String::New(""));
2307       }
2308     }
2309
2310     enum encoding enc = ParseEncoding(args[0], BINARY);
2311     if (enc == HEX) {
2312       // Hex encoding
2313       HexEncode(out_value, out_len, &out_hexdigest, &out_hex_len);
2314       outString = Encode(out_hexdigest, out_hex_len, BINARY);
2315       delete [] out_hexdigest;
2316     } else if (enc == BASE64) {
2317       // Check to see if we need to add in previous base64 overhang
2318       if (cipher->incomplete_base64!=NULL){
2319         unsigned char* complete_base64 = new unsigned char[out_len+cipher->incomplete_base64_len+1];
2320         memcpy(complete_base64, cipher->incomplete_base64, cipher->incomplete_base64_len);
2321         memcpy(&complete_base64[cipher->incomplete_base64_len], out_value, out_len);
2322         delete [] out_value;
2323
2324         delete [] cipher->incomplete_base64;
2325         cipher->incomplete_base64=NULL;
2326
2327         out_value=complete_base64;
2328         out_len += cipher->incomplete_base64_len;
2329       }
2330       base64(out_value, out_len, &out_hexdigest, &out_hex_len);
2331       outString = Encode(out_hexdigest, out_hex_len, BINARY);
2332       delete [] out_hexdigest;
2333     } else if (enc == BINARY) {
2334       outString = Encode(out_value, out_len, BINARY);
2335     } else {
2336       fprintf(stderr, "node-crypto : Cipher .final encoding "
2337                       "can be binary, hex or base64\n");
2338     }
2339
2340     delete [] out_value;
2341     return scope.Close(outString);
2342   }
2343
2344   Cipher () : ObjectWrap ()
2345   {
2346     initialised_ = false;
2347   }
2348
2349   ~Cipher () {
2350     if (initialised_) {
2351       EVP_CIPHER_CTX_cleanup(&ctx);
2352     }
2353   }
2354
2355  private:
2356
2357   EVP_CIPHER_CTX ctx; /* coverity[member_decl] */
2358   const EVP_CIPHER *cipher; /* coverity[member_decl] */
2359   bool initialised_;
2360   char* incomplete_base64; /* coverity[member_decl] */
2361   int incomplete_base64_len; /* coverity[member_decl] */
2362
2363 };
2364
2365
2366
2367 class Decipher : public ObjectWrap {
2368  public:
2369   static void
2370   Initialize (v8::Handle<v8::Object> target)
2371   {
2372     HandleScope scope;
2373
2374     Local<FunctionTemplate> t = FunctionTemplate::New(New);
2375
2376     t->InstanceTemplate()->SetInternalFieldCount(1);
2377
2378     NODE_SET_PROTOTYPE_METHOD(t, "init", DecipherInit);
2379     NODE_SET_PROTOTYPE_METHOD(t, "initiv", DecipherInitIv);
2380     NODE_SET_PROTOTYPE_METHOD(t, "update", DecipherUpdate);
2381     NODE_SET_PROTOTYPE_METHOD(t, "final", DecipherFinal<false>);
2382     // This is completely undocumented:
2383     NODE_SET_PROTOTYPE_METHOD(t, "finaltol", DecipherFinal<true>);
2384     NODE_SET_PROTOTYPE_METHOD(t, "setAutoPadding", SetAutoPadding);
2385
2386     target->Set(String::NewSymbol("Decipher"), t->GetFunction());
2387   }
2388
2389   bool DecipherInit(char* cipherType, char* key_buf, int key_buf_len) {
2390     cipher_ = EVP_get_cipherbyname(cipherType);
2391
2392     if(!cipher_) {
2393       fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);
2394       return false;
2395     }
2396
2397     unsigned char key[EVP_MAX_KEY_LENGTH],iv[EVP_MAX_IV_LENGTH];
2398     int key_len = EVP_BytesToKey(cipher_,
2399                                  EVP_md5(),
2400                                  NULL,
2401                                  (unsigned char*)(key_buf),
2402                                  key_buf_len,
2403                                  1,
2404                                  key,
2405                                  iv);
2406
2407     EVP_CIPHER_CTX_init(&ctx);
2408     EVP_CipherInit_ex(&ctx, cipher_, NULL, NULL, NULL, false);
2409     if (!EVP_CIPHER_CTX_set_key_length(&ctx, key_len)) {
2410       fprintf(stderr, "node-crypto : Invalid key length %d\n", key_len);
2411       EVP_CIPHER_CTX_cleanup(&ctx);
2412       return false;
2413     }
2414     EVP_CipherInit_ex(&ctx, NULL, NULL,
2415       (unsigned char *)key,
2416       (unsigned char *)iv, false);
2417     initialised_ = true;
2418     return true;
2419   }
2420
2421
2422   bool DecipherInitIv(char* cipherType,
2423                       char* key,
2424                       int key_len,
2425                       char *iv,
2426                       int iv_len) {
2427     cipher_ = EVP_get_cipherbyname(cipherType);
2428     if(!cipher_) {
2429       fprintf(stderr, "node-crypto : Unknown cipher %s\n", cipherType);
2430       return false;
2431     }
2432     /* OpenSSL versions up to 0.9.8l failed to return the correct
2433       iv_length (0) for ECB ciphers */
2434     if (EVP_CIPHER_iv_length(cipher_) != iv_len &&
2435       !(EVP_CIPHER_mode(cipher_) == EVP_CIPH_ECB_MODE && iv_len == 0)) {
2436       fprintf(stderr, "node-crypto : Invalid IV length %d\n", iv_len);
2437       return false;
2438     }
2439     EVP_CIPHER_CTX_init(&ctx);
2440     EVP_CipherInit_ex(&ctx, cipher_, NULL, NULL, NULL, false);
2441     if (!EVP_CIPHER_CTX_set_key_length(&ctx, key_len)) {
2442       fprintf(stderr, "node-crypto : Invalid key length %d\n", key_len);
2443       EVP_CIPHER_CTX_cleanup(&ctx);
2444       return false;
2445     }
2446     EVP_CipherInit_ex(&ctx, NULL, NULL,
2447       (unsigned char *)key,
2448       (unsigned char *)iv, false);
2449     initialised_ = true;
2450     return true;
2451   }
2452
2453   int DecipherUpdate(char* data, int len, unsigned char** out, int* out_len) {
2454     if (!initialised_) {
2455       *out_len = 0;
2456       *out = NULL;
2457       return 0;
2458     }
2459
2460     *out_len=len+EVP_CIPHER_CTX_block_size(&ctx);
2461     *out= new unsigned char[*out_len];
2462
2463     EVP_CipherUpdate(&ctx, *out, out_len, (unsigned char*)data, len);
2464     return 1;
2465   }
2466
2467   int SetAutoPadding(bool auto_padding) {
2468     if (!initialised_) return 0;
2469     return EVP_CIPHER_CTX_set_padding(&ctx, auto_padding ? 1 : 0);
2470   }
2471
2472   // coverity[alloc_arg]
2473   template <bool TOLERATE_PADDING>
2474   int DecipherFinal(unsigned char** out, int *out_len) {
2475     int r;
2476
2477     if (!initialised_) {
2478       *out_len = 0;
2479       *out = NULL;
2480       return 0;
2481     }
2482
2483     *out = new unsigned char[EVP_CIPHER_CTX_block_size(&ctx)];
2484     if (TOLERATE_PADDING) {
2485       r = local_EVP_DecryptFinal_ex(&ctx,*out,out_len);
2486     } else {
2487       r = EVP_CipherFinal_ex(&ctx,*out,out_len);
2488     }
2489     EVP_CIPHER_CTX_cleanup(&ctx);
2490     initialised_ = false;
2491     return r;
2492   }
2493
2494
2495  protected:
2496
2497   static Handle<Value> New (const Arguments& args) {
2498     HandleScope scope;
2499
2500     Decipher *cipher = new Decipher();
2501     cipher->Wrap(args.This());
2502     return args.This();
2503   }
2504
2505   static Handle<Value> DecipherInit(const Arguments& args) {
2506     Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
2507
2508     HandleScope scope;
2509
2510     cipher->incomplete_utf8 = NULL;
2511     cipher->incomplete_hex_flag = false;
2512
2513     if (args.Length() <= 1
2514         || !args[0]->IsString()
2515         || !(args[1]->IsString() || Buffer::HasInstance(args[1])))
2516     {
2517       return ThrowException(Exception::Error(String::New(
2518         "Must give cipher-type, key as argument")));
2519     }
2520
2521     ASSERT_IS_STRING_OR_BUFFER(args[1]);
2522     ssize_t key_len = DecodeBytes(args[1], BINARY);
2523
2524     if (key_len < 0) {
2525       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2526       return ThrowException(exception);
2527     }
2528
2529     char* key_buf = new char[key_len];
2530     ssize_t key_written = DecodeWrite(key_buf, key_len, args[1], BINARY);
2531     assert(key_written == key_len);
2532
2533     String::Utf8Value cipherType(args[0]);
2534
2535     bool r = cipher->DecipherInit(*cipherType, key_buf,key_len);
2536
2537     delete [] key_buf;
2538
2539     if (!r) {
2540       return ThrowException(Exception::Error(String::New("DecipherInit error")));
2541     }
2542
2543     return args.This();
2544   }
2545
2546   static Handle<Value> DecipherInitIv(const Arguments& args) {
2547     Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
2548
2549     HandleScope scope;
2550
2551     cipher->incomplete_utf8 = NULL;
2552     cipher->incomplete_hex_flag = false;
2553
2554     if (args.Length() <= 2
2555         || !args[0]->IsString()
2556         || !(args[1]->IsString() || Buffer::HasInstance(args[1]))
2557         || !(args[2]->IsString() || Buffer::HasInstance(args[2])))
2558     {
2559       return ThrowException(Exception::Error(String::New(
2560         "Must give cipher-type, key, and iv as argument")));
2561     }
2562
2563     ASSERT_IS_STRING_OR_BUFFER(args[1]);
2564     ssize_t key_len = DecodeBytes(args[1], BINARY);
2565
2566     if (key_len < 0) {
2567       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2568       return ThrowException(exception);
2569     }
2570
2571     ASSERT_IS_STRING_OR_BUFFER(args[2]);
2572     ssize_t iv_len = DecodeBytes(args[2], BINARY);
2573
2574     if (iv_len < 0) {
2575       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2576       return ThrowException(exception);
2577     }
2578
2579     char* key_buf = new char[key_len];
2580     ssize_t key_written = DecodeWrite(key_buf, key_len, args[1], BINARY);
2581     assert(key_written == key_len);
2582
2583     char* iv_buf = new char[iv_len];
2584     ssize_t iv_written = DecodeWrite(iv_buf, iv_len, args[2], BINARY);
2585     assert(iv_written == iv_len);
2586
2587     String::Utf8Value cipherType(args[0]);
2588
2589     bool r = cipher->DecipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len);
2590
2591     delete [] key_buf;
2592     delete [] iv_buf;
2593
2594     if (!r) {
2595       return ThrowException(Exception::Error(String::New("DecipherInitIv error")));
2596     }
2597
2598     return args.This();
2599   }
2600
2601   static Handle<Value> DecipherUpdate(const Arguments& args) {
2602     HandleScope scope;
2603
2604     Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
2605
2606     ASSERT_IS_STRING_OR_BUFFER(args[0]);
2607
2608     ssize_t len = DecodeBytes(args[0], BINARY);
2609     if (len < 0) {
2610         return ThrowException(Exception::Error(String::New(
2611             "node`DecodeBytes() failed")));
2612     }
2613
2614     char* buf;
2615     // if alloc_buf then buf must be deleted later
2616     bool alloc_buf = false;
2617     if (Buffer::HasInstance(args[0])) {
2618       Local<Object> buffer_obj = args[0]->ToObject();
2619       char *buffer_data = Buffer::Data(buffer_obj);
2620       size_t buffer_length = Buffer::Length(buffer_obj);
2621
2622       buf = buffer_data;
2623       len = buffer_length;
2624     } else {
2625       alloc_buf = true;
2626       buf = new char[len];
2627       ssize_t written = DecodeWrite(buf, len, args[0], BINARY);
2628       assert(written == len);
2629     }
2630
2631     char* ciphertext;
2632     int ciphertext_len;
2633
2634     enum encoding enc = ParseEncoding(args[1], BINARY);
2635     if (enc == HEX) {
2636       // Hex encoding
2637       // Do we have a previous hex carry over?
2638       if (cipher->incomplete_hex_flag) {
2639         char* complete_hex = new char[len+2];
2640         memcpy(complete_hex, &cipher->incomplete_hex, 1);
2641         memcpy(complete_hex+1, buf, len);
2642         if (alloc_buf) delete [] buf;
2643         alloc_buf = true;
2644         buf = complete_hex;
2645         len += 1;
2646       }
2647       // Do we have an incomplete hex stream?
2648       if ((len>0) && (len % 2 !=0)) {
2649         len--;
2650         cipher->incomplete_hex=buf[len];
2651         cipher->incomplete_hex_flag=true;
2652         buf[len]=0;
2653       }
2654       HexDecode((unsigned char*)buf, len, (char **)&ciphertext, &ciphertext_len);
2655
2656       if (alloc_buf) {
2657         delete [] buf;
2658       }
2659       buf = ciphertext;
2660       len = ciphertext_len;
2661       alloc_buf = true;
2662
2663     } else if (enc == BASE64) {
2664       unbase64((unsigned char*)buf, len, (char **)&ciphertext, &ciphertext_len);
2665       if (alloc_buf) {
2666         delete [] buf;
2667       }
2668       buf = ciphertext;
2669       len = ciphertext_len;
2670       alloc_buf = true;
2671
2672     } else if (enc == BINARY) {
2673       // Binary - do nothing
2674
2675     } else {
2676       fprintf(stderr, "node-crypto : Decipher .update encoding "
2677                       "can be binary, hex or base64\n");
2678     }
2679
2680     unsigned char *out=0;
2681     int out_len=0;
2682     int r = cipher->DecipherUpdate(buf, len, &out, &out_len);
2683
2684     if (!r) {
2685       delete [] out;
2686       Local<Value> exception = Exception::TypeError(String::New("DecipherUpdate fail"));
2687       return ThrowException(exception);
2688     }
2689
2690     Local<Value> outString;
2691     if (out_len==0) {
2692       outString=String::New("");
2693     } else {
2694       enum encoding enc = ParseEncoding(args[2], BINARY);
2695       if (enc == UTF8) {
2696         // See if we have any overhang from last utf8 partial ending
2697         if (cipher->incomplete_utf8!=NULL) {
2698           char* complete_out = new char[cipher->incomplete_utf8_len + out_len];
2699           memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len);
2700           memcpy((char *)complete_out+cipher->incomplete_utf8_len, out, out_len);
2701           delete [] out;
2702
2703           delete [] cipher->incomplete_utf8;
2704           cipher->incomplete_utf8 = NULL;
2705
2706           out = (unsigned char*)complete_out;
2707           out_len += cipher->incomplete_utf8_len;
2708         }
2709         // Check to see if we have a complete utf8 stream
2710         int utf8_len = LengthWithoutIncompleteUtf8((char *)out, out_len);
2711         if (utf8_len<out_len) { // We have an incomplete ut8 ending
2712           cipher->incomplete_utf8_len = out_len-utf8_len;
2713           cipher->incomplete_utf8 = new unsigned char[cipher->incomplete_utf8_len+1];
2714           memcpy(cipher->incomplete_utf8, &out[utf8_len], cipher->incomplete_utf8_len);
2715         }
2716         outString = Encode(out, utf8_len, enc);
2717       } else {
2718         outString = Encode(out, out_len, enc);
2719       }
2720     }
2721
2722     if (out) delete [] out;
2723
2724     if (alloc_buf) delete [] buf;
2725     return scope.Close(outString);
2726
2727   }
2728
2729   static Handle<Value> SetAutoPadding(const Arguments& args) {
2730     HandleScope scope;
2731     Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
2732
2733     cipher->SetAutoPadding(args.Length() < 1 || args[0]->BooleanValue());
2734
2735     return Undefined();
2736   }
2737
2738   template <bool TOLERATE_PADDING>
2739   static Handle<Value> DecipherFinal(const Arguments& args) {
2740     HandleScope scope;
2741
2742     Decipher *cipher = ObjectWrap::Unwrap<Decipher>(args.This());
2743
2744     unsigned char* out_value = NULL;
2745     int out_len = -1;
2746     Local<Value> outString;
2747
2748     int r = cipher->DecipherFinal<TOLERATE_PADDING>(&out_value, &out_len);
2749
2750     assert(out_value != NULL);
2751     assert(out_len != -1);
2752
2753     if (out_len == 0 || r == 0) {
2754       delete [] out_value; // allocated even if out_len == 0
2755       if (r == 0) {
2756         Local<Value> exception = Exception::TypeError(
2757           String::New("DecipherFinal fail"));
2758         return ThrowException(exception);
2759       } else {
2760         return scope.Close(String::New(""));
2761       }
2762     }
2763
2764     if (args.Length() == 0 || !args[0]->IsString()) {
2765       outString = Encode(out_value, out_len, BINARY);
2766     } else {
2767       enum encoding enc = ParseEncoding(args[0]);
2768       if (enc == UTF8) {
2769         // See if we have any overhang from last utf8 partial ending
2770         if (cipher->incomplete_utf8!=NULL) {
2771           char* complete_out = new char[cipher->incomplete_utf8_len + out_len];
2772           memcpy(complete_out, cipher->incomplete_utf8, cipher->incomplete_utf8_len);
2773           memcpy((char *)complete_out+cipher->incomplete_utf8_len, out_value, out_len);
2774
2775           delete [] cipher->incomplete_utf8;
2776           cipher->incomplete_utf8=NULL;
2777
2778           outString = Encode(complete_out, cipher->incomplete_utf8_len+out_len, enc);
2779           delete [] complete_out;
2780         } else {
2781           outString = Encode(out_value, out_len, enc);
2782         }
2783       } else {
2784         outString = Encode(out_value, out_len, enc);
2785       }
2786     }
2787     delete [] out_value;
2788     return scope.Close(outString);
2789   }
2790
2791   Decipher () : ObjectWrap () {
2792     initialised_ = false;
2793   }
2794
2795   ~Decipher () {
2796     if (initialised_) {
2797       EVP_CIPHER_CTX_cleanup(&ctx);
2798     }
2799   }
2800
2801  private:
2802
2803   EVP_CIPHER_CTX ctx;
2804   const EVP_CIPHER *cipher_;
2805   bool initialised_;
2806   unsigned char* incomplete_utf8;
2807   int incomplete_utf8_len;
2808   char incomplete_hex;
2809   bool incomplete_hex_flag;
2810 };
2811
2812
2813
2814
2815 class Hmac : public ObjectWrap {
2816  public:
2817   static void Initialize (v8::Handle<v8::Object> target) {
2818     HandleScope scope;
2819
2820     Local<FunctionTemplate> t = FunctionTemplate::New(New);
2821
2822     t->InstanceTemplate()->SetInternalFieldCount(1);
2823
2824     NODE_SET_PROTOTYPE_METHOD(t, "init", HmacInit);
2825     NODE_SET_PROTOTYPE_METHOD(t, "update", HmacUpdate);
2826     NODE_SET_PROTOTYPE_METHOD(t, "digest", HmacDigest);
2827
2828     target->Set(String::NewSymbol("Hmac"), t->GetFunction());
2829   }
2830
2831   bool HmacInit(char* hashType, char* key, int key_len) {
2832     md = EVP_get_digestbyname(hashType);
2833     if(!md) {
2834       fprintf(stderr, "node-crypto : Unknown message digest %s\n", hashType);
2835       return false;
2836     }
2837     HMAC_CTX_init(&ctx);
2838     HMAC_Init(&ctx, key, key_len, md);
2839     initialised_ = true;
2840     return true;
2841
2842   }
2843
2844   int HmacUpdate(char* data, int len) {
2845     if (!initialised_) return 0;
2846     HMAC_Update(&ctx, (unsigned char*)data, len);
2847     return 1;
2848   }
2849
2850   int HmacDigest(unsigned char** md_value, unsigned int *md_len) {
2851     if (!initialised_) return 0;
2852     *md_value = new unsigned char[EVP_MAX_MD_SIZE];
2853     HMAC_Final(&ctx, *md_value, md_len);
2854     HMAC_CTX_cleanup(&ctx);
2855     initialised_ = false;
2856     return 1;
2857   }
2858
2859
2860  protected:
2861
2862   static Handle<Value> New (const Arguments& args) {
2863     HandleScope scope;
2864
2865     Hmac *hmac = new Hmac();
2866     hmac->Wrap(args.This());
2867     return args.This();
2868   }
2869
2870   static Handle<Value> HmacInit(const Arguments& args) {
2871     Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This());
2872
2873     HandleScope scope;
2874
2875     if (args.Length() == 0 || !args[0]->IsString()) {
2876       return ThrowException(Exception::Error(String::New(
2877         "Must give hashtype string as argument")));
2878     }
2879
2880     ASSERT_IS_STRING_OR_BUFFER(args[1]);
2881     ssize_t len = DecodeBytes(args[1], BINARY);
2882
2883     if (len < 0) {
2884       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2885       return ThrowException(exception);
2886     }
2887
2888     String::Utf8Value hashType(args[0]);
2889
2890     bool r;
2891
2892     if( Buffer::HasInstance(args[1])) {
2893       Local<Object> buffer_obj = args[1]->ToObject();
2894       char* buffer_data = Buffer::Data(buffer_obj);
2895       size_t buffer_length = Buffer::Length(buffer_obj);
2896
2897       r = hmac->HmacInit(*hashType, buffer_data, buffer_length);
2898     } else {
2899       char* buf = new char[len];
2900       ssize_t written = DecodeWrite(buf, len, args[1], BINARY);
2901       assert(written == len);
2902
2903       r = hmac->HmacInit(*hashType, buf, len);
2904
2905       delete [] buf;
2906     }
2907
2908     if (!r) {
2909       return ThrowException(Exception::Error(String::New("hmac error")));
2910     }
2911
2912     return args.This();
2913   }
2914
2915   static Handle<Value> HmacUpdate(const Arguments& args) {
2916     Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This());
2917
2918     HandleScope scope;
2919
2920     ASSERT_IS_STRING_OR_BUFFER(args[0]);
2921     enum encoding enc = ParseEncoding(args[1]);
2922     ssize_t len = DecodeBytes(args[0], enc);
2923
2924     if (len < 0) {
2925       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
2926       return ThrowException(exception);
2927     }
2928
2929     int r;
2930
2931     if( Buffer::HasInstance(args[0])) {
2932       Local<Object> buffer_obj = args[0]->ToObject();
2933       char *buffer_data = Buffer::Data(buffer_obj);
2934       size_t buffer_length = Buffer::Length(buffer_obj);
2935
2936       r = hmac->HmacUpdate(buffer_data, buffer_length);
2937     } else {
2938       char* buf = new char[len];
2939       ssize_t written = DecodeWrite(buf, len, args[0], enc);
2940       assert(written == len);
2941       r = hmac->HmacUpdate(buf, len);
2942       delete [] buf;
2943     }
2944
2945     if (!r) {
2946       Local<Value> exception = Exception::TypeError(String::New("HmacUpdate fail"));
2947       return ThrowException(exception);
2948     }
2949
2950     return args.This();
2951   }
2952
2953   static Handle<Value> HmacDigest(const Arguments& args) {
2954     Hmac *hmac = ObjectWrap::Unwrap<Hmac>(args.This());
2955
2956     HandleScope scope;
2957
2958     unsigned char* md_value = NULL;
2959     unsigned int md_len = 0;
2960     char* md_hexdigest;
2961     int md_hex_len;
2962     Local<Value> outString;
2963
2964     int r = hmac->HmacDigest(&md_value, &md_len);
2965     if (md_len == 0 || r == 0) {
2966       return scope.Close(String::New(""));
2967     }
2968
2969     enum encoding enc = ParseEncoding(args[0], BINARY);
2970     if (enc == HEX) {
2971       // Hex encoding
2972       HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len);
2973       outString = Encode(md_hexdigest, md_hex_len, BINARY);
2974       delete [] md_hexdigest;
2975     } else if (enc == BASE64) {
2976       base64(md_value, md_len, &md_hexdigest, &md_hex_len);
2977       outString = Encode(md_hexdigest, md_hex_len, BINARY);
2978       delete [] md_hexdigest;
2979     } else if (enc == BINARY) {
2980       outString = Encode(md_value, md_len, BINARY);
2981     } else {
2982       fprintf(stderr, "node-crypto : Hmac .digest encoding "
2983                       "can be binary, hex or base64\n");
2984     }
2985     delete [] md_value;
2986     return scope.Close(outString);
2987   }
2988
2989   Hmac () : ObjectWrap () {
2990     initialised_ = false;
2991   }
2992
2993   ~Hmac () {
2994     if (initialised_) {
2995       HMAC_CTX_cleanup(&ctx);
2996     }
2997   }
2998
2999  private:
3000
3001   HMAC_CTX ctx; /* coverity[member_decl] */
3002   const EVP_MD *md; /* coverity[member_decl] */
3003   bool initialised_;
3004 };
3005
3006
3007 class Hash : public ObjectWrap {
3008  public:
3009   static void Initialize (v8::Handle<v8::Object> target) {
3010     HandleScope scope;
3011
3012     Local<FunctionTemplate> t = FunctionTemplate::New(New);
3013
3014     t->InstanceTemplate()->SetInternalFieldCount(1);
3015
3016     NODE_SET_PROTOTYPE_METHOD(t, "update", HashUpdate);
3017     NODE_SET_PROTOTYPE_METHOD(t, "digest", HashDigest);
3018
3019     target->Set(String::NewSymbol("Hash"), t->GetFunction());
3020   }
3021
3022   bool HashInit (const char* hashType) {
3023     md = EVP_get_digestbyname(hashType);
3024     if(!md) return false;
3025     EVP_MD_CTX_init(&mdctx);
3026     EVP_DigestInit_ex(&mdctx, md, NULL);
3027     initialised_ = true;
3028     return true;
3029   }
3030
3031   int HashUpdate(char* data, int len) {
3032     if (!initialised_) return 0;
3033     EVP_DigestUpdate(&mdctx, data, len);
3034     return 1;
3035   }
3036
3037
3038  protected:
3039
3040   static Handle<Value> New (const Arguments& args) {
3041     HandleScope scope;
3042
3043     if (args.Length() == 0 || !args[0]->IsString()) {
3044       return ThrowException(Exception::Error(String::New(
3045         "Must give hashtype string as argument")));
3046     }
3047
3048     String::Utf8Value hashType(args[0]);
3049
3050     Hash *hash = new Hash();
3051     if (!hash->HashInit(*hashType)) {
3052       delete hash;
3053       return ThrowException(Exception::Error(String::New(
3054         "Digest method not supported")));
3055     }
3056
3057     hash->Wrap(args.This());
3058     return args.This();
3059   }
3060
3061   static Handle<Value> HashUpdate(const Arguments& args) {
3062     HandleScope scope;
3063
3064     Hash *hash = ObjectWrap::Unwrap<Hash>(args.This());
3065
3066     ASSERT_IS_STRING_OR_BUFFER(args[0]);
3067     enum encoding enc = ParseEncoding(args[1]);
3068     ssize_t len = DecodeBytes(args[0], enc);
3069
3070     if (len < 0) {
3071       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
3072       return ThrowException(exception);
3073     }
3074
3075     int r;
3076
3077     if (Buffer::HasInstance(args[0])) {
3078       Local<Object> buffer_obj = args[0]->ToObject();
3079       char *buffer_data = Buffer::Data(buffer_obj);
3080       size_t buffer_length = Buffer::Length(buffer_obj);
3081       r = hash->HashUpdate(buffer_data, buffer_length);
3082     } else {
3083       char* buf = new char[len];
3084       ssize_t written = DecodeWrite(buf, len, args[0], enc);
3085       assert(written == len);
3086       r = hash->HashUpdate(buf, len);
3087       delete[] buf;
3088     }
3089
3090     if (!r) {
3091       Local<Value> exception = Exception::TypeError(String::New("HashUpdate fail"));
3092       return ThrowException(exception);
3093     }
3094
3095     return args.This();
3096   }
3097
3098   static Handle<Value> HashDigest(const Arguments& args) {
3099     HandleScope scope;
3100
3101     Hash *hash = ObjectWrap::Unwrap<Hash>(args.This());
3102
3103     if (!hash->initialised_) {
3104       return ThrowException(Exception::Error(String::New("Not initialized")));
3105     }
3106
3107     unsigned char md_value[EVP_MAX_MD_SIZE];
3108     unsigned int md_len;
3109
3110     EVP_DigestFinal_ex(&hash->mdctx, md_value, &md_len);
3111     EVP_MD_CTX_cleanup(&hash->mdctx);
3112     hash->initialised_ = false;
3113
3114     if (md_len == 0) {
3115       return scope.Close(String::New(""));
3116     }
3117
3118     Local<Value> outString;
3119
3120     enum encoding enc = ParseEncoding(args[0], BINARY);
3121     if (enc == HEX) {
3122       // Hex encoding
3123       char* md_hexdigest;
3124       int md_hex_len;
3125       HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len);
3126       outString = Encode(md_hexdigest, md_hex_len, BINARY);
3127       delete [] md_hexdigest;
3128     } else if (enc == BASE64) {
3129       char* md_hexdigest;
3130       int md_hex_len;
3131       base64(md_value, md_len, &md_hexdigest, &md_hex_len);
3132       outString = Encode(md_hexdigest, md_hex_len, BINARY);
3133       delete [] md_hexdigest;
3134     } else if (enc == BINARY) {
3135       outString = Encode(md_value, md_len, BINARY);
3136     } else {
3137       fprintf(stderr, "node-crypto : Hash .digest encoding "
3138                       "can be binary, hex or base64\n");
3139     }
3140
3141     return scope.Close(outString);
3142   }
3143
3144   Hash () : ObjectWrap () {
3145     initialised_ = false;
3146   }
3147
3148   ~Hash () {
3149     if (initialised_) {
3150       EVP_MD_CTX_cleanup(&mdctx);
3151     }
3152   }
3153
3154  private:
3155
3156   EVP_MD_CTX mdctx; /* coverity[member_decl] */
3157   const EVP_MD *md; /* coverity[member_decl] */
3158   bool initialised_;
3159 };
3160
3161 class Sign : public ObjectWrap {
3162  public:
3163   static void
3164   Initialize (v8::Handle<v8::Object> target) {
3165     HandleScope scope;
3166
3167     Local<FunctionTemplate> t = FunctionTemplate::New(New);
3168
3169     t->InstanceTemplate()->SetInternalFieldCount(1);
3170
3171     NODE_SET_PROTOTYPE_METHOD(t, "init", SignInit);
3172     NODE_SET_PROTOTYPE_METHOD(t, "update", SignUpdate);
3173     NODE_SET_PROTOTYPE_METHOD(t, "sign", SignFinal);
3174
3175     target->Set(String::NewSymbol("Sign"), t->GetFunction());
3176   }
3177
3178   bool SignInit (const char* signType) {
3179     md = EVP_get_digestbyname(signType);
3180     if(!md) {
3181       printf("Unknown message digest %s\n", signType);
3182       return false;
3183     }
3184     EVP_MD_CTX_init(&mdctx);
3185     EVP_SignInit_ex(&mdctx, md, NULL);
3186     initialised_ = true;
3187     return true;
3188
3189   }
3190
3191   int SignUpdate(char* data, int len) {
3192     if (!initialised_) return 0;
3193     EVP_SignUpdate(&mdctx, data, len);
3194     return 1;
3195   }
3196
3197   int SignFinal(unsigned char** md_value,
3198                 unsigned int *md_len,
3199                 char* key_pem,
3200                 int key_pemLen) {
3201     if (!initialised_) return 0;
3202
3203     BIO *bp = NULL;
3204     EVP_PKEY* pkey;
3205     bp = BIO_new(BIO_s_mem());
3206     if(!BIO_write(bp, key_pem, key_pemLen)) return 0;
3207
3208     pkey = PEM_read_bio_PrivateKey( bp, NULL, NULL, NULL );
3209     if (pkey == NULL) return 0;
3210
3211     EVP_SignFinal(&mdctx, *md_value, md_len, pkey);
3212     EVP_MD_CTX_cleanup(&mdctx);
3213     initialised_ = false;
3214     EVP_PKEY_free(pkey);
3215     BIO_free(bp);
3216     return 1;
3217   }
3218
3219
3220  protected:
3221
3222   static Handle<Value> New (const Arguments& args) {
3223     HandleScope scope;
3224
3225     Sign *sign = new Sign();
3226     sign->Wrap(args.This());
3227
3228     return args.This();
3229   }
3230
3231   static Handle<Value> SignInit(const Arguments& args) {
3232     HandleScope scope;
3233
3234     Sign *sign = ObjectWrap::Unwrap<Sign>(args.This());
3235
3236     if (args.Length() == 0 || !args[0]->IsString()) {
3237       return ThrowException(Exception::Error(String::New(
3238         "Must give signtype string as argument")));
3239     }
3240
3241     String::Utf8Value signType(args[0]);
3242
3243     bool r = sign->SignInit(*signType);
3244
3245     if (!r) {
3246       return ThrowException(Exception::Error(String::New("SignInit error")));
3247     }
3248
3249     return args.This();
3250   }
3251
3252   static Handle<Value> SignUpdate(const Arguments& args) {
3253     Sign *sign = ObjectWrap::Unwrap<Sign>(args.This());
3254
3255     HandleScope scope;
3256
3257     ASSERT_IS_STRING_OR_BUFFER(args[0]);
3258     enum encoding enc = ParseEncoding(args[1]);
3259     ssize_t len = DecodeBytes(args[0], enc);
3260
3261     if (len < 0) {
3262       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
3263       return ThrowException(exception);
3264     }
3265
3266     int r;
3267
3268     if (Buffer::HasInstance(args[0])) {
3269       Local<Object> buffer_obj = args[0]->ToObject();
3270       char *buffer_data = Buffer::Data(buffer_obj);
3271       size_t buffer_length = Buffer::Length(buffer_obj);
3272
3273       r = sign->SignUpdate(buffer_data, buffer_length);
3274     } else {
3275       char* buf = new char[len];
3276       ssize_t written = DecodeWrite(buf, len, args[0], enc);
3277       assert(written == len);
3278       r = sign->SignUpdate(buf, len);
3279       delete [] buf;
3280     }
3281
3282     if (!r) {
3283       Local<Value> exception = Exception::TypeError(String::New("SignUpdate fail"));
3284       return ThrowException(exception);
3285     }
3286
3287     return args.This();
3288   }
3289
3290   static Handle<Value> SignFinal(const Arguments& args) {
3291     Sign *sign = ObjectWrap::Unwrap<Sign>(args.This());
3292
3293     HandleScope scope;
3294
3295     unsigned char* md_value;
3296     unsigned int md_len;
3297     char* md_hexdigest;
3298     int md_hex_len;
3299     Local<Value> outString;
3300
3301     md_len = 8192; // Maximum key size is 8192 bits
3302     md_value = new unsigned char[md_len];
3303
3304     ASSERT_IS_STRING_OR_BUFFER(args[0]);
3305     ssize_t len = DecodeBytes(args[0], BINARY);
3306
3307     if (len < 0) {
3308       delete [] md_value;
3309       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
3310       return ThrowException(exception);
3311     }
3312
3313     char* buf = new char[len];
3314     ssize_t written = DecodeWrite(buf, len, args[0], BINARY);
3315     assert(written == len);
3316
3317     int r = sign->SignFinal(&md_value, &md_len, buf, len);
3318
3319     delete [] buf;
3320
3321     if (md_len == 0 || r == 0) {
3322       delete [] md_value;
3323       return scope.Close(String::New(""));
3324     }
3325
3326     enum encoding enc = ParseEncoding(args[1], BINARY);
3327     if (enc == HEX) {
3328       // Hex encoding
3329       HexEncode(md_value, md_len, &md_hexdigest, &md_hex_len);
3330       outString = Encode(md_hexdigest, md_hex_len, BINARY);
3331       delete [] md_hexdigest;
3332     } else if (enc == BASE64) {
3333       base64(md_value, md_len, &md_hexdigest, &md_hex_len);
3334       outString = Encode(md_hexdigest, md_hex_len, BINARY);
3335       delete [] md_hexdigest;
3336     } else if (enc == BINARY) {
3337       outString = Encode(md_value, md_len, BINARY);
3338     } else {
3339       outString = String::New("");
3340       fprintf(stderr, "node-crypto : Sign .sign encoding "
3341                       "can be binary, hex or base64\n");
3342     }
3343
3344     delete [] md_value;
3345     return scope.Close(outString);
3346   }
3347
3348   Sign () : ObjectWrap () {
3349     initialised_ = false;
3350   }
3351
3352   ~Sign () {
3353     if (initialised_) {
3354       EVP_MD_CTX_cleanup(&mdctx);
3355     }
3356   }
3357
3358  private:
3359
3360   EVP_MD_CTX mdctx; /* coverity[member_decl] */
3361   const EVP_MD *md; /* coverity[member_decl] */
3362   bool initialised_;
3363 };
3364
3365 class Verify : public ObjectWrap {
3366  public:
3367   static void Initialize (v8::Handle<v8::Object> target) {
3368     HandleScope scope;
3369
3370     Local<FunctionTemplate> t = FunctionTemplate::New(New);
3371
3372     t->InstanceTemplate()->SetInternalFieldCount(1);
3373
3374     NODE_SET_PROTOTYPE_METHOD(t, "init", VerifyInit);
3375     NODE_SET_PROTOTYPE_METHOD(t, "update", VerifyUpdate);
3376     NODE_SET_PROTOTYPE_METHOD(t, "verify", VerifyFinal);
3377
3378     target->Set(String::NewSymbol("Verify"), t->GetFunction());
3379   }
3380
3381
3382   bool VerifyInit (const char* verifyType) {
3383     md = EVP_get_digestbyname(verifyType);
3384     if(!md) {
3385       fprintf(stderr, "node-crypto : Unknown message digest %s\n", verifyType);
3386       return false;
3387     }
3388     EVP_MD_CTX_init(&mdctx);
3389     EVP_VerifyInit_ex(&mdctx, md, NULL);
3390     initialised_ = true;
3391     return true;
3392   }
3393
3394
3395   int VerifyUpdate(char* data, int len) {
3396     if (!initialised_) return 0;
3397     EVP_VerifyUpdate(&mdctx, data, len);
3398     return 1;
3399   }
3400
3401
3402   int VerifyFinal(char* key_pem, int key_pemLen, unsigned char* sig, int siglen) {
3403     if (!initialised_) return 0;
3404
3405     EVP_PKEY* pkey = NULL;
3406     BIO *bp = NULL;
3407     X509 *x509 = NULL;
3408     int r = 0;
3409
3410     bp = BIO_new(BIO_s_mem());
3411     if (bp == NULL) {
3412       ERR_print_errors_fp(stderr);
3413       return 0;
3414     }
3415     if(!BIO_write(bp, key_pem, key_pemLen)) {
3416       ERR_print_errors_fp(stderr);
3417       return 0;
3418     }
3419
3420     // Check if this is a PKCS#8 or RSA public key before trying as X.509.
3421     // Split this out into a separate function once we have more than one
3422     // consumer of public keys.
3423     if (strncmp(key_pem, PUBLIC_KEY_PFX, PUBLIC_KEY_PFX_LEN) == 0) {
3424       pkey = PEM_read_bio_PUBKEY(bp, NULL, NULL, NULL);
3425       if (pkey == NULL) {
3426         ERR_print_errors_fp(stderr);
3427         return 0;
3428       }
3429     } else if (strncmp(key_pem, PUBRSA_KEY_PFX, PUBRSA_KEY_PFX_LEN) == 0) {
3430       RSA* rsa = PEM_read_bio_RSAPublicKey(bp, NULL, NULL, NULL);
3431       if (rsa) {
3432         pkey = EVP_PKEY_new();
3433         if (pkey) EVP_PKEY_set1_RSA(pkey, rsa);
3434         RSA_free(rsa);
3435       }
3436       if (pkey == NULL) {
3437         ERR_print_errors_fp(stderr);
3438         return 0;
3439       }
3440     } else {
3441       // X.509 fallback
3442       x509 = PEM_read_bio_X509(bp, NULL, NULL, NULL);
3443       if (x509 == NULL) {
3444         ERR_print_errors_fp(stderr);
3445         return 0;
3446       }
3447
3448       pkey = X509_get_pubkey(x509);
3449       if (pkey == NULL) {
3450         ERR_print_errors_fp(stderr);
3451         return 0;
3452       }
3453     }
3454
3455     r = EVP_VerifyFinal(&mdctx, sig, siglen, pkey);
3456
3457     if(pkey != NULL)
3458       EVP_PKEY_free (pkey);
3459     if (x509 != NULL)
3460       X509_free(x509);
3461     if (bp != NULL)
3462       BIO_free(bp);
3463     EVP_MD_CTX_cleanup(&mdctx);
3464     initialised_ = false;
3465
3466     return r;
3467   }
3468
3469
3470  protected:
3471
3472   static Handle<Value> New (const Arguments& args) {
3473     HandleScope scope;
3474
3475     Verify *verify = new Verify();
3476     verify->Wrap(args.This());
3477
3478     return args.This();
3479   }
3480
3481
3482   static Handle<Value> VerifyInit(const Arguments& args) {
3483     Verify *verify = ObjectWrap::Unwrap<Verify>(args.This());
3484
3485     HandleScope scope;
3486
3487     if (args.Length() == 0 || !args[0]->IsString()) {
3488       return ThrowException(Exception::Error(String::New(
3489         "Must give verifytype string as argument")));
3490     }
3491
3492     String::Utf8Value verifyType(args[0]);
3493
3494     bool r = verify->VerifyInit(*verifyType);
3495
3496     if (!r) {
3497       return ThrowException(Exception::Error(String::New("VerifyInit error")));
3498     }
3499
3500     return args.This();
3501   }
3502
3503
3504   static Handle<Value> VerifyUpdate(const Arguments& args) {
3505     HandleScope scope;
3506
3507     Verify *verify = ObjectWrap::Unwrap<Verify>(args.This());
3508
3509     ASSERT_IS_STRING_OR_BUFFER(args[0]);
3510     enum encoding enc = ParseEncoding(args[1]);
3511     ssize_t len = DecodeBytes(args[0], enc);
3512
3513     if (len < 0) {
3514       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
3515       return ThrowException(exception);
3516     }
3517
3518     int r;
3519
3520     if(Buffer::HasInstance(args[0])) {
3521       Local<Object> buffer_obj = args[0]->ToObject();
3522       char *buffer_data = Buffer::Data(buffer_obj);
3523       size_t buffer_length = Buffer::Length(buffer_obj);
3524
3525       r = verify->VerifyUpdate(buffer_data, buffer_length);
3526     } else {
3527       char* buf = new char[len];
3528       ssize_t written = DecodeWrite(buf, len, args[0], enc);
3529       assert(written == len);
3530       r = verify->VerifyUpdate(buf, len);
3531       delete [] buf;
3532     }
3533
3534     if (!r) {
3535       Local<Value> exception = Exception::TypeError(String::New("VerifyUpdate fail"));
3536       return ThrowException(exception);
3537     }
3538
3539     return args.This();
3540   }
3541
3542
3543   static Handle<Value> VerifyFinal(const Arguments& args) {
3544     HandleScope scope;
3545
3546     Verify *verify = ObjectWrap::Unwrap<Verify>(args.This());
3547
3548     ASSERT_IS_STRING_OR_BUFFER(args[0]);
3549     ssize_t klen = DecodeBytes(args[0], BINARY);
3550
3551     if (klen < 0) {
3552       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
3553       return ThrowException(exception);
3554     }
3555
3556     char* kbuf = new char[klen];
3557     ssize_t kwritten = DecodeWrite(kbuf, klen, args[0], BINARY);
3558     assert(kwritten == klen);
3559
3560     ASSERT_IS_STRING_OR_BUFFER(args[1]);
3561     ssize_t hlen = DecodeBytes(args[1], BINARY);
3562
3563     if (hlen < 0) {
3564       delete [] kbuf;
3565       Local<Value> exception = Exception::TypeError(String::New("Bad argument"));
3566       return ThrowException(exception);
3567     }
3568
3569     unsigned char* hbuf = new unsigned char[hlen];
3570     ssize_t hwritten = DecodeWrite((char *)hbuf, hlen, args[1], BINARY);
3571     assert(hwritten == hlen);
3572     unsigned char* dbuf;
3573     int dlen;
3574
3575     int r=-1;
3576
3577     enum encoding enc = ParseEncoding(args[2], BINARY);
3578     if (enc == HEX) {
3579       // Hex encoding
3580       HexDecode(hbuf, hlen, (char **)&dbuf, &dlen);
3581       r = verify->VerifyFinal(kbuf, klen, dbuf, dlen);
3582       delete [] dbuf;
3583     } else if (enc == BASE64) {
3584       // Base64 encoding
3585       unbase64(hbuf, hlen, (char **)&dbuf, &dlen);
3586       r = verify->VerifyFinal(kbuf, klen, dbuf, dlen);
3587       delete [] dbuf;
3588     } else if (enc == BINARY) {
3589       r = verify->VerifyFinal(kbuf, klen, hbuf, hlen);
3590     } else {
3591       fprintf(stderr, "node-crypto : Verify .verify encoding "
3592                       "can be binary, hex or base64\n");
3593     }
3594
3595     delete [] kbuf;
3596     delete [] hbuf;
3597
3598     return Boolean::New(r && r != -1);
3599   }
3600
3601   Verify () : ObjectWrap () {
3602     initialised_ = false;
3603   }
3604
3605   ~Verify () {
3606     if (initialised_) {
3607       EVP_MD_CTX_cleanup(&mdctx);
3608     }
3609   }
3610
3611  private:
3612
3613   EVP_MD_CTX mdctx; /* coverity[member_decl] */
3614   const EVP_MD *md; /* coverity[member_decl] */
3615   bool initialised_;
3616
3617 };
3618
3619 class DiffieHellman : public ObjectWrap {
3620  public:
3621   static void Initialize(v8::Handle<v8::Object> target) {
3622     HandleScope scope;
3623
3624     Local<FunctionTemplate> t = FunctionTemplate::New(New);
3625
3626     t->InstanceTemplate()->SetInternalFieldCount(1);
3627
3628     NODE_SET_PROTOTYPE_METHOD(t, "generateKeys", GenerateKeys);
3629     NODE_SET_PROTOTYPE_METHOD(t, "computeSecret", ComputeSecret);
3630     NODE_SET_PROTOTYPE_METHOD(t, "getPrime", GetPrime);
3631     NODE_SET_PROTOTYPE_METHOD(t, "getGenerator", GetGenerator);
3632     NODE_SET_PROTOTYPE_METHOD(t, "getPublicKey", GetPublicKey);
3633     NODE_SET_PROTOTYPE_METHOD(t, "getPrivateKey", GetPrivateKey);
3634     NODE_SET_PROTOTYPE_METHOD(t, "setPublicKey", SetPublicKey);
3635     NODE_SET_PROTOTYPE_METHOD(t, "setPrivateKey", SetPrivateKey);
3636
3637     target->Set(String::NewSymbol("DiffieHellman"), t->GetFunction());
3638
3639     Local<FunctionTemplate> t2 = FunctionTemplate::New(DiffieHellmanGroup);
3640     t2->InstanceTemplate()->SetInternalFieldCount(1);
3641
3642     NODE_SET_PROTOTYPE_METHOD(t2, "generateKeys", GenerateKeys);
3643     NODE_SET_PROTOTYPE_METHOD(t2, "computeSecret", ComputeSecret);
3644     NODE_SET_PROTOTYPE_METHOD(t2, "getPrime", GetPrime);
3645     NODE_SET_PROTOTYPE_METHOD(t2, "getGenerator", GetGenerator);
3646     NODE_SET_PROTOTYPE_METHOD(t2, "getPublicKey", GetPublicKey);
3647     NODE_SET_PROTOTYPE_METHOD(t2, "getPrivateKey", GetPrivateKey);
3648
3649     target->Set(String::NewSymbol("DiffieHellmanGroup"), t2->GetFunction());
3650   }
3651
3652   bool Init(int primeLength) {
3653     dh = DH_new();
3654     DH_generate_parameters_ex(dh, primeLength, DH_GENERATOR_2, 0);
3655     bool result = VerifyContext();
3656     if (!result) return false;
3657     initialised_ = true;
3658     return true;
3659   }
3660
3661   bool Init(unsigned char* p, int p_len) {
3662     dh = DH_new();
3663     dh->p = BN_bin2bn(p, p_len, 0);
3664     dh->g = BN_new();
3665     if (!BN_set_word(dh->g, 2)) return false;
3666     bool result = VerifyContext();
3667     if (!result) return false;
3668     initialised_ = true;
3669     return true;
3670   }
3671
3672   bool Init(unsigned char* p, int p_len, unsigned char* g, int g_len) {
3673     dh = DH_new();
3674     dh->p = BN_bin2bn(p, p_len, 0);
3675     dh->g = BN_bin2bn(g, g_len, 0);
3676     initialised_ = true;
3677     return true;
3678   }
3679
3680  protected:
3681   static Handle<Value> DiffieHellmanGroup(const Arguments& args) {
3682     HandleScope scope;
3683
3684     DiffieHellman* diffieHellman = new DiffieHellman();
3685
3686     if (args.Length() != 1 || !args[0]->IsString()) {
3687       return ThrowException(Exception::Error(
3688           String::New("No group name given")));
3689     }
3690
3691     String::Utf8Value group_name(args[0]);
3692
3693     modp_group* it = modp_groups;
3694
3695     while(it->name != NULL) {
3696       if (!strcasecmp(*group_name, it->name))
3697           break;
3698       it++;
3699     }
3700
3701     if (it->name != NULL) {
3702       diffieHellman->Init(it->prime, it->prime_size,
3703               it->gen, it->gen_size);
3704     } else {
3705       return ThrowException(Exception::Error(
3706           String::New("Unknown group")));
3707     }
3708
3709     diffieHellman->Wrap(args.This());
3710
3711     return args.This();
3712   }
3713
3714   static Handle<Value> New(const Arguments& args) {
3715     HandleScope scope;
3716
3717     DiffieHellman* diffieHellman = new DiffieHellman();
3718     bool initialized = false;
3719
3720     if (args.Length() > 0) {
3721       if (args[0]->IsInt32()) {
3722         initialized = diffieHellman->Init(args[0]->Int32Value());
3723       } else {
3724         if (args[0]->IsString()) {
3725           char* buf;
3726           int len;
3727           if (args.Length() > 1 && args[1]->IsString()) {
3728             len = DecodeWithEncoding(args[0], args[1], &buf);
3729           } else {
3730             len = DecodeBinary(args[0], &buf);
3731           }
3732
3733           if (len == -1) {
3734             delete[] buf;
3735             return ThrowException(Exception::Error(
3736                   String::New("Invalid argument")));
3737           } else {
3738             initialized = diffieHellman->Init(
3739                 reinterpret_cast<unsigned char*>(buf), len);
3740             delete[] buf;
3741           }
3742         } else if (Buffer::HasInstance(args[0])) {
3743           Local<Object> buffer = args[0]->ToObject();
3744           initialized = diffieHellman->Init(
3745                   reinterpret_cast<unsigned char*>(Buffer::Data(buffer)),
3746                   Buffer::Length(buffer));
3747         }
3748       }
3749     }
3750
3751     if (!initialized) {
3752       return ThrowException(Exception::Error(
3753             String::New("Initialization failed")));
3754     }
3755
3756     diffieHellman->Wrap(args.This());
3757
3758     return args.This();
3759   }
3760
3761   static Handle<Value> GenerateKeys(const Arguments& args) {
3762     DiffieHellman* diffieHellman =
3763       ObjectWrap::Unwrap<DiffieHellman>(args.This());
3764
3765     HandleScope scope;
3766
3767     if (!diffieHellman->initialised_) {
3768       return ThrowException(Exception::Error(
3769             String::New("Not initialized")));
3770     }
3771
3772     if (!DH_generate_key(diffieHellman->dh)) {
3773       return ThrowException(Exception::Error(
3774             String::New("Key generation failed")));
3775     }
3776
3777     Local<Value> outString;
3778
3779     int dataSize = BN_num_bytes(diffieHellman->dh->pub_key);
3780     char* data = new char[dataSize];
3781     BN_bn2bin(diffieHellman->dh->pub_key,
3782         reinterpret_cast<unsigned char*>(data));
3783
3784     if (args.Length() > 0 && args[0]->IsString()) {
3785       outString = EncodeWithEncoding(args[0], data, dataSize);
3786     } else {
3787       outString = Encode(data, dataSize, BINARY);
3788     }
3789     delete[] data;
3790
3791     return scope.Close(outString);
3792   }
3793
3794   static Handle<Value> GetPrime(const Arguments& args) {
3795     DiffieHellman* diffieHellman =
3796       ObjectWrap::Unwrap<DiffieHellman>(args.This());
3797
3798     HandleScope scope;
3799
3800     if (!diffieHellman->initialised_) {
3801       return ThrowException(Exception::Error(String::New("Not initialized")));
3802     }
3803
3804     int dataSize = BN_num_bytes(diffieHellman->dh->p);
3805     char* data = new char[dataSize];
3806     BN_bn2bin(diffieHellman->dh->p, reinterpret_cast<unsigned char*>(data));
3807
3808     Local<Value> outString;
3809
3810     if (args.Length() > 0 && args[0]->IsString()) {
3811       outString = EncodeWithEncoding(args[0], data, dataSize);
3812     } else {
3813       outString = Encode(data, dataSize, BINARY);
3814     }
3815
3816     delete[] data;
3817
3818     return scope.Close(outString);
3819   }
3820
3821   static Handle<Value> GetGenerator(const Arguments& args) {
3822     DiffieHellman* diffieHellman =
3823       ObjectWrap::Unwrap<DiffieHellman>(args.This());
3824
3825     HandleScope scope;
3826
3827     if (!diffieHellman->initialised_) {
3828       return ThrowException(Exception::Error(String::New("Not initialized")));
3829     }
3830
3831     int dataSize = BN_num_bytes(diffieHellman->dh->g);
3832     char* data = new char[dataSize];
3833     BN_bn2bin(diffieHellman->dh->g, reinterpret_cast<unsigned char*>(data));
3834
3835     Local<Value> outString;
3836
3837     if (args.Length() > 0 && args[0]->IsString()) {
3838       outString = EncodeWithEncoding(args[0], data, dataSize);
3839     } else {
3840       outString = Encode(data, dataSize, BINARY);
3841     }
3842
3843     delete[] data;
3844
3845     return scope.Close(outString);
3846   }
3847
3848   static Handle<Value> GetPublicKey(const Arguments& args) {
3849     DiffieHellman* diffieHellman =
3850       ObjectWrap::Unwrap<DiffieHellman>(args.This());
3851
3852     HandleScope scope;
3853
3854     if (!diffieHellman->initialised_) {
3855       return ThrowException(Exception::Error(String::New("Not initialized")));
3856     }
3857
3858     if (diffieHellman->dh->pub_key == NULL) {
3859       return ThrowException(Exception::Error(
3860             String::New("No public key - did you forget to generate one?")));
3861     }
3862
3863     int dataSize = BN_num_bytes(diffieHellman->dh->pub_key);
3864     char* data = new char[dataSize];
3865     BN_bn2bin(diffieHellman->dh->pub_key,
3866         reinterpret_cast<unsigned char*>(data));
3867
3868     Local<Value> outString;
3869
3870     if (args.Length() > 0 && args[0]->IsString()) {
3871       outString = EncodeWithEncoding(args[0], data, dataSize);
3872     } else {
3873       outString = Encode(data, dataSize, BINARY);
3874     }
3875
3876     delete[] data;
3877
3878     return scope.Close(outString);
3879   }
3880
3881   static Handle<Value> GetPrivateKey(const Arguments& args) {
3882     DiffieHellman* diffieHellman =
3883       ObjectWrap::Unwrap<DiffieHellman>(args.This());
3884
3885     HandleScope scope;
3886
3887     if (!diffieHellman->initialised_) {
3888       return ThrowException(Exception::Error(String::New("Not initialized")));
3889     }
3890
3891     if (diffieHellman->dh->priv_key == NULL) {
3892       return ThrowException(Exception::Error(
3893             String::New("No private key - did you forget to generate one?")));
3894     }
3895
3896     int dataSize = BN_num_bytes(diffieHellman->dh->priv_key);
3897     char* data = new char[dataSize];
3898     BN_bn2bin(diffieHellman->dh->priv_key,
3899         reinterpret_cast<unsigned char*>(data));
3900
3901     Local<Value> outString;
3902
3903     if (args.Length() > 0 && args[0]->IsString()) {
3904       outString = EncodeWithEncoding(args[0], data, dataSize);
3905     } else {
3906       outString = Encode(data, dataSize, BINARY);
3907     }
3908
3909     delete[] data;
3910
3911     return scope.Close(outString);
3912   }
3913
3914   static Handle<Value> ComputeSecret(const Arguments& args) {
3915     HandleScope scope;
3916
3917     DiffieHellman* diffieHellman =
3918       ObjectWrap::Unwrap<DiffieHellman>(args.This());
3919
3920     if (!diffieHellman->initialised_) {
3921       return ThrowException(Exception::Error(String::New("Not initialized")));
3922     }
3923
3924     BIGNUM* key = 0;
3925
3926     if (args.Length() == 0) {
3927       return ThrowException(Exception::Error(
3928             String::New("First argument must be other party's public key")));
3929     } else {
3930       if (args[0]->IsString()) {
3931         char* buf;
3932         int len;
3933         if (args.Length() > 1) {
3934           len = DecodeWithEncoding(args[0], args[1], &buf);
3935         } else {
3936           len = DecodeBinary(args[0], &buf);
3937         }
3938         if (len == -1) {
3939           delete[] buf;
3940           return ThrowException(Exception::Error(
3941                 String::New("Invalid argument")));
3942         }
3943         key = BN_bin2bn(reinterpret_cast<unsigned char*>(buf), len, 0);
3944         delete[] buf;
3945       } else if (Buffer::HasInstance(args[0])) {
3946         Local<Object> buffer = args[0]->ToObject();
3947         key = BN_bin2bn(
3948           reinterpret_cast<unsigned char*>(Buffer::Data(buffer)),
3949           Buffer::Length(buffer), 0);
3950       } else {
3951         return ThrowException(Exception::Error(
3952               String::New("First argument must be other party's public key")));
3953       }
3954     }
3955
3956     int dataSize = DH_size(diffieHellman->dh);
3957     char* data = new char[dataSize];
3958
3959     int size = DH_compute_key(reinterpret_cast<unsigned char*>(data),
3960       key, diffieHellman->dh);
3961     BN_free(key);
3962
3963     Local<Value> outString;
3964
3965     // DH_size returns number of bytes in a prime number
3966     // DH_compute_key returns number of bytes in a remainder of exponent, which
3967     // may have less bytes than a prime number. Therefore add 0-padding to the
3968     // allocated buffer.
3969     if (size != dataSize) {
3970       assert(dataSize > size);
3971       memset(data + size, 0, dataSize - size);
3972     }
3973
3974     if (size == -1) {
3975       int checkResult;
3976       if (!DH_check_pub_key(diffieHellman->dh, key, &checkResult)) {
3977         return ThrowException(Exception::Error(String::New("Invalid key")));
3978       } else if (checkResult) {
3979         if (checkResult & DH_CHECK_PUBKEY_TOO_SMALL) {
3980           return ThrowException(Exception::Error(
3981                 String::New("Supplied key is too small")));
3982         } else if (checkResult & DH_CHECK_PUBKEY_TOO_LARGE) {
3983           return ThrowException(Exception::Error(
3984                 String::New("Supplied key is too large")));
3985         } else {
3986           return ThrowException(Exception::Error(String::New("Invalid key")));
3987         }
3988       } else {
3989         return ThrowException(Exception::Error(String::New("Invalid key")));
3990       }
3991     } else {
3992       if (args.Length() > 2 && args[2]->IsString()) {
3993         outString = EncodeWithEncoding(args[2], data, dataSize);
3994       } else if (args.Length() > 1 && args[1]->IsString()) {
3995         outString = EncodeWithEncoding(args[1], data, dataSize);
3996       } else {
3997         outString = Encode(data, dataSize, BINARY);
3998       }
3999     }
4000
4001     delete[] data;
4002     return scope.Close(outString);
4003   }
4004
4005   static Handle<Value> SetPublicKey(const Arguments& args) {
4006     HandleScope scope;
4007
4008     DiffieHellman* diffieHellman =
4009       ObjectWrap::Unwrap<DiffieHellman>(args.This());
4010
4011     if (!diffieHellman->initialised_) {
4012       return ThrowException(Exception::Error(String::New("Not initialized")));
4013     }
4014
4015     if (args.Length() == 0) {
4016       return ThrowException(Exception::Error(
4017             String::New("First argument must be public key")));
4018     } else {
4019       if (args[0]->IsString()) {
4020         char* buf;
4021         int len;
4022         if (args.Length() > 1) {
4023           len = DecodeWithEncoding(args[0], args[1], &buf);
4024         } else {
4025           len = DecodeBinary(args[0], &buf);
4026         }
4027         if (len == -1) {
4028           delete[] buf;
4029           return ThrowException(Exception::Error(
4030                 String::New("Invalid argument")));
4031         }
4032         diffieHellman->dh->pub_key =
4033           BN_bin2bn(reinterpret_cast<unsigned char*>(buf), len, 0);
4034         delete[] buf;
4035       } else if (Buffer::HasInstance(args[0])) {
4036         Local<Object> buffer = args[0]->ToObject();
4037         diffieHellman->dh->pub_key =
4038           BN_bin2bn(
4039             reinterpret_cast<unsigned char*>(Buffer::Data(buffer)),
4040             Buffer::Length(buffer), 0);
4041       } else {
4042         return ThrowException(Exception::Error(
4043               String::New("First argument must be public key")));
4044       }
4045     }
4046
4047     return args.This();
4048   }
4049
4050   static Handle<Value> SetPrivateKey(const Arguments& args) {
4051     HandleScope scope;
4052
4053     DiffieHellman* diffieHellman =
4054       ObjectWrap::Unwrap<DiffieHellman>(args.This());
4055
4056     if (!diffieHellman->initialised_) {
4057       return ThrowException(Exception::Error(
4058             String::New("Not initialized")));
4059     }
4060
4061     if (args.Length() == 0) {
4062       return ThrowException(Exception::Error(
4063             String::New("First argument must be private key")));
4064     } else {
4065       if (args[0]->IsString()) {
4066         char* buf;
4067         int len;
4068         if (args.Length() > 1) {
4069           len = DecodeWithEncoding(args[0], args[1], &buf);
4070         } else {
4071           len = DecodeBinary(args[0], &buf);
4072         }
4073         if (len == -1) {
4074           delete[] buf;
4075           return ThrowException(Exception::Error(
4076                 String::New("Invalid argument")));
4077         }
4078         diffieHellman->dh->priv_key =
4079           BN_bin2bn(reinterpret_cast<unsigned char*>(buf), len, 0);
4080         delete[] buf;
4081       } else if (Buffer::HasInstance(args[0])) {
4082         Local<Object> buffer = args[0]->ToObject();
4083         diffieHellman->dh->priv_key =
4084           BN_bin2bn(
4085             reinterpret_cast<unsigned char*>(Buffer::Data(buffer)),
4086             Buffer::Length(buffer), 0);
4087       } else {
4088         return ThrowException(Exception::Error(
4089               String::New("First argument must be private key")));
4090       }
4091     }
4092
4093     return args.This();
4094   }
4095
4096   DiffieHellman() : ObjectWrap() {
4097     initialised_ = false;
4098     dh = NULL;
4099   }
4100
4101   ~DiffieHellman() {
4102     if (dh != NULL) {
4103       DH_free(dh);
4104     }
4105   }
4106
4107  private:
4108   bool VerifyContext() {
4109     int codes;
4110     if (!DH_check(dh, &codes)) return false;
4111     if (codes & DH_CHECK_P_NOT_SAFE_PRIME) return false;
4112     if (codes & DH_CHECK_P_NOT_PRIME) return false;
4113     if (codes & DH_UNABLE_TO_CHECK_GENERATOR) return false;
4114     if (codes & DH_NOT_SUITABLE_GENERATOR) return false;
4115     return true;
4116   }
4117
4118   static int DecodeBinary(Handle<Value> str, char** buf) {
4119     int len = DecodeBytes(str);
4120     *buf = new char[len];
4121     int written = DecodeWrite(*buf, len, str, BINARY);
4122     if (written != len) {
4123       return -1;
4124     }
4125     return len;
4126   }
4127
4128   static int DecodeWithEncoding(Handle<Value> str, Handle<Value> encoding_v,
4129       char** buf) {
4130     int len = DecodeBinary(str, buf);
4131     if (len == -1) {
4132       return len;
4133     }
4134     enum encoding enc = ParseEncoding(encoding_v, (enum encoding) -1);
4135     char* retbuf = 0;
4136     int retlen;
4137
4138     if (enc == HEX) {
4139       HexDecode((unsigned char*)*buf, len, &retbuf, &retlen);
4140
4141     } else if (enc == BASE64) {
4142       unbase64((unsigned char*)*buf, len, &retbuf, &retlen);
4143
4144     } else if (enc == BINARY) {
4145       // Binary - do nothing
4146     } else {
4147       fprintf(stderr, "node-crypto : Diffie-Hellman parameter encoding "
4148                       "can be binary, hex or base64\n");
4149     }
4150
4151     if (retbuf != 0) {
4152       delete [] *buf;
4153       *buf = retbuf;
4154       len = retlen;
4155     }
4156
4157     return len;
4158   }
4159
4160   static Local<Value> EncodeWithEncoding(Handle<Value> encoding_v, char* buf,
4161       int len) {
4162     HandleScope scope;
4163
4164     Local<Value> outString;
4165     enum encoding enc = ParseEncoding(encoding_v, (enum encoding) -1);
4166     char* retbuf;
4167     int retlen;
4168
4169     if (enc == HEX) {
4170       // Hex encoding
4171       HexEncode(reinterpret_cast<unsigned char*>(buf), len, &retbuf, &retlen);
4172       outString = Encode(retbuf, retlen, BINARY);
4173       delete [] retbuf;
4174     } else if (enc == BASE64) {
4175       base64(reinterpret_cast<unsigned char*>(buf), len, &retbuf, &retlen);
4176       outString = Encode(retbuf, retlen, BINARY);
4177       delete [] retbuf;
4178     } else if (enc == BINARY) {
4179       outString = Encode(buf, len, BINARY);
4180     } else {
4181       fprintf(stderr, "node-crypto : Diffie-Hellman parameter encoding "
4182                       "can be binary, hex or base64\n");
4183     }
4184
4185     return scope.Close(outString);
4186   }
4187
4188   bool initialised_;
4189   DH* dh;
4190 };
4191
4192 struct pbkdf2_req {
4193   int err;
4194   char* pass;
4195   size_t passlen;
4196   char* salt;
4197   size_t saltlen;
4198   size_t iter;
4199   char* key;
4200   size_t keylen;
4201   Persistent<Object> obj;
4202 };
4203
4204 void
4205 EIO_PBKDF2(uv_work_t* req) {
4206   pbkdf2_req* request = (pbkdf2_req*)req->data;
4207   request->err = PKCS5_PBKDF2_HMAC_SHA1(
4208     request->pass,
4209     request->passlen,
4210     (unsigned char*)request->salt,
4211     request->saltlen,
4212     request->iter,
4213     request->keylen,
4214     (unsigned char*)request->key);
4215   memset(request->pass, 0, request->passlen);
4216   memset(request->salt, 0, request->saltlen);
4217 }
4218
4219 void
4220 EIO_PBKDF2After(uv_work_t* req) {
4221   HandleScope scope;
4222
4223   pbkdf2_req* request = (pbkdf2_req*)req->data;
4224   delete req;
4225
4226   Local<Value> argv[2];
4227   if (request->err) {
4228     argv[0] = Local<Value>::New(Undefined());
4229     argv[1] = Encode(request->key, request->keylen, BINARY);
4230     memset(request->key, 0, request->keylen);
4231   } else {
4232     argv[0] = Exception::Error(String::New("PBKDF2 error"));
4233     argv[1] = Local<Value>::New(Undefined());
4234   }
4235
4236   MakeCallback(request->obj, "ondone", ARRAY_SIZE(argv), argv);
4237
4238   delete[] request->pass;
4239   delete[] request->salt;
4240   delete[] request->key;
4241   request->obj.Dispose();
4242   request->obj.Clear();
4243
4244   delete request;
4245 }
4246
4247 Handle<Value>
4248 PBKDF2(const Arguments& args) {
4249   HandleScope scope;
4250
4251   const char* type_error = NULL;
4252   char* pass = NULL;
4253   char* salt = NULL;
4254   char* key = NULL;
4255   ssize_t passlen = -1;
4256   ssize_t saltlen = -1;
4257   ssize_t keylen = -1;
4258   ssize_t pass_written = -1;
4259   ssize_t salt_written = -1;
4260   ssize_t iter = -1;
4261   Local<Function> callback;
4262   pbkdf2_req* request = NULL;
4263   uv_work_t* req = NULL;
4264   Persistent<Object> obj;
4265
4266   if (args.Length() != 5) {
4267     type_error = "Bad parameter";
4268     goto err;
4269   }
4270
4271   ASSERT_IS_STRING_OR_BUFFER(args[0]);
4272   passlen = DecodeBytes(args[0], BINARY);
4273   if (passlen < 0) {
4274     type_error = "Bad password";
4275     goto err;
4276   }
4277
4278   pass = new char[passlen];
4279   pass_written = DecodeWrite(pass, passlen, args[0], BINARY);
4280   assert(pass_written == passlen);
4281
4282   ASSERT_IS_STRING_OR_BUFFER(args[1]);
4283   saltlen = DecodeBytes(args[1], BINARY);
4284   if (saltlen < 0) {
4285     type_error = "Bad salt";
4286     goto err;
4287   }
4288
4289   salt = new char[saltlen];
4290   salt_written = DecodeWrite(salt, saltlen, args[1], BINARY);
4291   assert(salt_written == saltlen);
4292
4293   if (!args[2]->IsNumber()) {
4294     type_error = "Iterations not a number";
4295     goto err;
4296   }
4297
4298   iter = args[2]->Int32Value();
4299   if (iter < 0) {
4300     type_error = "Bad iterations";
4301     goto err;
4302   }
4303
4304   if (!args[3]->IsNumber()) {
4305     type_error = "Key length not a number";
4306     goto err;
4307   }
4308
4309   keylen = args[3]->Int32Value();
4310   if (keylen < 0) {
4311     type_error = "Bad key length";
4312     goto err;
4313   }
4314
4315   key = new char[keylen];
4316
4317   if (!args[4]->IsFunction()) {
4318     type_error = "Callback not a function";
4319     goto err;
4320   }
4321
4322   obj = Persistent<Object>::New(Object::New());
4323   obj->Set(String::New("ondone"), args[4]);
4324
4325   request = new pbkdf2_req;
4326   request->err = 0;
4327   request->pass = pass;
4328   request->passlen = passlen;
4329   request->salt = salt;
4330   request->saltlen = saltlen;
4331   request->iter = iter;
4332   request->key = key;
4333   request->keylen = keylen;
4334   request->obj = obj;
4335
4336   req = new uv_work_t();
4337   req->data = request;
4338   uv_queue_work(uv_default_loop(), req, EIO_PBKDF2, EIO_PBKDF2After);
4339   return Undefined();
4340
4341 err:
4342   delete[] key;
4343   delete[] salt;
4344   delete[] pass;
4345   return ThrowException(Exception::TypeError(String::New(type_error)));
4346 }
4347
4348
4349 typedef int (*RandomBytesGenerator)(unsigned char* buf, int size);
4350
4351 struct RandomBytesRequest {
4352   ~RandomBytesRequest();
4353   Persistent<Object> obj_;
4354   unsigned long error_; // openssl error code or zero
4355   uv_work_t work_req_;
4356   size_t size_;
4357   char* data_;
4358 };
4359
4360
4361 RandomBytesRequest::~RandomBytesRequest() {
4362   if (obj_.IsEmpty()) return;
4363   obj_.Dispose();
4364   obj_.Clear();
4365 }
4366
4367
4368 void RandomBytesFree(char* data, void* hint) {
4369   delete[] data;
4370 }
4371
4372
4373 template <RandomBytesGenerator generator>
4374 void RandomBytesWork(uv_work_t* work_req) {
4375   RandomBytesRequest* req =
4376       container_of(work_req, RandomBytesRequest, work_req_);
4377
4378   int r = generator(reinterpret_cast<unsigned char*>(req->data_), req->size_);
4379
4380   switch (r) {
4381   case 0:
4382     // RAND_bytes() returns 0 on error, RAND_pseudo_bytes() returns 0
4383     // when the result is not cryptographically strong - the latter
4384     // sucks but is not an error
4385     if (generator == RAND_bytes)
4386       req->error_ = ERR_get_error();
4387     break;
4388
4389   case -1:
4390     // not supported - can this actually happen?
4391     req->error_ = (unsigned long) -1;
4392     break;
4393   }
4394 }
4395
4396
4397 // don't call this function without a valid HandleScope
4398 void RandomBytesCheck(RandomBytesRequest* req, Local<Value> argv[2]) {
4399   if (req->error_) {
4400     char errmsg[256] = "Operation not supported";
4401
4402     if (req->error_ != (unsigned long) -1)
4403       ERR_error_string_n(req->error_, errmsg, sizeof errmsg);
4404
4405     argv[0] = Exception::Error(String::New(errmsg));
4406     argv[1] = Local<Value>::New(Null());
4407   }
4408   else {
4409     // avoids the malloc + memcpy
4410     Buffer* buffer = Buffer::New(req->data_, req->size_, RandomBytesFree, NULL);
4411     argv[0] = Local<Value>::New(Null());
4412     argv[1] = Local<Object>::New(buffer->handle_);
4413   }
4414 }
4415
4416
4417 template <RandomBytesGenerator generator>
4418 void RandomBytesAfter(uv_work_t* work_req) {
4419   RandomBytesRequest* req =
4420       container_of(work_req, RandomBytesRequest, work_req_);
4421
4422   HandleScope scope;
4423   Local<Value> argv[2];
4424   RandomBytesCheck(req, argv);
4425   MakeCallback(req->obj_, "ondone", ARRAY_SIZE(argv), argv);
4426
4427   delete req;
4428 }
4429
4430
4431 template <RandomBytesGenerator generator>
4432 Handle<Value> RandomBytes(const Arguments& args) {
4433   HandleScope scope;
4434
4435   // maybe allow a buffer to write to? cuts down on object creation
4436   // when generating random data in a loop
4437   if (!args[0]->IsUint32()) {
4438     Local<String> s = String::New("Argument #1 must be number > 0");
4439     return ThrowException(Exception::TypeError(s));
4440   }
4441
4442   const size_t size = args[0]->Uint32Value();
4443
4444   RandomBytesRequest* req = new RandomBytesRequest();
4445   req->error_ = 0;
4446   req->data_ = new char[size];
4447   req->size_ = size;
4448
4449   if (args[1]->IsFunction()) {
4450     req->obj_ = Persistent<Object>::New(Object::New());
4451     req->obj_->Set(String::New("ondone"), args[1]);
4452
4453     uv_queue_work(uv_default_loop(),
4454                   &req->work_req_,
4455                   RandomBytesWork<generator>,
4456                   RandomBytesAfter<generator>);
4457
4458     return req->obj_;
4459   }
4460   else {
4461     Local<Value> argv[2];
4462     RandomBytesWork<generator>(&req->work_req_);
4463     RandomBytesCheck(req, argv);
4464     delete req;
4465
4466     if (!argv[0]->IsNull())
4467       return ThrowException(argv[0]);
4468     else
4469       return argv[1];
4470   }
4471 }
4472
4473
4474 void InitCrypto(Handle<Object> target) {
4475   HandleScope scope;
4476
4477   SSL_library_init();
4478   OpenSSL_add_all_algorithms();
4479   OpenSSL_add_all_digests();
4480   SSL_load_error_strings();
4481   ERR_load_crypto_strings();
4482
4483   crypto_lock_init();
4484   CRYPTO_set_locking_callback(crypto_lock_cb);
4485   CRYPTO_set_id_callback(crypto_id_cb);
4486
4487   // Turn off compression. Saves memory - do it in userland.
4488 #if !defined(OPENSSL_NO_COMP)
4489   STACK_OF(SSL_COMP)* comp_methods =
4490 #if OPENSSL_VERSION_NUMBER < 0x00908000L
4491     SSL_COMP_get_compression_method()
4492 #else
4493     SSL_COMP_get_compression_methods()
4494 #endif
4495   ;
4496   sk_SSL_COMP_zero(comp_methods);
4497   assert(sk_SSL_COMP_num(comp_methods) == 0);
4498 #endif
4499
4500   SecureContext::Initialize(target);
4501   Connection::Initialize(target);
4502   Cipher::Initialize(target);
4503   Decipher::Initialize(target);
4504   DiffieHellman::Initialize(target);
4505   Hmac::Initialize(target);
4506   Hash::Initialize(target);
4507   Sign::Initialize(target);
4508   Verify::Initialize(target);
4509
4510   NODE_SET_METHOD(target, "PBKDF2", PBKDF2);
4511   NODE_SET_METHOD(target, "randomBytes", RandomBytes<RAND_bytes>);
4512   NODE_SET_METHOD(target, "pseudoRandomBytes", RandomBytes<RAND_pseudo_bytes>);
4513
4514   subject_symbol    = NODE_PSYMBOL("subject");
4515   issuer_symbol     = NODE_PSYMBOL("issuer");
4516   valid_from_symbol = NODE_PSYMBOL("valid_from");
4517   valid_to_symbol   = NODE_PSYMBOL("valid_to");
4518   subjectaltname_symbol = NODE_PSYMBOL("subjectaltname");
4519   modulus_symbol        = NODE_PSYMBOL("modulus");
4520   exponent_symbol       = NODE_PSYMBOL("exponent");
4521   fingerprint_symbol   = NODE_PSYMBOL("fingerprint");
4522   name_symbol       = NODE_PSYMBOL("name");
4523   version_symbol    = NODE_PSYMBOL("version");
4524   ext_key_usage_symbol = NODE_PSYMBOL("ext_key_usage");
4525 }
4526
4527 }  // namespace crypto
4528 }  // namespace node
4529
4530 NODE_MODULE(node_crypto, node::crypto::InitCrypto)