From a00c3b10514c910f260d87b0898ed7c1f2f7912f Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 16:32:40 +0100
Subject: [PATCH 01/15] crypto: add KeyObject.prototype.equals method

---
 doc/api/crypto.md                        | 11 +++++++
 lib/internal/crypto/keys.js              | 10 ++++++
 src/crypto/crypto_keys.cc                | 38 +++++++++++++++++++++++
 src/crypto/crypto_keys.h                 |  1 +
 test/parallel/test-crypto-key-objects.js | 39 ++++++++++++++++++++++++
 5 files changed, 99 insertions(+)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 470c8f6641839a..f716deb3cae058 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2082,6 +2082,17 @@ encryption mechanism, PEM-level encryption is not supported when encrypting
 a PKCS#8 key. See [RFC 5208][] for PKCS#8 encryption and [RFC 1421][] for
 PKCS#1 and SEC1 encryption.
 
+### `keyObject.equals(otherKeyObject)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `otherKeyObject`: {KeyObject} A `KeyObject` with which to
+  compare `keyObject`.
+* Returns: {boolean} `true` or `false` depending on the whether the
+  keys have exactly the same type, value, and parameters.
+
 ### `keyObject.symmetricKeySize`
 
 <!-- YAML
diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js
index ea2ecc262ed665..5c9f1fd0926506 100644
--- a/lib/internal/crypto/keys.js
+++ b/lib/internal/crypto/keys.js
@@ -124,6 +124,16 @@ const {
         throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
       return key[kKeyObject];
     }
