namespace node {
namespace crypto {
+using v8::AccessorSignature;
using v8::Array;
using v8::Boolean;
using v8::Context;
nullptr,
env->as_external(),
DEFAULT,
- static_cast<PropertyAttribute>(ReadOnly | DontDelete));
+ static_cast<PropertyAttribute>(ReadOnly | DontDelete),
+ AccessorSignature::New(env->isolate(), t));
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"),
t->GetFunction());
void SecureContext::CtxGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
- HandleScope scope(info.GetIsolate());
-
- SSL_CTX* ctx = Unwrap<SecureContext>(info.Holder())->ctx_;
+ SSL_CTX* ctx = Unwrap<SecureContext>(info.This())->ctx_;
Local<External> ext = External::New(info.GetIsolate(), ctx);
info.GetReturnValue().Set(ext);
}
nullptr,
env->as_external(),
DEFAULT,
- static_cast<PropertyAttribute>(ReadOnly | DontDelete));
+ static_cast<PropertyAttribute>(ReadOnly | DontDelete),
+ AccessorSignature::New(env->isolate(), t));
}
template <class Base>
void SSLWrap<Base>::SSLGetter(Local<String> property,
- const PropertyCallbackInfo<Value>& info) {
- HandleScope scope(info.GetIsolate());
-
- SSL* ssl = Unwrap<Base>(info.Holder())->ssl_;
+ const PropertyCallbackInfo<Value>& info) {
+ SSL* ssl = Unwrap<Base>(info.This())->ssl_;
Local<External> ext = External::New(info.GetIsolate(), ssl);
info.GetReturnValue().Set(ext);
}
env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
- t->InstanceTemplate()->SetAccessor(env->verify_error_string(),
- DiffieHellman::VerifyErrorGetter,
- nullptr,
- env->as_external(),
- DEFAULT,
- attributes);
+ t->InstanceTemplate()->SetAccessor(
+ env->verify_error_string(),
+ DiffieHellman::VerifyErrorGetter,
+ nullptr,
+ env->as_external(),
+ DEFAULT,
+ attributes,
+ AccessorSignature::New(env->isolate(), t));
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"),
t->GetFunction());
env->SetProtoMethod(t2, "getPublicKey", GetPublicKey);
env->SetProtoMethod(t2, "getPrivateKey", GetPrivateKey);
- t2->InstanceTemplate()->SetAccessor(env->verify_error_string(),
- DiffieHellman::VerifyErrorGetter,
- nullptr,
- env->as_external(),
- DEFAULT,
- attributes);
+ t2->InstanceTemplate()->SetAccessor(
+ env->verify_error_string(),
+ DiffieHellman::VerifyErrorGetter,
+ nullptr,
+ env->as_external(),
+ DEFAULT,
+ attributes,
+ AccessorSignature::New(env->isolate(), t2));
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellmanGroup"),
t2->GetFunction());
--- /dev/null
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (!common.hasCrypto) {
+ console.log('1..0 # Skipped: missing crypto');
+ return;
+}
+
+// Ensure accessing ._external doesn't hit an assert in the accessor method.
+const tls = require('tls');
+{
+ const pctx = tls.createSecureContext().context;
+ const cctx = Object.create(pctx);
+ assert.throws(() => cctx._external, /incompatible receiver/);
+ pctx._external;
+}
+{
+ const pctx = tls.createSecurePair().credentials.context;
+ const cctx = Object.create(pctx);
+ assert.throws(() => cctx._external, /incompatible receiver/);
+ pctx._external;
+}