Lines Matching defs:env
10 #include "env-inl.h"
274 Environment* env,
281 return String::NewFromUtf8(env->isolate(), bptr->data,
287 return Buffer::Copy(env, bptr->data, bptr->length)
294 Environment* env,
388 ThrowCryptoError(env, ERR_get_error(), "Failed to encode private key");
391 return BIOToStringOrBuffer(env, bio.get(), config.format_);
422 MaybeLocal<Value> WritePublicKey(Environment* env,
429 ThrowCryptoError(env, ERR_get_error(), "Failed to encode public key");
432 return BIOToStringOrBuffer(env, bio.get(), config.format_);
436 Environment* env,
445 env->isolate(),
452 env->isolate()->ThrowException(error);
459 env->context(),
460 env->jwk_kty_string(),
461 env->jwk_oct_string()).IsNothing() ||
463 env->context(),
464 env->jwk_k_string(),
473 Environment* env,
476 if (!jwk->Get(env->context(), env->jwk_k_string()).ToLocal(&key) ||
478 THROW_ERR_CRYPTO_INVALID_JWK(env, "Invalid JWK secret key format");
483 ByteSource key_data = ByteSource::FromEncodedString(env, key.As<String>());
488 Environment* env,
494 if (handleRsaPss) return ExportJWKRsaKey(env, key, target);
497 case EVP_PKEY_RSA: return ExportJWKRsaKey(env, key, target);
498 case EVP_PKEY_EC: return ExportJWKEcKey(env, key, target).IsJust() ?
506 case EVP_PKEY_X448: return ExportJWKEdKey(env, key, target);
508 THROW_ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE(env);
513 Environment* env,
519 return ImportJWKRsaKey(env, jwk, args, offset);
521 return ImportJWKEcKey(env, jwk, args, offset);
524 THROW_ERR_CRYPTO_INVALID_JWK(env, "%s is not a supported JWK key type", kty);
529 Environment* env,
536 return target->Set(env->context(),
537 env->length_string(),
538 Number::New(env->isolate(), static_cast<double>(length)));
542 Environment* env,
548 case EVP_PKEY_RSA_PSS: return GetRsaKeyDetail(env, key, target);
549 case EVP_PKEY_DSA: return GetDsaKeyDetail(env, key, target);
550 case EVP_PKEY_EC: return GetEcKeyDetail(env, key, target);
551 case EVP_PKEY_DH: return GetDhKeyDetail(env, key, target);
553 THROW_ERR_CRYPTO_INVALID_KEYTYPE(env);
614 Maybe<bool> ExportJWKInner(Environment* env,
620 return ExportJWKSecretKey(env, key, result.As<Object>());
625 env, key, result.As<Object>(), handleRsaPss);
632 Environment* env,
641 return Tristate(KeyObjectHandle::Create(env, data).ToLocal(out));
645 *out = Object::New(env->isolate());
646 return ExportJWKInner(env, data, *out, false);
649 return Tristate(WritePublicKey(env, get(), config).ToLocal(out));
653 Environment* env,
660 return Tristate(KeyObjectHandle::Create(env, data).ToLocal(out));
664 *out = Object::New(env->isolate());
665 return ExportJWKInner(env, data, *out, false);
668 return Tristate(WritePrivateKey(env, get(), config).ToLocal(out));
676 Environment* env = Environment::GetCurrent(args);
688 Utf8Value cipher_name(env->isolate(), args[*offset]);
691 THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env);
706 THROW_ERR_OUT_OF_RANGE(env, "passphrase is too big");
734 Environment* env = Environment::GetCurrent(args);
735 ByteSource key = ByteSource::FromStringOrBuffer(env, args[(*offset)++]);
744 return GetParsedKey(env, std::move(pkey), ret,
760 Environment* env = Environment::GetCurrent(args);
763 THROW_ERR_OUT_OF_RANGE(env, "keyData is too big");
809 env, std::move(pkey), ret, "Failed to read asymmetric key");
820 ManagedEVPPKey ManagedEVPPKey::GetParsedKey(Environment* env,
829 THROW_ERR_MISSING_PASSPHRASE(env,
833 ThrowCryptoError(env, ERR_get_error(), default_msg);
892 bool KeyObjectHandle::HasInstance(Environment* env, Local<Value> value) {
893 Local<FunctionTemplate> t = env->crypto_key_object_handle_constructor();
897 v8::Local<v8::Function> KeyObjectHandle::Initialize(Environment* env) {
898 Local<FunctionTemplate> templ = env->crypto_key_object_handle_constructor();
900 Isolate* isolate = env->isolate();
904 templ->Inherit(BaseObject::GetConstructorTemplate(env));
921 env->set_crypto_key_object_handle_constructor(templ);
923 return templ->GetFunction(env->context()).ToLocalChecked();
943 Environment* env,
946 Local<Function> ctor = KeyObjectHandle::Initialize(env);
947 CHECK(!env->crypto_key_object_handle_constructor().IsEmpty());
948 if (!ctor->NewInstance(env->context(), 0, nullptr).ToLocal(&obj))
963 Environment* env = Environment::GetCurrent(args);
964 new KeyObjectHandle(env, args.This());
967 KeyObjectHandle::KeyObjectHandle(Environment* env,
969 : BaseObject(env, wrap) {
1017 Environment* env = Environment::GetCurrent(args);
1030 if (!input->Get(env->context(), env->jwk_kty_string()).ToLocal(&kty) ||
1032 return THROW_ERR_CRYPTO_INVALID_JWK(env);
1035 Utf8Value kty_string(env->isolate(), kty);
1039 key->data_ = ImportJWKSecretKey(env, input);
1045 key->data_ = ImportJWKAsymmetricKey(env, input, *kty_string, args, 1);
1056 Environment* env = Environment::GetCurrent(args);
1061 Utf8Value name(env->isolate(), args[0]);
1071 ECPointPointer pub(ECDH::BufferToPoint(env, group, args[1]));
1094 Environment* env = Environment::GetCurrent(args);
1099 Utf8Value name(env->isolate(), args[0]);
1170 Environment* env = Environment::GetCurrent(args);
1171 return THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(env);
1184 Environment* env = Environment::GetCurrent(args);
1194 if (GetSecretKeyDetail(env, data, args[0].As<Object>()).IsNothing())
1200 if (GetAsymmetricKeyDetail(env, data, args[0].As<Object>()).IsNothing())
1214 return env()->crypto_rsa_string();
1216 return env()->crypto_rsa_pss_string();
1218 return env()->crypto_dsa_string();
1220 return env()->crypto_dh_string();
1222 return env()->crypto_ec_string();
1224 return env()->crypto_ed25519_string();
1226 return env()->crypto_ed448_string();
1228 return env()->crypto_x25519_string();
1230 return env()->crypto_x448_string();
1232 return Undefined(env()->isolate());
1315 return Buffer::Copy(env(), buf, len).FromMaybe(Local<Value>());
1320 return WritePublicKey(env(), data_->GetAsymmetricKey().get(), config);
1325 return WritePrivateKey(env(), data_->GetAsymmetricKey().get(), config);
1330 Environment* env = Environment::GetCurrent(args);
1337 ExportJWKInner(env, key->Data(), args[0], args[1]->IsTrue());
1342 void NativeKeyObject::Initialize(Environment* env, Local<Object> target) {
1343 SetMethod(env->context(),
1356 Environment* env = Environment::GetCurrent(args);
1360 new NativeKeyObject(env, args.This(), handle->Data());
1365 Environment* env = Environment::GetCurrent(args);
1366 Isolate* isolate = env->isolate();
1376 t->Inherit(BaseObject::GetConstructorTemplate(env));
1379 if (!t->GetFunction(env->context()).ToLocal(&ctor))
1382 Local<Value> recv = Undefined(env->isolate());
1385 env->context(), recv, 1, &ctor).ToLocal(&ret_v)) {
1389 if (!ret->Get(env->context(), 1).ToLocal(&ctor)) return;
1390 env->set_crypto_key_object_secret_constructor(ctor.As<Function>());
1391 if (!ret->Get(env->context(), 2).ToLocal(&ctor)) return;
1392 env->set_crypto_key_object_public_constructor(ctor.As<Function>());
1393 if (!ret->Get(env->context(), 3).ToLocal(&ctor)) return;
1394 env->set_crypto_key_object_private_constructor(ctor.As<Function>());
1399 Environment* env,
1402 if (context != env->context()) {
1403 THROW_ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE(env);
1408 if (!KeyObjectHandle::Create(env, data_).ToLocal(&handle))
1412 Local<Value> arg = FIXED_ONE_BYTE_STRING(env->isolate(),
1414 if (env->builtin_module_require()
1415 ->Call(context, Null(env->isolate()), 1, &arg)
1421 key_ctor = env->crypto_key_object_secret_constructor();
1424 key_ctor = env->crypto_key_object_public_constructor();
1427 key_ctor = env->crypto_key_object_private_constructor();
1482 void Initialize(Environment* env, Local<Object> target) {
1483 target->Set(env->context(),
1484 FIXED_ONE_BYTE_STRING(env->isolate(), "KeyObjectHandle"),
1485 KeyObjectHandle::Initialize(env)).Check();