SimpleCRLCache.cpp

Go to the documentation of this file.

#include "SimpleCRLCache.h"
#include "PKIFCacheErrors.h"
#include "ToolkitUtils.h" 
#include "GottaMatch.h"
#include "CRL.h"
#include "DPAndCRLPair.h"
#include "Certificate.h"
#include "GeneralName.h"
#include "PKIFTime.h"
#include "Buffer.h"
#include "PKIFCacheException.h"
#include "CRLPassedNextUpdate.h"
#include "PKIFPathSettings.h"

#include "boost/filesystem/operations.hpp"
#include "boost/filesystem/path.hpp"
#include "boost/thread/recursive_mutex.hpp"

#include "boost/numeric/conversion/cast.hpp"
#include "boost/numeric/conversion/bounds.hpp"
#include "boost/limits.hpp"

using boost::numeric_cast;
using boost::bad_numeric_cast;

#include <sstream>
#ifdef _DEBUG
#include <iostream>
#endif //_DEBUG


namespace fs = boost::filesystem;
using namespace std;

struct SimpleCRLCacheImpl
{
    SimpleCRLCache * m_parent;
    SimpleCRLCacheImpl ():m_me() 
    {   
        m_parent = 0;
    };
    SimpleCRLCacheImpl (SimpleCRLCache  *p) :m_me()
    {
        m_parent = p;
    }
    CPKIFCRLList m_crlList;
    //CACMonitorDataPtr m_md;
    boost::recursive_mutex m_me;
    DPAndCRLPairList m_dpCRLList;

    bool m_bAutoCleanup;
    unsigned long m_interval;
    
    vector<string> m_pathList;

    unsigned long m_lastTickCount;
    bool NeedToCheckForOldCRLs();
    void CheckForAndRemoveOldCRLs();
};

CAC_API SimpleCRLCache* MakeSimpleCRLCache()
{
    return new SimpleCRLCache();
}
CAC_API void FreeSimpleCRLCache(
    SimpleCRLCache* s)
{
    if(s)
    {
        delete s;
    }
}
SimpleCRLCache::SimpleCRLCache(void)
    :m_impl (new SimpleCRLCacheImpl)
{
    LOG_STRING_DEBUG("SimpleCRLCache::SimpleCRLCache(void)", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    m_impl->m_parent = this;
    m_impl->m_bAutoCleanup=true;
    m_impl->m_lastTickCount = 0;
    m_impl->m_interval = 3600000;
}
SimpleCRLCache::~SimpleCRLCache(void)
{
//  LOG_STRING_DEBUG("SimpleCRLCache::~SimpleCRLCache(void)", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    delete m_impl;
    m_impl = NULL;
}

int SimpleCRLCache::size()
{
    int len = 0;

    try 
    {
        len = numeric_cast<int>(m_impl->m_crlList.size());
        return len;
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_CACHE, COMMON_INVALID_INPUT, "Cache size is larger than maximum integer size.");
    }
}

