Local<Object> wrap,

DTLSEndpoint* endpoint,

ncrypto::SSLPointer ssl,

BIO* enc_in,

BIO* enc_out,

const SocketAddress& remote,

bool is_server)

: AsyncWrap(env, wrap, PROVIDER_DTLS_SESSION),

endpoint_(endpoint),

ssl_(std::move(ssl)),

enc_in_(enc_in),

enc_out_(enc_out),

retransmit_timer_(env,

[this] {

if (destroyed_) return;

DTLS_STAT_INCREMENT(DTLSSessionStats,

retransmit_count);

int ret = DTLSv1_handle_timeout(ssl_.get());

if (ret < 0) {

// Handshake timeout expired.

HandleScope hs(this->env()->isolate());

Context::Scope cs(this->env()->context());

Local<Value> argv[] = {

String::NewFromUtf8(this->env()->isolate(),

"DTLS handshake timeout")

.ToLocalChecked(),

};

EmitCallback(DTLS_CB_SESSION_ERROR, 1, argv);

return;

}

Cycle();

}),

remote_address_(remote),

is_server_(is_server),

state_(env->isolate()),

stats_(env->isolate()) {

MakeWeak();

DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, created_at);

retransmit_timer_.Unref();

// Update shared state.

state_->handshaking = 1;

state_->open = 0;

// Store this session in SSL app data for callbacks.

SSL_set_app_data(ssl_.get(), this);

// Enable keylog for TLS key export (useful for Wireshark debugging).

SSL_CTX_set_keylog_callback(SSL_get_SSL_CTX(ssl_.get()), SSLKeylogCallback);

// Set the MTU on the SSL object.

SSL_set_mtu(ssl_.get(), endpoint->mtu());

auto tmpl = env->dtls_session_constructor_template();

if (tmpl.IsEmpty()) {

Isolate* isolate = env->isolate();

tmpl = NewFunctionTemplate(isolate, New);

tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "DTLSSession"));

tmpl->InstanceTemplate()->SetInternalFieldCount(

AsyncWrap::kInternalFieldCount);

SetProtoMethod(isolate, tmpl, "send", DoSend);

SetProtoMethod(isolate, tmpl, "close", DoClose);

SetProtoMethod(isolate, tmpl, "destroy", DoDestroy);

SetProtoMethod(isolate, tmpl, "getState", GetState);

SetProtoMethod(isolate, tmpl, "getStats", GetStats);

SetProtoMethod(isolate, tmpl, "getRemoteAddress", GetRemoteAddress);

SetProtoMethod(isolate, tmpl, "getProtocol", GetProtocol);

SetProtoMethod(isolate, tmpl, "getCipher", GetCipher);

SetProtoMethod(isolate, tmpl, "getPeerCertificate", GetPeerCertificate);

SetProtoMethod(isolate, tmpl, "getALPNProtocol", GetALPNProtocol);

SetProtoMethod(isolate, tmpl, "exportKeyingMaterial", ExportKeyingMaterial);

SetProtoMethod(isolate, tmpl, "getSRTPProfile", GetSRTPProfile);

SetProtoMethod(isolate, tmpl, "setServername", SetServername);

SetProtoMethod(isolate, tmpl, "getServername", GetServername);

env->set_dtls_session_constructor_template(tmpl);

}

return tmpl;

Local<Context> context,

