Attachment #500618 for bug #604978




using v8::Value;


#if OPENSSL_VERSION_NUMBER < 0x10100000L
static void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e,
                         const BIGNUM** d) {
  if (n != nullptr) {
    *n = r->n;
  }
  if (e != nullptr) {
    *e = r->e;
  }
  if (d != nullptr) {
    *d = r->d;
  }
}

static void DH_get0_pqg(const DH* dh, const BIGNUM** p, const BIGNUM** q,
                        const BIGNUM** g) {
  if (p != nullptr) {
    *p = dh->p;
  }
  if (q != nullptr) {
    *q = dh->q;
  }
  if (g != nullptr) {
    *g = dh->g;
  }
}

static int DH_set0_pqg(DH* dh, BIGNUM* p, BIGNUM* q, BIGNUM* g) {
  if ((dh->p == nullptr && p == nullptr) ||
      (dh->g == nullptr && g == nullptr)) {
    return 0;
  }

  if (p != nullptr) {
    BN_free(dh->p);
    dh->p = p;
  }
  if (q != nullptr) {
    BN_free(dh->q);
    dh->q = q;
  }
  if (g != nullptr) {
    BN_free(dh->g);
    dh->g = g;
  }

  return 1;
}

static void DH_get0_key(const DH* dh, const BIGNUM** pub_key,
                        const BIGNUM** priv_key) {
  if (pub_key != nullptr) {
    *pub_key = dh->pub_key;
  }
  if (priv_key != nullptr) {
    *priv_key = dh->priv_key;
  }
}

static int DH_set0_key(DH* dh, BIGNUM* pub_key, BIGNUM* priv_key) {
  if (pub_key != nullptr) {
    BN_free(dh->pub_key);
    dh->pub_key = pub_key;
  }
  if (priv_key != nullptr) {
    BN_free(dh->priv_key);
    dh->priv_key = priv_key;
  }

  return 1;
}

static const SSL_METHOD* TLS_method() { return SSLv23_method(); }

static void SSL_SESSION_get0_ticket(const SSL_SESSION* s,
                                    const unsigned char** tick, size_t* len) {
  *len = s->tlsext_ticklen;
  if (tick != nullptr) {
    *tick = s->tlsext_tick;
  }
}

#define SSL_get_tlsext_status_type(ssl) (ssl->tlsext_status_type)

#if !defined(OPENSSL_IS_BORINGSSL)
static int X509_STORE_up_ref(X509_STORE* store) {
  CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE);
  return 1;
}

static int X509_up_ref(X509* cert) {
  CRYPTO_add(&cert->references, 1, CRYPTO_LOCK_X509);
  return 1;
}
#endif  // !OPENSSL_IS_BORINGSSL

#define EVP_MD_CTX_new EVP_MD_CTX_create
#define EVP_MD_CTX_free EVP_MD_CTX_destroy

HMAC_CTX* HMAC_CTX_new() {
  HMAC_CTX* ctx = Malloc<HMAC_CTX>(1);
  HMAC_CTX_init(ctx);
  return ctx;
}

void HMAC_CTX_free(HMAC_CTX* ctx) {
  if (ctx == nullptr) {
    return;
  }
  HMAC_CTX_cleanup(ctx);
  free(ctx);
}
#endif  // OPENSSL_VERSION_NUMBER < 0x10100000L

// Subject DER of CNNIC ROOT CA and CNNIC EV ROOT CA are taken from
// https://hg.mozilla.org/mozilla-central/file/98820360ab66/security/
// certverifier/NSSCertDBTrustDomain.cpp#l672

    d2i_X509_NAME(nullptr, &cnnic_ev_p,
                  sizeof(CNNIC_EV_ROOT_CA_SUBJECT_DATA)-1);

static Mutex* mutexes;

static const char* const root_certs[] = {
#include "node_root_certs.h"  // NOLINT(build/include_order)
};

template void SSLWrap<TLSWrap>::InitNPN(SecureContext* sc);
template void SSLWrap<TLSWrap>::SetSNIContext(SecureContext* sc);
template int SSLWrap<TLSWrap>::SetCACerts(SecureContext* sc);
#if OPENSSL_VERSION_NUMBER < 0x10100000L
template SSL_SESSION* SSLWrap<TLSWrap>::GetSessionCallback(
    SSL* s,
    unsigned char* key,
    int len,
    int* copy);
#else
template SSL_SESSION* SSLWrap<TLSWrap>::GetSessionCallback(
    SSL* s,
    const unsigned char* key,
    int len,
    int* copy);
#endif
template int SSLWrap<TLSWrap>::NewSessionCallback(SSL* s,
                                                  SSL_SESSION* sess);
template void SSLWrap<TLSWrap>::OnClientHello(

    void* arg);
#endif  // TLSEXT_TYPE_application_layer_protocol_negotiation

#if OPENSSL_VERSION_NUMBER < 0x10100000L
static Mutex* mutexes;

static void crypto_threadid_cb(CRYPTO_THREADID* tid) {
  static_assert(sizeof(uv_thread_t) <= sizeof(void*),
                "uv_thread_t does not fit in a pointer");

  else
    mutex->Unlock();
}
#endif


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

  ASSIGN_OR_RETURN_UNWRAP(&sc, args.Holder());
  Environment* env = sc->env();

  const SSL_METHOD* method = TLS_method();

  if (args.Length() == 1 && args[0]->IsString()) {
    const node::Utf8Value sslmethod(env->isolate(), args[0]);

    // Note that SSLv2 and SSLv3 are disallowed but SSLv23_method and friends
    // are still accepted.  They are OpenSSL's way of saying that all known
    // protocols are supported unless explicitly disabled (which we do below
    // for SSLv2 and SSLv3.)

  sc->ctx_ = SSL_CTX_new(method);
  SSL_CTX_set_app_data(sc->ctx_, sc);

  // Disable SSLv2 in the case when method == TLS_method() and the
  // cipher list contains SSLv2 ciphers (not the default, should be rare.)
  // The bundled OpenSSL doesn't have SSLv2 support but the system OpenSSL may.
  // SSLv3 is disabled because it's susceptible to downgrade attacks (POODLE.)

                                 SSL_SESS_CACHE_NO_AUTO_CLEAR);
  SSL_CTX_sess_set_get_cb(sc->ctx_, SSLWrap<Connection>::GetSessionCallback);
  SSL_CTX_sess_set_new_cb(sc->ctx_, SSLWrap<Connection>::NewSessionCallback);

#if OPENSSL_VERSION_NUMBER >= 0x10100000L
  // OpenSSL 1.1.0 changed the ticket key size, but the OpenSSL 1.0.x size was
  // exposed in the public API. To retain compatibility, install a callback
  // which restores the old algorithm.
  if (RAND_bytes(sc->ticket_key_name_, sizeof(sc->ticket_key_name_)) <= 0 ||
      RAND_bytes(sc->ticket_key_hmac_, sizeof(sc->ticket_key_hmac_)) <= 0 ||
      RAND_bytes(sc->ticket_key_aes_, sizeof(sc->ticket_key_aes_)) <= 0) {
    return env->ThrowError("Error generating ticket keys");
  }
  SSL_CTX_set_tlsext_ticket_key_cb(sc->ctx_,
                                   SecureContext::TicketCompatibilityCallback);
#endif
}





int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer) {
  int ret;

  X509_STORE* store = SSL_CTX_get_cert_store(ctx);
  X509_STORE_CTX* store_ctx = X509_STORE_CTX_new();
  int ret = store_ctx != nullptr &&
            X509_STORE_CTX_init(store_ctx, store, nullptr, nullptr) == 1 &&
            X509_STORE_CTX_get1_issuer(issuer, store_ctx, cert) == 1;
  X509_STORE_CTX_free(store_ctx);

  ret = X509_STORE_CTX_get1_issuer(issuer, &store_ctx, cert);
  X509_STORE_CTX_cleanup(&store_ctx);

 end:
  return ret;
}


  x = PEM_read_bio_X509_AUX(in, nullptr, NoPasswordCallback, nullptr);

  if (x == nullptr) {
    SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_PEM_LIB);
    return 0;
  }


  // Read extra certs
  STACK_OF(X509)* extra_certs = sk_X509_new_null();
  if (extra_certs == nullptr) {
    SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE, ERR_R_MALLOC_FAILURE);
    goto done;
  }


}


#if OPENSSL_VERSION_NUMBER < 0x10100000L && !defined(OPENSSL_IS_BORINGSSL)
// This section contains OpenSSL 1.1.0 functions reimplemented for OpenSSL
// 1.0.2 so that the following code can be written without lots of #if lines.

static int X509_STORE_up_ref(X509_STORE* store) {
  CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE);
  return 1;
}

static int X509_up_ref(X509* cert) {
  CRYPTO_add(&cert->references, 1, CRYPTO_LOCK_X509);
  return 1;
}
#endif  // OPENSSL_VERSION_NUMBER < 0x10100000L && !OPENSSL_IS_BORINGSSL


static X509_STORE* NewRootCertStore() {
  static std::vector<X509*> root_certs_vector;
  if (root_certs_vector.empty()) {


  node::Utf8Value curve(env->isolate(), args[0]);

#if OPENSSL_VERSION_NUMBER < 0x10100000L
  SSL_CTX_set_options(sc->ctx_, SSL_OP_SINGLE_ECDH_USE);
  SSL_CTX_set_ecdh_auto(sc->ctx_, 1);
#endif

  if (strcmp(*curve, "auto") == 0)
    return;

  if (dh == nullptr)
    return;

  const BIGNUM* p;
  DH_get0_pqg(dh, &p, nullptr, nullptr);
  const int size = BN_num_bits(p);
  if (size < 1024) {
    return env->ThrowError("DH parameter is less than 1024 bits");
  } else if (size < 2048) {

  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());

  Local<Object> buff = Buffer::New(wrap->env(), 48).ToLocalChecked();
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
  memcpy(Buffer::Data(buff), wrap->ticket_key_name_, 16);
  memcpy(Buffer::Data(buff) + 16, wrap->ticket_key_hmac_, 16);
  memcpy(Buffer::Data(buff) + 32, wrap->ticket_key_aes_, 16);
#else
  if (SSL_CTX_get_tlsext_ticket_keys(wrap->ctx_,
                                     Buffer::Data(buff),
                                     Buffer::Length(buff)) != 1) {
    return wrap->env()->ThrowError("Failed to fetch tls ticket keys");
  }
#endif

  args.GetReturnValue().Set(buff);
#endif  // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)

    return env->ThrowTypeError("Ticket keys length must be 48 bytes");
  }

#if OPENSSL_VERSION_NUMBER >= 0x10100000L
  memcpy(wrap->ticket_key_name_, Buffer::Data(args[0]), 16);
  memcpy(wrap->ticket_key_hmac_, Buffer::Data(args[0]) + 16, 16);
  memcpy(wrap->ticket_key_aes_, Buffer::Data(args[0]) + 32, 16);
#else
  if (SSL_CTX_set_tlsext_ticket_keys(wrap->ctx_,
                                     Buffer::Data(args[0]),
                                     Buffer::Length(args[0])) != 1) {
    return env->ThrowError("Failed to fetch tls ticket keys");
  }
#endif

  args.GetReturnValue().Set(true);
#endif  // !def(OPENSSL_NO_TLSEXT) && def(SSL_CTX_get_tlsext_ticket_keys)

}


