PathResults.cpp

Go to the documentation of this file.

#include "PathResults.h"
#include "ToolkitUtils.h"

#include "PKIFCertificateNodeEntry.h"
#include "PKIFCertStatus.h"
#include "Certificate.h"
#include "AlgorithmIdentifier.h"
#include "OID.h"
#include "PolicyInformation.h"

#include "components.h"

#include <map>
using namespace std;
struct CPKIFPathValidationResultsImpl
{
    bool m_bBasicChecks;
    bool m_bExtensionHandlerChecks;
    bool m_bCertSignaturesVerified;
    RevocationStatus m_revStatus;
    //CPKIFCRLEntryPtr m_crlEntry;
    CPKIFCertStatusPtr m_certStatus;

    IPKIFTrustAnchorPtr m_trustAnchor;

    bool m_bTargetIsTrustAnchor;

    CPKIFAlgorithmIdentifierPtr m_wp;

    int m_nErrorCode;
    bool m_bExplicitPolicyIndicator;

    vector<CPKIFPolicyInformationListPtr>* m_authSet;
    CPKIFPolicyInformationListPtr m_userSet;
    CPKIFCertificateNodeEntryPtr m_cert;

    std::map<string, IPKIFExtHandlerDataPtr> m_extHandlerData;

    bool m_bPermittedSubtreesSet;
    CPKIFGeneralSubtreeListPtr m_permitted;
    bool m_bExcludedSubtreesSet;
    CPKIFGeneralSubtreeListPtr m_excluded;
    bool m_bPendingExplicitPolicySet;
    bool m_bPendingPolicyMappingSet;
    bool m_bPendingAnyPolicySet;
    bool m_bPendingPathLengthSet;
    int m_nPendingExplicitPolicy;
    int m_nPendingPolicyMapping;
    int m_nPendingAnyPolicy;
    int m_nPendingPathLength;
};

bool CPKIFPathValidationResults::GetBasicChecksSuccessfullyPerformed() const 
{
    return m_impl->m_bBasicChecks;
}

void CPKIFPathValidationResults::SetBasicChecksSuccessfullyPerformed(
        bool b)
{
    m_impl->m_bBasicChecks = b;
}

bool CPKIFPathValidationResults::GetCertSignaturesVerified() const 
{
    return m_impl->m_bCertSignaturesVerified;
}

void CPKIFPathValidationResults::SetCertSignaturesVerified(
    bool b) 
{
    m_impl->m_bCertSignaturesVerified = b;
}
bool CPKIFPathValidationResults::GetTargetIsTrustAnchor() const 
{
    return m_impl->m_bTargetIsTrustAnchor;
}
void CPKIFPathValidationResults::SetTargetIsTrustAnchor(
    bool b) 
{
    m_impl->m_bTargetIsTrustAnchor = b;
}

RevocationStatus CPKIFPathValidationResults::GetRevocationStatusMostSevere() const 
{
    return m_impl->m_revStatus;
}
void CPKIFPathValidationResults::SetRevocationStatusMostSevere(
        RevocationStatus r) 
{
    m_impl->m_revStatus = r;
}

CPKIFCertStatusPtr CPKIFPathValidationResults::GetCertStatus() const 
{
    return m_impl->m_certStatus;
}

void CPKIFPathValidationResults::SetCertStatus(
    CPKIFCertStatusPtr& certStatus)
{
    m_impl->m_certStatus = certStatus;
}
const vector<CPKIFPolicyInformationListPtr>* CPKIFPathValidationResults::GetAuthorityConstrainedSetTable() 
{
    return m_impl->m_authSet;
}
void CPKIFPathValidationResults::GetUserConstrainedSet(
    CPKIFPolicyInformationListPtr& userSet) 
{
    userSet = m_impl->m_userSet;
}

void CPKIFPathValidationResults::SetUserConstrainedSet(
    CPKIFPolicyInformationListPtr& userSet) 
{
    m_impl->m_userSet = userSet;
}
bool CPKIFPathValidationResults::GetExplicitPolicyIndicator() const 
{
    return m_impl->m_bExplicitPolicyIndicator;
}
void CPKIFPathValidationResults::SetExplicitPolicyIndicator(
    bool e) 
{
    m_impl->m_bExplicitPolicyIndicator = e;
}

//  f) cert being processed when failure occurred

void CPKIFPathValidationResults::SetCertificate(
    CPKIFCertificateNodeEntryPtr& cert) 
{
    m_impl->m_cert = cert;
}
CPKIFCertificateNodeEntryPtr CPKIFPathValidationResults::GetCertificate() const 
{
    return m_impl->m_cert;
}

//working parameters
void CPKIFPathValidationResults::SetWorkingParams(
    CPKIFAlgorithmIdentifierPtr& wp) 
{
    m_impl->m_wp = wp;
}