+
+    equals(otherKeyObject) {
+      if (!isKeyObject(otherKeyObject)) {
+        throw new ERR_INVALID_ARG_TYPE(
+          'otherKeyObject', 'KeyObject', otherKeyObject);
+      }
+
+      return otherKeyObject.type === this.type &&
+        this[kHandle].equals(otherKeyObject[kHandle]);
+    }
   }
 
   class SecretKeyObject extends KeyObject {
diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index c5b3e6b37183fd..14214ccc965e3b 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -921,6 +921,7 @@ v8::Local<v8::Function> KeyObjectHandle::Initialize(Environment* env) {
   env->SetProtoMethod(t, "initEDRaw", InitEDRaw);
   env->SetProtoMethod(t, "initJwk", InitJWK);
   env->SetProtoMethod(t, "keyDetail", GetKeyDetail);
+  env->SetProtoMethod(t, "equals", Equals);
 
   auto function = t->GetFunction(env->context()).ToLocalChecked();
   env->set_crypto_key_object_handle_constructor(function);
@@ -939,6 +940,7 @@ void KeyObjectHandle::RegisterExternalReferences(
   registry->Register(InitEDRaw);
   registry->Register(InitJWK);
   registry->Register(GetKeyDetail);
+  registry->Register(Equals);
 }
 
 MaybeLocal<Object> KeyObjectHandle::Create(
@@ -1134,6 +1136,42 @@ void KeyObjectHandle::InitEDRaw(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(true);
 }
 
+void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
+  std::shared_ptr<KeyObjectData> key =
+    Unwrap<KeyObjectHandle>(args.Holder())->Data();
+  std::shared_ptr<KeyObjectData> key2 =
+    Unwrap<KeyObjectHandle>(args[0].As<Object>())->Data();
+
+  KeyType keyType = key->GetKeyType();
+  CHECK_EQ(keyType, key2->GetKeyType());
+
+  bool ret;
+  switch (keyType) {
+    case kKeyTypeSecret: {
+      size_t size = key->GetSymmetricKeySize();
+      if (size == key2->GetSymmetricKeySize())
+        ret = CRYPTO_memcmp(
+          key->GetSymmetricKey(),
+          key2->GetSymmetricKey(),
+          key->GetSymmetricKeySize()) == 0;
+      else
+        ret = false;
+      break;
+    }
+    case kKeyTypePublic:
+      // Fall through
+    case kKeyTypePrivate:
+      ret = EVP_PKEY_eq(
+        key->GetAsymmetricKey().get(),
+        key2->GetAsymmetricKey().get()) == 1;
+      break;
+    default:
+      CHECK(false);
+  }
+
+  args.GetReturnValue().Set(ret);
+}
+
 void KeyObjectHandle::GetKeyDetail(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   KeyObjectHandle* key;
diff --git a/src/crypto/crypto_keys.h b/src/crypto/crypto_keys.h
index 48d38cd20b0899..d06565d8ad74a3 100644
--- a/src/crypto/crypto_keys.h
+++ b/src/crypto/crypto_keys.h
@@ -189,6 +189,7 @@ class KeyObjectHandle : public BaseObject {
   static void InitEDRaw(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void InitJWK(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetKeyDetail(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Equals(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void ExportJWK(const v8::FunctionCallbackInfo<v8::Value>& args);
 
diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js
index c564c4dcb43fac..5fd60a19384f86 100644
--- a/test/parallel/test-crypto-key-objects.js
+++ b/test/parallel/test-crypto-key-objects.js
@@ -21,6 +21,7 @@ const {
   privateDecrypt,
   privateEncrypt,
   getCurves,
+  generateKeySync,
   generateKeyPairSync,
   webcrypto,
 } = require('crypto');
@@ -846,3 +847,41 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
     assert(!isKeyObject(cryptoKey));
   });
 }
+
+{
+  const first = Buffer.from('Hello');
+  const second = Buffer.from('World');
+  const keyObject = createSecretKey(first);
+  assert(createSecretKey(first).equals(createSecretKey(first)));
+  assert(!createSecretKey(first).equals(createSecretKey(second)));
+
+  assert.throws(() => keyObject.equals(0), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: `The "otherKeyObject" argument must be an instance of KeyObject. Received type number (0)`
+  });
+
+  assert(keyObject.equals(keyObject));
+  assert(!keyObject.equals(createPublicKey(publicPem)));
+  assert(!keyObject.equals(createPrivateKey(privatePem)));
+}
+
+{
+  const first = generateKeyPairSync('ed25519');
+  const second = generateKeyPairSync('ed25519');
+  const secret = generateKeySync('aes', { length: 128 });
+
+  assert(first.publicKey.equals(first.publicKey));
+  assert(first.publicKey.equals(createPublicKey(
+    first.publicKey.export({ format: 'pem', type: 'spki' }))));
+  assert(!first.publicKey.equals(second.publicKey));
+  assert(!first.publicKey.equals(second.privateKey));
+  assert(!first.publicKey.equals(secret));
+
+  assert(first.privateKey.equals(first.privateKey));
+  assert(first.privateKey.equals(createPrivateKey(
+    first.privateKey.export({ format: 'pem', type: 'pkcs8' }))));
+  assert(!first.privateKey.equals(second.privateKey));
+  assert(!first.privateKey.equals(second.publicKey));
+  assert(!first.privateKey.equals(secret));
+}

From 143a4df3397ca86a6dc065d774b20bb8133ba751 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 16:41:45 +0100
Subject: [PATCH 02/15] fixup! crypto: add KeyObject.prototype.equals method

---
 test/parallel/test-crypto-key-objects.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js
index 5fd60a19384f86..bcd647e4d6bdc8 100644
--- a/test/parallel/test-crypto-key-objects.js
+++ b/test/parallel/test-crypto-key-objects.js
@@ -858,7 +858,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
   assert.throws(() => keyObject.equals(0), {
     name: 'TypeError',
     code: 'ERR_INVALID_ARG_TYPE',
-    message: `The "otherKeyObject" argument must be an instance of KeyObject. Received type number (0)`
+    message: 'The "otherKeyObject" argument must be an instance of KeyObject. Received type number (0)'
   });
 
   assert(keyObject.equals(keyObject));

From ed355764abe264f359839936155692345b0b9b0d Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 16:49:43 +0100
Subject: [PATCH 03/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index 14214ccc965e3b..a7dc5bd02c137a 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1153,7 +1153,7 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
         ret = CRYPTO_memcmp(
           key->GetSymmetricKey(),
           key2->GetSymmetricKey(),
-          key->GetSymmetricKeySize()) == 0;
+          size) == 0;
       else
         ret = false;
       break;

From 321750a62736fc93aedaa4fc2c56c655d995e012 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 16:56:35 +0100
Subject: [PATCH 04/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc                | 10 +++++++---
 test/parallel/test-crypto-key-objects.js | 17 +++++++++++++++++
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index a7dc5bd02c137a..7b0431e6d3a21a 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1161,9 +1161,13 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
     case kKeyTypePublic:
       // Fall through
     case kKeyTypePrivate:
-      ret = EVP_PKEY_eq(
-        key->GetAsymmetricKey().get(),
-        key2->GetAsymmetricKey().get()) == 1;
+      if (EVP_PKEY_id(key->GetAsymmetricKey().get()) ==
+        EVP_PKEY_id(key2->GetAsymmetricKey().get())) {
+        ret = EVP_PKEY_eq(
+          key->GetAsymmetricKey().get(),
+          key2->GetAsymmetricKey().get()) == 1;
+      } else {ret = false;
+      }
       break;
     default:
       CHECK(false);
diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js
index bcd647e4d6bdc8..d5151884a5678f 100644
--- a/test/parallel/test-crypto-key-objects.js
+++ b/test/parallel/test-crypto-key-objects.js
@@ -885,3 +885,20 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
   assert(!first.privateKey.equals(second.publicKey));
   assert(!first.privateKey.equals(secret));
 }
+
+{
+  const first = generateKeyPairSync('ed25519');
+  const second = generateKeyPairSync('ed448');
+
+  assert(first.publicKey.equals(first.publicKey));
+  assert(first.publicKey.equals(createPublicKey(
+    first.publicKey.export({ format: 'pem', type: 'spki' }))));
+  assert(!first.publicKey.equals(second.publicKey));
+  assert(!first.publicKey.equals(second.privateKey));
+
+  assert(first.privateKey.equals(first.privateKey));
+  assert(first.privateKey.equals(createPrivateKey(
+    first.privateKey.export({ format: 'pem', type: 'pkcs8' }))));
+  assert(!first.privateKey.equals(second.privateKey));
+  assert(!first.privateKey.equals(second.publicKey));
+}

From e5c75a8a91e0cddda4238e288c7044dcffcc465b Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 16:59:32 +0100
Subject: [PATCH 05/15] fixup! crypto: add KeyObject.prototype.equals method

---
 test/parallel/test-crypto-key-objects.js | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js
index d5151884a5678f..e543ff730dce6b 100644
--- a/test/parallel/test-crypto-key-objects.js
+++ b/test/parallel/test-crypto-key-objects.js
@@ -890,15 +890,8 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
   const first = generateKeyPairSync('ed25519');
   const second = generateKeyPairSync('ed448');
 
-  assert(first.publicKey.equals(first.publicKey));
-  assert(first.publicKey.equals(createPublicKey(
-    first.publicKey.export({ format: 'pem', type: 'spki' }))));
   assert(!first.publicKey.equals(second.publicKey));
   assert(!first.publicKey.equals(second.privateKey));
-
-  assert(first.privateKey.equals(first.privateKey));
-  assert(first.privateKey.equals(createPrivateKey(
-    first.privateKey.export({ format: 'pem', type: 'pkcs8' }))));
   assert(!first.privateKey.equals(second.privateKey));
   assert(!first.privateKey.equals(second.publicKey));
 }

From d78b7d3e83e6c5ee44aa81aa214d022a71a0671e Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 17:01:49 +0100
Subject: [PATCH 06/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index 7b0431e6d3a21a..516d97d5af3dcc 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1166,7 +1166,8 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
         ret = EVP_PKEY_eq(
           key->GetAsymmetricKey().get(),
           key2->GetAsymmetricKey().get()) == 1;
-      } else {ret = false;
+      } else {
+        ret = false;
       }
       break;
     default:

From 127d8db89c27a60bd386c7fd1e4d0a22d6960e16 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 17:24:23 +0100
Subject: [PATCH 07/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index 516d97d5af3dcc..e8bedcdc3f5fd9 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1160,16 +1160,15 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
     }
     case kKeyTypePublic:
       // Fall through
-    case kKeyTypePrivate:
-      if (EVP_PKEY_id(key->GetAsymmetricKey().get()) ==
-        EVP_PKEY_id(key2->GetAsymmetricKey().get())) {
-        ret = EVP_PKEY_eq(
-          key->GetAsymmetricKey().get(),
-          key2->GetAsymmetricKey().get()) == 1;
-      } else {
+    case kKeyTypePrivate: {
+      EVP_PKEY* fkey = key->GetAsymmetricKey().get();
+      EVP_PKEY* fkey2 = key2->GetAsymmetricKey().get();
+      if (EVP_PKEY_id(fkey) == EVP_PKEY_id(fkey2))
+        ret = EVP_PKEY_eq(fkey, fkey2) == 1;
+      else
         ret = false;
-      }
       break;
+    }
     default:
       CHECK(false);
   }

From 5da90270b98687a132f43005e3b3c89cde7e07e5 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 18:44:06 +0100
Subject: [PATCH 08/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index e8bedcdc3f5fd9..0ebafb24c01bdb 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1161,12 +1161,17 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
     case kKeyTypePublic:
       // Fall through
     case kKeyTypePrivate: {
-      EVP_PKEY* fkey = key->GetAsymmetricKey().get();
-      EVP_PKEY* fkey2 = key2->GetAsymmetricKey().get();
-      if (EVP_PKEY_id(fkey) == EVP_PKEY_id(fkey2))
-        ret = EVP_PKEY_eq(fkey, fkey2) == 1;
-      else
+      EVP_PKEY* pkey = key->GetAsymmetricKey().get();
+      EVP_PKEY* pkey2 = key2->GetAsymmetricKey().get();
+      if (EVP_PKEY_id(pkey) == EVP_PKEY_id(pkey2)) {
+        #if OPENSSL_VERSION_MAJOR >= 3
+          ret = EVP_PKEY_eq(pkey, pkey2) == 1;
+        #else
+          ret = EVP_PKEY_cmp(pkey, pkey2) == 1;
+        #endif
+      } else {
         ret = false;
+      }
       break;
     }
     default:

From a8ce83238560e9782e03285d18d8c4636cf385aa Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 18:46:18 +0100
Subject: [PATCH 09/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index 0ebafb24c01bdb..2af1f63daf5058 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1164,11 +1164,11 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
       EVP_PKEY* pkey = key->GetAsymmetricKey().get();
       EVP_PKEY* pkey2 = key2->GetAsymmetricKey().get();
       if (EVP_PKEY_id(pkey) == EVP_PKEY_id(pkey2)) {
-        #if OPENSSL_VERSION_MAJOR >= 3
+#if OPENSSL_VERSION_MAJOR >= 3
           ret = EVP_PKEY_eq(pkey, pkey2) == 1;
-        #else
+#else
           ret = EVP_PKEY_cmp(pkey, pkey2) == 1;
-        #endif
+#endif
       } else {
         ret = false;
       }

From 547c50f1403f1e1c19cf3ffa1e724e653852d51a Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 18:49:59 +0100
Subject: [PATCH 10/15] fixup! crypto: add KeyObject.prototype.equals method

Co-authored-by: Mestery <mestery@protonmail.com>
---
 doc/api/crypto.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index f716deb3cae058..463435749193ce 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2090,7 +2090,7 @@ added: REPLACEME
 
 * `otherKeyObject`: {KeyObject} A `KeyObject` with which to
   compare `keyObject`.
-* Returns: {boolean} `true` or `false` depending on the whether the
+* Returns: {boolean} `true` or `false` depending on whether the
   keys have exactly the same type, value, and parameters.
 
 ### `keyObject.symmetricKeySize`

From 7c77c048b490b15461fcb2859c6264de8c06f45e Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Wed, 23 Feb 2022 20:56:02 +0100
Subject: [PATCH 11/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index 2af1f63daf5058..cd1701a94a741e 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1137,29 +1137,31 @@ void KeyObjectHandle::InitEDRaw(const FunctionCallbackInfo<Value>& args) {
 }
 
 void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
-  std::shared_ptr<KeyObjectData> key =
-    Unwrap<KeyObjectHandle>(args.Holder())->Data();
-  std::shared_ptr<KeyObjectData> key2 =
-    Unwrap<KeyObjectHandle>(args[0].As<Object>())->Data();
+  KeyObjectHandle* self_handle;
+  KeyObjectHandle* arg_handle;
+  ASSIGN_OR_RETURN_UNWRAP(&self_handle, args.Holder());
+  ASSIGN_OR_RETURN_UNWRAP(&arg_handle, args[0].As<Object>());
+  std::shared_ptr<KeyObjectData> key = self_handle->Data();
+  std::shared_ptr<KeyObjectData> key2 = arg_handle->Data();
 
-  KeyType keyType = key->GetKeyType();
-  CHECK_EQ(keyType, key2->GetKeyType());
+  KeyType key_type = key->GetKeyType();
+  CHECK_EQ(key_type, key2->GetKeyType());
 
   bool ret;
-  switch (keyType) {
+  switch (key_type) {
     case kKeyTypeSecret: {
       size_t size = key->GetSymmetricKeySize();
-      if (size == key2->GetSymmetricKeySize())
+      if (size == key2->GetSymmetricKeySize()) {
         ret = CRYPTO_memcmp(
           key->GetSymmetricKey(),
           key2->GetSymmetricKey(),
           size) == 0;
-      else
+      } else {
         ret = false;
+      }
       break;
     }
     case kKeyTypePublic:
-      // Fall through
     case kKeyTypePrivate: {
       EVP_PKEY* pkey = key->GetAsymmetricKey().get();
       EVP_PKEY* pkey2 = key2->GetAsymmetricKey().get();

From 8b4be299e2009bf195762bcc8349f84fa42638a5 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Thu, 24 Feb 2022 17:22:47 +0100
Subject: [PATCH 12/15] fixup! crypto: add KeyObject.prototype.equals method

---
 src/crypto/crypto_keys.cc | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index cd1701a94a741e..d6ce0cf459da3e 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1165,15 +1165,16 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
     case kKeyTypePrivate: {
       EVP_PKEY* pkey = key->GetAsymmetricKey().get();
       EVP_PKEY* pkey2 = key2->GetAsymmetricKey().get();
-      if (EVP_PKEY_id(pkey) == EVP_PKEY_id(pkey2)) {
 #if OPENSSL_VERSION_MAJOR >= 3
-          ret = EVP_PKEY_eq(pkey, pkey2) == 1;
+      int ok = EVP_PKEY_eq(pkey, pkey2);
 #else
-          ret = EVP_PKEY_cmp(pkey, pkey2) == 1;
+      int ok = EVP_PKEY_cmp(pkey, pkey2);
 #endif
-      } else {
-        ret = false;
+      if (ok == -2) {
+        Environment* env = Environment::GetCurrent(args);
+        return THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(env);
       }
+      ret = ok == 1;
       break;
     }
     default:

From 5137cc0677d52f55184ee0853cfcaaafcf117950 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Fri, 25 Feb 2022 12:56:45 +0100
Subject: [PATCH 13/15] fixup! crypto: add KeyObject.prototype.equals method

Co-authored-by: Ben Noordhuis <info@bnoordhuis.nl>
---
 src/crypto/crypto_keys.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index d6ce0cf459da3e..08b95190698334 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -1178,7 +1178,7 @@ void KeyObjectHandle::Equals(const FunctionCallbackInfo<Value>& args) {
       break;
     }
     default:
-      CHECK(false);
+      UNREACHABLE("unsupported key type");
   }
 
   args.GetReturnValue().Set(ret);

From d4f9656a789897ee0a9626ce79c619d769ad822e Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Fri, 25 Feb 2022 13:18:28 +0100
Subject: [PATCH 14/15] fixup! crypto: add KeyObject.prototype.equals method

---
 doc/api/crypto.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 463435749193ce..f5ef9e36f02933 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2090,8 +2090,11 @@ added: REPLACEME
 
 * `otherKeyObject`: {KeyObject} A `KeyObject` with which to
   compare `keyObject`.
-* Returns: {boolean} `true` or `false` depending on whether the
-  keys have exactly the same type, value, and parameters.
+* Returns: {boolean}
+
+Returns `true` or `false` depending on whether the keys have exactly the same
+type, value, and parameters. This method is not 
+[constant time](https://en.wikipedia.org/wiki/Timing_attack).
 
 ### `keyObject.symmetricKeySize`
 

From 9deb3295ef71d9a77137d9b11a10adf7f04adca8 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Fri, 25 Feb 2022 13:23:03 +0100
Subject: [PATCH 15/15] fixup! crypto: add KeyObject.prototype.equals method

---
 doc/api/crypto.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index f5ef9e36f02933..8025e0f91829af 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2093,7 +2093,7 @@ added: REPLACEME
 * Returns: {boolean}
 
 Returns `true` or `false` depending on whether the keys have exactly the same
-type, value, and parameters. This method is not 
+type, value, and parameters. This method is not
 [constant time](https://en.wikipedia.org/wiki/Timing_attack).
 
 ### `keyObject.symmetricKeySize`