#if OPENSSL_VERSION_NUMBER >= 0x10100000L
int SecureContext::TicketCompatibilityCallback(SSL* ssl,
                                               unsigned char* name,
                                               unsigned char* iv,
                                               EVP_CIPHER_CTX* ectx,
                                               HMAC_CTX* hctx,
                                               int enc) {
  SecureContext* sc = static_cast<SecureContext*>(
      SSL_CTX_get_app_data(SSL_get_SSL_CTX(ssl)));

  if (enc) {
    memcpy(name, sc->ticket_key_name_, sizeof(sc->ticket_key_name_));
    if (RAND_bytes(iv, 16) <= 0 ||
        EVP_EncryptInit_ex(ectx, EVP_aes_128_cbc(), nullptr,
                           sc->ticket_key_aes_, iv) <= 0 ||
        HMAC_Init_ex(hctx, sc->ticket_key_hmac_, sizeof(sc->ticket_key_hmac_),
                     EVP_sha256(), nullptr) <= 0) {
      return -1;
    }
    return 1;
  }

  if (memcmp(name, sc->ticket_key_name_, sizeof(sc->ticket_key_name_)) != 0) {
    // The ticket key name does not match. Discard the ticket.
    return 0;
  }

  if (EVP_DecryptInit_ex(ectx, EVP_aes_128_cbc(), nullptr, sc->ticket_key_aes_,
                         iv) <= 0 ||
      HMAC_Init_ex(hctx, sc->ticket_key_hmac_, sizeof(sc->ticket_key_hmac_),
                   EVP_sha256(), nullptr) <= 0) {
    return -1;
  }
  return 1;
}
#endif


void SecureContext::CtxGetter(Local<String> property,

}


#if OPENSSL_VERSION_NUMBER < 0x10100000L
template <class Base>
SSL_SESSION* SSLWrap<Base>::GetSessionCallback(SSL* s,
                                               unsigned char* key,
                                               int len,
                                               int* copy) {
#else
template <class Base>
SSL_SESSION* SSLWrap<Base>::GetSessionCallback(SSL* s,
                                               const unsigned char* key,
                                               int len,
                                               int* copy) {
#endif
  Base* w = static_cast<Base*>(SSL_get_app_data(s));

  *copy = 0;

    rsa = EVP_PKEY_get1_RSA(pkey);

  if (rsa != nullptr) {
    const BIGNUM* n;
    const BIGNUM* e;
    RSA_get0_key(rsa, &n, &e, nullptr);
    BN_print(bio, n);
    BIO_get_mem_ptr(bio, &mem);
    info->Set(env->modulus_string(),
              String::NewFromUtf8(env->isolate(), mem->data,
                                  String::kNormalString, mem->length));
    (void) BIO_reset(bio);

    uint64_t exponent_word = static_cast<uint64_t>(BN_get_word(e));
    uint32_t lo = static_cast<uint32_t>(exponent_word);
    uint32_t hi = static_cast<uint32_t>(exponent_word >> 32);
    if (hi == 0) {

  Environment* env = w->ssl_env();

  SSL_SESSION* sess = SSL_get_session(w->ssl_);
  if (sess == nullptr)
    return;

  const unsigned char *ticket;
  size_t length;
  SSL_SESSION_get0_ticket(sess, &ticket, &length);

  if (ticket == nullptr)
    return;

  Local<Object> buff = Buffer::Copy(
      env, reinterpret_cast<const char*>(ticket), length).ToLocalChecked();
      reinterpret_cast<char*>(sess->tlsext_tick),
      sess->tlsext_ticklen).ToLocalChecked();

  args.GetReturnValue().Set(buff);
}

  Local<Object> info = Object::New(env->isolate());
  const char* cipher_name = SSL_CIPHER_get_name(c);
  info->Set(env->name_string(), OneByteString(args.GetIsolate(), cipher_name));
  const char* cipher_version = SSL_CIPHER_get_version(c);
  info->Set(env->version_string(),
            OneByteString(args.GetIsolate(), "TLSv1/SSLv3"));
  args.GetReturnValue().Set(info);
}


  unsigned alpn_protos_len = Buffer::Length(alpn_buffer);
  int status = SSL_select_next_proto(const_cast<unsigned char**>(out), outlen,
                                     alpn_protos, alpn_protos_len, in, inlen);
  // According to 3.2. Protocol Selection of RFC7301, fatal
  // no_application_protocol alert shall be sent but OpenSSL 1.0.2 does not
  // support it yet. See
  // https://rt.openssl.org/Ticket/Display.html?id=3463&user=guest&pass=guest
  return status == OPENSSL_NPN_NEGOTIATED ? SSL_TLSEXT_ERR_OK
                                          : SSL_TLSEXT_ERR_NOACK;
      // https://rt.openssl.org/Ticket/Display.html?id=3463&user=guest&pass=guest
      // Instead, we send a warning alert for now.
      return SSL_TLSEXT_ERR_ALERT_WARNING;
    case OPENSSL_NPN_NEGOTIATED:
      return SSL_TLSEXT_ERR_OK;
    default:
      return SSL_TLSEXT_ERR_ALERT_FATAL;
  }
}
#endif  // TLSEXT_TYPE_application_layer_protocol_negotiation



  bool ocsp = false;
#ifdef NODE__HAVE_TLSEXT_STATUS_CB
  ocsp = SSL_get_tlsext_status_type(s) == TLSEXT_STATUSTYPE_ocsp;
#endif

  info->Set(env->ocsp_request_string(), Boolean::New(env->isolate(), ocsp));

  }
#endif  // NODE_FIPS_MODE

  CHECK_EQ(ctx_, nullptr);
  const EVP_CIPHER* const cipher = EVP_get_cipherbyname(cipher_type);
  if (cipher == nullptr) {
    return env()->ThrowError("Unknown cipher");

                               key,
                               iv);

  ctx_ = EVP_CIPHER_CTX_new();
  const bool encrypt = (kind_ == kCipher);
  EVP_CipherInit_ex(ctx_, cipher, nullptr, nullptr, nullptr, encrypt);

  int mode = EVP_CIPHER_CTX_mode(ctx_);
  if (encrypt && (mode == EVP_CIPH_CTR_MODE || mode == EVP_CIPH_GCM_MODE ||
      mode == EVP_CIPH_CCM_MODE)) {
    ProcessEmitWarning(env(), "Use Cipheriv for counter mode of %s",

  }

  if (mode == EVP_CIPH_WRAP_MODE)
    EVP_CIPHER_CTX_set_flags(ctx_, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);

  CHECK_EQ(1, EVP_CIPHER_CTX_set_key_length(ctx_, key_len));

  EVP_CipherInit_ex(ctx_,
                    nullptr,
                    nullptr,
                    reinterpret_cast<unsigned char*>(key),
                    reinterpret_cast<unsigned char*>(iv),
                    kind_ == kCipher);
  initialised_ = true;
}



    return env()->ThrowError("Invalid IV length");
  }

  ctx_ = EVP_CIPHER_CTX_new();

  if (mode == EVP_CIPH_WRAP_MODE)
    EVP_CIPHER_CTX_set_flags(ctx_, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);

  const bool encrypt = (kind_ == kCipher);
  EVP_CipherInit_ex(ctx_, cipher, nullptr, nullptr, nullptr, encrypt);

  if (is_gcm_mode &&
      !EVP_CIPHER_CTX_ctrl(ctx_, EVP_CTRL_GCM_SET_IVLEN, iv_len, nullptr)) {
    EVP_CIPHER_CTX_free(ctx_);
    ctx_ = nullptr;
    return env()->ThrowError("Invalid IV length");
  }

  if (!EVP_CIPHER_CTX_set_key_length(ctx_, key_len)) {
    EVP_CIPHER_CTX_free(ctx_);
    ctx_ = nullptr;
    return env()->ThrowError("Invalid key length");
  }

  EVP_CipherInit_ex(ctx_,
                    nullptr,
                    nullptr,
                    reinterpret_cast<const unsigned char*>(key),
                    reinterpret_cast<const unsigned char*>(iv),
                    kind_ == kCipher);
  initialised_ = true;
}




bool CipherBase::IsAuthenticatedMode() const {
  // Check if this cipher operates in an AEAD mode that we support.
  CHECK_NE(ctx_, nullptr);
  const EVP_CIPHER* const cipher = EVP_CIPHER_CTX_cipher(ctx_);
  int mode = EVP_CIPHER_mode(cipher);
  return mode == EVP_CIPH_GCM_MODE;
}

  ASSIGN_OR_RETURN_UNWRAP(&cipher, args.Holder());

  // Only callable after Final and if encrypting.
  if (cipher->ctx_ ||
      cipher->kind_ != kCipher ||
      cipher->auth_tag_len_ == 0) {
    return env->ThrowError("Attempting to get auth tag in unsupported state");

  CipherBase* cipher;
  ASSIGN_OR_RETURN_UNWRAP(&cipher, args.Holder());

  if (!cipher->ctx_ ||
      !cipher->IsAuthenticatedMode() ||
      cipher->kind_ != kDecipher) {
    return env->ThrowError("Attempting to set auth tag in unsupported state");



bool CipherBase::SetAAD(const char* data, unsigned int len) {
  if (!ctx_ || !IsAuthenticatedMode())
    return false;
  int outlen;
  if (!EVP_CipherUpdate(ctx_,
                        nullptr,
                        &outlen,
                        reinterpret_cast<const unsigned char*>(data),

                        int len,
                        unsigned char** out,
                        int* out_len) {
  if (!ctx_)
    return 0;

  // on first update:
  if (kind_ == kDecipher && IsAuthenticatedMode() && auth_tag_len_ > 0) {
    EVP_CIPHER_CTX_ctrl(ctx_,
                        EVP_CTRL_GCM_SET_TAG,
                        auth_tag_len_,
                        reinterpret_cast<unsigned char*>(auth_tag_));
    auth_tag_len_ = 0;
  }

  *out_len = len + EVP_CIPHER_CTX_block_size(ctx_);
  *out = Malloc<unsigned char>(static_cast<size_t>(*out_len));
  return EVP_CipherUpdate(ctx_,
                          *out,
                          out_len,
                          reinterpret_cast<const unsigned char*>(data),



bool CipherBase::SetAutoPadding(bool auto_padding) {
  if (!ctx_)
    return false;
  return EVP_CIPHER_CTX_set_padding(ctx_, auto_padding);
}





bool CipherBase::Final(unsigned char** out, int *out_len) {
  if (!ctx_)
    return false;

  *out = Malloc<unsigned char>(
      static_cast<size_t>(EVP_CIPHER_CTX_block_size(ctx_)));
  int r = EVP_CipherFinal_ex(ctx_, *out, out_len);

  if (r == 1 && kind_ == kCipher && IsAuthenticatedMode()) {
    auth_tag_len_ = sizeof(auth_tag_);
    r = EVP_CIPHER_CTX_ctrl(ctx_, EVP_CTRL_GCM_GET_TAG, auth_tag_len_,
                            reinterpret_cast<unsigned char*>(auth_tag_));
    CHECK_EQ(r, 1);
  }

  EVP_CIPHER_CTX_free(ctx_);
  ctx_ = nullptr;

  return r == 1;
}


  CipherBase* cipher;
  ASSIGN_OR_RETURN_UNWRAP(&cipher, args.Holder());
  if (!cipher->ctx_) return env->ThrowError("Unsupported state");

  unsigned char* out_value = nullptr;
  int out_len = -1;

}


Hmac::~Hmac() {
  HMAC_CTX_free(ctx_);
}


void Hmac::Initialize(Environment* env, v8::Local<v8::Object> target) {
  Local<FunctionTemplate> t = env->NewFunctionTemplate(New);


  if (md == nullptr) {
    return env()->ThrowError("Unknown message digest");
  }
  HMAC_CTX_init(&ctx_);
  if (key_len == 0) {
    key = "";
  }
  ctx_ = HMAC_CTX_new();
  if (ctx_ == nullptr ||
      !HMAC_Init_ex(ctx_, key, key_len, md, nullptr)) {
    HMAC_CTX_free(ctx_);
    ctx_ = nullptr;
    return ThrowCryptoError(env(), ERR_get_error());
  }
  initialised_ = true;
}





bool Hmac::HmacUpdate(const char* data, int len) {
  if (!ctx_)
    return false;
  int r = HMAC_Update(ctx_, reinterpret_cast<const unsigned char*>(data), len);
  return r == 1;
}


  unsigned char md_value[EVP_MAX_MD_SIZE];
  unsigned int md_len = 0;

  if (hmac->ctx_) {
    HMAC_Final(hmac->ctx_, md_value, &md_len);
    HMAC_CTX_free(hmac->ctx_);
    hmac->ctx_ = nullptr;
  }

  Local<Value> error;

}


Hash::~Hash() {
  EVP_MD_CTX_free(mdctx_);
}


void Hash::Initialize(Environment* env, v8::Local<v8::Object> target) {
  Local<FunctionTemplate> t = env->NewFunctionTemplate(New);


  const EVP_MD* md = EVP_get_digestbyname(hash_type);
  if (md == nullptr)
    return false;
  mdctx_ = EVP_MD_CTX_new();
  if (mdctx_ == nullptr ||
      EVP_DigestInit_ex(mdctx_, md, nullptr) <= 0) {
    EVP_MD_CTX_free(mdctx_);
    mdctx_ = nullptr;
    return false;
  }
  initialised_ = true;
  finalized_ = false;
  return true;
}


bool Hash::HashUpdate(const char* data, int len) {
  if (!mdctx_)
    return false;
  EVP_DigestUpdate(mdctx_, data, len);
  return true;
}


  unsigned char md_value[EVP_MAX_MD_SIZE];
  unsigned int md_len;

  EVP_DigestFinal_ex(hash->mdctx_, md_value, &md_len);
  EVP_MD_CTX_cleanup(&hash->mdctx_);
  hash->finalized_ = true;

  Local<Value> error;

}


SignBase::~SignBase() {
  EVP_MD_CTX_free(mdctx_);
}


SignBase::Error SignBase::Init(const char* sign_type) {
  CHECK_EQ(mdctx_, nullptr);
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
  // Historically, "dss1" and "DSS1" were DSA aliases for SHA-1
  // exposed through the public API.
  if (strcmp(sign_type, "dss1") == 0 ||
      strcmp(sign_type, "DSS1") == 0) {
    sign_type = "SHA1";
  }
#endif
  const EVP_MD* md = EVP_get_digestbyname(sign_type);
  if (md == nullptr)
    return kSignUnknownDigest;

  mdctx_ = EVP_MD_CTX_new();
  if (mdctx_ == nullptr ||
      !EVP_DigestInit_ex(mdctx_, md, nullptr)) {
    EVP_MD_CTX_free(mdctx_);
    mdctx_ = nullptr;
    return kSignInit;
  }

  return kSignOk;
}


SignBase::Error SignBase::Update(const char* data, int len) {
  if (!mdctx_)
    return kSignNotInitialised;
  if (!EVP_DigestUpdate(mdctx_, data, len))
    return kSignUpdate;
  return kSignOk;
}


void SignBase::CheckThrow(SignBase::Error error) {
  HandleScope scope(env()->isolate());


}


SignBase::Error Sign::SignInit(const char* sign_type) {
  CHECK_EQ(initialised_, false);
  const EVP_MD* md = EVP_get_digestbyname(sign_type);
  if (md == nullptr)
    return kSignUnknownDigest;

  EVP_MD_CTX_init(&mdctx_);
  if (!EVP_DigestInit_ex(&mdctx_, md, nullptr))
    return kSignInit;
  initialised_ = true;

  return kSignOk;
}


void Sign::SignInit(const FunctionCallbackInfo<Value>& args) {
  Sign* sign;
  ASSIGN_OR_RETURN_UNWRAP(&sign, args.Holder());

  THROW_AND_RETURN_IF_NOT_STRING(args[0], "Sign type");

  const node::Utf8Value sign_type(args.GetIsolate(), args[0]);
  sign->CheckThrow(sign->Init(*sign_type));
}


SignBase::Error Sign::SignUpdate(const char* data, int len) {
  if (!initialised_)
    return kSignNotInitialised;
  if (!EVP_DigestUpdate(&mdctx_, data, len))
    return kSignUpdate;
  return kSignOk;
}



    StringBytes::InlineDecoder decoder;
    if (!decoder.Decode(env, args[0].As<String>(), args[1], UTF8))
      return;
    err = sign->Update(decoder.out(), decoder.size());
  } else {
    char* buf = Buffer::Data(args[0]);
    size_t buflen = Buffer::Length(args[0]);
    err = sign->Update(buf, buflen);
  }

  sign->CheckThrow(err);

                                unsigned int* sig_len,
                                int padding,
                                int salt_len) {
  if (!mdctx_)
    return kSignNotInitialised;

  BIO* bp = nullptr;

  }
#endif  // NODE_FIPS_MODE

  if (Node_SignFinal(mdctx_, sig, sig_len, pkey, padding, salt_len))
    fatal = false;

  initialised_ = false;

 exit:
  if (pkey != nullptr)
    EVP_PKEY_free(pkey);
  if (bp != nullptr)
    BIO_free_all(bp);

  EVP_MD_CTX_free(mdctx_);
  mdctx_ = nullptr;

  if (fatal)
    return kSignPrivateKey;

}


