#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;

 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;

    KeyObjectHandle* key;

            .IsNothing()) {

      // The CipherTraits::AdditionalConfig is responsible for

      // calling an appropriate THROW_CRYPTO_* variant reporting

      // whatever error caused initialization to fail.

    }

        env,

        mode,

        key,

        cipher_mode,

        data,

  }

      Environment* env,

      v8::Local<v8::Object> target) {

      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,

        key_(key->Data()),

        cipher_mode_(cipher_mode),

        in_(mode == kCryptoJobAsync

            ? data.ToCopy()

  WebCryptoCipherMode cipher_mode() const { return cipher_mode_; }

    const WebCryptoCipherStatus status =

            AsyncWrap::env(),

            key(),

            cipher_mode_,

            &out_);

      // Success!

    }

          break;

      }

    }

  }

      v8::Local<v8::Value>* err,

      v8::Local<v8::Value>* result) override {

    }

  }

  }

 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_