Environment* env) {

SetConstructorFunction(

context, target, "DTLSSession", GetConstructorTemplate(env));

ExternalReferenceRegistry* registry) {

registry->Register(New);

registry->Register(DoSend);

registry->Register(DoClose);

registry->Register(DoDestroy);

registry->Register(GetState);

registry->Register(GetStats);

registry->Register(GetRemoteAddress);

registry->Register(GetProtocol);

registry->Register(GetCipher);

registry->Register(GetPeerCertificate);

registry->Register(GetALPNProtocol);

registry->Register(ExportKeyingMaterial);

registry->Register(GetSRTPProfile);

registry->Register(SetServername);

registry->Register(GetServername);

DTLSEndpoint* endpoint,

SSL_CTX* ssl_ctx,

const SocketAddress& remote,

bool is_server) {

// Create the SSL object.

SSL* ssl_raw = SSL_new(ssl_ctx);

if (ssl_raw == nullptr) {

THROW_ERR_CRYPTO_OPERATION_FAILED(env, "SSL_new failed");

return {};

}

ncrypto::SSLPointer ssl(ssl_raw);

// Create memory BIOs for encrypted data I/O.

BIO* enc_in = BIO_new(BIO_s_mem());

BIO* enc_out = BIO_new(BIO_s_mem());

if (enc_in == nullptr || enc_out == nullptr) {

BIO_free(enc_in);

BIO_free(enc_out);

THROW_ERR_CRYPTO_OPERATION_FAILED(env, "BIO_new failed");

return {};

}

// Make the BIOs non-blocking.

BIO_set_mem_eof_return(enc_in, -1);

BIO_set_mem_eof_return(enc_out, -1);

// Associate BIOs with the SSL object. SSL_set_bio takes ownership.

SSL_set_bio(ssl.get(), enc_in, enc_out);

// Set the MTU (since we use SSL_OP_NO_QUERY_MTU).

SSL_set_mtu(ssl.get(), endpoint->mtu());

// Set the handshake direction.

if (is_server) {

SSL_set_accept_state(ssl.get());

} else {

SSL_set_connect_state(ssl.get());

}

// Create the JS wrapper object.

Local<FunctionTemplate> tmpl = GetConstructorTemplate(env);

Local<Object> obj;

if (!tmpl->InstanceTemplate()->NewInstance(env->context()).ToLocal(&obj)) {

return {};

}

auto session = MakeBaseObject<DTLSSession>(

env, obj, endpoint, std::move(ssl), enc_in, enc_out, remote, is_server);

return session;

Environment* env,

DTLSEndpoint* endpoint,

ncrypto::SSLPointer ssl,

BIO* enc_in,

BIO* enc_out,

const SocketAddress& remote) {

Local<FunctionTemplate> tmpl = GetConstructorTemplate(env);

Local<Object> obj;

if (!tmpl->InstanceTemplate()->NewInstance(env->context()).ToLocal(&obj)) {

return {};

}

return MakeBaseObject<DTLSSession>(env,

obj,

endpoint,

std::move(ssl),

enc_in,

enc_out,

remote,

true /* is_server */);

// Sessions are created internally via DTLSSession::Create,

// not directly from JS.

CHECK(args.IsConstructCall());

if (destroyed_ || closed_) return;

// Write the encrypted datagram into enc_in_ BIO.

int written = BIO_write(enc_in_, data, len);

if (written <= 0) return;

// Run the state machine.

Cycle();

if (destroyed_) return;

// Prevent infinite recursion.

if (++cycle_depth_ > 1) {

cycle_depth_--;

return;

}

HandleScope handle_scope(env()->isolate());

Context::Scope context_scope(env()->context());

// If handshake is not yet complete, drive it forward.

if (!handshake_complete_) {

int ret = SSL_do_handshake(ssl_.get());

if (ret <= 0) {

int err = SSL_get_error(ssl_.get(), ret);

if (err == SSL_ERROR_SSL) {

unsigned long ossl_err = ERR_get_error(); // NOLINT(runtime/int)

char err_buf[256];

ERR_error_string_n(ossl_err, err_buf, sizeof(err_buf));

Local<Value> argv[] = {

String::NewFromUtf8(env()->isolate(), err_buf).ToLocalChecked(),

};

EmitCallback(DTLS_CB_SESSION_ERROR, 1, argv);

cycle_depth_--;

return;

}

// SSL_ERROR_WANT_READ/WRITE is normal during handshake.

}

// Flush any handshake data produced.

EncOut();

// Check if handshake just completed.

if (SSL_is_init_finished(ssl_.get()) && !handshake_complete_) {

handshake_complete_ = true;

state_->handshaking = 0;

state_->open = 1;

DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, handshake_completed_at);

Local<Value> argv[] = {

String::NewFromUtf8(env()->isolate(), SSL_get_version(ssl_.get()))

.ToLocalChecked(),

};

EmitCallback(DTLS_CB_SESSION_HANDSHAKE, 1, argv);

}

}

// Read any decrypted application data.

ClearOut();

// Flush any pending encrypted output.

EncOut();

UpdateTimer();

cycle_depth_--;

if (destroyed_) return;

// Try to read decrypted application data from OpenSSL.

uint8_t buf[65536];

int read;

while ((read = SSL_read(ssl_.get(), buf, sizeof(buf))) > 0) {

DTLS_STAT_INCREMENT_N(DTLSSessionStats, bytes_received, read);

DTLS_STAT_INCREMENT(DTLSSessionStats, messages_received);

// Emit the data to JS via callback.

Local<Value> argv[] = {

Buffer::Copy(env(), reinterpret_cast<const char*>(buf), read)

.ToLocalChecked(),

};

EmitCallback(DTLS_CB_SESSION_MESSAGE, 1, argv);

}