SignBase::Error Verify::VerifyInit(const char* verify_type) {
  CHECK_EQ(initialised_, false);
  const EVP_MD* md = EVP_get_digestbyname(verify_type);
  if (md == nullptr)
    return kSignUnknownDigest;

  EVP_MD_CTX_init(&mdctx_);
  if (!EVP_DigestInit_ex(&mdctx_, md, nullptr))
    return kSignInit;
  initialised_ = true;

  return kSignOk;
}


void Verify::VerifyInit(const FunctionCallbackInfo<Value>& args) {
  Verify* verify;
  ASSIGN_OR_RETURN_UNWRAP(&verify, args.Holder());

  THROW_AND_RETURN_IF_NOT_STRING(args[0], "Verify type");

  const node::Utf8Value verify_type(args.GetIsolate(), args[0]);
  verify->CheckThrow(verify->Init(*verify_type));
}


SignBase::Error Verify::VerifyUpdate(const char* data, int len) {
  if (!initialised_)
    return kSignNotInitialised;

  if (!EVP_DigestUpdate(&mdctx_, data, len))
    return kSignUpdate;

  return kSignOk;
}



    StringBytes::InlineDecoder decoder;
    if (!decoder.Decode(env, args[0].As<String>(), args[1], UTF8))
      return;
    err = verify->Update(decoder.out(), decoder.size());
  } else {
    char* buf = Buffer::Data(args[0]);
    size_t buflen = Buffer::Length(args[0]);
    err = verify->Update(buf, buflen);
  }

  verify->CheckThrow(err);

                                    int padding,
                                    int saltlen,
                                    bool* verify_result) {
  if (!mdctx_)
    return kSignNotInitialised;

  EVP_PKEY* pkey = nullptr;

      goto exit;
  }

  if (!EVP_DigestFinal_ex(mdctx_, m, &m_len)) {
    goto exit;
  }


    goto err;
  if (!ApplyRSAOptions(pkey, pkctx, padding, saltlen))
    goto err;
  if (EVP_PKEY_CTX_set_signature_md(pkctx, EVP_MD_CTX_md(mdctx_)) <= 0)
    goto err;
  r = EVP_PKEY_verify(pkctx,
                      reinterpret_cast<const unsigned char*>(sig),

  if (x509 != nullptr)
    X509_free(x509);

  EVP_MD_CTX_free(mdctx_);
  mdctx_ = nullptr;

  if (fatal)
    return kSignPublicKey;


bool DiffieHellman::Init(const char* p, int p_len, int g) {
  dh = DH_new();
  BIGNUM* bn_p =
      BN_bin2bn(reinterpret_cast<const unsigned char*>(p), p_len, nullptr);
  BIGNUM* bn_g = BN_new();
  if (!BN_set_word(bn_g, g) ||
      !DH_set0_pqg(dh, bn_p, nullptr, bn_g)) {
    BN_free(bn_p);
    BN_free(bn_g);
    return false;
  }
  bool result = VerifyContext();
  if (!result)
    return false;


bool DiffieHellman::Init(const char* p, int p_len, const char* g, int g_len) {
  dh = DH_new();
  BIGNUM *bn_p = BN_bin2bn(reinterpret_cast<const unsigned char*>(p), p_len, 0);
  BIGNUM *bn_g = BN_bin2bn(reinterpret_cast<const unsigned char*>(g), g_len, 0);
  if (!DH_set0_pqg(dh, bn_p, nullptr, bn_g)) {
    BN_free(bn_p);
    BN_free(bn_g);
    return false;
  }
  bool result = VerifyContext();
  if (!result)
    return false;

    return ThrowCryptoError(env, ERR_get_error(), "Key generation failed");
  }

  const BIGNUM* pub_key;
  DH_get0_key(diffieHellman->dh, &pub_key, nullptr);
  size_t size = BN_num_bytes(pub_key);
  char* data = Malloc(size);
  BN_bn2bin(pub_key, reinterpret_cast<unsigned char*>(data));
  args.GetReturnValue().Set(Buffer::New(env, data, size).ToLocalChecked());
}


void DiffieHellman::GetField(const FunctionCallbackInfo<Value>& args,
                             const BIGNUM* (*get_field)(const DH*),
                             const char* err_if_null) {
  Environment* env = Environment::GetCurrent(args);

  DiffieHellman* dh;
  ASSIGN_OR_RETURN_UNWRAP(&dh, args.Holder());
  if (!dh->initialised_) return env->ThrowError("Not initialized");

  const BIGNUM* num = get_field(dh->dh);
  if (num == nullptr) return env->ThrowError(err_if_null);

  size_t size = BN_num_bytes(num);

}

void DiffieHellman::GetPrime(const FunctionCallbackInfo<Value>& args) {
  GetField(args, [](const DH* dh) -> const BIGNUM* {
    const BIGNUM* p;
    DH_get0_pqg(dh, &p, nullptr, nullptr);
    return p;
  }, "p is null");
}


void DiffieHellman::GetGenerator(const FunctionCallbackInfo<Value>& args) {
  GetField(args, [](const DH* dh) -> const BIGNUM* {
    const BIGNUM* g;
    DH_get0_pqg(dh, nullptr, nullptr, &g);
    return g;
  }, "g is null");
}


void DiffieHellman::GetPublicKey(const FunctionCallbackInfo<Value>& args) {
  GetField(args, [](const DH* dh) -> const BIGNUM* {
    const BIGNUM* pub_key;
    DH_get0_key(dh, &pub_key, nullptr);
    return pub_key;
  }, "No public key - did you forget to generate one?");
}


void DiffieHellman::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
  GetField(args, [](const DH* dh) -> const BIGNUM* {
    const BIGNUM* priv_key;
    DH_get0_key(dh, nullptr, &priv_key);
    return priv_key;
  }, "No private key - did you forget to generate one?");
}



  args.GetReturnValue().Set(rc);
}


void DiffieHellman::SetKey(const v8::FunctionCallbackInfo<v8::Value>& args,
                           void (*set_field)(DH*, BIGNUM*), const char* what) {
  Environment* env = Environment::GetCurrent(args);

  DiffieHellman* dh;
  ASSIGN_OR_RETURN_UNWRAP(&dh, args.Holder());
  if (!dh->initialised_) return env->ThrowError("Not initialized");

  BIGNUM** num = &((dh->dh)->*field);
  char errmsg[64];

  if (args.Length() == 0) {

    return env->ThrowTypeError(errmsg);
  }

  BIGNUM* num =
      BN_bin2bn(reinterpret_cast<unsigned char*>(Buffer::Data(args[0])),
                Buffer::Length(args[0]), nullptr);
  CHECK_NE(num, nullptr);
  set_field(dh->dh, num);
}


void DiffieHellman::SetPublicKey(const FunctionCallbackInfo<Value>& args) {
  SetKey(args, [](DH* dh, BIGNUM* num) { DH_set0_key(dh, num, nullptr); },
         "Public key");
}


void DiffieHellman::SetPrivateKey(const FunctionCallbackInfo<Value>& args) {
#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
    OPENSSL_VERSION_NUMBER < 0x10100070L
// Older versions of OpenSSL 1.1.0 have a DH_set0_key which does not work for
// Node. See https://github.com/openssl/openssl/pull/4384.
#error "OpenSSL 1.1.0 revisions before 1.1.0g are not supported"
#endif
  SetKey(args, [](DH* dh, BIGNUM* num) { DH_set0_key(dh, nullptr, num); },
         "Private key");
}



