src: register external references in crypto bindings

nodejs · Sep 28, 2021 · a7e3428 · a7e3428
1 parent 43291b9
commit a7e3428
Show file tree

Hide file tree

Showing 38 changed files with 402 additions and 33 deletions.
diff --git a/src/crypto/crypto_aes.cc b/src/crypto/crypto_aes.cc
@@ -603,5 +603,9 @@ void AES::Initialize(Environment* env, Local<Object> target) {
 #undef V
 }
 
+void AES::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  AESCryptoJob::RegisterExternalReferences(registry);
+}
+
 }  // namespace crypto
 }  // namespace node
diff --git a/src/crypto/crypto_aes.h b/src/crypto/crypto_aes.h
@@ -81,6 +81,7 @@ using AESCryptoJob = CipherJob<AESCipherTraits>;
 
 namespace AES {
 void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 }  // namespace AES
 }  // namespace crypto
 }  // namespace node

diff --git a/src/crypto/crypto_cipher.cc b/src/crypto/crypto_cipher.cc
@@ -297,6 +297,38 @@ void CipherBase::Initialize(Environment* env, Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, kWebCryptoCipherDecrypt);
 }
 
+void CipherBase::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+
+  registry->Register(Init);
+  registry->Register(InitIv);
+  registry->Register(Update);
+  registry->Register(Final);
+  registry->Register(SetAutoPadding);
+  registry->Register(GetAuthTag);
+  registry->Register(SetAuthTag);
+  registry->Register(SetAAD);
+
+  registry->Register(GetSSLCiphers);
+  registry->Register(GetCiphers);
+
+  registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
+                                             EVP_PKEY_encrypt_init,
+                                             EVP_PKEY_encrypt>);
+  registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
+                                             EVP_PKEY_decrypt_init,
+                                             EVP_PKEY_decrypt>);
+  registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
+                                             EVP_PKEY_sign_init,
+                                             EVP_PKEY_sign>);
+  registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
+                                             EVP_PKEY_verify_recover_init,
+                                             EVP_PKEY_verify_recover>);
+
+  registry->Register(GetCipherInfo);
+}
+
 void CipherBase::New(const FunctionCallbackInfo<Value>& args) {
   CHECK(args.IsConstructCall());
   Environment* env = Environment::GetCurrent(args);

diff --git a/src/crypto/crypto_cipher.h b/src/crypto/crypto_cipher.h
@@ -21,6 +21,7 @@ class CipherBase : public BaseObject {
   static void GetCiphers(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(CipherBase)
@@ -190,6 +191,10 @@ class CipherJob final : public CryptoJob<CipherTraits> {
     CryptoJob<CipherTraits>::Initialize(New, env, target);
   }
 
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+    CryptoJob<CipherTraits>::RegisterExternalReferences(New, registry);
+  }
+
   CipherJob(
       Environment* env,
       v8::Local<v8::Object> object,

diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc
@@ -339,6 +339,47 @@ void SecureContext::Initialize(Environment* env, Local<Object> target) {
                              IsExtraRootCertsFileLoaded);
 }
 
+void SecureContext::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(Init);
+  registry->Register(SetKey);
+  registry->Register(SetCert);
+  registry->Register(AddCACert);
+  registry->Register(AddCRL);
+  registry->Register(AddRootCerts);
+  registry->Register(SetCipherSuites);
+  registry->Register(SetCiphers);
+  registry->Register(SetSigalgs);
+  registry->Register(SetECDHCurve);
+  registry->Register(SetDHParam);
+  registry->Register(SetMaxProto);
+  registry->Register(SetMinProto);
+  registry->Register(GetMaxProto);
+  registry->Register(GetMinProto);
+  registry->Register(SetOptions);
+  registry->Register(SetSessionIdContext);
+  registry->Register(SetSessionTimeout);
+  registry->Register(Close);
+  registry->Register(LoadPKCS12);
+  registry->Register(SetTicketKeys);
+  registry->Register(SetFreeListLength);
+  registry->Register(EnableTicketKeyCallback);
+  registry->Register(GetTicketKeys);
+  registry->Register(GetCertificate<true>);
+  registry->Register(GetCertificate<false>);
+
+#ifndef OPENSSL_NO_ENGINE
+  registry->Register(SetEngineKey);
+  registry->Register(SetClientCertEngine);
+#endif  // !OPENSSL_NO_ENGINE
+
+  registry->Register(CtxGetter);
+
+  registry->Register(GetRootCertificates);
+  registry->Register(IsExtraRootCertsFileLoaded);
+}
+
 SecureContext* SecureContext::Create(Environment* env) {
   Local<Object> obj;
   if (!GetConstructorTemplate(env)

diff --git a/src/crypto/crypto_context.h b/src/crypto/crypto_context.h
@@ -38,6 +38,7 @@ class SecureContext final : public BaseObject {
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static SecureContext* Create(Environment* env);
 
   SSL_CTX* operator*() const { return ctx_.get(); }

diff --git a/src/crypto/crypto_dh.cc b/src/crypto/crypto_dh.cc
@@ -108,6 +108,28 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
   DHBitsJob::Initialize(env, target);
 }
 
+void DiffieHellman::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(DiffieHellmanGroup);
+
+  registry->Register(GenerateKeys);
+  registry->Register(ComputeSecret);
+  registry->Register(GetPrime);
+  registry->Register(GetGenerator);
+  registry->Register(GetPublicKey);
+  registry->Register(GetPrivateKey);
+  registry->Register(SetPublicKey);
+  registry->Register(SetPrivateKey);
+
+  registry->Register(DiffieHellman::VerifyErrorGetter);
+  registry->Register(DiffieHellman::Stateless);
+
+  DHKeyPairGenJob::RegisterExternalReferences(registry);
+  DHKeyExportJob::RegisterExternalReferences(registry);
+  DHBitsJob::RegisterExternalReferences(registry);
+}
+
 bool DiffieHellman::Init(int primeLength, int g) {
   dh_.reset(DH_new());
   if (!DH_generate_parameters_ex(dh_.get(), primeLength, g, nullptr))

diff --git a/src/crypto/crypto_dh.h b/src/crypto/crypto_dh.h
@@ -17,6 +17,7 @@ namespace crypto {
 class DiffieHellman : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   bool Init(int primeLength, int g);
   bool Init(const char* p, int p_len, int g);

diff --git a/src/crypto/crypto_dsa.cc b/src/crypto/crypto_dsa.cc
@@ -167,6 +167,11 @@ void Initialize(Environment* env, Local<Object> target) {
   DsaKeyPairGenJob::Initialize(env, target);
   DSAKeyExportJob::Initialize(env, target);
 }
+
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  DsaKeyPairGenJob::RegisterExternalReferences(registry);
+  DSAKeyExportJob::RegisterExternalReferences(registry);
+}
 }  // namespace DSAAlg
 }  // namespace crypto
 }  // namespace node
