@encharm/cws 4.4.1 → 4.5.1

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

@@ -1,301 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_KEYGEN_H_
-#define SRC_CRYPTO_CRYPTO_KEYGEN_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
-#include "async_wrap.h"
-#include "base_object.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "v8.h"
-
-namespace node {
-namespace crypto {
-namespace Keygen {
-void Initialize(Environment* env, v8::Local<v8::Object> target);
-}  // namespace Keygen
-
-enum class KeyGenJobStatus {
-  OK,
-  FAILED
-};
-
-// A Base CryptoJob for generating secret keys or key pairs.
-// The KeyGenTraits is largely responsible for the details of
-// the implementation, while KeyGenJob handles the common
-// mechanisms.
-template <typename KeyGenTraits>
-class KeyGenJob final : public CryptoJob<KeyGenTraits> {
- public:
-  using AdditionalParams = typename KeyGenTraits::AdditionalParameters;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    Environment* env = Environment::GetCurrent(args);
-    CHECK(args.IsConstructCall());
-
-    CryptoJobMode mode = GetCryptoJobMode(args[0]);
-
-    unsigned int offset = 1;
-
-    AdditionalParams params;
-    if (KeyGenTraits::AdditionalConfig(mode, args, &offset, &params)
-            .IsNothing()) {
-      // The KeyGenTraits::AdditionalConfig is responsible for
-      // calling an appropriate THROW_CRYPTO_* variant reporting
-      // whatever error caused initialization to fail.
-      return;
-    }
-
-    new KeyGenJob<KeyGenTraits>(env, args.This(), mode, std::move(params));
-  }
-
-  static void Initialize(
-      Environment* env,
-      v8::Local<v8::Object> target) {
-    CryptoJob<KeyGenTraits>::Initialize(New, env, target);
-  }
-
-  KeyGenJob(
-      Environment* env,
-      v8::Local<v8::Object> object,
-      CryptoJobMode mode,
-      AdditionalParams&& params)
-      : CryptoJob<KeyGenTraits>(
-            env,
-            object,
-            KeyGenTraits::Provider,
-            mode,
-            std::move(params)) {}
-
-  void DoThreadPoolWork() override {
-    // Make sure the CSPRNG is properly seeded so the results are secure.
-    CheckEntropy();
-
-    AdditionalParams* params = CryptoJob<KeyGenTraits>::params();
-
-    switch (KeyGenTraits::DoKeyGen(AsyncWrap::env(), params)) {
-      case KeyGenJobStatus::OK:
-        status_ = KeyGenJobStatus::OK;
-        // Success!
-        break;
-      case KeyGenJobStatus::FAILED: {
-        CryptoErrorStore* errors = CryptoJob<KeyGenTraits>::errors();
-        errors->Capture();
-        if (errors->Empty())
-          errors->Insert(NodeCryptoError::KEY_GENERATION_JOB_FAILED);
-      }
-    }
-  }
-
-  v8::Maybe<bool> ToResult(
-      v8::Local<v8::Value>* err,
-      v8::Local<v8::Value>* result) override {
-    Environment* env = AsyncWrap::env();
-    CryptoErrorStore* errors = CryptoJob<KeyGenTraits>::errors();
-    AdditionalParams* params = CryptoJob<KeyGenTraits>::params();
-
-    if (status_ == KeyGenJobStatus::OK) {
-      v8::Maybe<bool> ret = KeyGenTraits::EncodeKey(env, params, result);
-      if (ret.IsJust() && ret.FromJust()) {
-        *err = Undefined(env->isolate());
-      }
-      return ret;
-    }
-
-    if (errors->Empty())
-      errors->Capture();
-    CHECK(!errors->Empty());
-    *result = Undefined(env->isolate());
-    return v8::Just(errors->ToException(env).ToLocal(err));
-  }
-
-  SET_SELF_SIZE(KeyGenJob)
-
- private:
-  KeyGenJobStatus status_ = KeyGenJobStatus::FAILED;
-};
-
-// A Base KeyGenTraits for Key Pair generation algorithms.
-template <typename KeyPairAlgorithmTraits>
-struct KeyPairGenTraits final {
-  using AdditionalParameters =
-      typename KeyPairAlgorithmTraits::AdditionalParameters;
-
-  static const AsyncWrap::ProviderType Provider =
-      AsyncWrap::PROVIDER_KEYPAIRGENREQUEST;
-  static constexpr const char* JobName = KeyPairAlgorithmTraits::JobName;
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      AdditionalParameters* params) {
-    // Notice that offset is a pointer. Each of the AdditionalConfig,
-    // GetPublicKeyEncodingFromJs, and GetPrivateKeyEncodingFromJs
-    // functions will update the value of the offset as they successfully
-    // process input parameters. This allows each job to have a variable
-    // number of input parameters specific to each job type.
-    if (KeyPairAlgorithmTraits::AdditionalConfig(mode, args, offset, params)
-            .IsNothing()) {
-      return v8::Just(false);
-    }
-
-    params->public_key_encoding = ManagedEVPPKey::GetPublicKeyEncodingFromJs(
-        args,
-        offset,
-        kKeyContextGenerate);
-
-    auto private_key_encoding =
-        ManagedEVPPKey::GetPrivateKeyEncodingFromJs(
-            args,
-            offset,
-            kKeyContextGenerate);
-
-    if (!private_key_encoding.IsEmpty())
-      params->private_key_encoding = private_key_encoding.Release();
-
-    return v8::Just(true);
-  }
-
-  static KeyGenJobStatus DoKeyGen(
-      Environment* env,
-      AdditionalParameters* params) {
-    EVPKeyCtxPointer ctx = KeyPairAlgorithmTraits::Setup(params);
-
-    if (!ctx)
-      return KeyGenJobStatus::FAILED;
-
-    // Generate the key
-    EVP_PKEY* pkey = nullptr;
-    if (!EVP_PKEY_keygen(ctx.get(), &pkey))
-      return KeyGenJobStatus::FAILED;
-
-    params->key = ManagedEVPPKey(EVPKeyPointer(pkey));
-    return KeyGenJobStatus::OK;
-  }
-
-  static v8::Maybe<bool> EncodeKey(
-      Environment* env,
-      AdditionalParameters* params,
-      v8::Local<v8::Value>* result) {
-    v8::Local<v8::Value> keys[2];
-    if (ManagedEVPPKey::ToEncodedPublicKey(
-            env,
-            std::move(params->key),
-            params->public_key_encoding,
-            &keys[0]).IsNothing() ||
-        ManagedEVPPKey::ToEncodedPrivateKey(
-            env,
-            std::move(params->key),
-            params->private_key_encoding,
-            &keys[1]).IsNothing()) {
-      return v8::Nothing<bool>();
-    }
-    *result = v8::Array::New(env->isolate(), keys, arraysize(keys));
-    return v8::Just(true);
-  }
-};
-
-struct SecretKeyGenConfig final : public MemoryRetainer {
-  size_t length;  // Expressed a a number of bits
-  char* out = nullptr;  // Placeholder for the generated key bytes
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(SecretKeyGenConfig)
-  SET_SELF_SIZE(SecretKeyGenConfig)
-};
-
-struct SecretKeyGenTraits final {
-  using AdditionalParameters = SecretKeyGenConfig;
-  static const AsyncWrap::ProviderType Provider =
-      AsyncWrap::PROVIDER_KEYGENREQUEST;
-  static constexpr const char* JobName = "SecretKeyGenJob";
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      SecretKeyGenConfig* params);
-
-  static KeyGenJobStatus DoKeyGen(
-      Environment* env,
-      SecretKeyGenConfig* params);
-
-  static v8::Maybe<bool> EncodeKey(
-      Environment* env,
-      SecretKeyGenConfig* params,
-      v8::Local<v8::Value>* result);
-};
-
-template <typename AlgorithmParams>
-struct KeyPairGenConfig final : public MemoryRetainer {
-  PublicKeyEncodingConfig public_key_encoding;
-  PrivateKeyEncodingConfig private_key_encoding;
-  ManagedEVPPKey key;
-  AlgorithmParams params;
-
-  KeyPairGenConfig() = default;
-  ~KeyPairGenConfig() {
-    Mutex::ScopedLock priv_lock(*key.mutex());
-  }
-
-  explicit KeyPairGenConfig(KeyPairGenConfig&& other) noexcept
-      : public_key_encoding(other.public_key_encoding),
-        private_key_encoding(
-            std::forward<PrivateKeyEncodingConfig>(
-                other.private_key_encoding)),
-        key(std::move(other.key)),
-        params(std::move(other.params)) {}
-
-  KeyPairGenConfig& operator=(KeyPairGenConfig&& other) noexcept {
-    if (&other == this) return *this;
-    this->~KeyPairGenConfig();
-    return *new (this) KeyPairGenConfig(std::move(other));
-  }
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("key", key);
-    if (!private_key_encoding.passphrase_.IsEmpty()) {
-      tracker->TrackFieldWithSize("private_key_encoding.passphrase",
-                                  private_key_encoding.passphrase_->size());
-    }
-    tracker->TrackField("params", params);
-  }
-
-  SET_MEMORY_INFO_NAME(KeyPairGenConfig)
-  SET_SELF_SIZE(KeyPairGenConfig)
-};
-
-struct NidKeyPairParams final : public MemoryRetainer {
-  int id;
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(NidKeyPairParams)
-  SET_SELF_SIZE(NidKeyPairParams)
-};
-
-using NidKeyPairGenConfig = KeyPairGenConfig<NidKeyPairParams>;
-
-struct NidKeyPairGenTraits final {
-  using AdditionalParameters = NidKeyPairGenConfig;
-  static constexpr const char* JobName = "NidKeyPairGenJob";
-
-  static EVPKeyCtxPointer Setup(NidKeyPairGenConfig* params);
-
-  static v8::Maybe<bool> AdditionalConfig(
-      CryptoJobMode mode,
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      NidKeyPairGenConfig* params);
-};
-
-using NidKeyPairGenJob = KeyGenJob<KeyPairGenTraits<NidKeyPairGenTraits>>;
-using SecretKeyGenJob = KeyGenJob<SecretKeyGenTraits>;
-}  // namespace crypto
-}  // namespace node
-
-#endif  // !defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_KEYGEN_H_
-

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