void GetSSLCiphers(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);

  SSL_CTX* ctx = SSL_CTX_new(TLS_method());
  if (ctx == nullptr) {
    return env->ThrowError("SSL_CTX_new() failed.");
  }

  SSL_library_init();
  OpenSSL_add_all_algorithms();

#if OPENSSL_VERSION_NUMBER < 0x10100000L
  crypto_lock_init();
  CRYPTO_set_locking_callback(crypto_lock_cb);
  CRYPTO_THREADID_set_callback(crypto_threadid_cb);
#endif

#ifdef NODE_FIPS_MODE
  /* Override FIPS settings in cnf file, if needed. */




namespace node {
namespace crypto {

#if OPENSSL_VERSION_NUMBER < 0x10100000L
#define BIO_set_data(bio, data) bio->ptr = data
#define BIO_get_data(bio) bio->ptr
#define BIO_set_shutdown(bio, shutdown_) bio->shutdown = shutdown_
#define BIO_get_shutdown(bio) bio->shutdown
#define BIO_set_init(bio, init_) bio->init = init_
#define BIO_get_init(bio) bio->init
#endif
  NodeBIO::New,
  NodeBIO::Free,
  nullptr
};


BIO* NodeBIO::New() {
  // The const_cast doesn't violate const correctness.  OpenSSL's usage of
  // BIO_METHOD is effectively const but BIO_new() takes a non-const argument.
  return BIO_new(const_cast<BIO_METHOD*>(GetMethod()));
}





int NodeBIO::New(BIO* bio) {
  BIO_set_data(bio, new NodeBIO());

  // XXX Why am I doing it?!
  BIO_set_shutdown(bio, 1);
  BIO_set_init(bio, 1);
  bio->num = -1;

  return 1;
}

  if (bio == nullptr)
    return 0;

  if (BIO_get_shutdown(bio)) {
    if (BIO_get_init(bio) && BIO_get_data(bio) != nullptr) {
      delete FromBIO(bio);
      BIO_set_data(bio, nullptr);
    }
  }




int NodeBIO::Read(BIO* bio, char* out, int len) {
  int bytes;
  BIO_clear_retry_flags(bio);

  NodeBIO* nbio = FromBIO(bio);
  int bytes = nbio->Read(out, len);

  if (bytes == 0) {
    bytes = nbio->eof_return();
    if (bytes != 0) {
      BIO_set_retry_read(bio);
    }



int NodeBIO::Gets(BIO* bio, char* out, int size) {
  NodeBIO* nbio = FromBIO(bio);

  if (nbio->Length() == 0)
    return 0;

      ret = nbio->Length() == 0;
      break;
    case BIO_C_SET_BUF_MEM_EOF_RETURN:
      nbio->set_eof_return(num);
      break;
    case BIO_CTRL_INFO:
      ret = nbio->Length();

      ret = 0;
      break;
    case BIO_CTRL_GET_CLOSE:
      ret = BIO_get_shutdown(bio);
      break;
    case BIO_CTRL_SET_CLOSE:
      BIO_set_shutdown(bio, num);
      break;
    case BIO_CTRL_WPENDING:
      ret = 0;

}


const BIO_METHOD* NodeBIO::GetMethod() {
#if OPENSSL_VERSION_NUMBER < 0x10100000L
  static const BIO_METHOD method = {
    BIO_TYPE_MEM,
    "node.js SSL buffer",
    Write,
    Read,
    Puts,
    Gets,
    Ctrl,
    New,
    Free,
    nullptr
  };

  return &method;
#else
  static BIO_METHOD* method = nullptr;

  if (method == nullptr) {
    method = BIO_meth_new(BIO_TYPE_MEM, "node.js SSL buffer");
    BIO_meth_set_write(method, Write);
    BIO_meth_set_read(method, Read);
    BIO_meth_set_puts(method, Puts);
    BIO_meth_set_gets(method, Gets);
    BIO_meth_set_ctrl(method, Ctrl);
    BIO_meth_set_create(method, New);
    BIO_meth_set_destroy(method, Free);
  }

  return method;
#endif
}


void NodeBIO::TryMoveReadHead() {
  // `read_pos_` and `write_pos_` means the position of the reader and writer
  // inside the buffer, respectively. When they're equal - its safe to reset

  write_head_ = nullptr;
}


NodeBIO* NodeBIO::FromBIO(BIO* bio) {
  CHECK_NE(BIO_get_data(bio), nullptr);
  return static_cast<NodeBIO*>(BIO_get_data(bio));
}


}  // namespace crypto
}  // namespace node




  NodeBIO() : env_(nullptr),
              initial_(kInitialBufferLength),
              length_(0),
              eof_return_(-1),
              read_head_(nullptr),
              write_head_(nullptr) {
  }

    return length_;
  }

  inline void set_eof_return(int num) {
    eof_return_ = num;
  }

  inline int eof_return() {
    return eof_return_;
  }

  inline void set_initial(size_t initial) {
    initial_ = initial;
  }

  static NodeBIO* FromBIO(BIO* bio);
    CHECK_NE(bio->ptr, nullptr);
    return static_cast<NodeBIO*>(bio->ptr);
  }

 private:
  static int New(BIO* bio);

  static long Ctrl(BIO* bio, int cmd, long num,  // NOLINT(runtime/int)
                   void* ptr);

  static const BIO_METHOD* GetMethod();

  // Enough to handle the most of the client hellos
  static const size_t kInitialBufferLength = 1024;
  static const size_t kThroughputBufferLength = 16384;

  static const BIO_METHOD method;

  class Buffer {
   public:
    Buffer(Environment* env, size_t len) : env_(env),

  Environment* env_;
  size_t initial_;
  size_t length_;
  int eof_return_;
  Buffer* read_head_;
  Buffer* write_head_;
};

Lines 53-60 Link Here

(-)node-v8.8.1-orig/src/node_crypto.h (-38 / +53 lines)
53	#include <openssl/rand.h>	53	#include <openssl/rand.h>
54	#include <openssl/pkcs12.h>	54	#include <openssl/pkcs12.h>
55		55
56	#define EVP_F_EVP_DECRYPTFINAL 101
57
58	#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_set_tlsext_status_cb)	56	#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_set_tlsext_status_cb)
59	# define NODE__HAVE_TLSEXT_STATUS_CB	57	# define NODE__HAVE_TLSEXT_STATUS_CB
60	#endif // !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_set_tlsext_status_cb)	58	#endif // !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_set_tlsext_status_cb)
Lines 107-114 Link Here
107	static const int kTicketKeyNameIndex = 3;	105	static const int kTicketKeyNameIndex = 3;
108	static const int kTicketKeyIVIndex = 4;	106	static const int kTicketKeyIVIndex = 4;
109		107
		108	#if OPENSSL_VERSION_NUMBER >= 0x10100000L
		109	unsigned char ticket_key_name_[16];
		110	unsigned char ticket_key_aes_[16];
		111	unsigned char ticket_key_hmac_[16];
		112	#endif
		113
110	protected:	114	protected:
		115	#if OPENSSL_VERSION_NUMBER < 0x10100000L
111	static const int64_t kExternalSize = sizeof(SSL_CTX);	116	static const int64_t kExternalSize = sizeof(SSL_CTX);
		117	#else
		118	// OpenSSL 1.1.0 has opaque structures. This is an estimate based on the size
		119	// as of OpenSSL 1.1.0f.
		120	static const int64_t kExternalSize = 872;
		121	#endif
112		122
113	static void New(const v8::FunctionCallbackInfo<v8::Value>& args);	123	static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
114	static void Init(const v8::FunctionCallbackInfo<v8::Value>& args);	124	static void Init(const v8::FunctionCallbackInfo<v8::Value>& args);
Lines 146-151 Link Here
146	HMAC_CTX* hctx,	156	HMAC_CTX* hctx,
147	int enc);	157	int enc);
148		158
		159	#if OPENSSL_VERSION_NUMBER >= 0x10100000L
		160	static int TicketCompatibilityCallback(SSL* ssl,
		161	unsigned char* name,
		162	unsigned char* iv,
		163	EVP_CIPHER_CTX* ectx,
		164	HMAC_CTX* hctx,
		165	int enc);
		166	#endif
		167
149	SecureContext(Environment* env, v8::Local<v8::Object> wrap)	168	SecureContext(Environment* env, v8::Local<v8::Object> wrap)
150	: BaseObject(env, wrap),	169	: BaseObject(env, wrap),
151	ctx_(nullptr),	170	ctx_(nullptr),
Lines 222-240 Link Here
222	protected:	241	protected:
223	typedef void (CertCb)(void arg);	242	typedef void (CertCb)(void arg);
224		243
		244	#if OPENSSL_VERSION_NUMBER < 0x10100000L
225	// Size allocated by OpenSSL: one for SSL structure, one for SSL3_STATE and	245	// Size allocated by OpenSSL: one for SSL structure, one for SSL3_STATE and
226	// some for buffers.	246	// some for buffers.
227	// NOTE: Actually it is much more than this	247	// NOTE: Actually it is much more than this
228	static const int64_t kExternalSize =	248	static const int64_t kExternalSize =
229	sizeof(SSL) + sizeof(SSL3_STATE) + 42 * 1024;	249	sizeof(SSL) + sizeof(SSL3_STATE) + 42 * 1024;
		250	#else
		251	// OpenSSL 1.1.0 has opaque structures. This is an estimate based on the size
		252	// as of OpenSSL 1.1.0f.
		253	static const int64_t kExternalSize = 4448 + 1024 + 42 * 1024;
		254	#endif
230		255
231	static void InitNPN(SecureContext* sc);	256	static void InitNPN(SecureContext* sc);
232	static void AddMethods(Environment* env, v8::Local<v8::FunctionTemplate> t);	257	static void AddMethods(Environment* env, v8::Local<v8::FunctionTemplate> t);
233		258
		259	#if OPENSSL_VERSION_NUMBER < 0x10100000L
234	static SSL_SESSION* GetSessionCallback(SSL* s,	260	static SSL_SESSION* GetSessionCallback(SSL* s,
235	unsigned char* key,	261	unsigned char* key,
236	int len,	262	int len,
237	int* copy);	263	int* copy);
		264	#else
		265	static SSL_SESSION* GetSessionCallback(SSL* s,
		266	const unsigned char* key,
		267	int len,
		268	int* copy);
		269	#endif
