GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — src: add mutex to ManagedEVPPKey class · nodejs/node@79d44ba

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

src/crypto

Expand file treeCollapse file tree

Open diff view settings

Collapse file

`‎src/crypto/crypto_dsa.cc‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_dsa.cc

+4-3Lines changed: 4 additions & 3 deletions

Original file line number	Diff line number	Diff line change
`@@ -133,11 +133,12 @@ Maybe<bool> GetDsaKeyDetail(`
`133`	`133`	`const BIGNUM* p; // Modulus length`
`134`	`134`	`const BIGNUM* q; // Divisor length`
`135`	`135`
`136`		`- ManagedEVPPKey pkey = key->GetAsymmetricKey();`
`137`		`- int type = EVP_PKEY_id(pkey.get());`
	`136`	`+ ManagedEVPPKey m_pkey = key->GetAsymmetricKey();`
	`137`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`138`	`+ int type = EVP_PKEY_id(m_pkey.get());`
`138`	`139`	`CHECK(type == EVP_PKEY_DSA);`
`139`	`140`
`140`		`- DSA* dsa = EVP_PKEY_get0_DSA(pkey.get());`
	`141`	`+ DSA* dsa = EVP_PKEY_get0_DSA(m_pkey.get());`
`141`	`142`	`CHECK_NOT_NULL(dsa);`
`142`	`143`
`143`	`144`	`DSA_get0_pqg(dsa, &p, &q, nullptr);`

Collapse file

`‎src/crypto/crypto_ec.cc‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_ec.cc

+12-8Lines changed: 12 additions & 8 deletions

Original file line number	Diff line number	Diff line change
`@@ -601,9 +601,11 @@ WebCryptoKeyExportStatus EC_Raw_Export(`
`601`	`601`	`KeyObjectData* key_data,`
`602`	`602`	`const ECKeyExportConfig& params,`
`603`	`603`	`ByteSource* out) {`
`604`		`- CHECK(key_data->GetAsymmetricKey());`
	`604`	`+ ManagedEVPPKey m_pkey = key_data->GetAsymmetricKey();`
	`605`	`+ CHECK(m_pkey);`
	`606`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
`605`	`607`
`606`		`- EC_KEY* ec_key = EVP_PKEY_get0_EC_KEY(key_data->GetAsymmetricKey().get());`
	`608`	`+ EC_KEY* ec_key = EVP_PKEY_get0_EC_KEY(m_pkey.get());`
`607`	`609`
`608`	`610`	`unsigned char* data;`
`609`	`611`	`size_t len = 0;`
`@@ -688,10 +690,11 @@ Maybe<bool> ExportJWKEcKey(`
`688`	`690`	`Environment* env,`
`689`	`691`	`std::shared_ptr<KeyObjectData> key,`
`690`	`692`	`Local<Object> target) {`
`691`		`- ManagedEVPPKey pkey = key->GetAsymmetricKey();`
`692`		`- CHECK_EQ(EVP_PKEY_id(pkey.get()), EVP_PKEY_EC);`
	`693`	`+ ManagedEVPPKey m_pkey = key->GetAsymmetricKey();`
	`694`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`695`	`+ CHECK_EQ(EVP_PKEY_id(m_pkey.get()), EVP_PKEY_EC);`
`693`	`696`
`694`		`- EC_KEY* ec = EVP_PKEY_get0_EC_KEY(pkey.get());`
	`697`	`+ EC_KEY* ec = EVP_PKEY_get0_EC_KEY(m_pkey.get());`
`695`	`698`	`CHECK_NOT_NULL(ec);`
`696`	`699`
`697`	`700`	`const EC_POINT* pub = EC_KEY_get0_public_key(ec);`
`@@ -893,10 +896,11 @@ Maybe<bool> GetEcKeyDetail(`
`893`	`896`	`Environment* env,`
`894`	`897`	`std::shared_ptr<KeyObjectData> key,`
`895`	`898`	`Local<Object> target) {`
`896`		`- ManagedEVPPKey pkey = key->GetAsymmetricKey();`
`897`		`- CHECK_EQ(EVP_PKEY_id(pkey.get()), EVP_PKEY_EC);`
	`899`	`+ ManagedEVPPKey m_pkey = key->GetAsymmetricKey();`
	`900`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`901`	`+ CHECK_EQ(EVP_PKEY_id(m_pkey.get()), EVP_PKEY_EC);`
`898`	`902`
`899`		`- EC_KEY* ec = EVP_PKEY_get0_EC_KEY(pkey.get());`
	`903`	`+ EC_KEY* ec = EVP_PKEY_get0_EC_KEY(m_pkey.get());`
`900`	`904`	`CHECK_NOT_NULL(ec);`
`901`	`905`
`902`	`906`	`const EC_GROUP* group = EC_KEY_get0_group(ec);`

Collapse file

`‎src/crypto/crypto_keys.cc‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_keys.cc

+15-3Lines changed: 15 additions & 3 deletions

Original file line number	Diff line number	Diff line change
`@@ -552,7 +552,8 @@ Maybe<bool> GetAsymmetricKeyDetail(`
`552`	`552`	`}`
`553`	`553`	`} // namespace`
`554`	`554`
`555`		`-ManagedEVPPKey::ManagedEVPPKey(EVPKeyPointer&& pkey) : pkey_(std::move(pkey)) {}`
	`555`	`+ManagedEVPPKey::ManagedEVPPKey(EVPKeyPointer&& pkey) : pkey_(std::move(pkey)),`
	`556`	`+ mutex_(std::make_shared<Mutex>()) {}`
`556`	`557`
`557`	`558`	`ManagedEVPPKey::ManagedEVPPKey(const ManagedEVPPKey& that) {`
`558`	`559`	`*this = that;`
`@@ -564,6 +565,8 @@ ManagedEVPPKey& ManagedEVPPKey::operator=(const ManagedEVPPKey& that) {`
`564`	`565`	`if (pkey_)`
`565`	`566`	`EVP_PKEY_up_ref(pkey_.get());`
`566`	`567`
	`568`	`+ mutex_ = that.mutex_;`
	`569`	`+`
`567`	`570`	`return *this;`
`568`	`571`	`}`
`569`	`572`
`@@ -575,6 +578,10 @@ EVP_PKEY* ManagedEVPPKey::get() const {`
`575`	`578`	`return pkey_.get();`
`576`	`579`	`}`
`577`	`580`
	`581`	`+Mutex* ManagedEVPPKey::mutex() const {`
	`582`	`+ return mutex_.get();`
	`583`	`+}`
	`584`	`+`
`578`	`585`	`void ManagedEVPPKey::MemoryInfo(MemoryTracker* tracker) const {`
`579`	`586`	`tracker->TrackFieldWithSize("pkey",`
`580`	`587`	`!pkey_ ? 0 : kSizeOf_EVP_PKEY +`
`@@ -1326,8 +1333,10 @@ WebCryptoKeyExportStatus PKEY_SPKI_Export(`
`1326`	`1333`	`KeyObjectData* key_data,`
`1327`	`1334`	`ByteSource* out) {`
`1328`	`1335`	`CHECK_EQ(key_data->GetKeyType(), kKeyTypePublic);`
	`1336`	`+ ManagedEVPPKey m_pkey = key_data->GetAsymmetricKey();`
	`1337`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
`1329`	`1338`	`BIOPointer bio(BIO_new(BIO_s_mem()));`
`1330`		`- if (!i2d_PUBKEY_bio(bio.get(), key_data->GetAsymmetricKey().get()))`
	`1339`	`+ if (!i2d_PUBKEY_bio(bio.get(), m_pkey.get()))`
`1331`	`1340`	`return WebCryptoKeyExportStatus::FAILED;`
`1332`	`1341`
`1333`	`1342`	`*out = ByteSource::FromBIO(bio);`
`@@ -1338,8 +1347,11 @@ WebCryptoKeyExportStatus PKEY_PKCS8_Export(`
`1338`	`1347`	`KeyObjectData* key_data,`
`1339`	`1348`	`ByteSource* out) {`
`1340`	`1349`	`CHECK_EQ(key_data->GetKeyType(), kKeyTypePrivate);`
	`1350`	`+ ManagedEVPPKey m_pkey = key_data->GetAsymmetricKey();`
	`1351`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`1352`	`+`
`1341`	`1353`	`BIOPointer bio(BIO_new(BIO_s_mem()));`
`1342`		`- PKCS8Pointer p8inf(EVP_PKEY2PKCS8(key_data->GetAsymmetricKey().get()));`
	`1354`	`+ PKCS8Pointer p8inf(EVP_PKEY2PKCS8(m_pkey.get()));`
`1343`	`1355`	`if (!i2d_PKCS8_PRIV_KEY_INFO_bio(bio.get(), p8inf.get()))`
`1344`	`1356`	`return WebCryptoKeyExportStatus::FAILED;`
`1345`	`1357`

Collapse file

`‎src/crypto/crypto_keys.h‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_keys.h

+2Lines changed: 2 additions & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,7 @@ class ManagedEVPPKey : public MemoryRetainer {`
`81`	`81`
`82`	`82`	`operator bool() const;`
`83`	`83`	`EVP_PKEY* get() const;`
	`84`	`+ Mutex* mutex() const;`
`84`	`85`
`85`	`86`	`void MemoryInfo(MemoryTracker* tracker) const override;`
`86`	`87`	`SET_MEMORY_INFO_NAME(ManagedEVPPKey)`
`@@ -127,6 +128,7 @@ class ManagedEVPPKey : public MemoryRetainer {`
`127`	`128`	`size_t size_of_public_key() const;`
`128`	`129`
`129`	`130`	`EVPKeyPointer pkey_;`
	`131`	`+ std::shared_ptr<Mutex> mutex_;`
`130`	`132`	`};`
`131`	`133`
`132`	`134`	`// Objects of this class can safely be shared among threads.`

Collapse file

`‎src/crypto/crypto_rsa.cc‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_rsa.cc

+13-10Lines changed: 13 additions & 10 deletions

Original file line number	Diff line number	Diff line change
`@@ -191,9 +191,10 @@ WebCryptoCipherStatus RSA_Cipher(`
`191`	`191`	`const ByteSource& in,`
`192`	`192`	`ByteSource* out) {`
`193`	`193`	`CHECK_NE(key_data->GetKeyType(), kKeyTypeSecret);`
	`194`	`+ ManagedEVPPKey m_pkey = key_data->GetAsymmetricKey();`
	`195`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
`194`	`196`
`195`		`- EVPKeyCtxPointer ctx(`
`196`		`- EVP_PKEY_CTX_new(key_data->GetAsymmetricKey().get(), nullptr));`
	`197`	`+ EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new(m_pkey.get(), nullptr));`
`197`	`198`
`198`	`199`	`if (!ctx \|\| init(ctx.get()) <= 0)`
`199`	`200`	`return WebCryptoCipherStatus::FAILED;`
`@@ -363,17 +364,18 @@ Maybe<bool> ExportJWKRsaKey(`
`363`	`364`	`Environment* env,`
`364`	`365`	`std::shared_ptr<KeyObjectData> key,`
`365`	`366`	`Local<Object> target) {`
`366`		`- ManagedEVPPKey pkey = key->GetAsymmetricKey();`
`367`		`- int type = EVP_PKEY_id(pkey.get());`
	`367`	`+ ManagedEVPPKey m_pkey = key->GetAsymmetricKey();`
	`368`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`369`	`+ int type = EVP_PKEY_id(m_pkey.get());`
`368`	`370`	`CHECK(type == EVP_PKEY_RSA \|\| type == EVP_PKEY_RSA_PSS);`
`369`	`371`
`370`	`372`	`// TODO(tniessen): Remove the "else" branch once we drop support for OpenSSL`
`371`	`373`	`// versions older than 1.1.1e via FIPS / dynamic linking.`
`372`	`374`	`RSA* rsa;`
`373`	`375`	`if (OpenSSL_version_num() >= 0x1010105fL) {`
`374`		`- rsa = EVP_PKEY_get0_RSA(pkey.get());`
	`376`	`+ rsa = EVP_PKEY_get0_RSA(m_pkey.get());`
`375`	`377`	`} else {`
`376`		`- rsa = static_cast<RSA*>(EVP_PKEY_get0(pkey.get()));`
	`378`	`+ rsa = static_cast<RSA*>(EVP_PKEY_get0(m_pkey.get()));`
`377`	`379`	`}`
`378`	`380`	`CHECK_NOT_NULL(rsa);`
`379`	`381`
`@@ -511,17 +513,18 @@ Maybe<bool> GetRsaKeyDetail(`
`511`	`513`	`const BIGNUM* e; // Public Exponent`
`512`	`514`	`const BIGNUM* n; // Modulus`
`513`	`515`
`514`		`- ManagedEVPPKey pkey = key->GetAsymmetricKey();`
`515`		`- int type = EVP_PKEY_id(pkey.get());`
	`516`	`+ ManagedEVPPKey m_pkey = key->GetAsymmetricKey();`
	`517`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`518`	`+ int type = EVP_PKEY_id(m_pkey.get());`
`516`	`519`	`CHECK(type == EVP_PKEY_RSA \|\| type == EVP_PKEY_RSA_PSS);`
`517`	`520`
`518`	`521`	`// TODO(tniessen): Remove the "else" branch once we drop support for OpenSSL`
`519`	`522`	`// versions older than 1.1.1e via FIPS / dynamic linking.`
`520`	`523`	`RSA* rsa;`
`521`	`524`	`if (OpenSSL_version_num() >= 0x1010105fL) {`
`522`		`- rsa = EVP_PKEY_get0_RSA(pkey.get());`
	`525`	`+ rsa = EVP_PKEY_get0_RSA(m_pkey.get());`
`523`	`526`	`} else {`
`524`		`- rsa = static_cast<RSA*>(EVP_PKEY_get0(pkey.get()));`
	`527`	`+ rsa = static_cast<RSA*>(EVP_PKEY_get0(m_pkey.get()));`
`525`	`528`	`}`
`526`	`529`	`CHECK_NOT_NULL(rsa);`
`527`	`530`

Collapse file

`‎src/crypto/crypto_sig.cc‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_sig.cc

+13-11Lines changed: 13 additions & 11 deletions

Original file line number	Diff line number	Diff line change
`@@ -96,9 +96,9 @@ AllocatedBuffer Node_SignFinal(Environment* env,`
`96`	`96`	`return AllocatedBuffer();`
`97`	`97`	`}`
`98`	`98`
`99`		`-int GetDefaultSignPadding(const ManagedEVPPKey& key) {`
`100`		`- return EVP_PKEY_id(key.get()) == EVP_PKEY_RSA_PSS ? RSA_PKCS1_PSS_PADDING :`
`101`		`- RSA_PKCS1_PADDING;`
	`99`	`+int GetDefaultSignPadding(const ManagedEVPPKey& m_pkey) {`
	`100`	`+ return EVP_PKEY_id(m_pkey.get()) == EVP_PKEY_RSA_PSS ? RSA_PKCS1_PSS_PADDING :`
	`101`	`+ RSA_PKCS1_PADDING;`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`unsigned int GetBytesOfRS(const ManagedEVPPKey& pkey) {`
`@@ -752,11 +752,11 @@ Maybe<bool> SignTraits::AdditionalConfig(`
`752`	`752`	`}`
`753`	`753`	`// If this is an EC key (assuming ECDSA) we need to convert the`
`754`	`754`	`// the signature from WebCrypto format into DER format...`
`755`		`- if (EVP_PKEY_id(params->key->GetAsymmetricKey().get()) == EVP_PKEY_EC) {`
	`755`	`+ ManagedEVPPKey m_pkey = params->key->GetAsymmetricKey();`
	`756`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
	`757`	`+ if (EVP_PKEY_id(m_pkey.get()) == EVP_PKEY_EC) {`
`756`	`758`	`params->signature =`
`757`		`- ConvertFromWebCryptoSignature(`
`758`		`- params->key->GetAsymmetricKey(),`
`759`		`- signature.ToByteSource());`
	`759`	`+ ConvertFromWebCryptoSignature(m_pkey, signature.ToByteSource());`
`760`	`760`	`} else {`
`761`	`761`	`params->signature = mode == kCryptoJobAsync`
`762`	`762`	`? signature.ToCopy()`
`@@ -774,6 +774,8 @@ bool SignTraits::DeriveBits(`
`774`	`774`	`EVPMDPointer context(EVP_MD_CTX_new());`
`775`	`775`	`EVP_PKEY_CTX* ctx = nullptr;`
`776`	`776`
	`777`	`+ ManagedEVPPKey m_pkey = params.key->GetAsymmetricKey();`
	`778`	`+ Mutex::ScopedLock lock(*m_pkey.mutex());`
`777`	`779`	`switch (params.mode) {`
`778`	`780`	`case SignConfiguration::kSign:`
`779`	`781`	`CHECK_EQ(params.key->GetKeyType(), kKeyTypePrivate);`
`@@ -782,7 +784,7 @@ bool SignTraits::DeriveBits(`
`782`	`784`	`&ctx,`
`783`	`785`	`params.digest,`
`784`	`786`	`nullptr,`
`785`		`- params.key->GetAsymmetricKey().get())) {`
	`787`	`+ m_pkey.get())) {`
`786`	`788`	`return false;`
`787`	`789`	`}`
`788`	`790`	`break;`
`@@ -793,21 +795,21 @@ bool SignTraits::DeriveBits(`
`793`	`795`	`&ctx,`
`794`	`796`	`params.digest,`
`795`	`797`	`nullptr,`
`796`		`- params.key->GetAsymmetricKey().get())) {`
	`798`	`+ m_pkey.get())) {`
`797`	`799`	`return false;`
`798`	`800`	`}`
`799`	`801`	`break;`
`800`	`802`	`}`
`801`	`803`
`802`	`804`	`int padding = params.flags & SignConfiguration::kHasPadding`
`803`	`805`	`? params.padding`
`804`		`- : GetDefaultSignPadding(params.key->GetAsymmetricKey());`
	`806`	`+ : GetDefaultSignPadding(m_pkey);`
`805`	`807`
`806`	`808`	`Maybe<int> salt_length = params.flags & SignConfiguration::kHasSaltLength`
`807`	`809`	`? Just<int>(params.salt_length) : Nothing<int>();`
`808`	`810`
`809`	`811`	`if (!ApplyRSAOptions(`
`810`		`- params.key->GetAsymmetricKey(),`
	`812`	`+ m_pkey,`
`811`	`813`	`ctx,`
`812`	`814`	`padding,`
`813`	`815`	`salt_length)) {`

0 commit comments

Comments

0 (0)

You are visitor 01402520 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.