AsyncSslX509Extensions.h

Go to the documentation of this file.

 
#ifndef ASYNC_SSL_X509_EXTENSIONS_INCLUDED
#define ASYNC_SSL_X509_EXTENSIONS_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <openssl/x509v3.h>
#include <cstring>
#include <sstream>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncIpAddress.h>
#include <AsyncSslX509ExtSubjectAltName.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class SslX509Extensions
{
  public:
    SslX509Extensions(void)
    {
      m_exts = sk_X509_EXTENSION_new_null();
    }
 
    explicit SslX509Extensions(STACK_OF(X509_EXTENSION)* exts)
      : m_exts(exts)
    {
    }
 
    SslX509Extensions(SslX509Extensions&& other)
    {
      m_exts = other.m_exts;
      other.m_exts = nullptr;
    }
 
    explicit SslX509Extensions(const SslX509Extensions& other)
    {
      //std::cout << "### SslX509Extensions copy constructor" << std::endl;
      for (int i=0; i<X509v3_get_ext_count(other.m_exts); ++i)
      {
        const auto ext = X509v3_get_ext(other.m_exts, i);
        X509v3_add_ext(&m_exts, ext, -1);
      }
    }
 
    SslX509Extensions& operator=(const SslX509Extensions&) = delete;
 
    ~SslX509Extensions(void)
    {
      if (m_exts != nullptr)
      {
        sk_X509_EXTENSION_pop_free(m_exts, X509_EXTENSION_free);
        m_exts = nullptr;
      }
    }
 
    bool addBasicConstraints(const std::string& bc)
    {
      return addExt(NID_basic_constraints, bc);
    }
 
    bool addKeyUsage(const std::string& ku)
    {
      return addExt(NID_key_usage, ku);
    }
 
    bool addExtKeyUsage(const std::string& eku)
    {
      return addExt(NID_ext_key_usage, eku);
    }
 
    bool addSubjectAltNames(const std::string& san)
    {
      return addExt(NID_subject_alt_name, san);
    }
 
    SslX509ExtSubjectAltName subjectAltName(void) const
    {
      int ext_idx = X509v3_get_ext_by_NID(m_exts, NID_subject_alt_name, -1);
      if (ext_idx < 0)
      {
        return nullptr;
      }
      auto ext = X509v3_get_ext(m_exts, ext_idx);
      return ext;
    }
 
    bool addExtension(const SslX509ExtSubjectAltName& san)
    {
      const X509_EXTENSION* other_ext = san;
#if OPENSSL_VERSION_MAJOR >= 3
      auto ext = X509_EXTENSION_dup(other_ext);
#else
      auto ext = X509_EXTENSION_dup(const_cast<X509_EXTENSION*>(other_ext));
#endif
      return (sk_X509_EXTENSION_push(m_exts, ext) > 0);
    }
 
    operator const STACK_OF(X509_EXTENSION)*() const { return m_exts; }
 
  private:
    STACK_OF(X509_EXTENSION)* m_exts  = nullptr;
 
    bool addExt(int nid, const std::string& value)
    {
      auto ex = X509V3_EXT_conf_nid(NULL, NULL, nid, value.c_str());
      if (ex == nullptr)
      {
        return false;
      }
      sk_X509_EXTENSION_push(m_exts, ex);
      return true;
    }
 
    X509_EXTENSION* cloneExtension(int nid) const
    {
      int ext_idx = X509v3_get_ext_by_NID(m_exts, nid, -1);
      if (ext_idx < 0)
      {
        return nullptr;
      }
      auto ext = X509v3_get_ext(m_exts, ext_idx);
      return X509_EXTENSION_dup(ext);
    }
 
}; /* SslX509Extensions */
 
 
 
} /* namespace Async */
 
#endif /* ASYNC_SSL_X509_EXTENSIONS_INCLUDED */
 
/*
 * This file has not been truncated
 */