@@ -1,412 +0,0 @@
-#ifndef SRC_CRYPTO_CRYPTO_KEYS_H_
-#define SRC_CRYPTO_CRYPTO_KEYS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "crypto/crypto_util.h"
-#include "base_object.h"
-#include "env.h"
-#include "memory_tracker.h"
-#include "node_buffer.h"
-#include "node_worker.h"
-#include "v8.h"
-
-#include <openssl/evp.h>
-
-#include <memory>
-#include <string>
-
-namespace node {
-namespace crypto {
-enum PKEncodingType {
-  // RSAPublicKey / RSAPrivateKey according to PKCS#1.
-  kKeyEncodingPKCS1,
-  // PrivateKeyInfo or EncryptedPrivateKeyInfo according to PKCS#8.
-  kKeyEncodingPKCS8,
-  // SubjectPublicKeyInfo according to X.509.
-  kKeyEncodingSPKI,
-  // ECPrivateKey according to SEC1.
-  kKeyEncodingSEC1
-};
-
-enum PKFormatType {
-  kKeyFormatDER,
-  kKeyFormatPEM,
-  kKeyFormatJWK
-};
-
-enum KeyType {
-  kKeyTypeSecret,
-  kKeyTypePublic,
-  kKeyTypePrivate
-};
-
-enum KeyEncodingContext {
-  kKeyContextInput,
-  kKeyContextExport,
-  kKeyContextGenerate
-};
-
-enum class ParseKeyResult {
-  kParseKeyOk,
-  kParseKeyNotRecognized,
-  kParseKeyNeedPassphrase,
-  kParseKeyFailed
-};
-
-struct AsymmetricKeyEncodingConfig {
-  bool output_key_object_ = false;
-  PKFormatType format_ = kKeyFormatDER;
-  v8::Maybe<PKEncodingType> type_ = v8::Nothing<PKEncodingType>();
-};
-
-using PublicKeyEncodingConfig = AsymmetricKeyEncodingConfig;
-
-struct PrivateKeyEncodingConfig : public AsymmetricKeyEncodingConfig {
-  const EVP_CIPHER* cipher_;
-  // The ByteSource alone is not enough to distinguish between "no passphrase"
-  // and a zero-length passphrase (which can be a null pointer), therefore, we
-  // use a NonCopyableMaybe.
-  NonCopyableMaybe<ByteSource> passphrase_;
-};
-
-// This uses the built-in reference counter of OpenSSL to manage an EVP_PKEY
-// which is slightly more efficient than using a shared pointer and easier to
-// use.
-class ManagedEVPPKey : public MemoryRetainer {
- public:
-  ManagedEVPPKey() : mutex_(std::make_shared<Mutex>()) {}
-  explicit ManagedEVPPKey(EVPKeyPointer&& pkey);
-  ManagedEVPPKey(const ManagedEVPPKey& that);
-  ManagedEVPPKey& operator=(const ManagedEVPPKey& that);
-
-  operator bool() const;
-  EVP_PKEY* get() const;
-  Mutex* mutex() const;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(ManagedEVPPKey)
-  SET_SELF_SIZE(ManagedEVPPKey)
-
-  static PublicKeyEncodingConfig GetPublicKeyEncodingFromJs(
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      KeyEncodingContext context);
-
-  static NonCopyableMaybe<PrivateKeyEncodingConfig> GetPrivateKeyEncodingFromJs(
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      KeyEncodingContext context);
-
-  static ManagedEVPPKey GetParsedKey(Environment* env,
-                                     EVPKeyPointer&& pkey,
-                                     ParseKeyResult ret,
-                                     const char* default_msg);
-
-  static ManagedEVPPKey GetPublicOrPrivateKeyFromJs(
-    const v8::FunctionCallbackInfo<v8::Value>& args,
-    unsigned int* offset);
-
-  static ManagedEVPPKey GetPrivateKeyFromJs(
-      const v8::FunctionCallbackInfo<v8::Value>& args,
-      unsigned int* offset,
-      bool allow_key_object);
-
-  static v8::Maybe<bool> ToEncodedPublicKey(
-      Environment* env,
-      ManagedEVPPKey key,
-      const PublicKeyEncodingConfig& config,
-      v8::Local<v8::Value>* out);
-
-  static v8::Maybe<bool> ToEncodedPrivateKey(
-      Environment* env,
-      ManagedEVPPKey key,
-      const PrivateKeyEncodingConfig& config,
-      v8::Local<v8::Value>* out);
-
- private:
-  size_t size_of_private_key() const;
-  size_t size_of_public_key() const;
-
-  EVPKeyPointer pkey_;
-  std::shared_ptr<Mutex> mutex_;
-};
-
-// Objects of this class can safely be shared among threads.
-class KeyObjectData : public MemoryRetainer {
- public:
-  static std::shared_ptr<KeyObjectData> CreateSecret(ByteSource key);
-
-  static std::shared_ptr<KeyObjectData> CreateAsymmetric(
-      KeyType type,
-      const ManagedEVPPKey& pkey);
-
-  KeyType GetKeyType() const;
-
-  // These functions allow unprotected access to the raw key material and should
-  // only be used to implement cryptographic operations requiring the key.
-  ManagedEVPPKey GetAsymmetricKey() const;
-  const char* GetSymmetricKey() const;
-  size_t GetSymmetricKeySize() const;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(KeyObjectData)
-  SET_SELF_SIZE(KeyObjectData)
-
- private:
-  explicit KeyObjectData(ByteSource symmetric_key);
-
-  KeyObjectData(
-      KeyType type,
-      const ManagedEVPPKey& pkey);
-
-  const KeyType key_type_;
-  const ByteSource symmetric_key_;
-  const unsigned int symmetric_key_len_;
-  const ManagedEVPPKey asymmetric_key_;
-};
-
-class KeyObjectHandle : public BaseObject {
- public:
-  static v8::Local<v8::Function> Initialize(Environment* env);
-
-  static v8::MaybeLocal<v8::Object> Create(Environment* env,
-                                           std::shared_ptr<KeyObjectData> data);
-
-  // TODO(tniessen): track the memory used by OpenSSL types
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(KeyObjectHandle)
-  SET_SELF_SIZE(KeyObjectHandle)
-
-  const std::shared_ptr<KeyObjectData>& Data();
-
- protected:
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void Init(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void InitECRaw(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void InitEDRaw(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void InitJWK(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetKeyDetail(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void ExportJWK(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void GetAsymmetricKeyType(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  v8::Local<v8::Value> GetAsymmetricKeyType() const;
-
-  static void GetSymmetricKeySize(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void Export(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  v8::MaybeLocal<v8::Value> ExportSecretKey() const;
-  v8::MaybeLocal<v8::Value> ExportPublicKey(
-      const PublicKeyEncodingConfig& config) const;
-  v8::MaybeLocal<v8::Value> ExportPrivateKey(
-      const PrivateKeyEncodingConfig& config) const;
-
-  KeyObjectHandle(Environment* env,
-                  v8::Local<v8::Object> wrap);
-
- private:
-  std::shared_ptr<KeyObjectData> data_;
-};
-
-class NativeKeyObject : public BaseObject {
- public:
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CreateNativeKeyObjectClass(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(NativeKeyObject)
-  SET_SELF_SIZE(NativeKeyObject)
-
-  class KeyObjectTransferData : public worker::TransferData {
-   public:
-    explicit KeyObjectTransferData(const std::shared_ptr<KeyObjectData>& data)
-        : data_(data) {}
-
-    BaseObjectPtr<BaseObject> Deserialize(
-        Environment* env,
-        v8::Local<v8::Context> context,
-        std::unique_ptr<worker::TransferData> self) override;
-
-    SET_MEMORY_INFO_NAME(KeyObjectTransferData)
-    SET_SELF_SIZE(KeyObjectTransferData)
-    SET_NO_MEMORY_INFO()
-
-   private:
-    std::shared_ptr<KeyObjectData> data_;
-  };
-
-  BaseObject::TransferMode GetTransferMode() const override;
-  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
-
- private:
-  NativeKeyObject(Environment* env,
-                  v8::Local<v8::Object> wrap,
-                  const std::shared_ptr<KeyObjectData>& handle_data)
-    : BaseObject(env, wrap),
-      handle_data_(handle_data) {
-    MakeWeak();
-  }
-
-  std::shared_ptr<KeyObjectData> handle_data_;
-};
-
-enum WebCryptoKeyFormat {
-  kWebCryptoKeyFormatRaw,
-  kWebCryptoKeyFormatPKCS8,
-  kWebCryptoKeyFormatSPKI,
-  kWebCryptoKeyFormatJWK
-};
-
-enum class WebCryptoKeyExportStatus {
-  OK,
-  INVALID_KEY_TYPE,
-  FAILED
-};
-
-template <typename KeyExportTraits>
-class KeyExportJob final : public CryptoJob<KeyExportTraits> {
- public:
-  using AdditionalParams = typename KeyExportTraits::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());  // Export Type
-    CHECK(args[2]->IsObject());  // KeyObject
-
-    WebCryptoKeyFormat format =
-        static_cast<WebCryptoKeyFormat>(args[1].As<v8::Uint32>()->Value());
-
-    KeyObjectHandle* key;
-    ASSIGN_OR_RETURN_UNWRAP(&key, args[2]);
-
-    CHECK_NOT_NULL(key);
-
-    AdditionalParams params;
-    if (KeyExportTraits::AdditionalConfig(args, 3, &params).IsNothing()) {
-      // The KeyExportTraits::AdditionalConfig is responsible for
-      // calling an appropriate THROW_CRYPTO_* variant reporting
-      // whatever error caused initialization to fail.
-      return;
-    }
-
-    new KeyExportJob<KeyExportTraits>(
-        env,
-        args.This(),
-        mode,
-        key->Data(),
-        format,
-        std::move(params));
-  }
-
-  static void Initialize(
-      Environment* env,
-      v8::Local<v8::Object> target) {
-    CryptoJob<KeyExportTraits>::Initialize(New, env, target);
-  }
-
-  KeyExportJob(
-      Environment* env,
-      v8::Local<v8::Object> object,
-      CryptoJobMode mode,
-      std::shared_ptr<KeyObjectData> key,
-      WebCryptoKeyFormat format,
-      AdditionalParams&& params)
-      : CryptoJob<KeyExportTraits>(
-            env,
-            object,
-            AsyncWrap::PROVIDER_KEYEXPORTREQUEST,
-            mode,
-            std::move(params)),
-        key_(key),
-        format_(format) {}
-
-  WebCryptoKeyFormat format() const { return format_; }
-
-  void DoThreadPoolWork() override {
-    const WebCryptoKeyExportStatus status =
-        KeyExportTraits::DoExport(
-            key_,
-            format_,
-            *CryptoJob<KeyExportTraits>::params(),
-            &out_);
-    if (status == WebCryptoKeyExportStatus::OK) {
-      // Success!
-      return;
-    }
-    CryptoErrorStore* errors = CryptoJob<KeyExportTraits>::errors();
-    errors->Capture();
-    if (errors->Empty()) {
-      switch (status) {
-        case WebCryptoKeyExportStatus::OK:
-          UNREACHABLE();
-          break;
-        case WebCryptoKeyExportStatus::INVALID_KEY_TYPE:
-          errors->Insert(NodeCryptoError::INVALID_KEY_TYPE);
-          break;
-        case WebCryptoKeyExportStatus::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<KeyExportTraits>::errors();
-    if (out_.size() > 0) {
-      CHECK(errors->Empty());
-      *err = v8::Undefined(env->isolate());
-      *result = out_.ToArrayBuffer(env);
-      return v8::Just(!result->IsEmpty());
-    }
-
-    if (errors->Empty())
-      errors->Capture();
-    CHECK(!errors->Empty());
-    *result = v8::Undefined(env->isolate());
-    return v8::Just(errors->ToException(env).ToLocal(err));
-  }
-
-  SET_SELF_SIZE(KeyExportJob)
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackFieldWithSize("out", out_.size());
-    CryptoJob<KeyExportTraits>::MemoryInfo(tracker);
-  }
-
- private:
-  std::shared_ptr<KeyObjectData> key_;
-  WebCryptoKeyFormat format_;
-  ByteSource out_;
-};
-
-WebCryptoKeyExportStatus PKEY_SPKI_Export(
-    KeyObjectData* key_data,
-    ByteSource* out);
-
-WebCryptoKeyExportStatus PKEY_PKCS8_Export(
-    KeyObjectData* key_data,
-    ByteSource* out);
-
-namespace Keys {
-void Initialize(Environment* env, v8::Local<v8::Object> target);
-}  // namespace Keys
-
-}  // namespace crypto
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_CRYPTO_CRYPTO_KEYS_H_