ValPolRequest.cpp

Go to the documentation of this file.

#include "ValPolRequest.h"
#include "components.h"
#include "ToolkitUtils.h"
#include "Buffer.h"
#include "PKIFSCVPErrors.h"
#include "SCVPException.h"
#include "ASN1Helper.h"
#include "SCVP.h"
#include "private/PKIFSCVPMemoryHelper.h"
#include "IPKIFColleague.h"
#include "IPKIFCryptoMisc.h"
#include "PKIFCryptUtils.h"
#include "PKIFMessageErrors.h"


struct CPKIFValPolRequestImpl 
{
    CPKIFValPolRequest *m_parent;
    
    int m_version;
    CPKIFBufferPtr m_nonce;

    //convenience goo for auto-nonce generation
    bool m_bGenerateNonce;
    void GenerateNonce() const; //logical const
    IPKIFMediatorPtr m_mediator;

    //member for decoding
    CPKIFASNWrapper<ValPolRequest>* m_scvpValPolReq;

    void ClearAllMembers();
    void MakeSCVPValPolReq();
    void FreeSCVPValPolReq();
    void CallingAllGets();
};

void CPKIFValPolRequestImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFValPolRequestImpl::CallingAllGets()", TOOLKIT_SCVP_ASN, 0, this);

    m_parent->GetNonce();
    FreeSCVPValPolReq();
}

