@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{18 → 24}/crypto/crypto_dsa.h

@@ -10,8 +10,7 @@
 #include "memory_tracker.h"
 #include "v8.h"
 
-namespace node {
-namespace crypto {
+namespace node::crypto {
 struct DsaKeyPairParams final : public MemoryRetainer {
   unsigned int modulus_bits;
   int divisor_bits;
@@ -26,9 +25,9 @@ struct DsaKeyGenTraits final {
   using AdditionalParameters = DsaKeyPairGenConfig;
   static constexpr const char* JobName = "DsaKeyPairGenJob";
 
-  static EVPKeyCtxPointer Setup(DsaKeyPairGenConfig* params);
+  static ncrypto::EVPKeyCtxPointer Setup(DsaKeyPairGenConfig* params);
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       CryptoJobMode mode,
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int* offset,
@@ -37,41 +36,15 @@ struct DsaKeyGenTraits final {
 
 using DsaKeyPairGenJob = KeyGenJob<KeyPairGenTraits<DsaKeyGenTraits>>;
 
-struct DSAKeyExportConfig final : public MemoryRetainer {
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(DSAKeyExportConfig)
-  SET_SELF_SIZE(DSAKeyExportConfig)
-};
-
-struct DSAKeyExportTraits final {
-  static constexpr const char* JobName = "DSAKeyExportJob";
-  using AdditionalParameters = DSAKeyExportConfig;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int offset,
-      DSAKeyExportConfig* config);
-
-  static WebCryptoKeyExportStatus DoExport(
-      std::shared_ptr<KeyObjectData> key_data,
-      WebCryptoKeyFormat format,
-      const DSAKeyExportConfig& params,
-      ByteSource* out);
-};
-
-using DSAKeyExportJob = KeyExportJob<DSAKeyExportTraits>;
-
-v8::Maybe<bool> GetDsaKeyDetail(
-    Environment* env,
-    std::shared_ptr<KeyObjectData> key,
-    v8::Local<v8::Object> target);
+bool GetDsaKeyDetail(Environment* env,
+                     const KeyObjectData& key,
+                     v8::Local<v8::Object> target);
 
 namespace DSAAlg {
 void Initialize(Environment* env, v8::Local<v8::Object> target);
 void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 }  // namespace DSAAlg
-}  // namespace crypto
-}  // namespace node
+}  // namespace node::crypto
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 #endif  // SRC_CRYPTO_CRYPTO_DSA_H_

package/src/headers/{18 → 24}/crypto/crypto_ec.h

@@ -15,19 +15,17 @@
 
 namespace node {
 namespace crypto {
-int GetCurveFromName(const char* name);
-int GetOKPCurveFromName(const char* name);
 
 class ECDH final : public BaseObject {
  public:
-  ~ECDH() override;
+  ~ECDH() override = default;
 
   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);
+  static ncrypto::ECPointPointer BufferToPoint(Environment* env,
+                                               const EC_GROUP* group,
+                                               v8::Local<v8::Value> buf);
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(ECDH)
@@ -38,7 +36,9 @@ class ECDH final : public BaseObject {
   static void GetCurves(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  protected:
-  ECDH(Environment* env, v8::Local<v8::Object> wrap, ECKeyPointer&& key);
+  ECDH(Environment* env,
+       v8::Local<v8::Object> wrap,
+       ncrypto::ECKeyPointer&& key);
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GenerateKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -49,16 +49,16 @@ class ECDH final : public BaseObject {
   static void SetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   bool IsKeyPairValid();
-  bool IsKeyValidForCurve(const BignumPointer& private_key);
+  bool IsKeyValidForCurve(const ncrypto::BignumPointer& private_key);
 
-  ECKeyPointer key_;
+  ncrypto::ECKeyPointer key_;
   const EC_GROUP* group_;
 };
 
 struct ECDHBitsConfig final : public MemoryRetainer {
   int id_;
-  std::shared_ptr<KeyObjectData> private_;
-  std::shared_ptr<KeyObjectData> public_;
+  KeyObjectData private_;
+  KeyObjectData public_;
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(ECDHBitsConfig)
@@ -71,22 +71,20 @@ struct ECDHBitsTraits final {
   static constexpr AsyncWrap::ProviderType Provider =
       AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       CryptoJobMode mode,
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int offset,
       ECDHBitsConfig* params);
 
-  static bool DeriveBits(
-      Environment* env,
-      const ECDHBitsConfig& params,
-      ByteSource* out_);
+  static bool DeriveBits(Environment* env,
+                         const ECDHBitsConfig& params,
+                         ByteSource* out_,
+                         CryptoJobMode mode);
 
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const ECDHBitsConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const ECDHBitsConfig& params,
+                                                ByteSource* out);
 };
 
 using ECDHBitsJob = DeriveBitsJob<ECDHBitsTraits>;
@@ -105,9 +103,9 @@ struct EcKeyGenTraits final {
   using AdditionalParameters = EcKeyPairGenConfig;
   static constexpr const char* JobName = "EcKeyPairGenJob";
 
-  static EVPKeyCtxPointer Setup(EcKeyPairGenConfig* params);
+  static ncrypto::EVPKeyCtxPointer Setup(EcKeyPairGenConfig* params);
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       CryptoJobMode mode,
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int* offset,
@@ -129,40 +127,35 @@ struct ECKeyExportTraits final {
   static constexpr const char* JobName = "ECKeyExportJob";
   using AdditionalParameters = ECKeyExportConfig;
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int offset,
       ECKeyExportConfig* config);
 
-  static WebCryptoKeyExportStatus DoExport(
-      std::shared_ptr<KeyObjectData> key_data,
-      WebCryptoKeyFormat format,
-      const ECKeyExportConfig& params,
-      ByteSource* out);
+  static WebCryptoKeyExportStatus DoExport(const KeyObjectData& key_data,
+                                           WebCryptoKeyFormat format,
+                                           const ECKeyExportConfig& params,
+                                           ByteSource* out);
 };
 
 using ECKeyExportJob = KeyExportJob<ECKeyExportTraits>;
 
-v8::Maybe<void> ExportJWKEcKey(
-    Environment* env,
-    std::shared_ptr<KeyObjectData> key,
-    v8::Local<v8::Object> target);
-
-v8::Maybe<bool> ExportJWKEdKey(
-    Environment* env,
-    std::shared_ptr<KeyObjectData> key,
-    v8::Local<v8::Object> target);
-
-std::shared_ptr<KeyObjectData> ImportJWKEcKey(
-    Environment* env,
-    v8::Local<v8::Object> jwk,
-    const v8::FunctionCallbackInfo<v8::Value>& args,
-    unsigned int offset);
-
-v8::Maybe<bool> GetEcKeyDetail(
-    Environment* env,
-    std::shared_ptr<KeyObjectData> key,
-    v8::Local<v8::Object> target);
+bool ExportJWKEcKey(Environment* env,
+                    const KeyObjectData& key,
+                    v8::Local<v8::Object> target);
+
+bool ExportJWKEdKey(Environment* env,
+                    const KeyObjectData& key,
+                    v8::Local<v8::Object> target);
+
+KeyObjectData ImportJWKEcKey(Environment* env,
+                             v8::Local<v8::Object> jwk,
+                             const v8::FunctionCallbackInfo<v8::Value>& args,
+                             unsigned int offset);
+
+bool GetEcKeyDetail(Environment* env,
+                    const KeyObjectData& key,
+                    v8::Local<v8::Object> target);
 }  // namespace crypto
 }  // namespace node
 

package/src/headers/{18 → 24}/crypto/crypto_hash.h

@@ -25,6 +25,8 @@ class Hash final : public BaseObject {
   bool HashUpdate(const char* data, size_t len);
 
   static void GetHashes(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCachedAliases(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void OneShotDigest(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  protected:
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -34,7 +36,7 @@ class Hash final : public BaseObject {
   Hash(Environment* env, v8::Local<v8::Object> wrap);
 
  private:
-  EVPMDPointer mdctx_ {};
+  ncrypto::EVPMDCtxPointer mdctx_{};
   unsigned int md_len_ = 0;
   ByteSource digest_;
 };
@@ -62,22 +64,20 @@ struct HashTraits final {
   static constexpr AsyncWrap::ProviderType Provider =
       AsyncWrap::PROVIDER_HASHREQUEST;
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       CryptoJobMode mode,
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int offset,
       HashConfig* params);
 
-  static bool DeriveBits(
-      Environment* env,
-      const HashConfig& params,
-      ByteSource* out);
+  static bool DeriveBits(Environment* env,
+                         const HashConfig& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
 
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const HashConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const HashConfig& params,
+                                                ByteSource* out);
 };
 
 using HashJob = DeriveBitsJob<HashTraits>;

package/src/headers/{18 → 24}/crypto/crypto_hkdf.h

@@ -11,13 +11,11 @@
 
 namespace node {
 namespace crypto {
-static constexpr size_t kMaxDigestMultiplier = 255;
-
 struct HKDFConfig final : public MemoryRetainer {
   CryptoJobMode mode;
   size_t length;
-  const EVP_MD* digest;
-  std::shared_ptr<KeyObjectData> key;
+  ncrypto::Digest digest;
+  KeyObjectData key;
   ByteSource salt;
   ByteSource info;
 
@@ -38,22 +36,20 @@ struct HKDFTraits final {
   static constexpr AsyncWrap::ProviderType Provider =
       AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       CryptoJobMode mode,
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int offset,
       HKDFConfig* params);
 
-  static bool DeriveBits(
-      Environment* env,
-      const HKDFConfig& params,
-      ByteSource* out);
+  static bool DeriveBits(Environment* env,
+                         const HKDFConfig& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
 
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const HKDFConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const HKDFConfig& params,
+                                                ByteSource* out);
 };
 
 using HKDFJob = DeriveBitsJob<HKDFTraits>;

package/src/headers/{18 → 24}/crypto/crypto_hmac.h

@@ -36,16 +36,16 @@ class Hmac : public BaseObject {
   static void Sign(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  private:
-  HMACCtxPointer ctx_;
+  ncrypto::HMACCtxPointer ctx_;
 };
 
 struct HmacConfig final : public MemoryRetainer {
   CryptoJobMode job_mode;
   SignConfiguration::Mode mode;
-  std::shared_ptr<KeyObjectData> key;
+  KeyObjectData key;
   ByteSource data;
   ByteSource signature;
-  const EVP_MD* digest;
+  ncrypto::Digest digest;
 
   HmacConfig() = default;
 
@@ -67,22 +67,20 @@ struct HmacTraits final {
   static constexpr AsyncWrap::ProviderType Provider =
       AsyncWrap::PROVIDER_SIGNREQUEST;
 
-  static v8::Maybe<bool> AdditionalConfig(
+  static v8::Maybe<void> AdditionalConfig(
       CryptoJobMode mode,
       const v8::FunctionCallbackInfo<v8::Value>& args,
       unsigned int offset,
       HmacConfig* params);
 
-  static bool DeriveBits(
-      Environment* env,
-      const HmacConfig& params,
-      ByteSource* out);
+  static bool DeriveBits(Environment* env,
+                         const HmacConfig& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
 
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const HmacConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const HmacConfig& params,
+                                                ByteSource* out);
 };
 
 using HmacJob = DeriveBitsJob<HmacTraits>;

package/src/headers/24/crypto/crypto_kem.h

@@ -0,0 +1,113 @@
+#ifndef SRC_CRYPTO_CRYPTO_KEM_H_
+#define SRC_CRYPTO_CRYPTO_KEM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "node_external_reference.h"
+
+#if OPENSSL_VERSION_MAJOR >= 3
+
+namespace node {
+namespace crypto {
+
+enum class KEMMode { Encapsulate, Decapsulate };
+
+struct KEMConfiguration final : public MemoryRetainer {
+  CryptoJobMode job_mode;
+  KEMMode mode;
+  KeyObjectData key;
+  ByteSource ciphertext;
+
+  KEMConfiguration() = default;
+  explicit KEMConfiguration(KEMConfiguration&& other) noexcept;
+  KEMConfiguration& operator=(KEMConfiguration&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(KEMConfiguration)
+  SET_SELF_SIZE(KEMConfiguration)
+};
+
+struct KEMEncapsulateTraits final {
+  using AdditionalParameters = KEMConfiguration;
+  static constexpr const char* JobName = "KEMEncapsulateJob";
+
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      KEMConfiguration* params);
+
+  static bool DeriveBits(Environment* env,
+                         const KEMConfiguration& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const KEMConfiguration& params,
+                                                ByteSource* out);
+};
+
+struct KEMDecapsulateTraits final {
+  using AdditionalParameters = KEMConfiguration;
+  static constexpr const char* JobName = "KEMDecapsulateJob";
+
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      KEMConfiguration* params);
+
+  static bool DeriveBits(Environment* env,
+                         const KEMConfiguration& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const KEMConfiguration& params,
+                                                ByteSource* out);
+};
+
+using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
+using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
+
+void InitializeKEM(Environment* env, v8::Local<v8::Object> target);
+void RegisterKEMExternalReferences(ExternalReferenceRegistry* registry);
+
+namespace KEM {
+void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+}  // namespace KEM
+
+}  // namespace crypto
+}  // namespace node
+
+#else
+
+// Provide stub implementations when OpenSSL < 3.0
+namespace node {
+namespace crypto {
+namespace KEM {
+inline void Initialize(Environment* env, v8::Local<v8::Object> target) {
+  // No-op when OpenSSL < 3.0
+}
+inline void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  // No-op when OpenSSL < 3.0
+}
+}  // namespace KEM
+}  // namespace crypto
+}  // namespace node
+
+#endif
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_KEM_H_