@encharm/cws 4.5.1 → 4.5.2

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

@@ -0,0 +1,131 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_CRYPTO_CRYPTO_CLIENTHELLO_H_
+#define SRC_CRYPTO_CRYPTO_CLIENTHELLO_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstddef>  // size_t
+#include <cstdint>
+
+namespace node {
+namespace crypto {
+// Parse the client hello so we can do async session resumption. OpenSSL's
+// session resumption uses synchronous callbacks, see SSL_CTX_sess_set_get_cb
+// and get_session_cb.
+//
+// TLS1.3 handshakes masquerade as TLS1.2 session resumption, and to do this,
+// they always include a session_id in the ClientHello, making up a bogus value
+// if necessary. The parser can't know if its a bogus id, and will cause a
+// 'newSession' event to be emitted. This should do no harm, the id won't be
+// found, and the handshake will continue.
+class ClientHelloParser {
+ public:
+  inline ClientHelloParser();
+
+  class ClientHello {
+   public:
+    inline uint8_t session_size() const { return session_size_; }
+    inline const uint8_t* session_id() const { return session_id_; }
+    inline bool has_ticket() const { return has_ticket_; }
+    inline uint8_t servername_size() const { return servername_size_; }
+    inline const uint8_t* servername() const { return servername_; }
+
+   private:
+    uint8_t session_size_;
+    const uint8_t* session_id_;
+    bool has_ticket_;
+    uint8_t servername_size_;
+    const uint8_t* servername_;
+
+    friend class ClientHelloParser;
+  };
+
+  typedef void (*OnHelloCb)(void* arg, const ClientHello& hello);
+  typedef void (*OnEndCb)(void* arg);
+
+  void Parse(const uint8_t* data, size_t avail);
+
+  inline void Reset();
+  inline void Start(OnHelloCb onhello_cb, OnEndCb onend_cb, void* cb_arg);
+  inline void End();
+  inline bool IsPaused() const;
+  inline bool IsEnded() const;
+
+ private:
+  static const size_t kMaxTLSFrameLen = 16 * 1024 + 5;
+  static const size_t kMaxSSLExFrameLen = 32 * 1024;
+  static const uint8_t kServernameHostname = 0;
+  static const size_t kMinStatusRequestSize = 5;
+
+  enum ParseState {
+    kWaiting,
+    kTLSHeader,
+    kPaused,
+    kEnded
+  };
+
+  enum FrameType {
+    kChangeCipherSpec = 20,
+    kAlert = 21,
+    kHandshake = 22,
+    kApplicationData = 23,
+    kOther = 255
+  };
+
+  enum HandshakeType {
+    kClientHello = 1
+  };
+
+  enum ExtensionType {
+    kServerName = 0,
+    kTLSSessionTicket = 35
+  };
+
+  bool ParseRecordHeader(const uint8_t* data, size_t avail);
+  void ParseHeader(const uint8_t* data, size_t avail);
+  void ParseExtension(const uint16_t type,
+                      const uint8_t* data,
+                      size_t len);
+  bool ParseTLSClientHello(const uint8_t* data, size_t avail);
+
+  ParseState state_;
+  OnHelloCb onhello_cb_;
+  OnEndCb onend_cb_;
+  void* cb_arg_;
+  size_t frame_len_ = 0;
+  size_t body_offset_ = 0;
+  size_t extension_offset_ = 0;
+  uint8_t session_size_ = 0;
+  const uint8_t* session_id_ = nullptr;
+  uint16_t servername_size_ = 0;
+  const uint8_t* servername_ = nullptr;
+  uint16_t tls_ticket_size_ = -1;
+  const uint8_t* tls_ticket_ = nullptr;
+};
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CRYPTO_CRYPTO_CLIENTHELLO_H_

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

@@ -0,0 +1,48 @@
+#ifndef SRC_CRYPTO_CRYPTO_COMMON_H_
+#define SRC_CRYPTO_CRYPTO_COMMON_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+#include "ncrypto.h"
+#include "node_crypto.h"
+#include "v8.h"
+
+#include <string>
+
+namespace node {
+namespace crypto {
+
+ncrypto::SSLSessionPointer GetTLSSession(const unsigned char* buf,
+                                         size_t length);
+
+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 ncrypto::SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Object> GetCipherInfo(Environment* env,
+                                         const ncrypto::SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Object> GetEphemeralKey(Environment* env,
+                                           const ncrypto::SSLPointer& ssl);
+
+v8::MaybeLocal<v8::Value> GetPeerCert(Environment* env,
+                                      const ncrypto::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);
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CRYPTO_CRYPTO_COMMON_H_

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

@@ -0,0 +1,171 @@
+#ifndef SRC_CRYPTO_CRYPTO_CONTEXT_H_
+#define SRC_CRYPTO_CRYPTO_CONTEXT_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 "v8.h"
+
+namespace node {
+namespace crypto {
+// A maxVersion of 0 means "any", but OpenSSL may support TLS versions that
+// Node.js doesn't, so pin the max to what we do support.
+constexpr int kMaxSupportedVersion = TLS1_3_VERSION;
+
+void GetRootCertificates(
+    const v8::FunctionCallbackInfo<v8::Value>& args);
+
+X509_STORE* NewRootCertStore();
+
+X509_STORE* GetOrCreateRootCertStore();
+
+ncrypto::BIOPointer LoadBIO(Environment* env, v8::Local<v8::Value> v);
+
+class SecureContext final : public BaseObject {
+ public:
+  using GetSessionCb = SSL_SESSION* (*)(SSL*, const unsigned char*, int, int*);
+  using KeylogCb = void (*)(const SSL*, const char*);
+  using NewSessionCb = int (*)(SSL*, SSL_SESSION*);
+  using SelectSNIContextCb = int (*)(SSL*, int*, void*);
+
+  ~SecureContext() override;
+
+  static bool HasInstance(Environment* env, const v8::Local<v8::Value>& value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static SecureContext* Create(Environment* env);
+
+  const ncrypto::SSLCtxPointer& ctx() const { return ctx_; }
+
+  // Non-const ctx() that allows for non-default initialization of
+  // the SecureContext.
+  ncrypto::SSLCtxPointer& ctx() { return ctx_; }
+
+  ncrypto::SSLPointer CreateSSL();
+
+  void SetGetSessionCallback(GetSessionCb cb);
+  void SetKeylogCallback(KeylogCb cb);
+  void SetNewSessionCallback(NewSessionCb cb);
+  void SetSelectSNIContextCallback(SelectSNIContextCb cb);
+
+  inline const ncrypto::X509Pointer& issuer() const { return issuer_; }
+  inline const ncrypto::X509Pointer& cert() const { return cert_; }
+
+  v8::Maybe<void> AddCert(Environment* env, ncrypto::BIOPointer&& bio);
+  v8::Maybe<void> SetCRL(Environment* env, const ncrypto::BIOPointer& bio);
+  v8::Maybe<void> UseKey(Environment* env, const KeyObjectData& key);
+
+  void SetCACert(const ncrypto::BIOPointer& bio);
+  void SetRootCerts();
+
+  void SetX509StoreFlag(unsigned long flags);  // NOLINT(runtime/int)
+  X509_STORE* GetCertStoreOwnedByThisSecureContext();
+
+  // TODO(joyeecheung): track the memory used by OpenSSL types
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(SecureContext)
+  SET_SELF_SIZE(SecureContext)
+
+  static const int kMaxSessionSize = 10 * 1024;
+
+  // See TicketKeyCallback
+  static const int kTicketKeyReturnIndex = 0;
+  static const int kTicketKeyHMACIndex = 1;
+  static const int kTicketKeyAESIndex = 2;
+  static const int kTicketKeyNameIndex = 3;
+  static const int kTicketKeyIVIndex = 4;
+
+ protected:
+  // OpenSSL structures are opaque. This is sizeof(SSL_CTX) for OpenSSL 1.1.1b:
+  static const int64_t kExternalSize = 1024;
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Init(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetKey(const v8::FunctionCallbackInfo<v8::Value>& args);
+#ifndef OPENSSL_NO_ENGINE
+  static void SetEngineKey(const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif  // !OPENSSL_NO_ENGINE
+  static void SetCert(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddCACert(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAllowPartialTrustChain(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddCRL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddRootCerts(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetCipherSuites(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetCiphers(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSigalgs(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetECDHCurve(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetDHParam(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSessionIdContext(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSessionTimeout(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetMinProto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetMaxProto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinProto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaxProto(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoadPKCS12(const v8::FunctionCallbackInfo<v8::Value>& args);
+#ifndef OPENSSL_NO_ENGINE
+  static void SetClientCertEngine(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif  // !OPENSSL_NO_ENGINE
+  static void GetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EnableTicketKeyCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CtxGetter(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+  template <bool primary>
+  static void GetCertificate(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static int TicketKeyCallback(SSL* ssl,
+                               unsigned char* name,
+                               unsigned char* iv,
+                               EVP_CIPHER_CTX* ectx,
+                               HMAC_CTX* hctx,
+                               int enc);
+
+  static int TicketCompatibilityCallback(SSL* ssl,
+                                         unsigned char* name,
+                                         unsigned char* iv,
+                                         EVP_CIPHER_CTX* ectx,
+                                         HMAC_CTX* hctx,
+                                         int enc);
+
+  SecureContext(Environment* env, v8::Local<v8::Object> wrap);
+  void Reset();
+
+ private:
+  ncrypto::SSLCtxPointer ctx_;
+  ncrypto::X509Pointer cert_;
+  ncrypto::X509Pointer issuer_;
+  // Non-owning cache for SSL_CTX_get_cert_store(ctx_.get())
+  X509_STORE* own_cert_store_cache_ = nullptr;
+#ifndef OPENSSL_NO_ENGINE
+  bool client_cert_engine_provided_ = false;
+  ncrypto::EnginePointer private_key_engine_;
+#endif  // !OPENSSL_NO_ENGINE
+
+  unsigned char ticket_key_name_[16];
+  unsigned char ticket_key_aes_[16];
+  unsigned char ticket_key_hmac_[16];
+};
+
+int SSL_CTX_use_certificate_chain(SSL_CTX* ctx,
+                                  ncrypto::BIOPointer&& in,
+                                  ncrypto::X509Pointer* cert,
+                                  ncrypto::X509Pointer* issuer);
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_CONTEXT_H_

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

@@ -0,0 +1,126 @@
+#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 final : public BaseObject {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  DiffieHellman(Environment* env,
+                v8::Local<v8::Object> wrap,
+                ncrypto::DHPointer dh);
+  operator ncrypto::DHPointer&() { return dh_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(DiffieHellman)
+  SET_SELF_SIZE(DiffieHellman)
+
+ private:
+  ncrypto::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<ncrypto::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 ncrypto::EVPKeyCtxPointer Setup(DhKeyPairGenConfig* params);
+
+  static v8::Maybe<void> 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<void> AdditionalConfig(
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      DHKeyExportConfig* config);
+
+  static WebCryptoKeyExportStatus DoExport(const KeyObjectData& key_data,
+                                           WebCryptoKeyFormat format,
+                                           const DHKeyExportConfig& params,
+                                           ByteSource* out);
+};
+
+using DHKeyExportJob = KeyExportJob<DHKeyExportTraits>;
+
+struct DHBitsConfig final : public MemoryRetainer {
+  KeyObjectData private_key;
+  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<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      DHBitsConfig* params);
+
+  static bool DeriveBits(Environment* env,
+                         const DHBitsConfig& params,
+                         ByteSource* out_,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const DHBitsConfig& params,
+                                                ByteSource* out);
+};
+
+using DHBitsJob = DeriveBitsJob<DHBitsTraits>;
+
+bool GetDhKeyDetail(Environment* env,
+                    const 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/24/crypto/crypto_dsa.h

@@ -0,0 +1,50 @@
+#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::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 ncrypto::EVPKeyCtxPointer Setup(DsaKeyPairGenConfig* params);
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int* offset,
+      DsaKeyPairGenConfig* params);
+};
+
+using DsaKeyPairGenJob = KeyGenJob<KeyPairGenTraits<DsaKeyGenTraits>>;
+
+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 node::crypto
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_DSA_H_

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

@@ -0,0 +1,163 @@
+#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 {
+
+class ECDH final : public BaseObject {
+ public:
+  ~ECDH() override = default;
+
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  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)
+  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,
+       ncrypto::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 ncrypto::BignumPointer& private_key);
+
+  ncrypto::ECKeyPointer key_;
+  const EC_GROUP* group_;
+};
+
+struct ECDHBitsConfig final : public MemoryRetainer {
+  int id_;
+  KeyObjectData private_;
+  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<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_,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const ECDHBitsConfig& params,
+                                                ByteSource* out);
+};
+
+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 ncrypto::EVPKeyCtxPointer Setup(EcKeyPairGenConfig* params);
+
+  static v8::Maybe<void> 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<void> AdditionalConfig(
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      ECKeyExportConfig* config);
+
+  static WebCryptoKeyExportStatus DoExport(const KeyObjectData& key_data,
+                                           WebCryptoKeyFormat format,
+                                           const ECKeyExportConfig& params,
+                                           ByteSource* out);
+};
+
+using ECKeyExportJob = KeyExportJob<ECKeyExportTraits>;
+
+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
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_EC_H_