@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/crypto/crypto_rsa.h

@@ -0,0 +1,136 @@
+#ifndef SRC_CRYPTO_CRYPTO_RSA_H_
+#define SRC_CRYPTO_CRYPTO_RSA_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "crypto/crypto_cipher.h"
+#include "crypto/crypto_keygen.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+enum RSAKeyVariant {
+  kKeyVariantRSA_SSA_PKCS1_v1_5,
+  kKeyVariantRSA_PSS,
+  kKeyVariantRSA_OAEP
+};
+
+struct RsaKeyPairParams final : public MemoryRetainer {
+  RSAKeyVariant variant;
+  unsigned int modulus_bits;
+  unsigned int exponent;
+
+  // The following options are used for RSA-PSS. If any of them are set, a
+  // RSASSA-PSS-params sequence will be added to the key.
+  const EVP_MD* md = nullptr;
+  const EVP_MD* mgf1_md = nullptr;
+  int saltlen = -1;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(RsaKeyPairParams)
+  SET_SELF_SIZE(RsaKeyPairParams)
+};
+
+using RsaKeyPairGenConfig = KeyPairGenConfig<RsaKeyPairParams>;
+
+struct RsaKeyGenTraits final {
+  using AdditionalParameters = RsaKeyPairGenConfig;
+  static constexpr const char* JobName = "RsaKeyPairGenJob";
+
+  static ncrypto::EVPKeyCtxPointer Setup(RsaKeyPairGenConfig* params);
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int* offset,
+      RsaKeyPairGenConfig* params);
+};
+
+using RSAKeyPairGenJob = KeyGenJob<KeyPairGenTraits<RsaKeyGenTraits>>;
+
+struct RSAKeyExportConfig final : public MemoryRetainer {
+  RSAKeyVariant variant = kKeyVariantRSA_SSA_PKCS1_v1_5;
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(RSAKeyExportConfig)
+  SET_SELF_SIZE(RSAKeyExportConfig)
+};
+
+struct RSAKeyExportTraits final {
+  static constexpr const char* JobName = "RSAKeyExportJob";
+  using AdditionalParameters = RSAKeyExportConfig;
+
+  static v8::Maybe<void> AdditionalConfig(
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      RSAKeyExportConfig* config);
+
+  static WebCryptoKeyExportStatus DoExport(const KeyObjectData& key_data,
+                                           WebCryptoKeyFormat format,
+                                           const RSAKeyExportConfig& params,
+                                           ByteSource* out);
+};
+
+using RSAKeyExportJob = KeyExportJob<RSAKeyExportTraits>;
+
+struct RSACipherConfig final : public MemoryRetainer {
+  CryptoJobMode mode = kCryptoJobAsync;
+  ByteSource label;
+  int padding = 0;
+  const EVP_MD* digest = nullptr;
+
+  RSACipherConfig() = default;
+
+  RSACipherConfig(RSACipherConfig&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(RSACipherConfig)
+  SET_SELF_SIZE(RSACipherConfig)
+};
+
+struct RSACipherTraits final {
+  static constexpr const char* JobName = "RSACipherJob";
+  using AdditionalParameters = RSACipherConfig;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      WebCryptoCipherMode cipher_mode,
+      RSACipherConfig* config);
+
+  static WebCryptoCipherStatus DoCipher(Environment* env,
+                                        const KeyObjectData& key_data,
+                                        WebCryptoCipherMode cipher_mode,
+                                        const RSACipherConfig& params,
+                                        const ByteSource& in,
+                                        ByteSource* out);
+};
+
+using RSACipherJob = CipherJob<RSACipherTraits>;
+
+v8::Maybe<void> ExportJWKRsaKey(Environment* env,
+                                const KeyObjectData& key,
+                                v8::Local<v8::Object> target);
+
+KeyObjectData ImportJWKRsaKey(Environment* env,
+                              v8::Local<v8::Object> jwk,
+                              const v8::FunctionCallbackInfo<v8::Value>& args,
+                              unsigned int offset);
+
+v8::Maybe<void> GetRsaKeyDetail(Environment* env,
+                                const KeyObjectData& key,
+                                v8::Local<v8::Object> target);
+
+namespace RSAAlg {
+void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+}  // namespace RSAAlg
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_RSA_H_

package/dist/node/include/crypto/crypto_scrypt.h

@@ -0,0 +1,85 @@
+#ifndef SRC_CRYPTO_CRYPTO_SCRYPT_H_
+#define SRC_CRYPTO_CRYPTO_SCRYPT_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "crypto/crypto_util.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+#ifndef OPENSSL_NO_SCRYPT
+
+// Scrypt is a password-based key derivation algorithm
+// defined in https://tools.ietf.org/html/rfc7914
+
+// It takes as input a password, a salt value, and a
+// handful of additional parameters that control the
+// cost of the operation. In this case, the higher
+// the cost, the better the result. The length parameter
+// defines the number of bytes that are generated.
+
+// The salt must be as random as possible and should be
+// at least 16 bytes in length.
+
+struct ScryptConfig final : public MemoryRetainer {
+  CryptoJobMode mode;
+  ByteSource pass;
+  ByteSource salt;
+  uint32_t N;
+  uint32_t r;
+  uint32_t p;
+  uint64_t maxmem;
+  int32_t length;
+
+  ScryptConfig() = default;
+
+  explicit ScryptConfig(ScryptConfig&& other) noexcept;
+
+  ScryptConfig& operator=(ScryptConfig&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(ScryptConfig)
+  SET_SELF_SIZE(ScryptConfig)
+};
+
+struct ScryptTraits final {
+  using AdditionalParameters = ScryptConfig;
+  static constexpr const char* JobName = "ScryptJob";
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_SCRYPTREQUEST;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      ScryptConfig* params);
+
+  static bool DeriveBits(Environment* env,
+                         const ScryptConfig& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const ScryptConfig& params,
+                                                ByteSource* out);
+};
+
+using ScryptJob = DeriveBitsJob<ScryptTraits>;
+
+#else
+// If there is no Scrypt support, ScryptJob becomes a non-op
+struct ScryptJob {
+  static void Initialize(
+      Environment* env,
+      v8::Local<v8::Object> target) {}
+};
+#endif  // !OPENSSL_NO_SCRYPT
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_SCRYPT_H_