void CPKIFValPolRequestImpl::MakeSCVPValPolReq()
{
    LOG_STRING_DEBUG("CPKIFValPolRequestImpl::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);

    FreeSCVPValPolReq();
    m_scvpValPolReq = new CPKIFASNWrapper<ValPolRequest>( BEREncValPolRequest, BERDecValPolRequest );
}
void CPKIFValPolRequestImpl::FreeSCVPValPolReq()
{
    LOG_STRING_DEBUG("CPKIFValPolRequestImpl::FreeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);
    if(NULL != m_scvpValPolReq)
        delete m_scvpValPolReq;
    m_scvpValPolReq = NULL;
}

void CPKIFValPolRequestImpl::ClearAllMembers()
{
    m_version = 1;
    m_bGenerateNonce = false;

    IPKIFMediatorPtr tmp;
    m_mediator = tmp;
    
    CPKIFBufferPtr tmpNonce;
    m_nonce = tmpNonce;

    FreeSCVPValPolReq();
}

void CPKIFValPolRequestImpl::GenerateNonce() const
{
    LOG_STRING_DEBUG("CPKIFValPolRequestImpl::GenerateNonce()", TOOLKIT_SCVP_ASN, 0, this);

    IPKIFCryptoMisc* iMisc = NULL;
    if(NULL != m_mediator)
        iMisc = m_mediator->GetMediator<IPKIFCryptoMisc>();

    unsigned char buf[20];
    memset(buf, 0, 20); //avoid (unlikely) case of sending random memory to TSA

    if(NULL != iMisc)
    {
        //if we can get a pointer to an externally provided interface use it
        iMisc->GenRandom(buf, 20);
    }
    else
    {
        //otherwise create a temp object to generate the nonce
 
        IPKIFCryptoMisc *raw = GetPlatformCryptoMisc();
        raw->GenRandom(buf, 20);
    }


    //strip leading zeroes
    const unsigned char* bufEnd = buf + 20;
    unsigned char* bufP = buf;
    int nonZeroLen = 20;
    while(*bufP == 0x00)
    {
        ++bufP;
        --nonZeroLen;
    }
    CPKIFBufferPtr tmpNonce(new CPKIFBuffer(bufP, nonZeroLen));

    CPKIFValPolRequestImpl* nonConst = const_cast<CPKIFValPolRequestImpl*>(this);
    nonConst->m_nonce = tmpNonce;
}

CPKIFValPolRequest::CPKIFValPolRequest() :m_impl(new CPKIFValPolRequestImpl)
{
    LOG_STRING_DEBUG("CPKIFValPolRequest::CPKIFValPolRequest()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_version = 1;
    m_impl->m_bGenerateNonce = false;

    m_impl->m_scvpValPolReq = NULL;

}

CPKIFValPolRequest::~CPKIFValPolRequest()
{
    LOG_STRING_DEBUG("CPKIFValPolRequest::~CPKIFValPolRequest()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->FreeSCVPValPolReq();
    if (m_impl) {
      delete m_impl;
    }   
}
void CPKIFValPolRequest::SetNonce(
    CPKIFBufferPtr& nonce)
{
    LOG_STRING_DEBUG("CPKIFValPolRequest::SetNonce(CPKIFStringPtr& nonce)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_nonce = nonce;
}
const CPKIFBufferPtr CPKIFValPolRequest::GetNonce() const
{
    if(m_impl->m_nonce == NULL)
    {
        CPKIFBufferPtr t;
        return t;
    }
    else
        return m_impl->m_nonce;
}

void CPKIFValPolRequest::SetGenerateNonce(
    bool generateNonce)
{
    LOG_STRING_DEBUG("CPKIFValPolRequest::SetGenerateNonce(bool generateNonce, IPKIFMediatorPtr m)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_bGenerateNonce = generateNonce;
}

void CPKIFValPolRequest::SetGenerateNonce(
    bool generateNonce, 
    IPKIFMediatorPtr& m)
{
    LOG_STRING_DEBUG("CPKIFValPolRequest::SetGenerateNonce(bool generateNonce, IPKIFMediatorPtr m)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_bGenerateNonce = generateNonce;
    m_impl->m_mediator = m;
}
bool CPKIFValPolRequest::GetGenerateNonce() const
{
    return m_impl->m_bGenerateNonce;
}

void CPKIFValPolRequest::Decode(
    CPKIFBufferPtr& msg)
{
    m_impl->ClearAllMembers();

    //if the input is empty - fail now
    if(msg == (CPKIFBuffer*)NULL || 0 == msg->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    m_impl->MakeSCVPValPolReq();

    try
    {
        //otherwise try to parse it into the m_impl->m_scvpr member
        const unsigned char* tmpP = msg->GetBuffer();
        (*m_impl->m_scvpValPolReq).Decode(msg->GetBuffer(), msg->GetLength());

        m_impl->m_version = (*m_impl->m_scvpValPolReq)->vpRequestVersion;

        CPKIFBufferPtr algOID(new CPKIFBuffer((*m_impl->m_scvpValPolReq)->requestNonce.data, (*m_impl->m_scvpValPolReq)->requestNonce.numocts));
    
        m_impl->m_nonce = algOID;

        m_impl->m_bGenerateNonce = false;
    }
    catch(CPKIFException&)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, MSG_DECODE_FAILED);
    }
}
int CPKIFValPolRequest::GetVersion() const
{
    return m_impl->m_version;
}

void CPKIFValPolRequest::SetVersion(int v)
{
    m_impl->m_version = v;
}
CPKIFBufferPtr CPKIFValPolRequest::Encode() const
{
    PKIFSCVPMemoryHelper mhSCVPValPolRequest;
    mhSCVPValPolRequest.pValPolRequest = new ValPolRequest;
    memset(mhSCVPValPolRequest.pValPolRequest, 0, sizeof(ValPolRequest));
    //nonce
    if(m_impl->m_bGenerateNonce)
    {
        m_impl->GenerateNonce();
    }

    const CPKIFBufferPtr nonce = GetNonce();
    if(m_impl->m_nonce != (CPKIFBuffer*)NULL)
    {
        mhSCVPValPolRequest.pValPolRequest->requestNonce.data = m_impl->m_nonce->GetBuffer();
        mhSCVPValPolRequest.pValPolRequest->requestNonce.numocts = m_impl->m_nonce->GetLength();

    }
    else
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "ValPolRequest nonce value not specified.");
    }

    mhSCVPValPolRequest.pValPolRequest->vpRequestVersion = m_impl->m_version;

    CACASNWRAPPER_CREATE(ValPolRequest, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhSCVPValPolRequest.pValPolRequest);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;

    return tmp;
}