#ifndef SRC_NODE_CRYPTO_H_

#define SRC_NODE_CRYPTO_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "node_crypto_clienthello.h"

#include "allocated_buffer.h"

#include "env.h"

#include "base_object.h"

#include "util.h"

#include "v8.h"

#include <openssl/err.h>

#include <openssl/ssl.h>

#include <openssl/bn.h>

#include <openssl/dh.h>

#include <openssl/ec.h>

#include <openssl/rsa.h>

namespace node {

namespace crypto {

struct ClearErrorOnReturn {

~ClearErrorOnReturn() { ERR_clear_error(); }

};

struct MarkPopErrorOnReturn {

MarkPopErrorOnReturn() { ERR_set_mark(); }

~MarkPopErrorOnReturn() { ERR_pop_to_mark(); }

};

using X509Pointer = DeleteFnPtr<X509, X509_free>;

using BIOPointer = DeleteFnPtr<BIO, BIO_free_all>;

using SSLCtxPointer = DeleteFnPtr<SSL_CTX, SSL_CTX_free>;

using SSLSessionPointer = DeleteFnPtr<SSL_SESSION, SSL_SESSION_free>;

using SSLPointer = DeleteFnPtr<SSL, SSL_free>;

using PKCS8Pointer = DeleteFnPtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>;

using EVPKeyPointer = DeleteFnPtr<EVP_PKEY, EVP_PKEY_free>;

using EVPKeyCtxPointer = DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;

using EVPMDPointer = DeleteFnPtr<EVP_MD_CTX, EVP_MD_CTX_free>;

using RSAPointer = DeleteFnPtr<RSA, RSA_free>;

using ECPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>;

using BignumPointer = DeleteFnPtr<BIGNUM, BN_free>;

using NetscapeSPKIPointer = DeleteFnPtr<NETSCAPE_SPKI, NETSCAPE_SPKI_free>;

using ECGroupPointer = DeleteFnPtr<EC_GROUP, EC_GROUP_free>;

using ECPointPointer = DeleteFnPtr<EC_POINT, EC_POINT_free>;

using ECKeyPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>;

using DHPointer = DeleteFnPtr<DH, DH_free>;

using ECDSASigPointer = DeleteFnPtr<ECDSA_SIG, ECDSA_SIG_free>;

extern int VerifyCallback(int preverify_ok, X509_STORE_CTX* ctx);

extern void UseExtraCaCerts(const std::string& file);

void InitCryptoOnce();

class SecureContext final : public BaseObject {

};

template <class Base>

class SSLWrap {

};

class ByteSource {

};

enum PKEncodingType {

};

enum PKFormatType {

kKeyFormatDER,

kKeyFormatPEM

};

struct AsymmetricKeyEncodingConfig {

};

typedef AsymmetricKeyEncodingConfig PublicKeyEncodingConfig;

struct PrivateKeyEncodingConfig : public AsymmetricKeyEncodingConfig {

const EVP_CIPHER* cipher_;

ByteSource passphrase_;

};

enum KeyType {

};

class ManagedEVPPKey {

};

class KeyObject : public BaseObject {

};

class CipherBase : public BaseObject {

};

class Hmac : public BaseObject {

};

class Hash final : public BaseObject {

};

class SignBase : public BaseObject {

};

enum DSASigEnc {

kSigEncDER, kSigEncP1363

};

class Sign : public SignBase {

};

class Verify : public SignBase {

};

class PublicKeyCipher {

};

class DiffieHellman : public BaseObject {

};

class ECDH final : public BaseObject {

};

bool EntropySource(unsigned char* buffer, size_t length);

#ifndef OPENSSL_NO_ENGINE

void SetEngine(const v8::FunctionCallbackInfo<v8::Value>& args);

#endif // !OPENSSL_NO_ENGINE

void InitCrypto(v8::Local<v8::Object> target);

void ThrowCryptoError(Environment* env,

unsigned long err, // NOLINT(runtime/int)

const char* message = nullptr);

template <typename T>

inline T* MallocOpenSSL(size_t count) {

void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T)));

CHECK_IMPLIES(mem == nullptr, count == 0);

return static_cast<T*>(mem);

}

} // namespace crypto

} // namespace node

#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif // SRC_NODE_CRYPTO_H_