diff --git a/src/crypto/crypto_dsa.h b/src/crypto/crypto_dsa.h
@@ -68,6 +68,7 @@ v8::Maybe<bool> GetDsaKeyDetail(
 
 namespace DSAAlg {
 void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 }  // namespace DSAAlg
 }  // namespace crypto
 }  // namespace node

diff --git a/src/crypto/crypto_ec.cc b/src/crypto/crypto_ec.cc
@@ -83,6 +83,22 @@ void ECDH::Initialize(Environment* env, Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, OPENSSL_EC_EXPLICIT_CURVE);
 }
 
+void ECDH::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(GenerateKeys);
+  registry->Register(ComputeSecret);
+  registry->Register(GetPublicKey);
+  registry->Register(GetPrivateKey);
+  registry->Register(SetPublicKey);
+  registry->Register(SetPrivateKey);
+  registry->Register(ECDH::ConvertKey);
+  registry->Register(ECDH::GetCurves);
+
+  ECDHBitsJob::RegisterExternalReferences(registry);
+  ECKeyPairGenJob::RegisterExternalReferences(registry);
+  ECKeyExportJob::RegisterExternalReferences(registry);
+}
+
 void ECDH::GetCurves(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   const size_t num_curves = EC_get_builtin_curves(nullptr, 0);

diff --git a/src/crypto/crypto_ec.h b/src/crypto/crypto_ec.h
@@ -24,6 +24,8 @@ class ECDH final : public BaseObject {
   ~ECDH() override;
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
   static ECPointPointer BufferToPoint(Environment* env,
                                       const EC_GROUP* group,
                                       v8::Local<v8::Value> buf);

diff --git a/src/crypto/crypto_hash.cc b/src/crypto/crypto_hash.cc
@@ -57,6 +57,15 @@ void Hash::Initialize(Environment* env, Local<Object> target) {
   HashJob::Initialize(env, target);
 }
 
+void Hash::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(HashUpdate);
+  registry->Register(HashDigest);
+  registry->Register(GetHashes);
+
+  HashJob::RegisterExternalReferences(registry);
+}
+
 void Hash::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 

diff --git a/src/crypto/crypto_hash.h b/src/crypto/crypto_hash.h
@@ -16,6 +16,7 @@ namespace crypto {
 class Hash final : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Hash)

diff --git a/src/crypto/crypto_hmac.cc b/src/crypto/crypto_hmac.cc
@@ -53,6 +53,14 @@ void Hmac::Initialize(Environment* env, Local<Object> target) {
   HmacJob::Initialize(env, target);
 }
 
+void Hmac::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(HmacInit);
+  registry->Register(HmacUpdate);
+  registry->Register(HmacDigest);
+  HmacJob::RegisterExternalReferences(registry);
+}
+
 void Hmac::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   new Hmac(env, args.This());

