ValidationPolicy.cpp

Go to the documentation of this file.

#include "ASN1Helper.h"
#include "AlgorithmIdentifier.h"
#include "Buffer.h"
#include "OID.h"
#include "CVRequest.h" 
#include "ValidationPolicy.h" 
#include "SCVPException.h"
#include "PKCReference.h"
#include "KeyUsage.h"
#include "PolicyInformation.h"
#include "private/SCVPUtils.h"
#include <iostream>

#include "boost/filesystem/fstream.hpp"
#include "boost/filesystem/operations.hpp"
namespace fs = boost::filesystem;

using namespace std;


#include "SCVP.h"
#include "ToolkitUtils.h"


struct CPKIFValidationPolicyImpl 
{
    std::bitset<3> m_indicators;
    CPKIFValidationPolRefPtr m_validationPolRef;
    CPKIFPolicyInformationListPtr m_initPolSet;
    CPKIFValidationAlgPtr m_validationAlg;
    CPKIFKeyUsageListPtr m_keyUsages;
    CPKIFOIDListPtr m_EKUs;
    CPKIFOIDListPtr m_SKUs;
    CPKIFPKCReferenceListPtr m_TAs;
};


CPKIFValidationPolicy::CPKIFValidationPolicy() :m_impl(new CPKIFValidationPolicyImpl)
{
    LOG_STRING_DEBUG("CPKIFValidationPolicy::CPKIFValidationPolicy()", TOOLKIT_SCVP_ASN, 0, this);

}
CPKIFValidationPolicy::CPKIFValidationPolicy(
    const CPKIFBufferPtr& valPol)
  :m_impl (new CPKIFValidationPolicyImpl)
{
    if(valPol == (CPKIFBuffer*)NULL || 0 == valPol->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    CACASNWRAPPER_CREATE(ValidationPolicy, objPDU);
    objPDU.Decode(valPol->GetBuffer(), valPol->GetLength());

    //ValidationPolicyReference
    CPKIFOIDPtr algOID(new CPKIFOID(objPDU->validationPolRef.valPolId.subid, objPDU->validationPolRef.valPolId.numids));

    CPKIFBufferPtr algParams; 
    if(objPDU->validationPolRef.m.valPolParamsPresent == 1)
    {
        CPKIFBufferPtr tmpAlgParams(new CPKIFBuffer(objPDU->validationPolRef.valPolParams.data,
            objPDU->validationPolRef.valPolParams.numocts));

        algParams = tmpAlgParams;
    }
    CPKIFValidationPolRefPtr valPolRef(new CPKIFValidationPolRef(algOID, algParams));

    m_impl->m_validationPolRef = valPolRef;

    if(0 < objPDU->m.userPolicySetPresent)
    {
        CPKIFPolicyInformationListPtr tmpuserPolicySet(new CPKIFPolicyInformationList());
        DListNode* cur = objPDU->userPolicySet.head;
        while(NULL != cur)
        {
            ASN1OBJID* tmp = (ASN1OBJID*)cur->data;
            CPKIFOIDPtr tmpOID(new CPKIFOID(tmp->subid, tmp->numids));

            CPKIFPolicyInformationPtr tmpPolInfo(new CPKIFPolicyInformation(tmpOID));
            tmpuserPolicySet->push_back(tmpPolInfo);

            cur = cur->next;
        }
        m_impl->m_initPolSet = tmpuserPolicySet;
    }

    if(0 < objPDU->m.inhibitPolicyMappingPresent)
    {
        m_impl->m_indicators.set(POLICY_MAPPING);
    }
    if(0 < objPDU->m.requireExplicitPolicyPresent)
    {
        m_impl->m_indicators.set(EXPLICIT_POLICY);
    }
    if(0 < objPDU->m.inhibitAnyPolicyPresent)
    {
        m_impl->m_indicators.set(ANY_POLICY);
    }

    if(0 < objPDU->m.trustAnchorsPresent)
    {
        CPKIFPKCReferenceListPtr tmpTAList(new CPKIFPKCReferenceList());
        DListNode* cur = objPDU->trustAnchors.head;
        while(NULL != cur)
        {
            PKCReference* tmp = (PKCReference*)cur->data;
            CACASNWRAPPER_CREATE(PKCReference, objPDU2);
            ASN1OpenType* data1 = objPDU2.Encode(tmp);

            //fs::ofstream outFile;

            //try {
            //  outFile.open("test2.der",ios_base::out | ios_base::binary);
            //  outFile.write((const char *)tmp->u.cert->data,tmp->u.cert->numocts);
            //  outFile.close();
            //} catch(std::exception & ) {
            //  cout<<"could not open file"<<endl;
            //}

            CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFPKCReferencePtr tmpRevInfo(new CPKIFPKCReference(tmpBuf));

            if(NULL != data1)
                delete data1;

            tmpTAList->push_back(tmpRevInfo);

            cur = cur->next;
        }

        m_impl->m_TAs = tmpTAList;
    }

    if(0 < objPDU->m.validationAlgPresent)
    {
        CPKIFOIDPtr algOID(new CPKIFOID(objPDU->validationAlg.valAlgId.subid, objPDU->validationAlg.valAlgId.numids));

        CPKIFBufferPtr algParams; 
        if(objPDU->validationAlg.m.parametersPresent == 1)
        {
            CPKIFBufferPtr tmpAlgParams(new CPKIFBuffer(objPDU->validationAlg.parameters.data,
                objPDU->validationAlg.parameters.numocts));

            algParams = tmpAlgParams;
        }
        CPKIFValidationAlgPtr valAlg(new CPKIFValidationAlg(algOID, algParams));

        m_impl->m_validationAlg = valAlg;
    }
    if(0 < objPDU->m.keyUsagesPresent)
    {
        CPKIFKeyUsageListPtr tmpKeyUsageList(new CPKIFKeyUsageList());
        DListNode* cur = objPDU->keyUsages.head;
        while(NULL != cur)
        {
            CACX509V3KeyUsage* tmp = (CACX509V3KeyUsage*)cur->data;
            CACASNWRAPPER_CREATE(CACX509V3KeyUsage, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(tmp);           
            CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFKeyUsagePtr tmpKeyUsage(new CPKIFKeyUsage(false, tmpBuf));

            if(NULL != data1)
                delete data1;

            tmpKeyUsageList->push_back(tmpKeyUsage);

            cur = cur->next;
        }
        m_impl->m_keyUsages = tmpKeyUsageList;
    }
    if(0 < objPDU->m.extendedKeyUsagesPresent)
    {
        m_impl->m_EKUs = PopulatePKIFOIDList(&objPDU->extendedKeyUsages);
    }

    if(0 < objPDU->m.specifiedKeyUsagesPresent)
    {
        m_impl->m_SKUs = PopulatePKIFOIDList(&objPDU->specifiedKeyUsages);
    }
}
CPKIFValidationPolicy::~CPKIFValidationPolicy()
{
    LOG_STRING_DEBUG("CPKIFValidationPolicy::~CPKIFValidationPolicy()", TOOLKIT_SCVP_ASN, 0, this);

    if (m_impl) {
      delete m_impl;
    }   
}

void CPKIFValidationPolicy::SetInitialExplicitPolicyIndicator() {m_impl->m_indicators.set(EXPLICIT_POLICY);}
bool CPKIFValidationPolicy::GetInitialExplicitPolicyIndicator() {return m_impl->m_indicators[EXPLICIT_POLICY];}
void CPKIFValidationPolicy::SetInitialPolicyMappingInhibitIndicator() {m_impl->m_indicators.set(POLICY_MAPPING);}

bool CPKIFValidationPolicy::GetInitialPolicyMappingInhibitIndicator() {return m_impl->m_indicators[POLICY_MAPPING];}

void CPKIFValidationPolicy::SetInitialInhibitAnyPolicyIndicator() {m_impl->m_indicators.set(ANY_POLICY);}

bool CPKIFValidationPolicy::GetInitialInhibitAnyPolicyIndicator() {return m_impl->m_indicators[ANY_POLICY];}
void CPKIFValidationPolicy::SetInitialPolicySet(
    CPKIFPolicyInformationListPtr& initPolSet) 
{
    m_impl->m_initPolSet = initPolSet;
}

void CPKIFValidationPolicy::GetInitialPolicySet(
    CPKIFPolicyInformationListPtr& initPolSet)const 
{
    initPolSet = m_impl->m_initPolSet;
}
void CPKIFValidationPolicy::SetValidationPolRef(
    CPKIFValidationPolRefPtr& valPolRef)
{
    m_impl->m_validationPolRef = valPolRef;
}
CPKIFValidationPolRefPtr CPKIFValidationPolicy::GetValidationPolRef() const
{
    return m_impl->m_validationPolRef;
}

void CPKIFValidationPolicy::SetValidationAlg(
    CPKIFValidationAlgPtr& valAlg)
{
    m_impl->m_validationAlg = valAlg;
}
CPKIFValidationAlgPtr CPKIFValidationPolicy::GetValidationAlg() const
{
    return m_impl->m_validationAlg;
}
void CPKIFValidationPolicy::SetKeyUsages(
    CPKIFKeyUsageListPtr& keyUsages)
{
    m_impl->m_keyUsages = keyUsages;
}
void CPKIFValidationPolicy::GetKeyUsages(
    CPKIFKeyUsageListPtr& keyUsages) const
{
    keyUsages = m_impl->m_keyUsages;
}
void CPKIFValidationPolicy::SetEKUs(
    CPKIFOIDListPtr& ekus)
{
    m_impl->m_EKUs = ekus;
}
void CPKIFValidationPolicy::GetEKUs(    
    CPKIFOIDListPtr& ekus) const
{
    ekus = m_impl->m_EKUs;
}
void CPKIFValidationPolicy::SetSKUs(
    CPKIFOIDListPtr& skus)
{
    m_impl->m_SKUs = skus;
}
void CPKIFValidationPolicy::GetSKUs(
    CPKIFOIDListPtr& skus) const
{
    skus = m_impl->m_SKUs;
}
void CPKIFValidationPolicy::SetTAs(
    CPKIFPKCReferenceListPtr& tas)
{
    m_impl->m_TAs = tas;
}
void CPKIFValidationPolicy::GetTAs(
    CPKIFPKCReferenceListPtr& tas) const
{
    tas = m_impl->m_TAs;
}