int err = SSL_get_error(ssl_.get(), read);

switch (err) {

case SSL_ERROR_WANT_READ:

case SSL_ERROR_WANT_WRITE:

// Normal - need more data or need to flush.

break;

case SSL_ERROR_ZERO_RETURN:

// Peer sent close_notify.

if (!closed_) {

closed_ = true;

state_->closing = 1;

state_->open = 0;

// Send our close_notify back.

SSL_shutdown(ssl_.get());

EncOut();

Local<Value> argv[] = {};

EmitCallback(DTLS_CB_SESSION_CLOSE, 0, argv);

}

break;

case SSL_ERROR_SSL: {

// SSL error during handshake or data exchange.

unsigned long ossl_err = ERR_get_error(); // NOLINT(runtime/int)

char err_buf[256];

ERR_error_string_n(ossl_err, err_buf, sizeof(err_buf));

Local<Value> argv[] = {

String::NewFromUtf8(env()->isolate(), err_buf).ToLocalChecked(),

};

EmitCallback(DTLS_CB_SESSION_ERROR, 1, argv);

break;

}

default:

break;

}

if (destroyed_) return;

auto ep = endpoint_.get();

if (ep == nullptr) return;

// Read encrypted data from enc_out_ BIO and send via UDP.

// Read in a loop since there may be multiple DTLS records.

uint8_t buf[65536];

int read;

while ((read = BIO_read(enc_out_, buf, sizeof(buf))) > 0) {

ep->SendTo(remote_address_, buf, read);

}

if (destroyed_) return;

struct timeval tv;

if (DTLSv1_get_timeout(ssl_.get(), &tv)) {

uint64_t timeout_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;

if (timeout_ms == 0) timeout_ms = 1; // Minimum 1ms.

retransmit_timer_.Update(timeout_ms);

} else {

// No timeout needed (handshake complete or not started).

retransmit_timer_.Stop();

}

if (destroyed_ || closed_) return -1;

if (!handshake_complete_) {

// Can't send application data before handshake.

return -1;

}

int written = SSL_write(ssl_.get(), data, len);

if (written > 0) {

DTLS_STAT_INCREMENT_N(DTLSSessionStats, bytes_sent, written);

DTLS_STAT_INCREMENT(DTLSSessionStats, messages_sent);

EncOut();

}

return written;

if (destroyed_ || closed_) return;

closed_ = true;

state_->closing = 1;

DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, closing_at);

// Send close_notify.

int ret = SSL_shutdown(ssl_.get());

if (ret == 0) {

// Need to call again for bidirectional shutdown.

SSL_shutdown(ssl_.get());

}

EncOut();

retransmit_timer_.Stop();

state_->open = 0;

// Notify JS.

HandleScope handle_scope(env()->isolate());

Context::Scope context_scope(env()->context());

Local<Value> argv[] = {};

EmitCallback(DTLS_CB_SESSION_CLOSE, 0, argv);

if (destroyed_) return;

destroyed_ = true;

closed_ = true;

state_->destroyed = 1;

DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, destroyed_at);

state_->open = 0;

state_->handshaking = 0;

retransmit_timer_.Close();

// Promote to strong ref to keep endpoint alive during removal,

// then release our weak pointer.

BaseObjectPtr<DTLSEndpoint> ep = endpoint_;

endpoint_.reset();

if (ep) ep->RemoveSession(remote_address_);

DTLSSession* session = static_cast<DTLSSession*>(SSL_get_app_data(ssl));

if (session == nullptr || session->destroyed_) return;

HandleScope handle_scope(session->env()->isolate());

Context::Scope context_scope(session->env()->context());

Local<Value> argv[] = {

String::NewFromUtf8(session->env()->isolate(), line).ToLocalChecked(),

};

session->EmitCallback(DTLS_CB_SESSION_KEYLOG, 1, argv);

int argc,

Local<Value>* argv) {

auto ep = endpoint_.get();

if (ep == nullptr) return MaybeLocal<Value>();

Local<Function> cb = ep->GetCallback(cb_index);

if (cb.IsEmpty()) return MaybeLocal<Value>();

return MakeCallback(cb, argc, argv);

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

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

return THROW_ERR_INVALID_ARG_TYPE(session->env(), "data must be a Buffer");

}

const uint8_t* data = reinterpret_cast<const uint8_t*>(Buffer::Data(args[0]));

size_t len = Buffer::Length(args[0]);

int written = session->Send(data, len);

