@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/crypto/crypto_common.h

@@ -1,151 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_COMMON_H_
-#define SRC_CRYPTO_CRYPTO_COMMON_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_crypto.h"
-#include "v8.h"
-#include <openssl/ssl.h>
-#include <openssl/x509v3.h>
-
-#include <string>
-
-namespace node {
-namespace crypto {
-
-struct StackOfX509Deleter {
-  void operator()(STACK_OF(X509)* p) const { sk_X509_pop_free(p, X509_free); }
-};
-using StackOfX509 = std::unique_ptr<STACK_OF(X509), StackOfX509Deleter>;
-
-struct StackOfXASN1Deleter {
-  void operator()(STACK_OF(ASN1_OBJECT)* p) const {
-    sk_ASN1_OBJECT_pop_free(p, ASN1_OBJECT_free);
-  }
-};
-using StackOfASN1 = std::unique_ptr<STACK_OF(ASN1_OBJECT), StackOfXASN1Deleter>;
-
-X509Pointer SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert);
-
-void LogSecret(
-    const SSLPointer& ssl,
-    const char* name,
-    const unsigned char* secret,
-    size_t secretlen);
-
-bool SetALPN(const SSLPointer& ssl, const std::string& alpn);
-
-bool SetALPN(const SSLPointer& ssl, v8::Local<v8::Value> alpn);
-
-v8::MaybeLocal<v8::Value> GetSSLOCSPResponse(
-    Environment* env,
-    SSL* ssl,
-    v8::Local<v8::Value> default_value);
-
-bool SetTLSSession(
-    const SSLPointer& ssl,
-    const SSLSessionPointer& session);
-
-SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length);
-
-long VerifyPeerCertificate(  // NOLINT(runtime/int)
-    const SSLPointer& ssl,
-    long def = X509_V_ERR_UNSPECIFIED);  // NOLINT(runtime/int)
-
-bool UseSNIContext(const SSLPointer& ssl, BaseObjectPtr<SecureContext> context);
-
-const char* GetClientHelloALPN(const SSLPointer& ssl);
-
-const char* GetClientHelloServerName(const SSLPointer& ssl);
-
-const char* GetServerName(SSL* ssl);
-
-v8::MaybeLocal<v8::Array> GetClientHelloCiphers(
-    Environment* env,
-    const SSLPointer& ssl);
-
-bool SetGroups(SecureContext* sc, const char* groups);
-
-const char* X509ErrorCode(long err);  // NOLINT(runtime/int)
-
-v8::MaybeLocal<v8::Value> GetValidationErrorReason(Environment* env, int err);
-
-v8::MaybeLocal<v8::Value> GetValidationErrorCode(Environment* env, int err);
-
-v8::MaybeLocal<v8::Value> GetCert(Environment* env, const SSLPointer& ssl);
-
-v8::MaybeLocal<v8::Object> GetCipherInfo(
-    Environment* env,
-    const SSLPointer& ssl);
-
-v8::MaybeLocal<v8::Object> GetEphemeralKey(
-    Environment* env,
-    const SSLPointer& ssl);
-
-v8::MaybeLocal<v8::Value> GetPeerCert(
-    Environment* env,
-    const SSLPointer& ssl,
-    bool abbreviated = false,
-    bool is_server = false);
-
-v8::MaybeLocal<v8::Object> ECPointToBuffer(
-    Environment* env,
-    const EC_GROUP* group,
-    const EC_POINT* point,
-    point_conversion_form_t form,
-    const char** error);
-
-v8::MaybeLocal<v8::Object> X509ToObject(
-    Environment* env,
-    X509* cert);
-
-v8::MaybeLocal<v8::Value> GetValidTo(
-    Environment* env,
-    X509* cert,
-    const BIOPointer& bio);
-
-v8::MaybeLocal<v8::Value> GetValidFrom(
-    Environment* env,
-    X509* cert,
-    const BIOPointer& bio);
-
-v8::MaybeLocal<v8::Value> GetFingerprintDigest(
-    Environment* env,
-    const EVP_MD* method,
-    X509* cert);
-
-v8::MaybeLocal<v8::Value> GetKeyUsage(Environment* env, X509* cert);
-
-v8::MaybeLocal<v8::Value> GetSerialNumber(Environment* env, X509* cert);
-
-v8::MaybeLocal<v8::Object> GetRawDERCertificate(Environment* env, X509* cert);
-
-v8::Local<v8::Value> ToV8Value(Environment* env, const BIOPointer& bio);
-bool SafeX509SubjectAltNamePrint(const BIOPointer& out, X509_EXTENSION* ext);
-
-v8::MaybeLocal<v8::Value> GetSubject(
-    Environment* env,
-    const BIOPointer& bio,
-    X509* cert);
-
-v8::MaybeLocal<v8::Value> GetIssuerString(
-    Environment* env,
-    const BIOPointer& bio,
-    X509* cert);
-
-v8::MaybeLocal<v8::Value> GetSubjectAltNameString(
-    Environment* env,
-    const BIOPointer& bio,
-    X509* cert);
-
-v8::MaybeLocal<v8::Value> GetInfoAccessString(
-    Environment* env,
-    const BIOPointer& bio,
-    X509* cert);
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_CRYPTO_CRYPTO_COMMON_H_