diff --git a/src/crypto/crypto_hmac.h b/src/crypto/crypto_hmac.h
@@ -17,6 +17,7 @@ namespace crypto {
 class Hmac : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Hmac)

diff --git a/src/crypto/crypto_keygen.cc b/src/crypto/crypto_keygen.cc
@@ -104,6 +104,12 @@ void Initialize(Environment* env, Local<Object> target) {
   NidKeyPairGenJob::Initialize(env, target);
   SecretKeyGenJob::Initialize(env, target);
 }
+
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  NidKeyPairGenJob::RegisterExternalReferences(registry);
+  SecretKeyGenJob::RegisterExternalReferences(registry);
+}
+
 }  // namespace Keygen
 }  // namespace crypto
 }  // namespace node
diff --git a/src/crypto/crypto_keygen.h b/src/crypto/crypto_keygen.h
@@ -16,6 +16,7 @@ namespace node {
 namespace crypto {
 namespace Keygen {
 void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 }  // namespace Keygen
 
 enum class KeyGenJobStatus {
@@ -58,6 +59,10 @@ class KeyGenJob final : public CryptoJob<KeyGenTraits> {
     CryptoJob<KeyGenTraits>::Initialize(New, env, target);
   }
 
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+    CryptoJob<KeyGenTraits>::RegisterExternalReferences(New, registry);
+  }
+
   KeyGenJob(
       Environment* env,
       v8::Local<v8::Object> object,

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
@@ -927,6 +927,20 @@ v8::Local<v8::Function> KeyObjectHandle::Initialize(Environment* env) {
   return function;
 }
 
+void KeyObjectHandle::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(Init);
+  registry->Register(GetSymmetricKeySize);
+  registry->Register(GetAsymmetricKeyType);
+  registry->Register(Export);
+  registry->Register(ExportJWK);
+  registry->Register(InitECRaw);
+  registry->Register(InitEDRaw);
+  registry->Register(InitJWK);
+  registry->Register(GetKeyDetail);
+}
+
 MaybeLocal<Object> KeyObjectHandle::Create(
     Environment* env,
     std::shared_ptr<KeyObjectData> data) {
@@ -1256,6 +1270,12 @@ void NativeKeyObject::Initialize(Environment* env, Local<Object> target) {
                  NativeKeyObject::CreateNativeKeyObjectClass);
 }
 
+void NativeKeyObject::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(NativeKeyObject::CreateNativeKeyObjectClass);
+  registry->Register(NativeKeyObject::New);
+}
+
 void NativeKeyObject::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK_EQ(args.Length(), 1);
@@ -1405,6 +1425,10 @@ void Initialize(Environment* env, Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, kSigEncDER);
   NODE_DEFINE_CONSTANT(target, kSigEncP1363);
 }
+
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  KeyObjectHandle::RegisterExternalReferences(registry);
+}
 }  // namespace Keys
 
 }  // namespace crypto

diff --git a/src/crypto/crypto_keys.h b/src/crypto/crypto_keys.h
@@ -169,6 +169,7 @@ class KeyObjectData : public MemoryRetainer {
 class KeyObjectHandle : public BaseObject {
  public:
   static v8::Local<v8::Function> Initialize(Environment* env);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   static v8::MaybeLocal<v8::Object> Create(Environment* env,
                                            std::shared_ptr<KeyObjectData> data);
@@ -216,6 +217,7 @@ class KeyObjectHandle : public BaseObject {
 class NativeKeyObject : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CreateNativeKeyObjectClass(
@@ -316,6 +318,10 @@ class KeyExportJob final : public CryptoJob<KeyExportTraits> {
     CryptoJob<KeyExportTraits>::Initialize(New, env, target);
   }
 
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+    CryptoJob<KeyExportTraits>::RegisterExternalReferences(New, registry);
+  }
+
   KeyExportJob(
       Environment* env,
       v8::Local<v8::Object> object,
@@ -403,6 +409,7 @@ WebCryptoKeyExportStatus PKEY_PKCS8_Export(
 
 namespace Keys {
 void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 }  // namespace Keys
 
 }  // namespace crypto

diff --git a/src/crypto/crypto_random.cc b/src/crypto/crypto_random.cc
@@ -246,6 +246,12 @@ void Initialize(Environment* env, Local<Object> target) {
   RandomPrimeJob::Initialize(env, target);
   CheckPrimeJob::Initialize(env, target);
 }
+
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  RandomBytesJob::RegisterExternalReferences(registry);
+  RandomPrimeJob::RegisterExternalReferences(registry);
+  CheckPrimeJob::RegisterExternalReferences(registry);
+}
 }  // namespace Random
 }  // namespace crypto
 }  // namespace node