KeyAgreePublicKey.cpp

Go to the documentation of this file.

#include "KeyAgreePublicKey.h"
#include "components.h"
#include "ToolkitUtils.h"
#include "Buffer.h"
#include "PKIFSCVPErrors.h"
#include "SCVPException.h"
#include "ASN1Helper.h"
#include "SCVP.h"
#include "AlgorithmIdentifier.h"
#include "OID.h"


struct CPKIFKeyAgreePublicKeyImpl 
{   
    CPKIFBufferPtr m_publicKey;
    CPKIFAlgorithmIdentifierPtr m_algorithm;
    CPKIFAlgorithmIdentifierPtr m_macAlgorithm;
    CPKIFAlgorithmIdentifierPtr m_kDF;
};


CPKIFKeyAgreePublicKey::CPKIFKeyAgreePublicKey() :m_impl(new CPKIFKeyAgreePublicKeyImpl)
{
    LOG_STRING_DEBUG("CPKIFKeyAgreePublicKey::CPKIFKeyAgreePublicKey()", TOOLKIT_SCVP_ASN, 0, this);

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

    CACASNWRAPPER_CREATE(KeyAgreePublicKey, objPDU);
    objPDU.Decode(keyAgreePublicKey->GetBuffer(), keyAgreePublicKey->GetLength());

    CPKIFBufferPtr buff(new CPKIFBuffer(objPDU->publicKey.data, objPDU->publicKey.numbits/8));

    m_impl->m_publicKey = buff;

    //algorithm
    CPKIFOIDPtr algOID(new CPKIFOID(objPDU->algorithm.algorithm.subid, objPDU->algorithm.algorithm.numids));

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

        algParams = tmpAlgParams;
    }
    CPKIFAlgorithmIdentifierPtr alg(new CPKIFAlgorithmIdentifier(algOID, algParams));

    m_impl->m_algorithm = alg;


    //MACalgorithm
    CPKIFOIDPtr macAlgOID(new CPKIFOID(objPDU->macAlgorithm.algorithm.subid, objPDU->macAlgorithm.algorithm.numids));

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

        macAlgParams = tmpAlgParams;
    }
    CPKIFAlgorithmIdentifierPtr macAlg(new CPKIFAlgorithmIdentifier(macAlgOID, macAlgParams));

    m_impl->m_macAlgorithm = macAlg;

    //KDFalgorithm
    CPKIFOIDPtr kDFAlgOID(new CPKIFOID(objPDU->kDF.algorithm.subid, objPDU->kDF.algorithm.numids));

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

        kDFAlgParams = tmpAlgParams;
    }
    CPKIFAlgorithmIdentifierPtr kDFAlg(new CPKIFAlgorithmIdentifier(kDFAlgOID, kDFAlgParams));

    m_impl->m_kDF = kDFAlg;
    
}
CPKIFKeyAgreePublicKey::~CPKIFKeyAgreePublicKey()
{
    LOG_STRING_DEBUG("CPKIFKeyAgreePublicKey::~CPKIFKeyAgreePublicKey()", TOOLKIT_SCVP_ASN, 0, this);

    if (m_impl) {
      delete m_impl;
    }   
}
void CPKIFKeyAgreePublicKey::SetPublicKey(
    CPKIFBufferPtr& publicKey)
{
    LOG_STRING_DEBUG("CPKIFKeyAgreePublicKey::SetNonce(CPKIFStringPtr& nonce)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_publicKey = publicKey;
}
const CPKIFBufferPtr CPKIFKeyAgreePublicKey::GetPublicKey() const
{
    if(m_impl->m_publicKey == NULL)
    {
        CPKIFBufferPtr t;
        return t;
    }
    else
        return m_impl->m_publicKey;
}

void CPKIFKeyAgreePublicKey::SetAlgorithm(
    CPKIFAlgorithmIdentifierPtr& algorithm)
{
    m_impl->m_algorithm = algorithm;
}
CPKIFAlgorithmIdentifierPtr CPKIFKeyAgreePublicKey::GetAlgorithm() const
{
    return m_impl->m_algorithm;
}

void CPKIFKeyAgreePublicKey::SetMACAlgorithm(
    CPKIFAlgorithmIdentifierPtr& macAlgorithm)
{
    m_impl->m_macAlgorithm = macAlgorithm;
}
CPKIFAlgorithmIdentifierPtr CPKIFKeyAgreePublicKey::GetMACAlgorithm() const
{
    return m_impl->m_macAlgorithm;
}

void CPKIFKeyAgreePublicKey::SetKDF(
    CPKIFAlgorithmIdentifierPtr& kDF)
{
    m_impl->m_kDF = kDF;
}
CPKIFAlgorithmIdentifierPtr CPKIFKeyAgreePublicKey::GetKDF() const
{
    return m_impl->m_kDF;
}