package/src/headers/18/crypto/crypto_dh.h

@@ -1,156 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_DH_H_
-#define SRC_CRYPTO_CRYPTO_DH_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_keygen.h"
-#include "crypto/crypto_util.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "v8.h"
-
-#include <variant>
-
-namespace node {
-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);
-  bool Init(const char* p, int p_len, const char* g, int g_len);
-
-  static void Stateless(const v8::FunctionCallbackInfo<v8::Value>& args);
-
- protected:
-  static void DiffieHellmanGroup(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GenerateKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPrime(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetGenerator(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ComputeSecret(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void VerifyErrorGetter(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  DiffieHellman(Environment* env, v8::Local<v8::Object> wrap);
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(DiffieHellman)
-  SET_SELF_SIZE(DiffieHellman)
-
- private:
-  static void GetField(const v8::FunctionCallbackInfo<v8::Value>& args,
-                       const BIGNUM* (*get_field)(const DH*),
-                       const char* err_if_null);
-  static void SetKey(const v8::FunctionCallbackInfo<v8::Value>& args,
-                     int (*set_field)(DH*, BIGNUM*), const char* what);
-  bool VerifyContext();
-
-  int verifyError_;
-  DHPointer dh_;
-};
-
-struct DhKeyPairParams final : public MemoryRetainer {
-  // Diffie-Hellman can either generate keys using a fixed prime, or by first
-  // generating a random prime of a given size (in bits). Only one of both
-  // options may be specified.
-  std::variant<BignumPointer, int> prime;
-  unsigned int generator;
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(DhKeyPairParams)
-  SET_SELF_SIZE(DhKeyPairParams)
-};
-
-using DhKeyPairGenConfig = KeyPairGenConfig<DhKeyPairParams>;
-
-struct DhKeyGenTraits final {
-  using AdditionalParameters = DhKeyPairGenConfig;
-  static constexpr const char* JobName = "DhKeyPairGenJob";
-
-  static EVPKeyCtxPointer Setup(DhKeyPairGenConfig* params);
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      DhKeyPairGenConfig* params);
-};
-
-using DHKeyPairGenJob = KeyGenJob<KeyPairGenTraits<DhKeyGenTraits>>;
-
-struct DHKeyExportConfig final : public MemoryRetainer {
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(DHKeyExportConfig)
-  SET_SELF_SIZE(DHKeyExportConfig)
-};
-
-struct DHKeyExportTraits final {
-  static constexpr const char* JobName = "DHKeyExportJob";
-  using AdditionalParameters = DHKeyExportConfig;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int offset,
-      DHKeyExportConfig* config);
-
-  static WebCryptoKeyExportStatus DoExport(
-      std::shared_ptr<KeyObjectData> key_data,
-      WebCryptoKeyFormat format,
-      const DHKeyExportConfig& params,
-      ByteSource* out);
-};
-
-using DHKeyExportJob = KeyExportJob<DHKeyExportTraits>;
-
-struct DHBitsConfig final : public MemoryRetainer {
-  std::shared_ptr<KeyObjectData> private_key;
-  std::shared_ptr<KeyObjectData> public_key;
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(DHBitsConfig)
-  SET_SELF_SIZE(DHBitsConfig)
-};
-
-struct DHBitsTraits final {
-  using AdditionalParameters = DHBitsConfig;
-  static constexpr const char* JobName = "DHBitsJob";
-  static constexpr AsyncWrap::ProviderType Provider =
-      AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int offset,
-      DHBitsConfig* params);
-
-  static bool DeriveBits(
-      Environment* env,
-      const DHBitsConfig& params,
-      ByteSource* out_);
-
-  static v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const DHBitsConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
-};
-
-using DHBitsJob = DeriveBitsJob<DHBitsTraits>;
-
-v8::Maybe<bool> GetDhKeyDetail(
-    Environment* env,
-    std::shared_ptr<KeyObjectData> key,
-    v8::Local<v8::Object> target);
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_DH_H_

package/src/headers/18/crypto/crypto_dsa.h

@@ -1,77 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_DSA_H_
-#define SRC_CRYPTO_CRYPTO_DSA_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_keygen.h"
-#include "crypto/crypto_util.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-struct DsaKeyPairParams final : public MemoryRetainer {
-  unsigned int modulus_bits;
-  int divisor_bits;
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(DsaKeyPairParams)
-  SET_SELF_SIZE(DsaKeyPairParams)
-};
-
-using DsaKeyPairGenConfig = KeyPairGenConfig<DsaKeyPairParams>;
-
-struct DsaKeyGenTraits final {
-  using AdditionalParameters = DsaKeyPairGenConfig;
-  static constexpr const char* JobName = "DsaKeyPairGenJob";
-
-  static EVPKeyCtxPointer Setup(DsaKeyPairGenConfig* params);
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      DsaKeyPairGenConfig* params);
-};
-
-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);
-
-namespace DSAAlg {
-void Initialize(Environment* env, v8::Local<v8::Object> target);
-void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-}  // namespace DSAAlg
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_DSA_H_