238	static int NewSessionCallback(SSL* s, SSL_SESSION* sess);	270	static int NewSessionCallback(SSL* s, SSL_SESSION* sess);
239	static void OnClientHello(void* arg,	271	static void OnClientHello(void* arg,
240	const ClientHelloParser::ClientHello& hello);	272	const ClientHelloParser::ClientHello& hello);
Lines 425-433 Link Here
425	class CipherBase : public BaseObject {	457	class CipherBase : public BaseObject {
426	public:	458	public:
427	~CipherBase() override {	459	~CipherBase() override {
428	if (!initialised_)	460	EVP_CIPHER_CTX_free(ctx_);
429	return;
430	EVP_CIPHER_CTX_cleanup(&ctx_);
431	}	461	}
432		462
433	static void Initialize(Environment* env, v8::Local<v8::Object> target);	463	static void Initialize(Environment* env, v8::Local<v8::Object> target);
Lines 466-480 Link Here
466	v8::Local<v8::Object> wrap,	496	v8::Local<v8::Object> wrap,
467	CipherKind kind)	497	CipherKind kind)
468	: BaseObject(env, wrap),	498	: BaseObject(env, wrap),
469	initialised_(false),	499	ctx_(nullptr),
470	kind_(kind),	500	kind_(kind),
471	auth_tag_len_(0) {	501	auth_tag_len_(0) {
472	MakeWeak<CipherBase>(this);	502	MakeWeak<CipherBase>(this);
473	}	503	}
474		504
475	private:	505	private:
476	EVP_CIPHER_CTX ctx_; /* coverity[member_decl] */	506	EVP_CIPHER_CTX* ctx_;
477	bool initialised_;
478	const CipherKind kind_;	507	const CipherKind kind_;
479	unsigned int auth_tag_len_;	508	unsigned int auth_tag_len_;
480	char auth_tag_[EVP_GCM_TLS_TAG_LEN];	509	char auth_tag_[EVP_GCM_TLS_TAG_LEN];
Lines 482-492 Link Here
482		511
483	class Hmac : public BaseObject {	512	class Hmac : public BaseObject {
484	public:	513	public:
485	~Hmac() override {	514	~Hmac() override;
486	if (!initialised_)
487	return;
488	HMAC_CTX_cleanup(&ctx_);
489	}
490		515
491	static void Initialize(Environment* env, v8::Local<v8::Object> target);	516	static void Initialize(Environment* env, v8::Local<v8::Object> target);
492		517
Lines 501-522 Link Here
501		526
502	Hmac(Environment* env, v8::Local<v8::Object> wrap)	527	Hmac(Environment* env, v8::Local<v8::Object> wrap)
503	: BaseObject(env, wrap),	528	: BaseObject(env, wrap),
504	initialised_(false) {	529	ctx_(nullptr) {
505	MakeWeak<Hmac>(this);	530	MakeWeak<Hmac>(this);
506	}	531	}
507		532
508	private:	533	private:
509	HMAC_CTX ctx_; /* coverity[member_decl] */	534	HMAC_CTX* ctx_;
510	bool initialised_;
511	};	535	};
512		536
513	class Hash : public BaseObject {	537	class Hash : public BaseObject {
514	public:	538	public:
515	~Hash() override {	539	~Hash() override;
516	if (!initialised_)
517	return;
518	EVP_MD_CTX_cleanup(&mdctx_);
519	}
520		540
521	static void Initialize(Environment* env, v8::Local<v8::Object> target);	541	static void Initialize(Environment* env, v8::Local<v8::Object> target);
522		542
Lines 530-542 Link Here
530		550
531	Hash(Environment* env, v8::Local<v8::Object> wrap)	551	Hash(Environment* env, v8::Local<v8::Object> wrap)
532	: BaseObject(env, wrap),	552	: BaseObject(env, wrap),
533	initialised_(false) {	553	mdctx_(nullptr),
		554	finalized_(false) {
534	MakeWeak<Hash>(this);	555	MakeWeak<Hash>(this);
535	}	556	}
536		557
537	private:	558	private:
538	EVP_MD_CTX mdctx_; /* coverity[member_decl] */	559	EVP_MD_CTX* mdctx_;
539	bool initialised_;
540	bool finalized_;	560	bool finalized_;
541	};	561	};
542		562
Lines 554-581 Link Here
554		574
555	SignBase(Environment* env, v8::Local<v8::Object> wrap)	575	SignBase(Environment* env, v8::Local<v8::Object> wrap)
556	: BaseObject(env, wrap),	576	: BaseObject(env, wrap),
557	initialised_(false) {	577	mdctx_(nullptr) {
558	}	578	}
559		579
560	~SignBase() override {	580	~SignBase() override;
561	if (!initialised_)	581
562	return;	582	Error Init(const char* sign_type);
563	EVP_MD_CTX_cleanup(&mdctx_);	583	Error Update(const char* data, int len);
564	}
565		584
566	protected:	585	protected:
567	void CheckThrow(Error error);	586	void CheckThrow(Error error);
568		587
569	EVP_MD_CTX mdctx_; /* coverity[member_decl] */	588	EVP_MD_CTX* mdctx_;
570	bool initialised_;
571	};	589	};
572		590
573	class Sign : public SignBase {	591	class Sign : public SignBase {
574	public:	592	public:
575	static void Initialize(Environment* env, v8::Local<v8::Object> target);	593	static void Initialize(Environment* env, v8::Local<v8::Object> target);
576		594
577	Error SignInit(const char* sign_type);
578	Error SignUpdate(const char* data, int len);
579	Error SignFinal(const char* key_pem,	595	Error SignFinal(const char* key_pem,
580	int key_pem_len,	596	int key_pem_len,
581	const char* passphrase,	597	const char* passphrase,
Lines 599-606 Link Here
599	public:	615	public:
600	static void Initialize(Environment* env, v8::Local<v8::Object> target);	616	static void Initialize(Environment* env, v8::Local<v8::Object> target);
601		617
602	Error VerifyInit(const char* verify_type);
603	Error VerifyUpdate(const char* data, int len);
604	Error VerifyFinal(const char* key_pem,	618	Error VerifyFinal(const char* key_pem,
605	int key_pem_len,	619	int key_pem_len,
606	const char* sig,	620	const char* sig,
Lines 690-698 Link Here
690		704
691	private:	705	private:
692	static void GetField(const v8::FunctionCallbackInfo<v8::Value>& args,	706	static void GetField(const v8::FunctionCallbackInfo<v8::Value>& args,
693	BIGNUM* (DH::field), const char err_if_null);	707	const BIGNUM* (get_field)(const DH),
		708	const char* err_if_null);
694	static void SetKey(const v8::FunctionCallbackInfo<v8::Value>& args,	709	static void SetKey(const v8::FunctionCallbackInfo<v8::Value>& args,
695	BIGNUM* (DH::field), const char what);	710	void (set_field)(DH, BIGNUM), const char what);
696	bool VerifyContext();	711	bool VerifyContext();
697		712
698	bool initialised_;	713	bool initialised_;





assert.strictEqual(secret1, secret3);

// computeSecret works without a public key set at all.
const dh4 = crypto.createDiffieHellman(p1, 'buffer');
dh4.setPrivateKey(privkey1);

assert.deepStrictEqual(dh1.getPrime(), dh4.getPrime());
assert.deepStrictEqual(dh1.getGenerator(), dh4.getGenerator());
assert.deepStrictEqual(dh1.getPrivateKey(), dh4.getPrivateKey());
assert.strictEqual(dh4.verifyError, 0);

const secret4 = dh4.computeSecret(key2, 'hex', 'base64');

assert.strictEqual(secret1, secret4);

const wrongBlockLength =
  /^Error: error:0606506D:digital envelope routines:EVP_DecryptFinal_ex:wrong final block length$/;





added: v0.11.4
-->

Returns an object representing the cipher name. The `version` key is a legacy
field which always contains the value `'TLSv1/SSLv3'`.

For example: `{ name: 'AES256-SHA', version: 'TLSv1/SSLv3' }`

See `SSL_CIPHER_get_name()` in
https://www.openssl.org/docs/man1.0.2/ssl/SSL_CIPHER_get_name.html for more
information.





assert(tlsCiphers.every((value) => noCapitals.test(value)));
validateList(tlsCiphers);

// Assert that we have sha1 and sha256 but not SHA1 and SHA256.
assert.notStrictEqual(0, crypto.getHashes().length);
assert(crypto.getHashes().includes('sha1'));
assert(crypto.getHashes().includes('sha256'));
assert(!crypto.getHashes().includes('SHA1'));
assert(!crypto.getHashes().includes('SHA156'));
assert(crypto.getHashes().includes('RSA-SHA1'));
assert(!crypto.getHashes().includes('rsa-sha1'));
validateList(crypto.getHashes());

  // Throws crypto error, so there is an opensslErrorStack property.
  // The openSSL stack should have content.
  if ((err instanceof Error) &&
      /asn1 encoding routines:[^:]*:wrong tag/.test(err) &&
      err.opensslErrorStack !== undefined &&
      Array.isArray(err.opensslErrorStack) &&
      err.opensslErrorStack.length > 0) {

Lines 21-27 Link Here

(-)node-v8.8.1-orig/test/parallel/test-tls-junk-server.js (-1 / +3 lines)
21	req.end();	21	req.end();
22		22
23	req.once('error', common.mustCall(function(err) {	23	req.once('error', common.mustCall(function(err) {
24	assert(/unknown protocol/.test(err.message));	24	// OpenSSL 1.0.x and 1.1.x use different error messages for junk inputs.
		25	assert(/unknown protocol/.test(err.message) \|\|
		26	/wrong version number/.test(err.message));
25	server.close();	27	server.close();
26	}));	28	}));
27	});	29	});

Lines 46-51 Link Here

(-)node-v8.8.1-orig/test/parallel/test-tls-no-sslv3.js (-1 / +3 lines)
46	common.printSkipMessage('`openssl s_client -ssl3` not supported.');	46	common.printSkipMessage('`openssl s_client -ssl3` not supported.');
47	} else {	47	} else {
48	assert.strictEqual(errors.length, 1);	48	assert.strictEqual(errors.length, 1);
49	assert(/:wrong version number/.test(errors[0].message));	49	// OpenSSL 1.0.x and 1.1.x report invalid client versions differently.
		50	assert(/:wrong version number/.test(errors[0].message) \|\|
		51	/:version too low/.test(errors[0].message));
50	}	52	}
51	});	53	});

Lines 20-27 Link Here