args.GetReturnValue().Set(written);

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

session->Close();

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

session->Destroy();

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

args.GetReturnValue().Set(session->state_.GetArrayBuffer());

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

args.GetReturnValue().Set(session->stats_.GetArrayBuffer());

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

Environment* env = session->env();

Local<Object> obj;

if (session->remote_address_.ToJS(env).ToLocal(&obj)) {

args.GetReturnValue().Set(obj);

}

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

const char* version = SSL_get_version(session->ssl_.get());

args.GetReturnValue().Set(

String::NewFromUtf8(session->env()->isolate(), version).ToLocalChecked());

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

Environment* env = session->env();

const SSL_CIPHER* cipher = SSL_get_current_cipher(session->ssl_.get());

if (cipher == nullptr) return;

Local<Object> info = Object::New(env->isolate());

info->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "name"),

String::NewFromUtf8(env->isolate(), SSL_CIPHER_get_name(cipher))

.ToLocalChecked())

.Check();

info->Set(

env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "standardName"),

String::NewFromUtf8(env->isolate(), SSL_CIPHER_standard_name(cipher))

.ToLocalChecked())

.Check();

info->Set(env->context(),

FIXED_ONE_BYTE_STRING(env->isolate(), "version"),

String::NewFromUtf8(env->isolate(), SSL_CIPHER_get_version(cipher))

.ToLocalChecked())

.Check();

args.GetReturnValue().Set(info);

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

Environment* env = session->env();

X509* peer_cert = SSL_get0_peer_certificate(session->ssl_.get());

if (peer_cert == nullptr) return;

// Return the PEM-encoded certificate.

BIO* bio = BIO_new(BIO_s_mem());

if (PEM_write_bio_X509(bio, peer_cert)) {

char* data;

long len = BIO_get_mem_data(bio, &data); // NOLINT(runtime/int)

if (len > 0) {

args.GetReturnValue().Set(

String::NewFromUtf8(

env->isolate(), data, v8::NewStringType::kNormal, len)

.ToLocalChecked());

}

}

BIO_free(bio);

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

const unsigned char* alpn = nullptr;

unsigned int alpn_len = 0;

SSL_get0_alpn_selected(session->ssl_.get(), &alpn, &alpn_len);

if (alpn != nullptr && alpn_len > 0) {

args.GetReturnValue().Set(

String::NewFromUtf8(session->env()->isolate(),

reinterpret_cast<const char*>(alpn),

v8::NewStringType::kNormal,

alpn_len)

.ToLocalChecked());

}

const FunctionCallbackInfo<Value>& args) {

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

Environment* env = session->env();

if (!args[0]->IsNumber() || !args[1]->IsString()) {

return THROW_ERR_INVALID_ARG_TYPE(

env, "Expected (length: number, label: string[, context: Buffer])");

}

int length = args[0]->Int32Value(env->context()).FromJust();

Utf8Value label(env->isolate(), args[1]);

const uint8_t* context_value = nullptr;

size_t context_len = 0;

bool use_context = false;

if (args.Length() > 2 && Buffer::HasInstance(args[2])) {

context_value = reinterpret_cast<const uint8_t*>(Buffer::Data(args[2]));

context_len = Buffer::Length(args[2]);

use_context = true;

}

std::vector<uint8_t> out(length);

int ret = SSL_export_keying_material(session->ssl_.get(),

out.data(),

length,

*label,

label.length(),

context_value,

context_len,

use_context ? 1 : 0);

if (ret != 1) {

return THROW_ERR_CRYPTO_OPERATION_FAILED(

env, "SSL_export_keying_material failed");

}

args.GetReturnValue().Set(

Buffer::Copy(env, reinterpret_cast<const char*>(out.data()), length)

.ToLocalChecked());

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

const SRTP_PROTECTION_PROFILE* profile =

SSL_get_selected_srtp_profile(session->ssl_.get());

if (profile != nullptr) {

args.GetReturnValue().Set(

String::NewFromUtf8(session->env()->isolate(), profile->name)

.ToLocalChecked());

}

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

CHECK(args[0]->IsString());

Utf8Value servername(session->env()->isolate(), args[0]);

SSL_set_tlsext_host_name(session->ssl_.get(), *servername);

DTLSSession* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

const char* servername =

SSL_get_servername(session->ssl_.get(), TLSEXT_NAMETYPE_host_name);

if (servername != nullptr) {

args.GetReturnValue().Set(

String::NewFromUtf8(session->env()->isolate(), servername)

.ToLocalChecked());

}