PKIFX509Extensions2.cpp

Go to the documentation of this file.

#include "PKIFX509Extensions2.h"
#include "PKIFException.h"
#include "IPKIFColleague.h"
#include "NameConstraintsFactory.h"
#include "ToolkitUtils.h"
#include "PKIFCommonErrors.h"
#include "ASN1Helper.h"

#include "AuthorityKeyIdentifierFactory.h"
#include "SubjectKeyIdentifierFactory.h"
#include "KeyUsageFactory.h"
#include "ExtendedKeyUsageFactory.h"
#include "PrivateKeyUsageFactory.h"
#include "PolicyInformationSetFactory.h"
#include "PolicyMappingsFactory.h"
#include "SubjectAltNameFactory.h"
#include "IssuerAltNameFactory.h"
#include "BasicConstraintsFactory.h"
#include "PolicyConstraintsFactory.h"
#include "InhibitAnyPolicyFactory.h"
#include "CRLNumberFactory.h"
#include "CRLReasonFactory.h"
#include "HoldInstructionCodeFactory.h"
#include "InvalidityDateFactory.h"
#include "CRLStreamIdentifierFactory.h"
#include "CRLDistributionPointsFactory.h"
#include "IssuingDistributionPointFactory.h"
#include "CertificateIssuerFactory.h"
#include "DeltaCRLIndicatorFactory.h"
#include "FreshestCRLFactory.h"
#include "AuthorityInfoAccessFactory.h"
#include "SubjectInfoAccessFactory.h"
#include "Buffer.h"
#include "OID.h"
#include "X509Extension.h"
#include "ScopeGuard.h"

#ifdef _WIN32
#ifdef _DEBUG
#include "crtdbg.h"
#endif //_DEBUG
#endif //_WIN32

#include <map>
#include "boost/thread/recursive_mutex.hpp"
using namespace std;

CPKIFX509ExtensionMediator2 * CPKIFX509ExtensionMediator2::m_hInstance = 0;

struct CPKIFX509ExtensionMediator2Impl
{
    std::vector<IPKIFColleague*> m_vModules;
    std::vector<IPKIFColleague*> m_vModulesToDelete;
    boost::recursive_mutex m_me;
};


CPKIFX509ExtensionMediator2 * CPKIFX509ExtensionMediator2::GetInstance(void)
{
    if(m_hInstance) return m_hInstance;
    m_hInstance = new CPKIFX509ExtensionMediator2();
    m_hInstance->InitializeMediator(0);
    return m_hInstance;
}

CPKIFX509ExtensionMediator2::CPKIFX509ExtensionMediator2(void)
  :m_impl (new CPKIFX509ExtensionMediator2Impl)
{
}

CPKIFX509ExtensionMediator2::~CPKIFX509ExtensionMediator2(void)
{
    if(m_impl)
    {
        try
        {
            //6/2/2004
            //replaced FreeAdditionalModules call with Terminate
            //clean up any modules that were added using AddColleague
            //FreeAdditionalModules(m_impl->m_vModulesToDelete, this);
            Terminate();
        }
        catch(...)
        {
            _ASSERT(false);
        }

        delete m_impl;
        m_impl = 0;
    }
    // if the singleton's being deleted, set the pointer so that
    // GetInstance() will create a new one
    if(m_hInstance == this) // this should really always be true if this d'tor is invoked
    {
        m_hInstance = 0;
    }
}

void CPKIFX509ExtensionMediator2::Terminate()
{
    m_impl->m_vModules.clear();
    FreeAdditionalModules(m_impl->m_vModulesToDelete, this);
}

