openssl.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_OPENSSL_HPP__
#define __JOIN_OPENSSL_HPP__
 
// Libraries.
#include <openssl/bn.h>
#include <openssl/ecdsa.h>
#include <openssl/pem.h>
#include <openssl/x509.h>
#include <openssl/x509_vfy.h>
#include <openssl/x509v3.h>
#include <openssl/evp.h>
#include <openssl/ssl.h>
 
// C++.
#include <memory>
#include <vector>
#include <string>
 
namespace join
{
    struct BigNumDelete
    {
        constexpr BigNumDelete () noexcept = default;
 
        void operator ()(BIGNUM* num)
        {
            BN_free (num);
        }
    };
 
    using BigNumPtr = std::unique_ptr <BIGNUM, BigNumDelete>;
 
    struct EcdsaSigDelete
    {
        constexpr EcdsaSigDelete () noexcept = default;
 
        void operator ()(ECDSA_SIG* ecSig)
        {
            ECDSA_SIG_free (ecSig);
        }
    };
 
    using EcdsaSigPtr = std::unique_ptr <ECDSA_SIG, EcdsaSigDelete>;
 
    struct EvpPkeyDelete
    {
        constexpr EvpPkeyDelete () noexcept = default;
 
        void operator ()(EVP_PKEY* evpPkey)
        {
            EVP_PKEY_free (evpPkey);
        }
    };
 
    using EvpPkeyPtr = std::unique_ptr <EVP_PKEY, EvpPkeyDelete>;
 
    struct EvpPkeyCtxDelete
    {
        constexpr EvpPkeyCtxDelete () noexcept = default;
 
        void operator ()(EVP_PKEY_CTX* evpPkeyCtx)
        {
            EVP_PKEY_CTX_free (evpPkeyCtx);
        }
    };
 
    using EvpPkeyCtxPtr = std::unique_ptr <EVP_PKEY_CTX, EvpPkeyCtxDelete>;
 
    struct EvpEncodeCtxDelete
    {
        constexpr EvpEncodeCtxDelete () noexcept = default;
 
        void operator ()(EVP_ENCODE_CTX* evpEncodeCtx)
        {
            EVP_ENCODE_CTX_free (evpEncodeCtx);
        }
    };
 
    using EvpEncodeCtxPtr = std::unique_ptr <EVP_ENCODE_CTX, EvpEncodeCtxDelete>;
 
    struct EvpMdCtxDelete
    {
        constexpr EvpMdCtxDelete () noexcept = default;
 
        void operator ()(EVP_MD_CTX* evpMdCtx)
        {
            EVP_MD_CTX_free (evpMdCtx);
        }
    };
 
    using EvpMdCtxPtr = std::unique_ptr <EVP_MD_CTX, EvpMdCtxDelete>;
 
#if OPENSSL_VERSION_NUMBER < 0x30000000L
    struct HmacCtxDelete
    {
        constexpr HmacCtxDelete () noexcept = default;
 
        void operator ()(HMAC_CTX* hmacCtx)
        {
            HMAC_CTX_free (hmacCtx);
        }
    };
 
    using HmacCtxPtr = std::unique_ptr <HMAC_CTX, HmacCtxDelete>;
#else
    struct EvpMacDelete
    {
        constexpr EvpMacDelete () noexcept = default;
 
        void operator ()(EVP_MAC* evpMac)
        {
            EVP_MAC_free (evpMac);
        }
    };
 
    using EvpMacPtr = std::unique_ptr <EVP_MAC, EvpMacDelete>;
 
    struct EvpMacCtxDelete
    {
        constexpr EvpMacCtxDelete () noexcept = default;
 
        void operator ()(EVP_MAC_CTX* evpMacCtx)
        {
            EVP_MAC_CTX_free (evpMacCtx);
        }
    };
 
    using EvpMacCtxPtr = std::unique_ptr <EVP_MAC_CTX, EvpMacCtxDelete>;
#endif
 
    struct StackOfX509NameDelete
    {
        constexpr StackOfX509NameDelete () noexcept = default;
 
        void operator()(STACK_OF (X509_NAME)* stack)
        {
            sk_X509_NAME_pop_free (stack, X509_NAME_free);
        }
    };
 
    using StackOfX509NamePtr = std::unique_ptr <STACK_OF (X509_NAME), StackOfX509NameDelete>;
 
    struct StackOfGeneralNameDelete
    {
        constexpr StackOfGeneralNameDelete () noexcept = default;
 
        void operator ()(STACK_OF (GENERAL_NAME)* stack)
        {
            sk_GENERAL_NAME_pop_free (stack, GENERAL_NAME_free);
        }
    };
 
    using StackOfGeneralNamePtr = std::unique_ptr <STACK_OF (GENERAL_NAME), StackOfGeneralNameDelete>;
 
    struct SslDelete
    {
        constexpr SslDelete () noexcept = default;
 
        void operator ()(SSL* p)
        {
            SSL_free (p);
        }
    };
 
    using SslPtr = std::unique_ptr <SSL, SslDelete>;
 
    struct SslCtxDelete
    {
        constexpr SslCtxDelete () noexcept = default;
 
        void operator ()(SSL_CTX* p)
        {
            SSL_CTX_free (p);
        }
    };
 
    using SslCtxPtr = std::unique_ptr <SSL_CTX, SslCtxDelete>;
 
#if OPENSSL_VERSION_NUMBER < 0x30000000L
    struct DhKeyDelete
    {
        constexpr DhKeyDelete () noexcept = default;
 
        void operator()(DH* p)
        {
            DH_free (p);
        }
    };
 
    using DhKeyPtr = std::unique_ptr <DH, DhKeyDelete>;
 
    struct EcdhKeyDelete
    {
        constexpr EcdhKeyDelete () noexcept = default;
 
        void operator()(EC_KEY* p)
        {
            EC_KEY_free (p);
        }
    };
 
    using EcdhKeyPtr = std::unique_ptr <EC_KEY, EcdhKeyDelete>;
#endif
 
    void initializeOpenSSL ();
 
    // default cipher.
    extern const std::string defaultCipher;
 
    // default cipher.
    extern const std::string defaultCipher_1_3;
 
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
    // default curve.
    extern const std::string defaultCurve;
#endif
}
 
#endif