@encharm/cws 4.4.1 → 4.5.2

package/src/headers/16/crypto/crypto_cipher.h

@@ -1,286 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_CIPHER_H_
-#define SRC_CRYPTO_CRYPTO_CIPHER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
-#include "base_object.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "v8.h"
-
-#include <string>
-
-namespace node {
-namespace crypto {
-class CipherBase : public BaseObject {
- public:
-  static void GetSSLCiphers(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetCiphers(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(CipherBase)
-  SET_SELF_SIZE(CipherBase)
-
- protected:
-  enum CipherKind {
-    kCipher,
-    kDecipher
-  };
-  enum UpdateResult {
-    kSuccess,
-    kErrorMessageSize,
-    kErrorState
-  };
-  enum AuthTagState {
-    kAuthTagUnknown,
-    kAuthTagKnown,
-    kAuthTagPassedToOpenSSL
-  };
-  static const unsigned kNoAuthTagLength = static_cast<unsigned>(-1);
-
-  void CommonInit(const char* cipher_type,
-                  const EVP_CIPHER* cipher,
-                  const unsigned char* key,
-                  int key_len,
-                  const unsigned char* iv,
-                  int iv_len,
-                  unsigned int auth_tag_len);
-  void Init(const char* cipher_type,
-            const ArrayBufferOrViewContents<unsigned char>& key_buf,
-            unsigned int auth_tag_len);
-  void InitIv(const char* cipher_type,
-              const ByteSource& key_buf,
-              const ArrayBufferOrViewContents<unsigned char>& iv_buf,
-              unsigned int auth_tag_len);
-  bool InitAuthenticated(const char* cipher_type, int iv_len,
-                         unsigned int auth_tag_len);
-  bool CheckCCMMessageLength(int message_len);
-  UpdateResult Update(const char* data, size_t len, AllocatedBuffer* out);
-  bool Final(AllocatedBuffer* out);
-  bool SetAutoPadding(bool auto_padding);
-
-  bool IsAuthenticatedMode() const;
-  bool SetAAD(
-      const ArrayBufferOrViewContents<unsigned char>& data,
-      int plaintext_len);
-  bool MaybePassAuthTagToOpenSSL();
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Init(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void InitIv(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Final(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetAutoPadding(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void GetAuthTag(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetAuthTag(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetAAD(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  CipherBase(Environment* env, v8::Local<v8::Object> wrap, CipherKind kind);
-
- private:
-  DeleteFnPtr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> ctx_;
-  const CipherKind kind_;
-  AuthTagState auth_tag_state_;
-  unsigned int auth_tag_len_;
-  char auth_tag_[EVP_GCM_TLS_TAG_LEN];
-  bool pending_auth_failed_;
-  int max_message_size_;
-};
-
-class PublicKeyCipher {
- public:
-  typedef int (*EVP_PKEY_cipher_init_t)(EVP_PKEY_CTX* ctx);
-  typedef int (*EVP_PKEY_cipher_t)(EVP_PKEY_CTX* ctx,
-                                   unsigned char* out, size_t* outlen,
-                                   const unsigned char* in, size_t inlen);
-
-  enum Operation {
-    kPublic,
-    kPrivate
-  };
-
-  template <Operation operation,
-            EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
-            EVP_PKEY_cipher_t EVP_PKEY_cipher>
-  static bool Cipher(Environment* env,
-                     const ManagedEVPPKey& pkey,
-                     int padding,
-                     const EVP_MD* digest,
-                     const ArrayBufferOrViewContents<unsigned char>& oaep_label,
-                     const ArrayBufferOrViewContents<unsigned char>& data,
-                     AllocatedBuffer* out);
-
-  template <Operation operation,
-            EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
-            EVP_PKEY_cipher_t EVP_PKEY_cipher>
-  static void Cipher(const v8::FunctionCallbackInfo<v8::Value>& args);
-};
-
-enum WebCryptoCipherMode {
-  kWebCryptoCipherEncrypt,
-  kWebCryptoCipherDecrypt
-};
-
-enum class WebCryptoCipherStatus {
-  OK,
-  INVALID_KEY_TYPE,
-  FAILED
-};
-
-// CipherJob is a base implementation class for implementations of
-// one-shot sync and async ciphers. It has been added primarily to
-// support the AES and RSA ciphers underlying the WebCrypt API.
-//
-// See the crypto_aes and crypto_rsa headers for examples of how to
-// use CipherJob.
-template <typename CipherTraits>
-class CipherJob final : public CryptoJob<CipherTraits> {
- public:
-  using AdditionalParams = typename CipherTraits::AdditionalParameters;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    Environment* env = Environment::GetCurrent(args);
-    CHECK(args.IsConstructCall());
-
-    CryptoJobMode mode = GetCryptoJobMode(args[0]);
-
-    CHECK(args[1]->IsUint32());  // Cipher Mode
-
-    uint32_t cmode = args[1].As<v8::Uint32>()->Value();
-    CHECK_LE(cmode, WebCryptoCipherMode::kWebCryptoCipherDecrypt);
-    WebCryptoCipherMode cipher_mode = static_cast<WebCryptoCipherMode>(cmode);
-
-    CHECK(args[2]->IsObject());  // KeyObject
-    KeyObjectHandle* key;
-    ASSIGN_OR_RETURN_UNWRAP(&key, args[2]);
-    CHECK_NOT_NULL(key);
-
-    ArrayBufferOrViewContents<char> data(args[3]);  // data to operate on
-    if (!data.CheckSizeInt32())
-      return THROW_ERR_OUT_OF_RANGE(env, "data is too large");
-
-    AdditionalParams params;
-    if (CipherTraits::AdditionalConfig(mode, args, 4, cipher_mode, &params)
-            .IsNothing()) {
-      // The CipherTraits::AdditionalConfig is responsible for
-      // calling an appropriate THROW_CRYPTO_* variant reporting
-      // whatever error caused initialization to fail.
-      return;
-    }
-
-    new CipherJob<CipherTraits>(
-        env,
-        args.This(),
-        mode,
-        key,
-        cipher_mode,
-        data,
-        std::move(params));
-  }
-
-  static void Initialize(
-      Environment* env,
-      v8::Local<v8::Object> target) {
-    CryptoJob<CipherTraits>::Initialize(New, env, target);
-  }
-
-  CipherJob(
-      Environment* env,
-      v8::Local<v8::Object> object,
-      CryptoJobMode mode,
-      KeyObjectHandle* key,
-      WebCryptoCipherMode cipher_mode,
-      const ArrayBufferOrViewContents<char>& data,
-      AdditionalParams&& params)
-      : CryptoJob<CipherTraits>(
-            env,
-            object,
-            AsyncWrap::PROVIDER_CIPHERREQUEST,
-            mode,
-            std::move(params)),
-        key_(key->Data()),
-        cipher_mode_(cipher_mode),
-        in_(mode == kCryptoJobAsync
-            ? data.ToCopy()
-            : data.ToByteSource()) {}
-
-  std::shared_ptr<KeyObjectData> key() const { return key_; }
-
-  WebCryptoCipherMode cipher_mode() const { return cipher_mode_; }
-
-  void DoThreadPoolWork() override {
-    const WebCryptoCipherStatus status =
-        CipherTraits::DoCipher(
-            AsyncWrap::env(),
-            key(),
-            cipher_mode_,
-            *CryptoJob<CipherTraits>::params(),
-            in_,
-            &out_);
-    if (status == WebCryptoCipherStatus::OK) {
-      // Success!
-      return;
-    }
-    CryptoErrorStore* errors = CryptoJob<CipherTraits>::errors();
-    errors->Capture();
-    if (errors->Empty()) {
-      switch (status) {
-        case WebCryptoCipherStatus::OK:
-          UNREACHABLE();
-          break;
-        case WebCryptoCipherStatus::INVALID_KEY_TYPE:
-          errors->Insert(NodeCryptoError::INVALID_KEY_TYPE);
-          break;
-        case WebCryptoCipherStatus::FAILED:
-          errors->Insert(NodeCryptoError::CIPHER_JOB_FAILED);
-          break;
-      }
-    }
-  }
-
-  v8::Maybe<bool> ToResult(
-      v8::Local<v8::Value>* err,
-      v8::Local<v8::Value>* result) override {
-    Environment* env = AsyncWrap::env();
-    CryptoErrorStore* errors = CryptoJob<CipherTraits>::errors();
-
-    if (errors->Empty())
-      errors->Capture();
-
-    if (out_.size() > 0 || errors->Empty()) {
-      CHECK(errors->Empty());
-      *err = v8::Undefined(env->isolate());
-      *result = out_.ToArrayBuffer(env);
-      return v8::Just(!result->IsEmpty());
-    }
-
-    *result = v8::Undefined(env->isolate());
-    return v8::Just(errors->ToException(env).ToLocal(err));
-  }
-
-  SET_SELF_SIZE(CipherJob)
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    if (CryptoJob<CipherTraits>::mode() == kCryptoJobAsync)
-      tracker->TrackFieldWithSize("in", in_.size());
-    tracker->TrackFieldWithSize("out", out_.size());
-    CryptoJob<CipherTraits>::MemoryInfo(tracker);
-  }
-
- private:
-  std::shared_ptr<KeyObjectData> key_;
-  WebCryptoCipherMode cipher_mode_;
-  ByteSource in_;
-  ByteSource out_;
-};
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_CIPHER_H_

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

@@ -1,187 +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>
-#include <unordered_map>
-
-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>;
-
-int SSL_CTX_get_issuer(SSL_CTX* ctx, X509* cert, X509** issuer);
-
-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 unsigned char* buf,
-    size_t length);
-
-bool SetTLSSession(
-    const SSLPointer& ssl,
-    const SSLSessionPointer& session);
-
-SSLSessionPointer GetTLSSession(v8::Local<v8::Value> val);
-
-SSLSessionPointer GetTLSSession(const unsigned char* buf, size_t length);
-
-std::unordered_multimap<std::string, std::string>
-GetCertificateAltNames(X509* cert);
-
-std::string GetCertificateCN(X509* cert);
-
-long VerifyPeerCertificate(  // NOLINT(runtime/int)
-    const SSLPointer& ssl,
-    long def = X509_V_ERR_UNSPECIFIED);  // NOLINT(runtime/int)
-
-int 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::Value> GetCipherName(
-    Environment* env,
-    const SSLPointer& ssl);
-
-v8::MaybeLocal<v8::Value> GetCipherStandardName(
-    Environment* env,
-    const SSLPointer& ssl);
-
-v8::MaybeLocal<v8::Value> GetCipherVersion(
-    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 SafeX509ExtPrint(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);
-
-template <int nid>
-v8::MaybeLocal<v8::Value> GetInfoString(
-    Environment* env,
-    const BIOPointer& bio,
-    X509* cert) {
-  int index = X509_get_ext_by_NID(cert, nid, -1);
-  if (index < 0)
-    return Undefined(env->isolate());
-
-  X509_EXTENSION* ext = X509_get_ext(cert, index);
-  CHECK_NOT_NULL(ext);
-
-  if (!SafeX509ExtPrint(bio, ext) &&
-      X509V3_EXT_print(bio.get(), ext, 0, 0) != 1) {
-    USE(BIO_reset(bio.get()));
-    return v8::Null(env->isolate());
-  }
-
-  return ToV8Value(env, bio);
-}
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_CRYPTO_CRYPTO_COMMON_H_

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

@@ -1,157 +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 <vector>
-
-namespace node {
-namespace crypto {
-class DiffieHellman : public BaseObject {
- public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-
-  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 {
-  // TODO(tniessen): Use std::variant instead.
-  // 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.
-  BignumPointer prime_fixed_value;
-  unsigned int prime_size;
-  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/16/crypto/crypto_dsa.h

@@ -1,76 +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);
-}  // namespace DSAAlg
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_DSA_H_