void CPKIFX509ExtensionMediator2::InitializeMediator(
    std::vector<CPKIFException*>* errorInfo)
{
    LOG_STRING_DEBUG("Initializing CPKIFX509ExtensionMediator2 mediator", thisComponent, 0, this);

    if(!m_impl->m_vModules.empty()) {
        throw CPKIFException(thisComponent, COMMON_ALREADY_INITIALIZED, "This instance has already been initialized.  Call Terminate prior to re-initializing.");
    }
    //populate the m_impl->m_vModules vector with any modules that were configured at compile-time
    //error information will be collected in the errorInfo parameter if desired
    /*if(NULL != errorInfo)
        PopulateVectorFunc(m_modules, this, m_impl->m_vModules, *errorInfo);//functon was templated 
    else
    {
        std::vector<CPKIFException*> ei;
        PopulateVectorFunc(m_modules, this, m_impl->m_vModules, ei);//function was templated
    }*/

    IPKIFColleague *x1 = new CPKIFAuthorityKeyIdentifierFactory(); 
    x1->Initialize();
    x1->AddParent(this);
    m_impl->m_vModules.push_back(x1);
    m_impl->m_vModulesToDelete.push_back(x1);

    IPKIFColleague *x2 = new CPKIFSubjectKeyIdentifierFactory();
    x2->Initialize();
    x2->AddParent(this);
    m_impl->m_vModules.push_back(x2);
    m_impl->m_vModulesToDelete.push_back(x2);

    IPKIFColleague *x3 = new CPKIFKeyUsageFactory(); 
    x3->Initialize();
    x3->AddParent(this);
    m_impl->m_vModules.push_back(x3);
    m_impl->m_vModulesToDelete.push_back(x3);

    IPKIFColleague *x4 = new CPKIFExtendedKeyUsageFactory();
    x4->Initialize();
    x4->AddParent(this);
    m_impl->m_vModules.push_back(x4);
    m_impl->m_vModulesToDelete.push_back(x4);

    IPKIFColleague *x5 = new CPKIFPrivateKeyUsageFactory();
    x5->Initialize();
    x5->AddParent(this);
    m_impl->m_vModules.push_back(x5);
    m_impl->m_vModulesToDelete.push_back(x5);

    IPKIFColleague *x6 = new CPKIFPolicyInformationSetFactory();
    x6->Initialize();
    x6->AddParent(this);
    m_impl->m_vModules.push_back(x6);
    m_impl->m_vModulesToDelete.push_back(x6);

    IPKIFColleague *x7 = new CPKIFPolicyMappingsFactory();
    x7->Initialize();
    x7->AddParent(this);
    m_impl->m_vModules.push_back(x7);
    m_impl->m_vModulesToDelete.push_back(x7);

    IPKIFColleague *x8 = new CPKIFSubjectAltNameFactory(); 
    x8->Initialize();
    x8->AddParent(this);
    m_impl->m_vModules.push_back(x8);
    m_impl->m_vModulesToDelete.push_back(x8);

    IPKIFColleague *x9 = new CPKIFIssuerAltNameFactory(); 
    x9->Initialize();
    x9->AddParent(this);
    m_impl->m_vModules.push_back(x9);
    m_impl->m_vModulesToDelete.push_back(x9);

    IPKIFColleague *x10 = new CPKIFBasicConstraintsFactory(); 
    x10->Initialize();
    x10->AddParent(this);
    m_impl->m_vModules.push_back(x10);
    m_impl->m_vModulesToDelete.push_back(x10);

    IPKIFColleague *x11 = new CPKIFNameConstraintsFactory(); 
    x11->Initialize();
    x11->AddParent(this);
    m_impl->m_vModules.push_back(x11);
    m_impl->m_vModulesToDelete.push_back(x11);

    IPKIFColleague *x12 = new CPKIFPolicyConstraintsFactory(); 
    x12->Initialize();
    x12->AddParent(this);
    m_impl->m_vModules.push_back(x12);
    m_impl->m_vModulesToDelete.push_back(x12);

    IPKIFColleague *x13 = new CPKIFInhibitAnyPolicyFactory(); 
    x13->Initialize();
    x13->AddParent(this);
    m_impl->m_vModules.push_back(x13);
    m_impl->m_vModulesToDelete.push_back(x13);

    IPKIFColleague *x14 = new CPKIFCRLNumberFactory(); 
    x14->Initialize();
    x14->AddParent(this);
    m_impl->m_vModules.push_back(x14);
    m_impl->m_vModulesToDelete.push_back(x14);

    IPKIFColleague *x15 = new CPKIFCRLReasonFactory(); 
    x15->Initialize();
    x15->AddParent(this);
    m_impl->m_vModules.push_back(x15);
    m_impl->m_vModulesToDelete.push_back(x15);

    IPKIFColleague *x16 = new CPKIFHoldInstructionCodeFactory(); 
    x16->Initialize();
    x16->AddParent(this);
    m_impl->m_vModules.push_back(x16);
    m_impl->m_vModulesToDelete.push_back(x16);

    IPKIFColleague *x17 = new CPKIFInvalidityDateFactory();
    x17->Initialize();
    x17->AddParent(this);
    m_impl->m_vModules.push_back(x17);
    m_impl->m_vModulesToDelete.push_back(x17);

    IPKIFColleague *x18 = new CPKIFCRLStreamIdentifierFactory();    
    x18->Initialize();
    x18->AddParent(this);
    m_impl->m_vModules.push_back(x18);
    m_impl->m_vModulesToDelete.push_back(x18);

    IPKIFColleague *x19 = new CPKIFCRLDistributionPointsFactory(); 
    x19->Initialize();
    x19->AddParent(this);
    m_impl->m_vModules.push_back(x19);
    m_impl->m_vModulesToDelete.push_back(x19);

    IPKIFColleague *x20 = new CPKIFIssuingDistributionPointFactory(); 
    x20->Initialize();
    x20->AddParent(this);
    m_impl->m_vModules.push_back(x20);
    m_impl->m_vModulesToDelete.push_back(x20);

    IPKIFColleague *x21 = new CPKIFCertificateIssuerFactory(); 
    x21->Initialize();
    x21->AddParent(this);
    m_impl->m_vModules.push_back(x21);
    m_impl->m_vModulesToDelete.push_back(x21);

    IPKIFColleague *x22 = new CPKIFDeltaCRLIndicatorFactory(); 
    x22->Initialize();
    x22->AddParent(this);
    m_impl->m_vModules.push_back(x22);
    m_impl->m_vModulesToDelete.push_back(x22);

    IPKIFColleague *x23 = new CPKIFFreshestCRLFactory();    
    x23->Initialize();
    x23->AddParent(this);
    m_impl->m_vModules.push_back(x23);
    m_impl->m_vModulesToDelete.push_back(x23);

    IPKIFColleague *x24 = new CPKIFAuthorityInfoAccessFactory();
    x24->Initialize();
    x24->AddParent(this);
    m_impl->m_vModules.push_back(x24);
    m_impl->m_vModulesToDelete.push_back(x24);

    IPKIFColleague *x25 = new CPKIFSubjectInfoAccessFactory();
    x25->Initialize();
    x25->AddParent(this);
    m_impl->m_vModules.push_back(x25);
    m_impl->m_vModulesToDelete.push_back(x25);
}