//IPKIFColleague functions
void SimpleCRLCache::Initialize(void)
{
    LOG_STRING_DEBUG("SimpleCRLCache::Initialize(void)", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);
}
void SimpleCRLCache::GetCRLs(
    const CPKIFCertificatePtr& cert,
    CPKIFCRLList& crlList,
    PKIInfoSource source)
{
    LOG_STRING_DEBUG("SimpleCRLCache::GetCRLs(const CPKIFCertificatePtr& cert, CPKIFCRLList& crlList, PKIInfoSource source)", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

#ifdef _DEBUG
    //cout << "SimpleCRLCache size: " << m_impl->m_crlList.size() << endl;
#endif

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock lock(m_impl->m_me);

    const size_t origSize = crlList.size();

    if(m_impl->NeedToCheckForOldCRLs())
        m_impl->CheckForAndRemoveOldCRLs();

    //ignore requests for remote certificates
    if(REMOTE == source)
    {
        LOG_STRING_DEBUG("Skipping SimpleCRLCache colleague - searching REMOTE sources only", thisComponent, 0, this);
        return;
    }

    if(cert == (CPKIFCertificate*)NULL)
    {
        std::string reason;
        FormatErrorMessage(reason, "NULL certificate passed to GetCRLs.", COMMON_INVALID_INPUT);
        LOG_STRING_DEBUG(reason.c_str(), thisComponent, COMMON_INVALID_INPUT, this);
        return;
    }

    CPKIFNamePtr issuer = cert->Issuer();
    if(issuer == (CPKIFName*)NULL)
    {
        std::string reason;
        FormatErrorMessage(reason, "Certificate with NULL issuer passed to GetCRLs.", COMMON_INVALID_INPUT);
        LOG_STRING_DEBUG(reason.c_str(), thisComponent, COMMON_INVALID_INPUT, this);
        return;
    }

    CPKIFCRLList::iterator pos;
    CPKIFCRLList::iterator end = m_impl->m_crlList.end();
    for(pos = m_impl->m_crlList.begin(); pos != end; ++pos)
    {
        if(*issuer == *(*pos)->Issuer())
        {
            GottaMatch<CPKIFCRLPtr> gm;
            gm.SetRHS(*pos);
            if(crlList.end() == find_if(crlList.begin(), crlList.end(), gm))
                crlList.push_back(*pos); 
        }
    }

    //DP based retrieval
    CPKIFGeneralNameList namesFromCert;
    CollectNamesFromCRLDP(cert, namesFromCert);

    CPKIFGeneralNameList::iterator gnPos;
    CPKIFGeneralNameList::iterator gnEnd = namesFromCert.end();
    for(gnPos = namesFromCert.begin(); gnPos != gnEnd; ++gnPos)
    {
        DPAndCRLPairList::iterator dpListPos;
        DPAndCRLPairList::iterator dpListEnd = m_impl->m_dpCRLList.end();
        for(dpListPos = m_impl->m_dpCRLList.begin(); dpListEnd != dpListPos; ++dpListPos)
        {
            //added proper de-reference (had been comparing smart pointers - oops)
            //2/19/2004 CRW
            if(*(*dpListPos)->m_dp == *(*gnPos))
            {
                //added GottaMatch stuff 7/21/2005 CRW
                GottaMatch<CPKIFCRLPtr> gm;
                gm.SetRHS((*dpListPos)->m_crl);
                if(crlList.end() == find_if(crlList.begin(), crlList.end(), gm))
                    crlList.push_back((*dpListPos)->m_crl);
            }
        }

        if(CPKIFGeneralName::DIRECTORYNAME == (*gnPos)->GetType())
        {
            CPKIFNamePtr dpDN = (*gnPos)->directoryName();
            if(dpDN != (CPKIFName*)NULL)
            {
                CPKIFCRLList::iterator pos;
                CPKIFCRLList::iterator end = m_impl->m_crlList.end();
                for(pos = m_impl->m_crlList.begin(); pos != end; ++pos)
                {
                    if(*dpDN == *(*pos)->Issuer())
                    {
                        //added GottaMatch stuff 7/21/2005 CRW
                        GottaMatch<CPKIFCRLPtr> gm;
                        gm.SetRHS(*pos);
                        if(crlList.end() == find_if(crlList.begin(), crlList.end(), gm))
                            crlList.push_back(*pos);
                    }
                }
            }
        }
    }

    if(origSize != crlList.size())
    {
        std::string logStr = "Found one or more CRLs issued by ";
        logStr.append(cert->Issuer()->ToString());
        LOG_STRING_DEBUG(logStr.c_str(), thisComponent, 0, this);
    }
    else
    {
        std::string logStr = "Failed to find a CRL issued by ";
        logStr.append(cert->Issuer()->ToString());
        LOG_STRING_DEBUG(logStr.c_str(), thisComponent, 0, this);
    }
}
void SimpleCRLCache::Clear()
{
    LOG_STRING_DEBUG("SimpleCRLCache::Clear()", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock lock(m_impl->m_me);
    LOG_STRING_DEBUG("Emptying SimpleCRLCache instance", thisComponent, 0, this);
    m_impl->m_crlList.clear();
}
void SimpleCRLCache::SetAutoCleanup(
    bool on, 
    unsigned long interval) 
{
    LOG_STRING_DEBUG("SimpleCRLCache::SetAutoCleanup(bool on, int interval)", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock lock(m_impl->m_me);
    m_impl->m_bAutoCleanup = on;

    m_impl->m_interval = interval;
//  if(m_interval < 0)
//      m_interval *= -1;
}
void SimpleCRLCache::AddCRL(
    const CPKIFCRLPtr& crl, 
    const CPKIFGeneralNamePtr& dp)
{
    LOG_STRING_DEBUG("SimpleCRLCache::AddCRL(const CPKIFCRLPtr& crl, const CPKIFGeneralNamePtr& dp)", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock lock(m_impl->m_me);
    //This function adds a CRL to two internal vectors.  One vector will be used to retrieve
    //CRLs using issuer name from a cert and the other will use a distribution point from a cert.
    //Thus, if a CRL was retrieved from www.getyourcrlshere.com with an issuer name different from
    //the cert issuer (not that we support indirect CRLs in this version of PKIF) then the cache will 
    //still function.

    if(m_impl->NeedToCheckForOldCRLs())
        m_impl->CheckForAndRemoveOldCRLs();

    GottaMatch<CPKIFCRLPtr> gm;
    gm.SetRHS(crl);

    //avoid growing the cache with duplicates
    if(m_impl->m_crlList.end() == find_if(m_impl->m_crlList.begin(), m_impl->m_crlList.end(), gm))
    {
        m_impl->m_crlList.push_back(crl);

        std::ostringstream os;
        os << "Successfully added CRL to SimpleCRLCache store.  Size =  " << m_impl->m_crlList.size() << " after addition.";
        LOG_STRING_DEBUG(os.str().c_str(), thisComponent, 0, this)
    }

    //DP based CRL storage
    if(dp != (CPKIFGeneralName*)NULL)
    {
        DPAndCRLPairPtr newDPCRLPair(new DPAndCRLPair);
        newDPCRLPair->m_dp = dp;
        newDPCRLPair->m_crl = crl;

        GottaMatch<DPAndCRLPairPtr> gm2;
        gm2.SetRHS(newDPCRLPair);
        if(m_impl->m_dpCRLList.end() == find_if(m_impl->m_dpCRLList.begin(), m_impl->m_dpCRLList.end(), gm2))
        {
            m_impl->m_dpCRLList.push_back(newDPCRLPair);

            std::ostringstream os;
            os << "Successfully added DP CRL to SimpleCRLCache store.  Size =  " << m_impl->m_dpCRLList.size() << " after addition.";
            LOG_STRING_DEBUG(os.str().c_str(), thisComponent, 0, this)
        }
    }
}
void SimpleCRLCache::WriteCRLsToDirectory(
    const char * path)
{
    try
    {
        std::string CRLdirPath  = path;
        CPKIFCRLList::iterator pos;
        CPKIFCRLList::iterator end = m_impl->m_crlList.end();
        for(pos = m_impl->m_crlList.begin(); pos != end; ++pos)
        {
            string tmpCRLName = (*pos)->Issuer()->ToString();           
            string tmpCRLThisUpdate = (*pos)->ThisUpdate()->GetTime();
            string tmpPath = CRLdirPath;
            if(tmpPath[tmpPath.size() -1] != '\\')
                tmpPath.append("\\");
            tmpPath.append(tmpCRLName);
            tmpPath.append("_");
            tmpPath.append(tmpCRLThisUpdate);
            tmpPath.append(".crl");

            FILE* f = fopen(tmpPath.c_str(), "wb");
            fwrite((*pos)->Encoded()->GetBuffer(), 1, (*pos)->Encoded()->GetLength(), f);
            fclose(f);
        }

        DPAndCRLPairList::iterator pos2;
        DPAndCRLPairList::iterator end2 = m_impl->m_dpCRLList.end();
        for(pos2 = m_impl->m_dpCRLList.begin(); pos2 != end2; ++pos2)
        {
            string tmpCRLName = (*pos2)->m_crl->Issuer()->ToString();       
            string tmpCRLThisUpdate = (*pos)->ThisUpdate()->GetTime();
            string tmpPath = CRLdirPath;
            if(tmpPath[tmpPath.size() -1] != '\\')
                tmpPath.append("\\");
            tmpPath.append(tmpCRLName);
            tmpPath.append("_");
            tmpPath.append(tmpCRLThisUpdate);
            tmpPath.append(".crl");
            
            FILE* f = fopen(tmpPath.c_str(), "wb");
            fwrite((*pos)->Encoded()->GetBuffer(), 1, (*pos)->Encoded()->GetLength(), f);
            fclose(f);
        }
    }catch( const std::exception&)
    {
            RAISE_CACHE_EXCEPTION("Error Writing files to a directory", thisComponent, COMMON_UNKNOWN_ERROR, this)
     }
}

void SimpleCRLCache::ReadCRLsFromDirectory(
    const char * path)
{
    fs::path full_path( fs::initial_path() );

    if(NULL != path)
        full_path = fs::system_complete( fs::path( path, fs::native ) );
    else
        RAISE_CACHE_EXCEPTION("NULL Pointer passed as a parameter", thisComponent, COMMON_INVALID_INPUT, this)

    if ( !fs::exists( full_path ) )
    {
        RAISE_CACHE_EXCEPTION("Invalid Path", thisComponent, COMMON_INVALID_INPUT, this)
    }   

   fs::directory_iterator end_iter;
   for ( fs::directory_iterator dir_itr( full_path ); dir_itr != end_iter; ++dir_itr )
   {
       try
       {
           if ( !fs::is_directory( *dir_itr ) )
           {
                FILE* f = fopen(dir_itr->string().c_str(), "rb");

                unsigned char *crlraw = NULL;

                //reviewed 4/24 - added bounds check below
                boost::intmax_t crlrawlen = fs::file_size( *dir_itr );

                if(crlrawlen > boost::numeric::bounds<int>::highest())
                {
                    throw CPKIFCacheException(TOOLKIT_SR_SIMPLECRLCACHE, COMMON_INVALID_INPUT, "CRL too big.");
                }

                int tmpST = 0;
                try 
                {
                    tmpST = numeric_cast<int>(crlrawlen);
                }
                catch(bad_numeric_cast &) 
                {
                    throw CPKIFException(TOOLKIT_UTILS, COMMON_INVALID_INPUT, "CRL size too big.");
                }

                crlraw = new unsigned char[tmpST];
                size_t bytesread = fread(crlraw, 1, tmpST, f);
            
                CPKIFCRLPtr crl(new CPKIFCRL);
                crl->Decode(crlraw, tmpST);
            
                CPKIFGeneralNamePtr dummy;
                AddCRL(crl, dummy);
                
                fclose(f);
                delete[] crlraw;
           }
       }
       catch( const std::exception & )
       {
            RAISE_CACHE_EXCEPTION("Unable to open file", thisComponent, COMMON_UNKNOWN_ERROR, this)
       }

   }
    
}
bool SimpleCRLCacheImpl::NeedToCheckForOldCRLs()
{
    LOG_STRING_DEBUG("SimpleCRLCache::NeedToCheckForOldCRLs()", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    unsigned long tmpTickCount = GetTickCount();
    if((tmpTickCount - m_lastTickCount) > m_interval)
    {
        m_lastTickCount = tmpTickCount;
        return true;
    }
    else
        return false;
}
void SimpleCRLCacheImpl::CheckForAndRemoveOldCRLs()
{
    LOG_STRING_DEBUG("SimpleCRLCache::CheckForAndRemoveOldCRLs()", TOOLKIT_SR_SIMPLECRLCACHE, 0, this);

    if(!m_bAutoCleanup)
        return;

    LOG_STRING_DEBUG("Purging old CRLs from SimpleCRLCache store", m_parent->thisComponent, 0, this);

    CRLPassedNextUpdate funcObj;
    // needed for g++ as opposed to
    // funcObj.SetCurTime(CPKIFTime::CurrentTime()
    CPKIFTimePtr now = CPKIFTime::CurrentTime();
    funcObj.SetCurTime(now);
    CPKIFCRLList::iterator crlEnd = remove_if(m_crlList.begin(), m_crlList.end(), funcObj);
    m_crlList.erase(crlEnd, m_crlList.end());

    DPAndCRLPairList::iterator dpEnd = remove_if(m_dpCRLList.begin(), m_dpCRLList.end(), funcObj);
    m_dpCRLList.erase(dpEnd, m_dpCRLList.end());
}
void SimpleCRLCache::GetCRLs(
    std::vector<CPKIFCRLPtr>& v)
{
    CPKIFCRLList::iterator pos;
    CPKIFCRLList::iterator end = m_impl->m_crlList.end();
    for(pos = m_impl->m_crlList.begin(); pos != end; ++pos)
    {
        v.push_back(*pos);
    }
}

void CRLCoversTimeOfInterest::SetTimeOfInterest(
    CPKIFTimePtr& time) 
{
    m_time = time;
}
bool CRLCoversTimeOfInterest::operator ()(const CPKIFCRLPtr& crl)
{
    CPKIFTimePtr nextUpdate = crl->NextUpdate();
    CPKIFTimePtr thisUpdate = crl->ThisUpdate();

#ifdef _DEBUG
    const char* thisUpdateStr = thisUpdate->GetTime();
    const char* toiStr = m_time->GetTime();
    if(nextUpdate)
    {
        const char* nextUpdateStr = nextUpdate->GetTime();
    }
#endif

    if(nextUpdate == (CPKIFTime*)NULL)
        return false;
    else if(*nextUpdate < *m_time || *thisUpdate > *m_time)
        return true;
    else
        return false;
}

void SimpleCRLCache::GetCRLs(const CPKIFCertificatePtr& cert, CPKIFCRLList& crlList, PKIInfoSource source, CPKIFPathSettingsPtr& ps)
{
    CPKIFCRLList tempCrlList;
    GetCRLs(cert, tempCrlList, source);

    CPKIFTimePtr valTime;
    if(ps)
        valTime = ps->GetValidationTime();

    if(valTime && ps->GetRequireValidationTimeNesting())
    {
        CRLCoversTimeOfInterest cctoi;
        cctoi.SetTimeOfInterest(valTime);
        CPKIFCRLList::iterator newEnd = remove_if(tempCrlList.begin(), tempCrlList.end(), cctoi);
        tempCrlList.erase(newEnd, tempCrlList.end());
    }

    copy(tempCrlList.begin(), tempCrlList.end(), back_inserter(crlList));
}