@encharm/cws 4.5.3 → 4.6.0

package/src/headers/26/crypto/crypto_rsa.h

@@ -0,0 +1,108 @@
+#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.
+  ncrypto::Digest md = nullptr;
+  ncrypto::Digest 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 RSACipherConfig final : public MemoryRetainer {
+  ByteSource label;
+  int padding = 0;
+  ncrypto::Digest digest;
+
+  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>;
+
+bool ExportJWKRsaKey(Environment* env,
+                     const KeyObjectData& key,
+                     v8::Local<v8::Object> target);
+
+KeyObjectData ImportJWKRsaKey(Environment* env, v8::Local<v8::Object> jwk);
+
+bool 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/src/headers/26/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 {
+  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,
+                         CryptoErrorStore* errors);
+
+  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/src/headers/26/crypto/crypto_sig.h

@@ -0,0 +1,159 @@
+#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 class DSASigEnc { DER, P1363, Invalid };
+
+class SignBase : public BaseObject {
+ public:
+  enum class Error {
+    Ok,
+    UnknownDigest,
+    Init,
+    NotInitialised,
+    Update,
+    PrivateKey,
+    PublicKey,
+    MalformedSignature,
+    ContextUnsupported,
+  };
+
+  SignBase(Environment* env, v8::Local<v8::Object> wrap);
+
+  Error Init(const char* digest);
+  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 final : 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;
+
+    inline 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,
+                       std::optional<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 final : 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,
+                    std::optional<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 class Mode { Sign, Verify };
+  enum Flags {
+    kHasNone = 0,
+    kHasSaltLength = 1,
+    kHasPadding = 2,
+    kHasContextString = 4
+  };
+
+  Mode mode;
+  KeyObjectData key;
+  ByteSource data;
+  ByteSource signature;
+  ncrypto::Digest digest;
+  int flags = SignConfiguration::kHasNone;
+  int padding = 0;
+  int salt_length = 0;
+  DSASigEnc dsa_encoding = DSASigEnc::DER;
+  ByteSource context_string;
+
+  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";
+
+  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,
+                         CryptoErrorStore* errors);
+
+  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/src/headers/26/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/src/headers/26/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_