CPKIFAlgorithmIdentifierPtr CPKIFPathValidationResults::GetWorkingParams() const
{
    return m_impl->m_wp;
}

void CPKIFPathValidationResults::SetExtHandlerData(const std::string& id, IPKIFExtHandlerDataPtr& data)
{
    m_impl->m_extHandlerData[id] = data;
}

IPKIFExtHandlerDataPtr CPKIFPathValidationResults::GetExtHandlerData(const std::string& id) const
{
    return m_impl->m_extHandlerData[id];
}

CPKIFPathValidationResults::CPKIFPathValidationResults()
:m_impl(new CPKIFPathValidationResultsImpl)
{
    LOG_STRING_DEBUG("CPKIFPathValidationResults::CPKIFPathValidationResults()", TOOLKIT_PATH_MISC, 0, this);

    m_impl->m_authSet = NULL; 
    m_impl->m_bExplicitPolicyIndicator=false;
    m_impl->m_nErrorCode=0;
    m_impl->m_bBasicChecks=false;
    m_impl->m_bExtensionHandlerChecks = true;   //assume these pass, since most of the time there aren't any
    m_impl->m_bCertSignaturesVerified = false;
    m_impl->m_revStatus = NOT_CHECKED;

    m_impl->m_bTargetIsTrustAnchor = false;

    m_impl->m_bPermittedSubtreesSet = false;
    m_impl->m_bExcludedSubtreesSet = false;
    m_impl->m_bPendingExplicitPolicySet = false;
    m_impl->m_bPendingPolicyMappingSet = false;
    m_impl->m_bPendingAnyPolicySet = false;
    m_impl->m_nPendingExplicitPolicy = -1;
    m_impl->m_nPendingPolicyMapping = -1;
    m_impl->m_nPendingAnyPolicy = -1;

    m_impl->m_nPendingPathLength = -1;
    m_impl->m_bPendingPathLengthSet = false;

}
CPKIFPathValidationResults::~CPKIFPathValidationResults()
{
    LOG_STRING_DEBUG("CPKIFPathValidationResults::~CPKIFPathValidationResults()", TOOLKIT_PATH_MISC, 0, this);

    if(m_impl)
    {
        if(NULL != m_impl->m_authSet) 
            delete m_impl->m_authSet; 
        delete m_impl; m_impl = NULL;
    }
}
bool CPKIFPathValidationResults::PathSuccessfullyValidated() const 
{
    return (GetBasicChecksSuccessfullyPerformed() && 
        GetCertSignaturesVerified() && 
        (NOT_REVOKED == GetRevocationStatusMostSevere()) &&
        GetExtensionHandlerChecksSuccessfullyPerformed()) || GetTargetIsTrustAnchor() ;
}
void CPKIFPathValidationResults::GetAuthorityConstrainedSet(
    CPKIFPolicyInformationListPtr& authSet)
{
    LOG_STRING_DEBUG("CPKIFPathValidationResults::GetAuthorityConstrainedSet", TOOLKIT_PATH_MISC, 0, this);

    CPKIFPolicyInformationListPtr tmp(new CPKIFPolicyInformationList);

    CPKIFOIDPtr anyPolicyOID(new CPKIFOID(CPKIFStringPtr(new std::string("2.5.29.32.0"))));
    CPKIFPolicyInformationPtr anyPolicy(new CPKIFPolicyInformation(anyPolicyOID));


    if(NULL == m_impl->m_authSet || m_impl->m_authSet->empty())
    {
        authSet = tmp;
        return;
    }
    else if(*m_impl->m_authSet->front()->back() == *anyPolicy)
    {
        tmp->push_back(anyPolicy);
        authSet = tmp;
        return;
    }
    else
    {
        vector<CPKIFPolicyInformationListPtr>::const_iterator authSetPos;
        vector<CPKIFPolicyInformationListPtr>::const_iterator authSetEnd = m_impl->m_authSet->end();
        for(authSetPos = m_impl->m_authSet->begin(); authSetPos != authSetEnd; ++authSetPos)
        {
            CPKIFPolicyInformationList::const_iterator authSetPolPos;
            CPKIFPolicyInformationList::const_iterator authSetPolEnd = (*authSetPos)->end();
            for(authSetPolPos = (*authSetPos)->begin(); authSetPolPos != authSetPolEnd; ++authSetPolPos)
            {
                if(!(*(*authSetPolPos) == *anyPolicy))
                {
                    tmp->push_back(*authSetPolPos);
                    break;
                }
            }
        }

        authSet = tmp;
        return;
    }
}
void CPKIFPathValidationResults::SetAuthorityConstrainedSet(

    vector<CPKIFPolicyInformationListPtr>* authSet) 
{
    LOG_STRING_DEBUG("CPKIFPathValidationResults::SetAuthorityConstrainedSet", TOOLKIT_PATH_MISC, 0, this);

    if(NULL != m_impl->m_authSet) 
    {
        delete m_impl->m_authSet; m_impl->m_authSet = NULL;
    }
    m_impl->m_authSet = authSet;
}
int CPKIFPathValidationResults::DiagnosticCode() const
{
    LOG_STRING_DEBUG("CPKIFPathValidationResults::DiagnosticCode()", TOOLKIT_PATH_MISC, 0, this);

    if(m_impl->m_cert == (CPKIFCertificateNodeEntry*)NULL)
        return 0;

    CPKIFCertStatusPtr status = m_impl->m_cert->GetStatus();
    if(status == (CPKIFCertStatus*)NULL)
        return 0;

    return status->GetDiagnosticCode();
}

