@encharm/cws 4.1.0 → 4.2.0

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

@@ -0,0 +1,156 @@
+#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

@@ -0,0 +1,77 @@
+#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

@@ -0,0 +1,170 @@
+#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_

package/src/headers/{12/node_crypto_groups.h → 18/crypto/crypto_groups.h}

@@ -19,8 +19,8 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#ifndef SRC_NODE_CRYPTO_GROUPS_H_
-#define SRC_NODE_CRYPTO_GROUPS_H_
+#ifndef SRC_CRYPTO_CRYPTO_GROUPS_H_
+#define SRC_CRYPTO_CRYPTO_GROUPS_H_
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
@@ -412,4 +412,4 @@ static const modp_group modp_groups[] = {
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#endif  // SRC_NODE_CRYPTO_GROUPS_H_
+#endif  // SRC_CRYPTO_CRYPTO_GROUPS_H_

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

@@ -0,0 +1,89 @@
+#ifndef SRC_CRYPTO_CRYPTO_HASH_H_
+#define SRC_CRYPTO_CRYPTO_HASH_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 {
+class Hash final : public BaseObject {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Hash)
+  SET_SELF_SIZE(Hash)
+
+  bool HashInit(const EVP_MD* md, v8::Maybe<unsigned int> xof_md_len);
+  bool HashUpdate(const char* data, size_t len);
+
+  static void GetHashes(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ protected:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HashUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HashDigest(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  Hash(Environment* env, v8::Local<v8::Object> wrap);
+
+ private:
+  EVPMDPointer mdctx_ {};
+  unsigned int md_len_ = 0;
+  ByteSource digest_;
+};
+
+struct HashConfig final : public MemoryRetainer {
+  CryptoJobMode mode;
+  ByteSource in;
+  const EVP_MD* digest;
+  unsigned int length;
+
+  HashConfig() = default;
+
+  explicit HashConfig(HashConfig&& other) noexcept;
+
+  HashConfig& operator=(HashConfig&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HashConfig)
+  SET_SELF_SIZE(HashConfig)
+};
+
+struct HashTraits final {
+  using AdditionalParameters = HashConfig;
+  static constexpr const char* JobName = "HashJob";
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_HASHREQUEST;
+
+  static v8::Maybe<bool> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      HashConfig* params);
+
+  static bool DeriveBits(
+      Environment* env,
+      const HashConfig& params,
+      ByteSource* out);
+
+  static v8::Maybe<bool> EncodeOutput(
+      Environment* env,
+      const HashConfig& params,
+      ByteSource* out,
+      v8::Local<v8::Value>* result);
+};
+
+using HashJob = DeriveBitsJob<HashTraits>;
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_HASH_H_

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

@@ -0,0 +1,65 @@
+#ifndef SRC_CRYPTO_CRYPTO_HKDF_H_
+#define SRC_CRYPTO_CRYPTO_HKDF_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "base_object.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+static constexpr size_t kMaxDigestMultiplier = 255;
+
+struct HKDFConfig final : public MemoryRetainer {
+  CryptoJobMode mode;
+  size_t length;
+  const EVP_MD* digest;
+  std::shared_ptr<KeyObjectData> key;
+  ByteSource salt;
+  ByteSource info;
+
+  HKDFConfig() = default;
+
+  explicit HKDFConfig(HKDFConfig&& other) noexcept;
+
+  HKDFConfig& operator=(HKDFConfig&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HKDFConfig)
+  SET_SELF_SIZE(HKDFConfig)
+};
+
+struct HKDFTraits final {
+  using AdditionalParameters = HKDFConfig;
+  static constexpr const char* JobName = "HKDFJob";
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_DERIVEBITSREQUEST;
+
+  static v8::Maybe<bool> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      HKDFConfig* params);
+
+  static bool DeriveBits(
+      Environment* env,
+      const HKDFConfig& params,
+      ByteSource* out);
+
+  static v8::Maybe<bool> EncodeOutput(
+      Environment* env,
+      const HKDFConfig& params,
+      ByteSource* out,
+      v8::Local<v8::Value>* result);
+};
+
+using HKDFJob = DeriveBitsJob<HKDFTraits>;
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_HKDF_H_

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

@@ -0,0 +1,94 @@
+#ifndef SRC_CRYPTO_CRYPTO_HMAC_H_
+#define SRC_CRYPTO_CRYPTO_HMAC_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_sig.h"
+#include "crypto/crypto_util.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "v8.h"
+
+namespace node {
+namespace crypto {
+class Hmac : public BaseObject {
+ public:
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Hmac)
+  SET_SELF_SIZE(Hmac)
+
+ protected:
+  void HmacInit(const char* hash_type, const char* key, int key_len);
+  bool HmacUpdate(const char* data, size_t len);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HmacInit(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HmacUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HmacDigest(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  Hmac(Environment* env, v8::Local<v8::Object> wrap);
+
+  static void Sign(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  HMACCtxPointer ctx_;
+};
+
+struct HmacConfig final : public MemoryRetainer {
+  CryptoJobMode job_mode;
+  SignConfiguration::Mode mode;
+  std::shared_ptr<KeyObjectData> key;
+  ByteSource data;
+  ByteSource signature;
+  const EVP_MD* digest;
+
+  HmacConfig() = default;
+
+  explicit HmacConfig(HmacConfig&& other) noexcept;
+
+  HmacConfig& operator=(HmacConfig&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HmacConfig)
+  SET_SELF_SIZE(HmacConfig)
+};
+
+struct HmacTraits final {
+  using AdditionalParameters = HmacConfig;
+  static constexpr const char* JobName = "HmacJob";
+
+// TODO(@jasnell): Sign request vs. Verify request
+
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_SIGNREQUEST;
+
+  static v8::Maybe<bool> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      HmacConfig* params);
+
+  static bool DeriveBits(
+      Environment* env,
+      const HmacConfig& params,
+      ByteSource* out);
+
+  static v8::Maybe<bool> EncodeOutput(
+      Environment* env,
+      const HmacConfig& params,
+      ByteSource* out,
+      v8::Local<v8::Value>* result);
+};
+
+using HmacJob = DeriveBitsJob<HmacTraits>;
+
+}  // namespace crypto
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_HMAC_H_