(-)node-v8.8.1-orig/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js (-1 / +3 lines)
20	}).on('tlsClientError', common.mustCall(function(e) {	20	}).on('tlsClientError', common.mustCall(function(e) {
21	assert.ok(e instanceof Error,	21	assert.ok(e instanceof Error,
22	'Instance of Error should be passed to error handler');	22	'Instance of Error should be passed to error handler');
		23	// OpenSSL 1.0.x and 1.1.x use different error codes for junk inputs.
23	assert.ok(	24	assert.ok(
24	/SSL routines:SSL23_GET_CLIENT_HELLO:unknown protocol/.test(e.message),	25	/SSL routines:[^:]*:(unknown protocol\|wrong version number)/.test(
		26	e.message),
25	'Expecting SSL unknown protocol');	27	'Expecting SSL unknown protocol');
26		28
27	server.close();	29	server.close();

Lines 20-27 Link Here

(-)node-v8.8.1-orig/test/parallel/test-tls-socket-failed-handshake-emits-error.js (-1 / +3 lines)
20	s.on('error', common.mustCall(function(e) {	20	s.on('error', common.mustCall(function(e) {
21	assert.ok(e instanceof Error,	21	assert.ok(e instanceof Error,
22	'Instance of Error should be passed to error handler');	22	'Instance of Error should be passed to error handler');
		23	// OpenSSL 1.0.x and 1.1.x use different error codes for junk inputs.
23	assert.ok(	24	assert.ok(
24	/SSL routines:SSL23_GET_CLIENT_HELLO:unknown protocol/.test(e.message),	25	/SSL routines:[^:]*:(unknown protocol\|wrong version number)/.test(
		26	e.message),
25	'Expecting SSL unknown protocol');	27	'Expecting SSL unknown protocol');
26	}));	28	}));
27		29





const tls = require('tls');


const cert =
`-----BEGIN CERTIFICATE-----
MIIDNDCCAp2gAwIBAgIJAJvXLQpGPpm7MA0GCSqGSIb3DQEBBQUAMHAxCzAJBgNV
BAYTAkdCMRAwDgYDVQQIEwdHd3luZWRkMREwDwYDVQQHEwhXYXVuZmF3cjEUMBIG
A1UEChMLQWNrbmFjayBMdGQxEjAQBgNVBAsTCVRlc3QgQ2VydDESMBAGA1UEAxMJ
bG9jYWxob3N0MB4XDTA5MTEwMjE5MzMwNVoXDTEwMTEwMjE5MzMwNVowcDELMAkG
A1UEBhMCR0IxEDAOBgNVBAgTB0d3eW5lZGQxETAPBgNVBAcTCFdhdW5mYXdyMRQw
EgYDVQQKEwtBY2tuYWNrIEx0ZDESMBAGA1UECxMJVGVzdCBDZXJ0MRIwEAYDVQQD
Ewlsb2NhbGhvc3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANdym7nGe2yw
6LlJfJrQtC5TmKOGrSXiyolYCbGOy4xZI4KD31d3097jhlQFJyF+10gwkE62DuJe
fLvBZDUsvLe1R8bzlVhZnBVn+3QJyUIWQAL+DsRj8P3KoD7k363QN5dIaA1GOAg2
vZcPy1HCUsvOgvDXGRUCZqNLAyt+h/cpAgMBAAGjgdUwgdIwHQYDVR0OBBYEFK4s
VBV4shKUj3UX/fvSJnFaaPBjMIGiBgNVHSMEgZowgZeAFK4sVBV4shKUj3UX/fvS
JnFaaPBjoXSkcjBwMQswCQYDVQQGEwJHQjEQMA4GA1UECBMHR3d5bmVkZDERMA8G
A1UEBxMIV2F1bmZhd3IxFDASBgNVBAoTC0Fja25hY2sgTHRkMRIwEAYDVQQLEwlU
ZXN0IENlcnQxEjAQBgNVBAMTCWxvY2FsaG9zdIIJAJvXLQpGPpm7MAwGA1UdEwQF
MAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAFxR7BA1mUlsYqPiogtxSIfLzHWh+s0bJ
SBuhNrHes4U8QxS8+x/KWjd/81gzsf9J1C2VzTlFaydAgigz3SkQYgs+TMnFkT2o
9jqoJrcdf4WpZ2DQXUALaZgwNzPumMUSx8Ac5gO+BY/RHyP6fCodYvdNwyKslnI3
US7eCSHZsVo=
-----END CERTIFICATE-----`;

const key =
`-----BEGIN RSA PRIVATE KEY-----
MIICXgIBAAKBgQDXcpu5xntssOi5SXya0LQuU5ijhq0l4sqJWAmxjsuMWSOCg99X
d9Pe44ZUBSchftdIMJBOtg7iXny7wWQ1LLy3tUfG85VYWZwVZ/t0CclCFkAC/g7E
Y/D9yqA+5N+t0DeXSGgNRjgINr2XD8tRwlLLzoLw1xkVAmajSwMrfof3KQIDAQAB
AoGBAIBHR/tT93ce2mJAJAXV0AJpWc+7x2pwX2FpXtQujnlxNZhnRlrBCRCD7h4m
t0bVS/86kyGaesBDvAbavfx/N5keYzzmmSp5Ht8IPqKPydGWdigk4x90yWvktai7
dWuRKF94FXr0GUuBONb/dfHdp4KBtzN7oIF9WydYGGXA9ZmBAkEA8/k01bfwQZIu
AgcdNEM94Zcug1gSspXtUu8exNQX4+PNVbadghZb1+OnUO4d3gvWfqvAnaXD3KV6
N4OtUhQQ0QJBAOIRbKMfaymQ9yE3CQQxYfKmEhHXWARXVwuYqIFqjmhSjSXx0l/P
7mSHz1I9uDvxkJev8sQgu1TKIyTOdqPH1tkCQQDPa6H1yYoj1Un0Q2Qa2Mg1kTjk
Re6vkjPQ/KcmJEOjZjtekgFbZfLzmwLXFXqjG2FjFFaQMSxR3QYJSJQEYjbhAkEA
sy7OZcjcXnjZeEkv61Pc57/7qIp/6Aj2JGnefZ1gvI1Z9Q5kCa88rA/9Iplq8pA4
ZBKAoDW1ZbJGAsFmxc/6mQJAdPilhci0qFN86IGmf+ZBnwsDflIwHKDaVofti4wQ
sPWhSOb9VQjMXekI4Y2l8fqAVTS2Fn6+8jkVKxXBywSVCw==
-----END RSA PRIVATE KEY-----`;

function test(cert, key, cb) {




  common.skip('missing crypto');

const assert = require('assert');
const fixtures = require('../common/fixtures');
const net = require('net');
const tls = require('tls');

const cacert =
`-----BEGIN CERTIFICATE-----
MIIBxTCCAX8CAnXnMA0GCSqGSIb3DQEBBQUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
VQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEZMBcGA1UEChMQU3Ryb25n
TG9vcCwgSW5jLjESMBAGA1UECxMJU3Ryb25nT3BzMRowGAYDVQQDExFjYS5zdHJv
bmdsb29wLmNvbTAeFw0xNDAxMTcyMjE1MDdaFw00MTA2MDMyMjE1MDdaMH0xCzAJ
BgNVBAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEZ
MBcGA1UEChMQU3Ryb25nTG9vcCwgSW5jLjESMBAGA1UECxMJU3Ryb25nT3BzMRow
GAYDVQQDExFjYS5zdHJvbmdsb29wLmNvbTBMMA0GCSqGSIb3DQEBAQUAAzsAMDgC
MQDKbQ6rIR5t1q1v4Ha36jrq0IkyUohy9EYNvLnXUly1PGqxby0ILlAVJ8JawpY9
AVkCAwEAATANBgkqhkiG9w0BAQUFAAMxALA1uS4CqQXRSAyYTfio5oyLGz71a+NM
+0AFLBwh5AQjhGd0FcenU4OfHxyDEOJT/Q==
-----END CERTIFICATE-----`;

const cert =
`-----BEGIN CERTIFICATE-----
MIIBfDCCATYCAgQaMA0GCSqGSIb3DQEBBQUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
VQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEZMBcGA1UEChMQU3Ryb25n
TG9vcCwgSW5jLjESMBAGA1UECxMJU3Ryb25nT3BzMRowGAYDVQQDExFjYS5zdHJv
bmdsb29wLmNvbTAeFw0xNDAxMTcyMjE1MDdaFw00MTA2MDMyMjE1MDdaMBkxFzAV
BgNVBAMTDnN0cm9uZ2xvb3AuY29tMEwwDQYJKoZIhvcNAQEBBQADOwAwOAIxAMfk
I0LWU15pPUwIQNMnRVhhOibi0TQmAau8FBtgwEfGK01WpfGUaJr1a41K8Uq7xwID
AQABoxkwFzAVBgNVHREEDjAMhwQAAAAAhwR/AAABMA0GCSqGSIb3DQEBBQUAAzEA
cGpYrhkrb7mIh9DNhV0qp7pGjqBzlHqB7KQXw2luLDp//6dyHBMexDCQznkhZKRU
-----END CERTIFICATE-----`;

const key =
`-----BEGIN RSA PRIVATE KEY-----
MIH0AgEAAjEAx+QjQtZTXmk9TAhA0ydFWGE6JuLRNCYBq7wUG2DAR8YrTVal8ZRo
mvVrjUrxSrvHAgMBAAECMBCGccvSwC2r8Z9Zh1JtirQVxaL1WWpAQfmVwLe0bAgg
/JWMU/6hS36TsYyZMxwswQIZAPTAfht/zDLb7Hwgu2twsS1Ra9w/yyvtlwIZANET
26votwJAHK1yUrZGA5nnp5qcmQ/JUQIZAII5YV/UUZvF9D/fUplJ7puENPWNY9bN
pQIZAMMwxuS3XiO7two2sQF6W+JTYyX1DPCwAQIZAOYg1TvEGT38k8e8jygv8E8w
YqrWTeQFNQ==
-----END RSA PRIVATE KEY-----`;

const ca = [ cert, cacert ];

let clientError = null;
let connectError = null;

const server = tls.createServer({
  cert: fixtures.readKey('agent1-cert.pem'),
  key: fixtures.readKey('agent1-key.pem'),
}, common.mustNotCall()).on('tlsClientError', function(err, conn) {
  assert(!clientError && conn);
  clientError = err;
  server.close();
}).listen(0, function() {
  net.connect(this.address().port, function() {
    // Destroy the socket once it is connected, so the server sees ECONNRESET.
    port: this.address().port,
    ca: ca
  };
  tls.connect(options).on('error', function(err) {
    assert(!connectError);

    connectError = err;
    this.destroy();
  }).on('error', common.mustNotCall());
  }).write('123');
});

process.on('exit', function() {
  assert(clientError);
  assert(connectError);
  assert(/socket hang up/.test(clientError.message));
  assert(/ECONNRESET/.test(clientError.code));
});




  common.skip('no IPv6 support');

const assert = require('assert');
const fixtures = require('../common/fixtures');
const https = require('https');
const dns = require('dns');

function runTest() {
  https.createServer({
    cert: fixtures.readKey('agent1-cert.pem'),
    key: fixtures.readKey('agent1-key.pem'),
  }, common.mustCall(function(req, res) {
    this.close();
    res.end();
  })).listen(0, '::1', common.mustCall(function() {

      host: 'localhost',
      port: this.address().port,
      family: 6,
      ciphers: ciphers,
      rejectUnauthorized: false,
    };
    // Will fail with ECONNREFUSED if the address family is not honored.




  common.skip('no IPv6 support');

const assert = require('assert');
const fixtures = require('../common/fixtures');
const tls = require('tls');
const dns = require('dns');

function runTest() {
  tls.createServer({
    cert: fixtures.readKey('agent1-cert.pem'),
    key: fixtures.readKey('agent1-key.pem'),
  }, common.mustCall(function() {
    this.close();
  })).listen(0, '::1', common.mustCall(function() {
    const options = {
      host: 'localhost',
      port: this.address().port,
      family: 6,
      ciphers: ciphers,
      rejectUnauthorized: false,
    };
    // Will fail with ECONNREFUSED if the address family is not honored.

Lines 755-760 Link Here

(-)node-v8.8.1-orig/src/node_constants.cc (+4 lines)
755	}	755	}
756		756
757	void DefineOpenSSLConstants(Local<Object> target) {	757	void DefineOpenSSLConstants(Local<Object> target) {
		758	#ifdef OPENSSL_VERSION_NUMBER
		759	NODE_DEFINE_CONSTANT(target, OPENSSL_VERSION_NUMBER);
		760	#endif
		761
758	#ifdef SSL_OP_ALL	762	#ifdef SSL_OP_ALL
759	NODE_DEFINE_CONSTANT(target, SSL_OP_ALL);	763	NODE_DEFINE_CONSTANT(target, SSL_OP_ALL);
760	#endif	764	#endif





const assert = require('assert');
const https = require('https');
const { OPENSSL_VERSION_NUMBER, SSL_OP_NO_TICKET } =
    require('crypto').constants;

const options = {
  key: readKey('agent1-key.pem'),

    res.resume();
  });

  if (OPENSSL_VERSION_NUMBER >= 0x10100000) {
    // Although we have a TLS 1.2 session to offer to the TLS 1.0 server,
    // connection to the TLS 1.0 server should work.
    req.on('response', common.mustCall(function(res) {
      // The test is now complete for OpenSSL 1.1.0.
      server.close();
    }));
  } else {
    // OpenSSL 1.0.x mistakenly locked versions based on the session it was
    // offering. This causes this sequent request to fail. Let it fail, but
    // test that this is mitigated on the next try by invalidating the session.
    req.on('error', common.mustCall(function(err) {
      assert(/wrong version number/.test(err.message));

      req.on('close', function() {
        third(server);
      });
    }));
  }
  req.end();
}





// Tests http2.connect()

const common = require('../common');
const Countdown = require('../common/countdown');
if (!common.hasCrypto)
  common.skip('missing crypto');
const fixtures = require('../common/fixtures');

      [{ port: port, hostname: '127.0.0.1' }, { protocol: 'http:' }]
    ];

    const serverClose = new Countdown(items.length + 1,
                                      () => setImmediate(() => server.close()));

    const maybeClose = common.mustCall((client) => {
      client.destroy();
      serverClose.dec();
        setImmediate(() => server.close());
      }
    }, items.length);

    items.forEach((i) => {


    // Will fail because protocol does not match the server.
    h2.connect({ port: port, protocol: 'https:' })
      .on('socketError', common.mustCall(() => serverClose.dec()));
  }));
}


      [{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts]
    ];

    const serverClose = new Countdown(items.length,
                                      () => setImmediate(() => server.close()));

    const maybeClose = common.mustCall((client) => {
      client.destroy();
      serverClose.dec();
        setImmediate(() => server.close());
      }
    }, items.length);

    items.forEach((i) => {

Lines 27-32 Link Here

(-)node-v8.8.1-orig/test/parallel/test-tls-ecdh-disable.js (+5 lines)
27	if (!common.opensslCli)	27	if (!common.opensslCli)
28	common.skip('missing openssl-cli');	28	common.skip('missing openssl-cli');
29		29
		30	const OPENSSL_VERSION_NUMBER =
		31	require('crypto').constants.OPENSSL_VERSION_NUMBER;
		32	if (OPENSSL_VERSION_NUMBER >= 0x10100000)
		33	common.skip('false ecdhCurve not supported in OpenSSL 1.1.0')
		34
30	const assert = require('assert');	35	const assert = require('assert');
31	const tls = require('tls');	36	const tls = require('tls');
32	const exec = require('child_process').exec;	37	const exec = require('child_process').exec;

Return to bug 604978

Lines 29-52 Link Here

(-)node-v8.8.1-orig/src/node_crypto_bio.cc (-27 / +64 lines)
29	namespace node {	29	namespace node {
30	namespace crypto {	30	namespace crypto {
31		31
32	const BIO_METHOD NodeBIO::method = {	32	#if OPENSSL_VERSION_NUMBER < 0x10100000L
33	BIO_TYPE_MEM,	33	#define BIO_set_data(bio, data) bio->ptr = data
34	"node.js SSL buffer",	34	#define BIO_get_data(bio) bio->ptr
35	NodeBIO::Write,	35	#define BIO_set_shutdown(bio, shutdown_) bio->shutdown = shutdown_
36	NodeBIO::Read,	36	#define BIO_get_shutdown(bio) bio->shutdown
37	NodeBIO::Puts,	37	#define BIO_set_init(bio, init_) bio->init = init_
38	NodeBIO::Gets,	38	#define BIO_get_init(bio) bio->init
39	NodeBIO::Ctrl,	39	#endif
40	NodeBIO::New,
41	NodeBIO::Free,
42	nullptr
43	};
44		40
45		41
46	BIO* NodeBIO::New() {	42	BIO* NodeBIO::New() {
47	// The const_cast doesn't violate const correctness. OpenSSL's usage of	43	// The const_cast doesn't violate const correctness. OpenSSL's usage of
48	// BIO_METHOD is effectively const but BIO_new() takes a non-const argument.	44	// BIO_METHOD is effectively const but BIO_new() takes a non-const argument.
49	return BIO_new(const_cast<BIO_METHOD*>(&method));	45	return BIO_new(const_cast<BIO_METHOD*>(GetMethod()));
50	}	46	}
51		47
52		48
Lines 71-82 Link Here
71		67
72		68
73	int NodeBIO::New(BIO* bio) {	69	int NodeBIO::New(BIO* bio) {
74	bio->ptr = new NodeBIO();	70	BIO_set_data(bio, new NodeBIO());
75		71
76	// XXX Why am I doing it?!	72	// XXX Why am I doing it?!
77	bio->shutdown = 1;	73	BIO_set_shutdown(bio, 1);
78	bio->init = 1;	74	BIO_set_init(bio, 1);
79	bio->num = -1;
80		75
81	return 1;	76	return 1;
82	}	77	}
Lines 86-95 Link Here
86	if (bio == nullptr)	81	if (bio == nullptr)
87	return 0;	82	return 0;
88		83
89	if (bio->shutdown) {	84	if (BIO_get_shutdown(bio)) {
90	if (bio->init && bio->ptr != nullptr) {	85	if (BIO_get_init(bio) && BIO_get_data(bio) != nullptr) {
91	delete FromBIO(bio);	86	delete FromBIO(bio);
92	bio->ptr = nullptr;	87	BIO_set_data(bio, nullptr);
93	}	88	}
94	}	89	}
95		90
Lines 98-110 Link Here
98		93
99		94
100	int NodeBIO::Read(BIO* bio, char* out, int len) {	95	int NodeBIO::Read(BIO* bio, char* out, int len) {
101	int bytes;
102	BIO_clear_retry_flags(bio);	96	BIO_clear_retry_flags(bio);
103		97
104	bytes = FromBIO(bio)->Read(out, len);	98	NodeBIO* nbio = FromBIO(bio);
		99	int bytes = nbio->Read(out, len);
105		100
106	if (bytes == 0) {	101	if (bytes == 0) {
107	bytes = bio->num;	102	bytes = nbio->eof_return();
108	if (bytes != 0) {	103	if (bytes != 0) {
109	BIO_set_retry_read(bio);	104	BIO_set_retry_read(bio);
110	}	105	}
Lines 162-168 Link Here
162		157
163		158
164	int NodeBIO::Gets(BIO* bio, char* out, int size) {	159	int NodeBIO::Gets(BIO* bio, char* out, int size) {
165	NodeBIO* nbio = FromBIO(bio);	160	NodeBIO* nbio = FromBIO(bio);
166		161
167	if (nbio->Length() == 0)	162	if (nbio->Length() == 0)
168	return 0;	163	return 0;
Lines 202-208 Link Here
202	ret = nbio->Length() == 0;	197	ret = nbio->Length() == 0;
203	break;	198	break;
204	case BIO_C_SET_BUF_MEM_EOF_RETURN:	199	case BIO_C_SET_BUF_MEM_EOF_RETURN:
205	bio->num = num;	200	nbio->set_eof_return(num);
206	break;	201	break;
207	case BIO_CTRL_INFO:	202	case BIO_CTRL_INFO:
208	ret = nbio->Length();	203	ret = nbio->Length();
Lines 217-226 Link Here
217	ret = 0;	212	ret = 0;
218	break;	213	break;
219	case BIO_CTRL_GET_CLOSE:	214	case BIO_CTRL_GET_CLOSE:
220	ret = bio->shutdown;	215	ret = BIO_get_shutdown(bio);
221	break;	216	break;
222	case BIO_CTRL_SET_CLOSE:	217	case BIO_CTRL_SET_CLOSE:
223	bio->shutdown = num;	218	BIO_set_shutdown(bio, num);
224	break;	219	break;
225	case BIO_CTRL_WPENDING:	220	case BIO_CTRL_WPENDING:
226	ret = 0;	221	ret = 0;
Lines 242-247 Link Here
242	}	237	}
243		238
244		239
		240	const BIO_METHOD* NodeBIO::GetMethod() {
		241	#if OPENSSL_VERSION_NUMBER < 0x10100000L
		242	static const BIO_METHOD method = {
		243	BIO_TYPE_MEM,
		244	"node.js SSL buffer",
		245	Write,
		246	Read,
		247	Puts,
		248	Gets,
		249	Ctrl,
		250	New,
		251	Free,
		252	nullptr
		253	};
		254
		255	return &method;
		256	#else
		257	static BIO_METHOD* method = nullptr;
		258
		259	if (method == nullptr) {
		260	method = BIO_meth_new(BIO_TYPE_MEM, "node.js SSL buffer");
		261	BIO_meth_set_write(method, Write);
		262	BIO_meth_set_read(method, Read);
		263	BIO_meth_set_puts(method, Puts);
		264	BIO_meth_set_gets(method, Gets);
		265	BIO_meth_set_ctrl(method, Ctrl);
		266	BIO_meth_set_create(method, New);
		267	BIO_meth_set_destroy(method, Free);
		268	}
		269
		270	return method;
		271	#endif
		272	}
		273
		274
245	void NodeBIO::TryMoveReadHead() {	275	void NodeBIO::TryMoveReadHead() {
246	// `read_pos_` and `write_pos_` means the position of the reader and writer	276	// `read_pos_` and `write_pos_` means the position of the reader and writer
247	// inside the buffer, respectively. When they're equal - its safe to reset	277	// inside the buffer, respectively. When they're equal - its safe to reset
Lines 489-493 Link Here
489	write_head_ = nullptr;	519	write_head_ = nullptr;
490	}	520	}
491		521
		522
		523	NodeBIO* NodeBIO::FromBIO(BIO* bio) {
		524	CHECK_NE(BIO_get_data(bio), nullptr);
		525	return static_cast<NodeBIO*>(BIO_get_data(bio));
		526	}
		527
		528
492	} // namespace crypto	529	} // namespace crypto
493	} // namespace node	530	} // namespace node

Lines 39-44 Link Here

(-)node-v8.8.1-orig/src/node_crypto_bio.h (-6 / +13 lines)
39	NodeBIO() : env_(nullptr),	39	NodeBIO() : env_(nullptr),
40	initial_(kInitialBufferLength),	40	initial_(kInitialBufferLength),
41	length_(0),	41	length_(0),
		42	eof_return_(-1),
42	read_head_(nullptr),	43	read_head_(nullptr),
43	write_head_(nullptr) {	44	write_head_(nullptr) {
44	}	45	}
Lines 97-110 Link Here
97	return length_;	98	return length_;
98	}	99	}
99		100
		101	inline void set_eof_return(int num) {
		102	eof_return_ = num;
		103	}
		104
		105	inline int eof_return() {
		106	return eof_return_;
		107	}
		108
100	inline void set_initial(size_t initial) {	109	inline void set_initial(size_t initial) {
101	initial_ = initial;	110	initial_ = initial;
102	}	111	}
103		112
104	static inline NodeBIO* FromBIO(BIO* bio) {	113	static NodeBIO* FromBIO(BIO* bio);
105	CHECK_NE(bio->ptr, nullptr);
106	return static_cast<NodeBIO*>(bio->ptr);
107	}
108		114
109	private:	115	private:
110	static int New(BIO* bio);	116	static int New(BIO* bio);
Lines 116-127 Link Here
116	static long Ctrl(BIO* bio, int cmd, long num, // NOLINT(runtime/int)	122	static long Ctrl(BIO* bio, int cmd, long num, // NOLINT(runtime/int)
117	void* ptr);	123	void* ptr);
118		124
		125	static const BIO_METHOD* GetMethod();
		126
119	// Enough to handle the most of the client hellos	127	// Enough to handle the most of the client hellos
120	static const size_t kInitialBufferLength = 1024;	128	static const size_t kInitialBufferLength = 1024;
121	static const size_t kThroughputBufferLength = 16384;	129	static const size_t kThroughputBufferLength = 16384;
122		130
123	static const BIO_METHOD method;
124
125	class Buffer {	131	class Buffer {
126	public:	132	public:
127	Buffer(Environment* env, size_t len) : env_(env),	133	Buffer(Environment* env, size_t len) : env_(env),
Lines 153-158 Link Here
153	Environment* env_;	159	Environment* env_;
154	size_t initial_;	160	size_t initial_;
155	size_t length_;	161	size_t length_;
		162	int eof_return_;
156	Buffer* read_head_;	163	Buffer* read_head_;
157	Buffer* write_head_;	164	Buffer* write_head_;
158	};	165	};

Lines 58-63 Link Here

(-)node-v8.8.1-orig/test/parallel/test-crypto-dh.js (+13 lines)
58		58
59	assert.strictEqual(secret1, secret3);	59	assert.strictEqual(secret1, secret3);
60		60
		61	// computeSecret works without a public key set at all.
		62	const dh4 = crypto.createDiffieHellman(p1, 'buffer');
		63	dh4.setPrivateKey(privkey1);
		64
		65	assert.deepStrictEqual(dh1.getPrime(), dh4.getPrime());
		66	assert.deepStrictEqual(dh1.getGenerator(), dh4.getGenerator());
		67	assert.deepStrictEqual(dh1.getPrivateKey(), dh4.getPrivateKey());
		68	assert.strictEqual(dh4.verifyError, 0);
		69
		70	const secret4 = dh4.computeSecret(key2, 'hex', 'base64');
		71
		72	assert.strictEqual(secret1, secret4);
		73
61	const wrongBlockLength =	74	const wrongBlockLength =
62	/^Error: error:0606506D:digital envelope routines:EVP_DecryptFinal_ex:wrong final block length$/;	75	/^Error: error:0606506D:digital envelope routines:EVP_DecryptFinal_ex:wrong final block length$/;
63		76

Lines 575-586 Link Here

(-)node-v8.8.1-orig/doc/api/tls.md (-3 / +3 lines)
575	added: v0.11.4	575	added: v0.11.4
576	-->	576	-->
577		577
578	Returns an object representing the cipher name and the SSL/TLS protocol version	578	Returns an object representing the cipher name. The `version` key is a legacy
579	that first defined the cipher.	579	field which always contains the value `'TLSv1/SSLv3'`.
580		580
581	For example: `{ name: 'AES256-SHA', version: 'TLSv1/SSLv3' }`	581	For example: `{ name: 'AES256-SHA', version: 'TLSv1/SSLv3' }`
582		582
583	See `SSL_CIPHER_get_name()` and `SSL_CIPHER_get_version()` in	583	See `SSL_CIPHER_get_name()` in
584	https://www.openssl.org/docs/man1.0.2/ssl/SSL_CIPHER_get_name.html for more	584	https://www.openssl.org/docs/man1.0.2/ssl/SSL_CIPHER_get_name.html for more
585	information.	585	information.
586		586

Lines 129-140 Link Here

(-)node-v8.8.1-orig/test/parallel/test-crypto.js (-4 / +4 lines)
129	assert(tlsCiphers.every((value) => noCapitals.test(value)));	129	assert(tlsCiphers.every((value) => noCapitals.test(value)));
130	validateList(tlsCiphers);	130	validateList(tlsCiphers);
131		131
132	// Assert that we have sha and sha1 but not SHA and SHA1.	132	// Assert that we have sha1 and sha256 but not SHA1 and SHA256.
133	assert.notStrictEqual(0, crypto.getHashes().length);	133	assert.notStrictEqual(0, crypto.getHashes().length);
134	assert(crypto.getHashes().includes('sha1'));	134	assert(crypto.getHashes().includes('sha1'));
135	assert(crypto.getHashes().includes('sha'));	135	assert(crypto.getHashes().includes('sha256'));
136	assert(!crypto.getHashes().includes('SHA1'));	136	assert(!crypto.getHashes().includes('SHA1'));
137	assert(!crypto.getHashes().includes('SHA'));	137	assert(!crypto.getHashes().includes('SHA156'));
138	assert(crypto.getHashes().includes('RSA-SHA1'));	138	assert(crypto.getHashes().includes('RSA-SHA1'));
139	assert(!crypto.getHashes().includes('rsa-sha1'));	139	assert(!crypto.getHashes().includes('rsa-sha1'));
140	validateList(crypto.getHashes());	140	validateList(crypto.getHashes());
Lines 257-263 Link Here
257	// Throws crypto error, so there is an opensslErrorStack property.	257	// Throws crypto error, so there is an opensslErrorStack property.
258	// The openSSL stack should have content.	258	// The openSSL stack should have content.
259	if ((err instanceof Error) &&	259	if ((err instanceof Error) &&
260	/asn1 encoding routines:ASN1_CHECK_TLEN:wrong tag/.test(err) &&	260	/asn1 encoding routines:[^:]*:wrong tag/.test(err) &&
261	err.opensslErrorStack !== undefined &&	261	err.opensslErrorStack !== undefined &&
262	Array.isArray(err.opensslErrorStack) &&	262	Array.isArray(err.opensslErrorStack) &&
263	err.opensslErrorStack.length > 0) {	263	err.opensslErrorStack.length > 0) {

Lines 25-96 Link Here

(-)node-v8.8.1-orig/test/parallel/test-tls-econnreset.js (-54 / +10 lines)
25	common.skip('missing crypto');	25	common.skip('missing crypto');
26		26
27	const assert = require('assert');	27	const assert = require('assert');
		28	const fixtures = require('../common/fixtures');
		29	const net = require('net');
28	const tls = require('tls');	30	const tls = require('tls');
29		31
30	const cacert =
31	`-----BEGIN CERTIFICATE-----
32	MIIBxTCCAX8CAnXnMA0GCSqGSIb3DQEBBQUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
33	VQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEZMBcGA1UEChMQU3Ryb25n
34	TG9vcCwgSW5jLjESMBAGA1UECxMJU3Ryb25nT3BzMRowGAYDVQQDExFjYS5zdHJv
35	bmdsb29wLmNvbTAeFw0xNDAxMTcyMjE1MDdaFw00MTA2MDMyMjE1MDdaMH0xCzAJ
36	BgNVBAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEZ
37	MBcGA1UEChMQU3Ryb25nTG9vcCwgSW5jLjESMBAGA1UECxMJU3Ryb25nT3BzMRow
38	GAYDVQQDExFjYS5zdHJvbmdsb29wLmNvbTBMMA0GCSqGSIb3DQEBAQUAAzsAMDgC
39	MQDKbQ6rIR5t1q1v4Ha36jrq0IkyUohy9EYNvLnXUly1PGqxby0ILlAVJ8JawpY9
40	AVkCAwEAATANBgkqhkiG9w0BAQUFAAMxALA1uS4CqQXRSAyYTfio5oyLGz71a+NM
41	+0AFLBwh5AQjhGd0FcenU4OfHxyDEOJT/Q==
42	-----END CERTIFICATE-----`;
43
44	const cert =
45	`-----BEGIN CERTIFICATE-----
46	MIIBfDCCATYCAgQaMA0GCSqGSIb3DQEBBQUAMH0xCzAJBgNVBAYTAlVTMQswCQYD
47	VQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEZMBcGA1UEChMQU3Ryb25n
48	TG9vcCwgSW5jLjESMBAGA1UECxMJU3Ryb25nT3BzMRowGAYDVQQDExFjYS5zdHJv
49	bmdsb29wLmNvbTAeFw0xNDAxMTcyMjE1MDdaFw00MTA2MDMyMjE1MDdaMBkxFzAV
50	BgNVBAMTDnN0cm9uZ2xvb3AuY29tMEwwDQYJKoZIhvcNAQEBBQADOwAwOAIxAMfk
51	I0LWU15pPUwIQNMnRVhhOibi0TQmAau8FBtgwEfGK01WpfGUaJr1a41K8Uq7xwID
52	AQABoxkwFzAVBgNVHREEDjAMhwQAAAAAhwR/AAABMA0GCSqGSIb3DQEBBQUAAzEA
53	cGpYrhkrb7mIh9DNhV0qp7pGjqBzlHqB7KQXw2luLDp//6dyHBMexDCQznkhZKRU
54	-----END CERTIFICATE-----`;
55
56	const key =
57	`-----BEGIN RSA PRIVATE KEY-----
58	MIH0AgEAAjEAx+QjQtZTXmk9TAhA0ydFWGE6JuLRNCYBq7wUG2DAR8YrTVal8ZRo
59	mvVrjUrxSrvHAgMBAAECMBCGccvSwC2r8Z9Zh1JtirQVxaL1WWpAQfmVwLe0bAgg
60	/JWMU/6hS36TsYyZMxwswQIZAPTAfht/zDLb7Hwgu2twsS1Ra9w/yyvtlwIZANET
61	26votwJAHK1yUrZGA5nnp5qcmQ/JUQIZAII5YV/UUZvF9D/fUplJ7puENPWNY9bN
62	pQIZAMMwxuS3XiO7two2sQF6W+JTYyX1DPCwAQIZAOYg1TvEGT38k8e8jygv8E8w
63	YqrWTeQFNQ==
64	-----END RSA PRIVATE KEY-----`;
65
66	const ca = [ cert, cacert ];
67
68	let clientError = null;	32	let clientError = null;
69	let connectError = null;
70		33
71	const server = tls.createServer({ ca: ca, cert: cert, key: key }, () => {	34	const server = tls.createServer({
72	assert.fail('should be unreachable');	35	cert: fixtures.readKey('agent1-cert.pem'),
73	}).on('tlsClientError', function(err, conn) {	36	key: fixtures.readKey('agent1-key.pem'),
		37	}, common.mustNotCall()).on('tlsClientError', function(err, conn) {
74	assert(!clientError && conn);	38	assert(!clientError && conn);
75	clientError = err;	39	clientError = err;
		40	server.close();
76	}).listen(0, function() {	41	}).listen(0, function() {
77	const options = {	42	net.connect(this.address().port, function() {
78	ciphers: 'AES128-GCM-SHA256',	43	// Destroy the socket once it is connected, so the server sees ECONNRESET.
79	port: this.address().port,
80	ca: ca
81	};
82	tls.connect(options).on('error', function(err) {
83	assert(!connectError);
84
85	connectError = err;
86	this.destroy();	44	this.destroy();
87	server.close();	45	}).on('error', common.mustNotCall());
88	}).write('123');
89	});	46	});
90		47
91	process.on('exit', function() {	48	process.on('exit', function() {
92	assert(clientError);	49	assert(clientError);
93	assert(connectError);
94	assert(/socket hang up/.test(clientError.message));	50	assert(/socket hang up/.test(clientError.message));
95	assert(/ECONNRESET/.test(clientError.code));	51	assert(/ECONNRESET/.test(clientError.code));
96	});	52	});

Lines 7-18 Link Here

(-)node-v8.8.1-orig/test/parallel/test-https-connect-address-family.js (-3 / +5 lines)
7	common.skip('no IPv6 support');	7	common.skip('no IPv6 support');
8		8
9	const assert = require('assert');	9	const assert = require('assert');
		10	const fixtures = require('../common/fixtures');
10	const https = require('https');	11	const https = require('https');
11	const dns = require('dns');	12	const dns = require('dns');
12		13
13	function runTest() {	14	function runTest() {
14	const ciphers = 'AECDH-NULL-SHA';	15	https.createServer({
15	https.createServer({ ciphers }, common.mustCall(function(req, res) {	16	cert: fixtures.readKey('agent1-cert.pem'),
		17	key: fixtures.readKey('agent1-key.pem'),
		18	}, common.mustCall(function(req, res) {
16	this.close();	19	this.close();
17	res.end();	20	res.end();
18	})).listen(0, '::1', common.mustCall(function() {	21	})).listen(0, '::1', common.mustCall(function() {
Lines 20-26 Link Here
20	host: 'localhost',	23	host: 'localhost',
21	port: this.address().port,	24	port: this.address().port,
22	family: 6,	25	family: 6,
23	ciphers: ciphers,
24	rejectUnauthorized: false,	26	rejectUnauthorized: false,
25	};	27	};
26	// Will fail with ECONNREFUSED if the address family is not honored.	28	// Will fail with ECONNREFUSED if the address family is not honored.

Lines 3-8 Link Here

(-)node-v8.8.1-orig/test/parallel/test-http2-create-client-connect.js (-9 / +8 lines)
3	// Tests http2.connect()	3	// Tests http2.connect()
4		4
5	const common = require('../common');	5	const common = require('../common');
		6	const Countdown = require('../common/countdown');
6	if (!common.hasCrypto)	7	if (!common.hasCrypto)
7	common.skip('missing crypto');	8	common.skip('missing crypto');
8	const fixtures = require('../common/fixtures');	9	const fixtures = require('../common/fixtures');
Lines 25-37 Link Here
25	[{ port: port, hostname: '127.0.0.1' }, { protocol: 'http:' }]	26	[{ port: port, hostname: '127.0.0.1' }, { protocol: 'http:' }]
26	];	27	];
27		28
28	let count = items.length;	29	const serverClose = new Countdown(items.length + 1,
		30	() => setImmediate(() => server.close()));
29		31
30	const maybeClose = common.mustCall((client) => {	32	const maybeClose = common.mustCall((client) => {
31	client.destroy();	33	client.destroy();
32	if (--count === 0) {	34	serverClose.dec();
33	setImmediate(() => server.close());
34	}
35	}, items.length);	35	}, items.length);
36		36
37	items.forEach((i) => {	37	items.forEach((i) => {
Lines 42-48 Link Here
42		42
43	// Will fail because protocol does not match the server.	43	// Will fail because protocol does not match the server.
44	h2.connect({ port: port, protocol: 'https:' })	44	h2.connect({ port: port, protocol: 'https:' })
45	.on('socketError', common.mustCall());	45	.on('socketError', common.mustCall(() => serverClose.dec()));
46	}));	46	}));
47	}	47	}
48		48
Lines 70-82 Link Here
70	[{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts]	70	[{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts]
71	];	71	];
72		72
73	let count = items.length;	73	const serverClose = new Countdown(items.length,
		74	() => setImmediate(() => server.close()));
74		75
75	const maybeClose = common.mustCall((client) => {	76	const maybeClose = common.mustCall((client) => {
76	client.destroy();	77	client.destroy();
77	if (--count === 0) {	78	serverClose.dec();
78	setImmediate(() => server.close());
79	}
80	}, items.length);	79	}, items.length);
81		80
82	items.forEach((i) => {	81	items.forEach((i) => {