bool CPKIFPathValidationResults::GetExtensionHandlerChecksSuccessfullyPerformed() const 
{
    return m_impl->m_bExtensionHandlerChecks;
}

void CPKIFPathValidationResults::SetExtensionHandlerChecksSuccessfullyPerformed(
        bool b)
{
    //only accept the new value if the previous value was true
    if(m_impl->m_bExtensionHandlerChecks)
        m_impl->m_bExtensionHandlerChecks = b;
}

IPKIFTrustAnchorPtr CPKIFPathValidationResults::GetTrustAnchor() const
{
    return m_impl->m_trustAnchor;
}

void CPKIFPathValidationResults::SetTrustAnchor(IPKIFTrustAnchorPtr& ta)
{
    m_impl->m_trustAnchor = ta;
}

bool CPKIFPathValidationResults::IsPermittedSubtreesSet()
{
    return m_impl->m_bPermittedSubtreesSet;
}

CPKIFGeneralSubtreeListPtr CPKIFPathValidationResults::GetPermittedSubtrees() const
{
    return m_impl->m_permitted;
}

void CPKIFPathValidationResults::SetPermittedSubtrees(CPKIFGeneralSubtreeListPtr& subtree)
{
    m_impl->m_permitted = subtree;
    m_impl->m_bPermittedSubtreesSet = true;
}
bool CPKIFPathValidationResults::IsExcludedSubtreesSet()
{
    return m_impl->m_bExcludedSubtreesSet;
}

CPKIFGeneralSubtreeListPtr CPKIFPathValidationResults::GetExcludedSubtrees() const
{
    return m_impl->m_excluded;
}

void CPKIFPathValidationResults::SetExcludedSubtrees(CPKIFGeneralSubtreeListPtr& subtree)
{
    m_impl->m_excluded = subtree;
    m_impl->m_bExcludedSubtreesSet = true;
}

bool CPKIFPathValidationResults::IsPendingExplicitPolicySet()
{
    return m_impl->m_bPendingExplicitPolicySet;
}

int CPKIFPathValidationResults::GetPendingExplicitPolicy() const
{
    return m_impl->m_nPendingExplicitPolicy;
}

void CPKIFPathValidationResults::SetPendingExplicitPolicy(int skipCerts)
{
    m_impl->m_bPendingExplicitPolicySet = true;
    m_impl->m_nPendingExplicitPolicy = skipCerts;
}

bool CPKIFPathValidationResults::IsPendingPolicyMappingSet()
{
    return m_impl->m_bPendingPolicyMappingSet;
}

int CPKIFPathValidationResults::GetPendingPolicyMapping() const
{
    return m_impl->m_nPendingPolicyMapping;
}

void CPKIFPathValidationResults::SetPendingPolicyMapping(int skipCerts)
{
    m_impl->m_nPendingPolicyMapping = skipCerts;
    m_impl->m_bPendingPolicyMappingSet = true;
}

bool CPKIFPathValidationResults::IsPendingAnyPolicySet()
{
    return m_impl->m_bPendingAnyPolicySet;
}

int CPKIFPathValidationResults::GetPendingAnyPolicy() const
{
    return m_impl->m_nPendingAnyPolicy;
}

void CPKIFPathValidationResults::SetPendingAnyPolicy(int skipCerts)
{
    m_impl->m_nPendingAnyPolicy = skipCerts;
    m_impl->m_bPendingAnyPolicySet = true;
}

bool CPKIFPathValidationResults::IsPendingPathLengthSet()
{
    return m_impl->m_bPendingPathLengthSet;
}

int CPKIFPathValidationResults::GetPendingPathLength() const
{
    return m_impl->m_nPendingPathLength;
}

void CPKIFPathValidationResults::SetPendingPathLength(int skipCerts)
{
    m_impl->m_nPendingPathLength = skipCerts;
    m_impl->m_bPendingPathLengthSet = true;
}