1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

src: use EVPKeyPointer in more places

Browse Source 
Rejoice, the code base is now free of manual EVP_PKEY_free() calls!

PR-URL: https://github.com/nodejs/node/pull/26632
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
This commit is contained in:
Ben Noordhuis 2019-03-13 11:46:47 +01:00 committed by Daniel Bevenius
parent 0f745bf9bd
commit 36101558fd
2 changed files with 33 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/node_crypto.cc
View File

@ -2233,16 +2233,17 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
Local<Object> info = Object::New(env->isolate()); Local<Object> info = Object::New(env->isolate());
EVP_PKEY* key; EVP_PKEY* raw_key;
if (SSL_get_server_tmp_key(w->ssl_.get(), &raw_key)) {
if (SSL_get_server_tmp_key(w->ssl_.get(), &key)) { EVPKeyPointer key(raw_key);
int kid = EVP_PKEY_id(key); int kid = EVP_PKEY_id(key.get());
switch (kid) { switch (kid) {
case EVP_PKEY_DH: case EVP_PKEY_DH:
info->Set(context, env->type_string(), info->Set(context, env->type_string(),
FIXED_ONE_BYTE_STRING(env->isolate(), "DH")).FromJust(); FIXED_ONE_BYTE_STRING(env->isolate(), "DH")).FromJust();
info->Set(context, env->size_string(), info->Set(context, env->size_string(),
Integer::New(env->isolate(), EVP_PKEY_bits(key))).FromJust(); Integer::New(env->isolate(), EVP_PKEY_bits(key.get())))
.FromJust();
break; break;
case EVP_PKEY_EC: case EVP_PKEY_EC:
// TODO(shigeki) Change this to EVP_PKEY_X25519 and add EVP_PKEY_X448 // TODO(shigeki) Change this to EVP_PKEY_X25519 and add EVP_PKEY_X448
@ -2251,7 +2252,7 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
{ {
const char* curve_name; const char* curve_name;
if (kid == EVP_PKEY_EC) { if (kid == EVP_PKEY_EC) {
EC_KEY* ec = EVP_PKEY_get1_EC_KEY(key); EC_KEY* ec = EVP_PKEY_get1_EC_KEY(key.get());
int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec)); int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
curve_name = OBJ_nid2sn(nid); curve_name = OBJ_nid2sn(nid);
EC_KEY_free(ec); EC_KEY_free(ec);
@ -2265,11 +2266,10 @@ void SSLWrap<Base>::GetEphemeralKeyInfo(
curve_name)).FromJust(); curve_name)).FromJust();
info->Set(context, env->size_string(), info->Set(context, env->size_string(),
Integer::New(env->isolate(), Integer::New(env->isolate(),
EVP_PKEY_bits(key))).FromJust(); EVP_PKEY_bits(key.get()))).FromJust();
} }
break; break;
} }
EVP_PKEY_free(key);
} }
return args.GetReturnValue().Set(info); return args.GetReturnValue().Set(info);
@ -3138,7 +3138,7 @@ static ManagedEVPPKey GetPrivateKeyFromJs(
ParsePrivateKey(config.Release(), key.get(), key.size()); ParsePrivateKey(config.Release(), key.get(), key.size());
if (!pkey) if (!pkey)
ThrowCryptoError(env, ERR_get_error(), "Failed to read private key"); ThrowCryptoError(env, ERR_get_error(), "Failed to read private key");
return ManagedEVPPKey(pkey.release()); return ManagedEVPPKey(std::move(pkey));
} else { } else {
CHECK(args[*offset]->IsObject() && allow_key_object); CHECK(args[*offset]->IsObject() && allow_key_object);
KeyObject* key; KeyObject* key;
@ -3197,7 +3197,7 @@ static ManagedEVPPKey GetPublicOrPrivateKeyFromJs(
} }
if (!pkey) if (!pkey)
ThrowCryptoError(env, ERR_get_error(), "Failed to read asymmetric key"); ThrowCryptoError(env, ERR_get_error(), "Failed to read asymmetric key");
return ManagedEVPPKey(pkey.release()); return ManagedEVPPKey(std::move(pkey));
} else { } else {
CHECK(args[*offset]->IsObject()); CHECK(args[*offset]->IsObject());
KeyObject* key = Unwrap<KeyObject>(args[*offset].As<Object>()); KeyObject* key = Unwrap<KeyObject>(args[*offset].As<Object>());
@ -3287,42 +3287,27 @@ static MaybeLocal<Value> WritePrivateKey(
return BIOToStringOrBuffer(env, bio.get(), config.format_); return BIOToStringOrBuffer(env, bio.get(), config.format_);
} }
ManagedEVPPKey::ManagedEVPPKey() : pkey_(nullptr) {} ManagedEVPPKey::ManagedEVPPKey(EVPKeyPointer&& pkey) : pkey_(std::move(pkey)) {}
ManagedEVPPKey::ManagedEVPPKey(EVP_PKEY* pkey) : pkey_(pkey) {} ManagedEVPPKey::ManagedEVPPKey(const ManagedEVPPKey& that) {
*this = that;
ManagedEVPPKey::ManagedEVPPKey(const ManagedEVPPKey& key) : pkey_(nullptr) {
*this = key;
} }
ManagedEVPPKey::ManagedEVPPKey(ManagedEVPPKey&& key) { ManagedEVPPKey& ManagedEVPPKey::operator=(const ManagedEVPPKey& that) {
*this = key; pkey_.reset(that.get());
}
ManagedEVPPKey::~ManagedEVPPKey() { if (pkey_)
EVP_PKEY_free(pkey_); EVP_PKEY_up_ref(pkey_.get());
}
ManagedEVPPKey& ManagedEVPPKey::operator=(const ManagedEVPPKey& key) {
EVP_PKEY_free(pkey_);
pkey_ = key.pkey_;
EVP_PKEY_up_ref(pkey_);
return *this;
}
ManagedEVPPKey& ManagedEVPPKey::operator=(ManagedEVPPKey&& key) {
EVP_PKEY_free(pkey_);
pkey_ = key.pkey_;
key.pkey_ = nullptr;
return *this; return *this;
} }
ManagedEVPPKey::operator bool() const { ManagedEVPPKey::operator bool() const {
return pkey_ != nullptr; return !!pkey_;
} }
EVP_PKEY* ManagedEVPPKey::get() const { EVP_PKEY* ManagedEVPPKey::get() const {
return pkey_; return pkey_.get();
} }
Local<Function> KeyObject::Initialize(Environment* env, Local<Object> target) { Local<Function> KeyObject::Initialize(Environment* env, Local<Object> target) {
@ -5704,13 +5689,13 @@ class DSAKeyPairGenerationConfig : public KeyPairGenerationConfig {
} }
} }
EVP_PKEY* params = nullptr; EVP_PKEY* raw_params = nullptr;
if (EVP_PKEY_paramgen(param_ctx.get(), &params) <= 0) if (EVP_PKEY_paramgen(param_ctx.get(), &raw_params) <= 0)
return nullptr; return nullptr;
EVPKeyPointer params(raw_params);
param_ctx.reset(); param_ctx.reset();
EVPKeyCtxPointer key_ctx(EVP_PKEY_CTX_new(params, nullptr)); EVPKeyCtxPointer key_ctx(EVP_PKEY_CTX_new(params.get(), nullptr));
EVP_PKEY_free(params);
return key_ctx; return key_ctx;
} }
@ -5739,13 +5724,13 @@ class ECKeyPairGenerationConfig : public KeyPairGenerationConfig {
if (EVP_PKEY_CTX_set_ec_param_enc(param_ctx.get(), param_encoding_) <= 0) if (EVP_PKEY_CTX_set_ec_param_enc(param_ctx.get(), param_encoding_) <= 0)
return nullptr; return nullptr;
EVP_PKEY* params = nullptr; EVP_PKEY* raw_params = nullptr;
if (EVP_PKEY_paramgen(param_ctx.get(), &params) <= 0) if (EVP_PKEY_paramgen(param_ctx.get(), &raw_params) <= 0)
return nullptr; return nullptr;
EVPKeyPointer params(raw_params);
param_ctx.reset(); param_ctx.reset();
EVPKeyCtxPointer key_ctx(EVP_PKEY_CTX_new(params, nullptr)); EVPKeyCtxPointer key_ctx(EVP_PKEY_CTX_new(params.get(), nullptr));
EVP_PKEY_free(params);
return key_ctx; return key_ctx;
} }
@ -5793,7 +5778,7 @@ class GenerateKeyPairJob : public CryptoJob {
EVP_PKEY* pkey = nullptr; EVP_PKEY* pkey = nullptr;
if (EVP_PKEY_keygen(ctx.get(), &pkey) != 1) if (EVP_PKEY_keygen(ctx.get(), &pkey) != 1)
return false; return false;
pkey_ = ManagedEVPPKey(pkey); pkey_ = ManagedEVPPKey(EVPKeyPointer(pkey));
return true; return true;
} }

14
src/node_crypto.h
View File

@ -421,20 +421,16 @@ enum KeyType {
// use. // use.
class ManagedEVPPKey { class ManagedEVPPKey {
public: public:
ManagedEVPPKey(); ManagedEVPPKey() = default;
explicit ManagedEVPPKey(EVP_PKEY* pkey); explicit ManagedEVPPKey(EVPKeyPointer&& pkey);
ManagedEVPPKey(const ManagedEVPPKey& key); ManagedEVPPKey(const ManagedEVPPKey& that);
ManagedEVPPKey(ManagedEVPPKey&& key); ManagedEVPPKey& operator=(const ManagedEVPPKey& that);
~ManagedEVPPKey();
ManagedEVPPKey& operator=(const ManagedEVPPKey& key);
ManagedEVPPKey& operator=(ManagedEVPPKey&& key);
operator bool() const; operator bool() const;
EVP_PKEY* get() const; EVP_PKEY* get() const;
private: private:
EVP_PKEY* pkey_; EVPKeyPointer pkey_;
}; };
class KeyObject : public BaseObject { class KeyObject : public BaseObject {