//CPKIFX509ExtensionPtr CPKIFX509ExtensionMediator2::GetExtension(
//  //![in] A refernce to a CACX509V3Extension object.
//  CACX509V3Extension& refExtension)
//{
//  CPKIFOID oid(refExtension.extnID);
//
//  vector<IPKIFColleague*>::iterator pos;
//  vector<IPKIFColleague*>::iterator end = m_impl->m_vModules.end();
//  ICACExtensionFactory* ext = NULL;
//  for(pos = m_impl->m_vModules.begin(); pos != end; ++pos)
//  {
//      ext = dynamic_cast<ICACExtensionFactory*>(*pos);
//      if(NULL != ext && oid == ext->refOID())
//      {
//          try
//          {
//              CPKIFX509ExtensionPtr tmp = ext->create(refExtension); 
//              return tmp;
//          }
//          catch(...)
//          {
//              //do nothing - if the extension is non-critical we'll let it pass
//              //otherwise it will die in path validation
//              std::string reason("Failed to parse a certificate extension: ");
//              reason.append(oid.ToString());
//              LOG_STRING_FATAL(reason.c_str(), thisComponent, ASN1_DECODE_ERROR, this);
//              break;
//          }
//      }
//  }
//
//  CPKIFX509ExtensionPtr tmpExtPtr(new CPKIFX509Extension(refExtension));
//  return tmpExtPtr;
//}
void CPKIFX509ExtensionMediator2::ParseExtensions(
    CPKIFBufferPtr& buf,
    vector<CPKIFX509ExtensionPtr>& exts)
{
    if (!buf || buf->GetLength () == 0)
        return;
    
    // Decode the asn1 data into a list of extensions
    CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
    CACX509V3Extensions *extsPtr = extsWrapper.Decode(buf->GetBuffer(), buf->GetLength());

    if (extsPtr->count == 0)
      return;

    // Build a colleague look-up table
    std::map<std::string, ICACExtensionFactory*> OIDMap;
    std::string *OIDStrings = new std::string[m_impl->m_vModules.size ()];  
    int index = 0;

    vector<IPKIFColleague*>::iterator pos;
    vector<IPKIFColleague*>::iterator end = m_impl->m_vModules.end();
    for(pos = m_impl->m_vModules.begin(); pos != end; ++pos)
    {
        ICACExtensionFactory *ext = dynamic_cast<ICACExtensionFactory*>(*pos);
        
        if (ext)
        {
            OIDStrings[index] = ext->refOID();
            OIDMap[OIDStrings[index]] = ext;
            ++index;
        }
    }

    //iterate over the list of extensions and populate the extensions vector
    DListNode* cur = extsPtr->head;
    for(unsigned int i = 0; i < extsPtr->count; ++i)
    {
        CACX509V3Extension *ext = static_cast<CACX509V3Extension*>(cur->data);
        CPKIFOIDPtr cpkifOIDPtr (new CPKIFOID (ext->extnID.subid, ext->extnID.numids));
        std::string OID = cpkifOIDPtr->ToString();
        std::map<std::string, ICACExtensionFactory*>::iterator itr = OIDMap.find (OID);

        // We first have to create the buffer to hold the data and it's length.
        CPKIFBufferPtr extensionBufPtr(new CPKIFBuffer (ext->extnValue.data, ext->extnValue.numocts));
        bool criticality = false;

        if(FALSE == ext->critical)
          criticality = false;
        else
          criticality = true;

        if (itr != OIDMap.end ()) 
        {
            // Use the colleague to parse the extension
            try
            {
                CPKIFX509ExtensionPtr anExtPtr = (*itr).second->create (criticality, extensionBufPtr);
                exts.push_back (anExtPtr);
            }
            catch(...)
            {
                //This was added to get around the problem of parsing busted policy extensions

                if(!criticality)
                {
                    // instantiate default extension
                    CPKIFX509ExtensionPtr anExtPtr (new CPKIFX509Extension (cpkifOIDPtr, criticality, extensionBufPtr));
                    exts.push_back (anExtPtr); 
                }
            }
        } 
        else 
        { 
            // instantiate default extension
            CPKIFX509ExtensionPtr anExtPtr (new CPKIFX509Extension (cpkifOIDPtr, criticality, extensionBufPtr));
            exts.push_back (anExtPtr); 
        }

        cur = cur->next;
    }  

    delete [] OIDStrings;
}
void CPKIFX509ExtensionMediator2::AddColleague(
    IPKIFColleague* module,
    bool transferOwnership)
{
    LOG_STRING_DEBUG("CPKIFX509ExtensionMediator2::AddColleague(IPKIFColleague* module, bool transferOwnership)", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    if(NULL == module)
        return;

    //if the module throws an exception let the caller catch it
    module->Initialize();
    module->AddParent(this);//added 3/12/2003 CRW

    try
    {
        //set upa n array of pointers that we will need to delete
        if(transferOwnership)
            m_impl->m_vModulesToDelete.push_back(module);

        //create a guard on the vector so if the push onto the primary vector fails we can
        //pop the one off of m_impl->m_vModulesToDelete
        ScopeGuard guard = MakeObjGuard(m_impl->m_vModulesToDelete, &vector<IPKIFColleague*>::pop_back);
        m_impl->m_vModules.push_back(module);
        guard.Dismiss();
    }
    catch(...)
    {
        throw;
    }
}
void CPKIFX509ExtensionMediator2::CPKIFX509ExtensionMediator2Destructor()
{
    if(m_hInstance) {
        delete m_hInstance;
        m_hInstance = 0;
    }
}

class CPKIFX509ExtensionMediator2Cleaner
{
    public:
        ~CPKIFX509ExtensionMediator2Cleaner()
        {
            CPKIFX509ExtensionMediator2::CPKIFX509ExtensionMediator2Destructor();
        }
} CPKIFX509ExtensionMediator2CleanerInstance;