package/src/headers/18/crypto/crypto_ec.h

@@ -1,170 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_EC_H_
-#define SRC_CRYPTO_CRYPTO_EC_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "base_object.h"
-#include "crypto/crypto_keygen.h"
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "node_internals.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-int GetCurveFromName(const char* name);
-int GetOKPCurveFromName(const char* name);
-
-class ECDH final : public BaseObject {
- public:
-  ~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);
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(ECDH)
-  SET_SELF_SIZE(ECDH)
-
-  static void ConvertKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void GetCurves(const v8::FunctionCallbackInfo<v8::Value>& args);
-
- protected:
-  ECDH(Environment* env, v8::Local<v8::Object> wrap, ECKeyPointer&& key);
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GenerateKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ComputeSecret(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  bool IsKeyPairValid();
-  bool IsKeyValidForCurve(const BignumPointer& private_key);
-
-  ECKeyPointer key_;
-  const EC_GROUP* group_;
-};
-
-struct ECDHBitsConfig final : public MemoryRetainer {
-  int id_;
-  std::shared_ptr<KeyObjectData> private_;
-  std::shared_ptr<KeyObjectData> public_;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(ECDHBitsConfig)
-  SET_SELF_SIZE(ECDHBitsConfig)
-};
-
-struct ECDHBitsTraits final {
-  using AdditionalParameters = ECDHBitsConfig;
-  static constexpr const char* JobName = "ECDHBitsJob";
-  static constexpr AsyncWrap::ProviderType Provider =
-      AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
-
-  static v8::Maybe<bool> 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 v8::Maybe<bool> EncodeOutput(
-      Environment* env,
-      const ECDHBitsConfig& params,
-      ByteSource* out,
-      v8::Local<v8::Value>* result);
-};
-
-using ECDHBitsJob = DeriveBitsJob<ECDHBitsTraits>;
-
-struct EcKeyPairParams final : public MemoryRetainer {
-  int curve_nid;
-  int param_encoding;
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(EcKeyPairParams)
-  SET_SELF_SIZE(EcKeyPairParams)
-};
-
-using EcKeyPairGenConfig = KeyPairGenConfig<EcKeyPairParams>;
-
-struct EcKeyGenTraits final {
-  using AdditionalParameters = EcKeyPairGenConfig;
-  static constexpr const char* JobName = "EcKeyPairGenJob";
-
-  static EVPKeyCtxPointer Setup(EcKeyPairGenConfig* params);
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      EcKeyPairGenConfig* params);
-};
-
-using ECKeyPairGenJob = KeyGenJob<KeyPairGenTraits<EcKeyGenTraits>>;
-
-// There is currently no additional information that the
-// ECKeyExport needs to collect, but we need to provide
-// the base struct anyway.
-struct ECKeyExportConfig final : public MemoryRetainer {
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(ECKeyExportConfig)
-  SET_SELF_SIZE(ECKeyExportConfig)
-};
-
-struct ECKeyExportTraits final {
-  static constexpr const char* JobName = "ECKeyExportJob";
-  using AdditionalParameters = ECKeyExportConfig;
-
-  static v8::Maybe<bool> 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);
-};
-
-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);
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_EC_H_