package/dist/node/include/crypto/crypto_sig.h

@@ -0,0 +1,165 @@
+#ifndef SRC_CRYPTO_CRYPTO_SIG_H_
+#define SRC_CRYPTO_CRYPTO_SIG_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"
+
+namespace node {
+namespace crypto {
+static const unsigned int kNoDsaSignature = static_cast<unsigned int>(-1);
+
+enum DSASigEnc {
+  kSigEncDER,
+  kSigEncP1363
+};
+
+class SignBase : public BaseObject {
+ public:
+  enum Error {
+    kSignOk,
+    kSignUnknownDigest,
+    kSignInit,
+    kSignNotInitialised,
+    kSignUpdate,
+    kSignPrivateKey,
+    kSignPublicKey,
+    kSignMalformedSignature
+  };
+
+  SignBase(Environment* env, v8::Local<v8::Object> wrap);
+
+  Error Init(const char* sign_type);
+  Error Update(const char* data, size_t len);
+
+  // TODO(joyeecheung): track the memory used by OpenSSL types
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SignBase)
+  SET_SELF_SIZE(SignBase)
+
+ protected:
+  ncrypto::EVPMDCtxPointer mdctx_;
+};
+
+class Sign : public SignBase {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  struct SignResult {
+    Error error;
+    std::unique_ptr<v8::BackingStore> signature;
+
+    explicit SignResult(
+        Error err,
+        std::unique_ptr<v8::BackingStore>&& sig = nullptr)
+      : error(err), signature(std::move(sig)) {}
+  };
+
+  SignResult SignFinal(const ncrypto::EVPKeyPointer& pkey,
+                       int padding,
+                       const v8::Maybe<int>& saltlen,
+                       DSASigEnc dsa_sig_enc);
+
+  static void SignSync(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ protected:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SignInit(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SignUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SignFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  Sign(Environment* env, v8::Local<v8::Object> wrap);
+};
+
+class Verify : public SignBase {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  Error VerifyFinal(const ncrypto::EVPKeyPointer& key,
+                    const ByteSource& sig,
+                    int padding,
+                    const v8::Maybe<int>& saltlen,
+                    bool* verify_result);
+
+  static void VerifySync(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ protected:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void VerifyInit(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void VerifyUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void VerifyFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  Verify(Environment* env, v8::Local<v8::Object> wrap);
+};
+
+struct SignConfiguration final : public MemoryRetainer {
+  enum Mode {
+    kSign,
+    kVerify
+  };
+  enum Flags {
+    kHasNone = 0,
+    kHasSaltLength = 1,
+    kHasPadding = 2
+  };
+
+  CryptoJobMode job_mode;
+  Mode mode;
+  KeyObjectData key;
+  ByteSource data;
+  ByteSource signature;
+  const EVP_MD* digest = nullptr;
+  int flags = SignConfiguration::kHasNone;
+  int padding = 0;
+  int salt_length = 0;
+  DSASigEnc dsa_encoding = kSigEncDER;
+
+  SignConfiguration() = default;
+
+  explicit SignConfiguration(SignConfiguration&& other) noexcept;
+
+  SignConfiguration& operator=(SignConfiguration&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SignConfiguration)
+  SET_SELF_SIZE(SignConfiguration)
+};
+
+struct SignTraits final {
+  using AdditionalParameters = SignConfiguration;
+  static constexpr const char* JobName = "SignJob";
+
+// TODO(@jasnell): Sign request vs. Verify request
+
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_SIGNREQUEST;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      SignConfiguration* params);
+
+  static bool DeriveBits(Environment* env,
+                         const SignConfiguration& params,
+                         ByteSource* out,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const SignConfiguration& params,
+                                                ByteSource* out);
+};
+
+using SignJob = DeriveBitsJob<SignTraits>;
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_SIG_H_

package/dist/node/include/crypto/crypto_spkac.h

@@ -0,0 +1,21 @@
+#ifndef SRC_CRYPTO_CRYPTO_SPKAC_H_
+#define SRC_CRYPTO_CRYPTO_SPKAC_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "env.h"
+#include "v8.h"
+
+#include <openssl/evp.h>
+
+namespace node {
+namespace crypto {
+namespace SPKAC {
+void Initialize(Environment* env, v8::Local<v8::Object>);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+}  // namespace SPKAC
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_SPKAC_H_

package/dist/node/include/crypto/crypto_timing.h

@@ -0,0 +1,20 @@
+#ifndef SRC_CRYPTO_CRYPTO_TIMING_H_
+#define SRC_CRYPTO_CRYPTO_TIMING_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "env.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+namespace Timing {
+void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+}  // namespace Timing
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CRYPTO_CRYPTO_TIMING_H_