Lines Matching refs:env
3 #include "env-inl.h"
93 Environment* env,
103 Buffer::Copy(env, reinterpret_cast<const char*>(resp), len);
251 MaybeLocal<Value> GetValidationErrorReason(Environment* env, int err) {
253 return Undefined(env->isolate());
255 return OneByteString(env->isolate(), reason);
258 MaybeLocal<Value> GetValidationErrorCode(Environment* env, int err) {
260 return Undefined(env->isolate());
261 return OneByteString(env->isolate(), X509ErrorCode(err));
264 MaybeLocal<Value> GetCert(Environment* env, const SSLPointer& ssl) {
268 return Undefined(env->isolate());
270 MaybeLocal<Object> maybe_cert = X509ToObject(env, cert);
274 Local<Value> ToV8Value(Environment* env, const BIOPointer& bio) {
279 env->isolate(),
306 MaybeLocal<Value> GetCipherValue(Environment* env, const SSL_CIPHER* cipher) {
308 return Undefined(env->isolate());
310 return OneByteString(env->isolate(), getstr(cipher));
337 Environment* const env) {
338 Local<Context> context = env->isolate()->GetCurrentContext();
348 MaybeLocal<Object> maybe_ca_info = X509ToObject(env, ca);
352 if (!Set<Object>(context, object, env->issuercert_string(), ca_info))
373 Environment* const env) {
374 Local<Context> context = env->isolate()->GetCurrentContext();
381 MaybeLocal<Object> maybe_ca_info = X509ToObject(env, ca.get());
385 if (!Set<Object>(context, issuer_chain, env->issuercert_string(), ca_info))
419 MaybeLocal<Value> GetCurveName(Environment* env, const int nid) {
422 MaybeLocal<Value>(OneByteString(env->isolate(), name)) :
423 MaybeLocal<Value>(Undefined(env->isolate()));
427 Environment* env,
432 return Undefined(env->isolate());
435 env,
443 Environment* env,
447 return Undefined(env->isolate());
451 return Undefined(env->isolate());
453 return Integer::New(env->isolate(), bits);
456 MaybeLocal<Object> GetPubKey(Environment* env, const RSAPointer& rsa) {
462 NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
463 bs = ArrayBuffer::NewBackingStore(env->isolate(), size);
469 Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));
470 return Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local<Object>());
474 Environment* env,
479 return ToV8Value(env, bio);
482 Local<Value> GetBits(Environment* env, const BIGNUM* n) {
483 return Integer::New(env->isolate(), BN_num_bits(n));
487 Environment* env,
491 return ToV8Value(env, bio);
495 MaybeLocal<Value> GetRawDERCertificate(Environment* env, X509* cert) {
500 NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
501 bs = ArrayBuffer::NewBackingStore(env->isolate(), size);
507 Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));
508 return Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local<Object>());
511 MaybeLocal<Value> GetSerialNumber(Environment* env, X509* cert) {
517 if (buf) return OneByteString(env->isolate(), buf.data<unsigned char>());
521 return Undefined(env->isolate());
524 MaybeLocal<Value> GetKeyUsage(Environment* env, X509* cert) {
537 ext_key_usage[j++] = OneByteString(env->isolate(), buf);
541 return Array::New(env->isolate(), ext_key_usage.out(), count);
544 return Undefined(env->isolate());
547 MaybeLocal<Value> GetCurrentCipherName(Environment* env,
549 return GetCipherName(env, SSL_get_current_cipher(ssl.get()));
552 MaybeLocal<Value> GetCurrentCipherVersion(Environment* env,
554 return GetCipherVersion(env, SSL_get_current_cipher(ssl.get()));
558 Environment* env,
567 return OneByteString(env->isolate(), fingerprint);
569 return Undefined(env->isolate());
573 Environment* env,
577 return ToV8Value(env, bio);
581 Environment* env,
585 return ToV8Value(env, bio);
875 v8::MaybeLocal<v8::Value> GetSubjectAltNameString(Environment* env,
880 return Undefined(env->isolate());
887 return v8::Null(env->isolate());
890 return ToV8Value(env, bio);
893 v8::MaybeLocal<v8::Value> GetInfoAccessString(Environment* env,
898 return Undefined(env->isolate());
905 return v8::Null(env->isolate());
908 return ToV8Value(env, bio);
911 MaybeLocal<Value> GetIssuerString(Environment* env,
921 return Undefined(env->isolate());
924 return ToV8Value(env, bio);
927 MaybeLocal<Value> GetSubject(Environment* env,
936 return Undefined(env->isolate());
939 return ToV8Value(env, bio);
943 static MaybeLocal<Value> GetX509NameObject(Environment* env, X509* cert) {
951 Object::New(env->isolate(), Null(env->isolate()), nullptr, nullptr, 0);
981 if (!String::NewFromUtf8(env->isolate(), type_str).ToLocal(&v8_name)) {
993 return Undefined(env->isolate());
998 if (!String::NewFromUtf8(env->isolate(),
1012 if (!result->HasOwnProperty(env->context(), v8_name).To(&multiple)) {
1016 if (!result->Get(env->context(), v8_name).ToLocal(&accum)) {
1020 accum = Array::New(env->isolate(), &accum, 1);
1021 if (result->Set(env->context(), v8_name, accum).IsNothing()) {
1026 if (array->Set(env->context(), array->Length(), v8_value).IsNothing()) {
1029 } else if (result->Set(env->context(), v8_name, v8_value).IsNothing()) {
1037 template <MaybeLocal<Value> (*Get)(Environment* env, const SSL_CIPHER* cipher)>
1038 MaybeLocal<Value> GetCurrentCipherValue(Environment* env,
1040 return Get(env, SSL_get_current_cipher(ssl.get()));
1044 Environment* env,
1046 EscapableHandleScope scope(env->isolate());
1055 Local<Object> obj = Object::New(env->isolate());
1056 if (!Set(env->context(),
1058 env->name_string(),
1059 GetCipherName(env, cipher)) ||
1060 !Set(env->context(),
1062 env->standard_name_string(),
1063 GetCipherStandardName(env, cipher)) ||
1064 !Set(env->context(),
1066 env->version_string(),
1067 GetCipherVersion(env, cipher))) {
1072 Local<Array> ret = Array::New(env->isolate(), ciphers.out(), count);
1077 MaybeLocal<Object> GetCipherInfo(Environment* env, const SSLPointer& ssl) {
1080 EscapableHandleScope scope(env->isolate());
1081 Local<Object> info = Object::New(env->isolate());
1083 if (!Set<Value>(env->context(),
1085 env->name_string(),
1086 GetCurrentCipherValue<GetCipherName>(env, ssl)) ||
1087 !Set<Value>(env->context(),
1089 env->standard_name_string(),
1090 GetCurrentCipherValue<GetCipherStandardName>(env, ssl)) ||
1091 !Set<Value>(env->context(),
1093 env->version_string(),
1094 GetCurrentCipherValue<GetCipherVersion>(env, ssl))) {
1101 MaybeLocal<Object> GetEphemeralKey(Environment* env, const SSLPointer& ssl) {
1105 EscapableHandleScope scope(env->isolate());
1106 Local<Object> info = Object::New(env->isolate());
1110 Local<Context> context = env->context();
1117 if (!Set<String>(context, info, env->type_string(), env->dh_string()) ||
1120 env->size_string(),
1121 Integer::New(env->isolate(), bits))) {
1139 env->type_string(),
1140 env->ecdh_string()) ||
1143 env->name_string(),
1144 OneByteString(env->isolate(), curve_name)) ||
1147 env->size_string(),
1148 Integer::New(env->isolate(), bits))) {
1158 MaybeLocal<Object> ECPointToBuffer(Environment* env,
1171 NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
1172 bs = ArrayBuffer::NewBackingStore(env->isolate(), len);
1186 Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));
1187 return Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local<Object>());
1191 Environment* env,
1204 return Undefined(env->isolate());
1209 X509ToObject(env, cert ? cert.get() : sk_X509_value(ssl_certs, 0));
1215 return Undefined(env->isolate());
1220 maybe_cert = X509ToObject(env, first_cert.release());
1232 env);
1241 env);
1249 !Set<Object>(env->context(),
1251 env->issuercert_string(),
1260 Environment* env,
1262 EscapableHandleScope scope(env->isolate());
1263 Local<Context> context = env->context();
1264 Local<Object> info = Object::New(env->isolate());
1270 auto is_ca = Boolean::New(env->isolate(), 1 == X509_check_ca(cert));
1273 env->subject_string(),
1274 GetX509NameObject<X509_get_subject_name>(env, cert)) ||
1277 env->issuer_string(),
1278 GetX509NameObject<X509_get_issuer_name>(env, cert)) ||
1281 env->subjectaltname_string(),
1282 GetSubjectAltNameString(env, cert, bio)) ||
1285 env->infoaccess_string(),
1286 GetInfoAccessString(env, cert, bio)) ||
1287 !Set<Boolean>(context, info, env->ca_string(), is_ca)) {
1311 env->modulus_string(),
1312 GetModulusString(env, bio, n)) ||
1313 !Set<Value>(context, info, env->bits_string(), GetBits(env, n)) ||
1316 env->exponent_string(),
1317 GetExponentString(env, bio, e)) ||
1320 env->pubkey_string(),
1321 GetPubKey(env, rsa))) {
1329 env->bits_string(),
1330 GetECGroup(env, group, ec)) ||
1333 env->pubkey_string(),
1334 GetECPubKey(env, group, ec))) {
1344 env->asn1curve_string(),
1345 GetCurveName<OBJ_nid2sn>(env, nid)) ||
1348 env->nistcurve_string(),
1349 GetCurveName<EC_curve_nid2nist>(env, nid))) {
1365 env->valid_from_string(),
1366 GetValidFrom(env, cert, bio)) ||
1369 env->valid_to_string(),
1370 GetValidTo(env, cert, bio))) {
1379 env->fingerprint_string(),
1380 GetFingerprintDigest(env, EVP_sha1(), cert)) ||
1383 env->fingerprint256_string(),
1384 GetFingerprintDigest(env, EVP_sha256(), cert)) ||
1387 env->fingerprint512_string(),
1388 GetFingerprintDigest(env, EVP_sha512(), cert)) ||
1390 context, info, env->ext_key_usage_string(), GetKeyUsage(env, cert)) ||
1393 env->serial_number_string(),
1394 GetSerialNumber(env, cert)) ||
1396 context, info, env->raw_string(), GetRawDERCertificate(env, cert))) {