KeyUsage.cpp

Go to the documentation of this file.

#include "KeyUsage.h"
#include "OID.h"
#include "Buffer.h"

#include "ASN1Helper.h"
#include "PKIX1Implicit88.h"
#include "PKIX1Explicit88.h"

#include <iostream>

using namespace std;


struct CPKIFKeyUsageImpl
{
    enum {DIGSIG, NONREP,KEYENC,DATAENC,KEYAGREE,CERT,CRL,ENCONLY,DECONLY};
    std::bitset<9> m_bits;
    CPKIFBufferPtr m_value;
    bool m_extModified;
};


char CPKIFKeyUsage::extOID[] =                  "2.5.29.15";

CPKIFKeyUsage::CPKIFKeyUsage()
  :m_impl (new CPKIFKeyUsageImpl)
{
}


CPKIFKeyUsage::CPKIFKeyUsage(
    const bool& criticality, 
    const CPKIFBufferPtr& ext) 
  : CPKIFX509Extension (criticality, ext), m_impl (new CPKIFKeyUsageImpl)
{
    CACASNWRAPPER_CREATE(CACX509V3KeyUsage, objPDU);
    objPDU.Decode(ext->GetBuffer(), ext->GetLength());

    if( objPDU->data[BytXCACX509V3digitalSignature] & BitMCACX509V3digitalSignature ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::DIGSIG);
    }
    if( objPDU->data[BytXCACX509V3nonRepudiation] & BitMCACX509V3nonRepudiation ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::NONREP);
    }
    if( objPDU->data[BytXCACX509V3dataEncipherment] & BitMCACX509V3dataEncipherment ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::DATAENC);
    }
    if( objPDU->data[BytXCACX509V3keyEncipherment] & BitMCACX509V3keyEncipherment ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::KEYENC);
    }
    if( objPDU->data[BytXCACX509V3keyAgreement] & BitMCACX509V3keyAgreement ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::KEYAGREE);
    }
    if( objPDU->data[BytXCACX509V3keyCertSign] & BitMCACX509V3keyCertSign ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::CERT);
    }
    if( objPDU->data[BytXCACX509V3cRLSign] & BitMCACX509V3cRLSign ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::CRL);
    }
    if( objPDU->data[BytXCACX509V3encipherOnly] & BitMCACX509V3encipherOnly ) 
    {
        m_impl->m_bits.set(CPKIFKeyUsageImpl::ENCONLY);
    }
    if (objPDU->numbits > 8)    // only second byte is used if needed and uninitialized otherwise
    {
        if( objPDU->data[BytXCACX509V3decipherOnly] & BitMCACX509V3decipherOnly ) 
        {
            m_impl->m_bits.set(CPKIFKeyUsageImpl::DECONLY);
        }
    }

    m_impl->m_value = ext;
    m_impl->m_extModified = false;
}

CPKIFKeyUsage::~CPKIFKeyUsage()
{
    if(m_impl)
    {
        delete m_impl;
        m_impl = 0;
    }
}
const CPKIFOIDPtr CPKIFKeyUsage::oid() const
{
    //added static variable for copying instead of string creation each call
    static CPKIFOID staticOID(extOID);
    //CPKIFOIDPtr tmp(new CPKIFOID(new std::string(extOID)));
    static CPKIFOIDPtr tmp(new CPKIFOID(staticOID));
    return tmp;
}
bool CPKIFKeyUsage::DigitalSignature() const {return m_impl->m_bits[CPKIFKeyUsageImpl::DIGSIG];}
bool CPKIFKeyUsage::NonRepudiation() const {return m_impl->m_bits[CPKIFKeyUsageImpl::NONREP];}
bool CPKIFKeyUsage::KeyEncipherment() const {return m_impl->m_bits[CPKIFKeyUsageImpl::KEYENC];}

bool CPKIFKeyUsage::DataEncipherment() const {return m_impl->m_bits[CPKIFKeyUsageImpl::DATAENC];}
bool CPKIFKeyUsage::KeyAgreement() const {return m_impl->m_bits[CPKIFKeyUsageImpl::KEYAGREE];}
bool CPKIFKeyUsage::KeyCertSign() const {return m_impl->m_bits[CPKIFKeyUsageImpl::CERT];}
bool CPKIFKeyUsage::CRLSign() const {return m_impl->m_bits[CPKIFKeyUsageImpl::CRL];}
bool CPKIFKeyUsage::EncipherOnly() const {return m_impl->m_bits[CPKIFKeyUsageImpl::ENCONLY];}
bool CPKIFKeyUsage::DecipherOnly() const {return m_impl->m_bits[CPKIFKeyUsageImpl::DECONLY];}

void CPKIFKeyUsage::SetDigitalSignature() {m_impl->m_bits.set(CPKIFKeyUsageImpl::DIGSIG);}
void CPKIFKeyUsage::SetNonRepudiation() {m_impl->m_bits.set(CPKIFKeyUsageImpl::NONREP);}
void CPKIFKeyUsage::SetKeyEncipherment() {m_impl->m_bits.set(CPKIFKeyUsageImpl::KEYENC);}

void CPKIFKeyUsage::SetDataEncipherment() {m_impl->m_bits.set(CPKIFKeyUsageImpl::DATAENC);}
void CPKIFKeyUsage::SetKeyAgreement() {m_impl->m_bits.set(CPKIFKeyUsageImpl::KEYAGREE);}
void CPKIFKeyUsage::SetKeyCertSign() {m_impl->m_bits.set(CPKIFKeyUsageImpl::CERT);}
void CPKIFKeyUsage::SetCRLSign() {m_impl->m_bits.set(CPKIFKeyUsageImpl::CRL);}
void CPKIFKeyUsage::SetEncipherOnly() {m_impl->m_bits.set(CPKIFKeyUsageImpl::ENCONLY);}
void CPKIFKeyUsage::SetDecipherOnly() {m_impl->m_bits.set(CPKIFKeyUsageImpl::DECONLY);}

bitset<9> CPKIFKeyUsage::GetKeyUsage()
{
    return m_impl->m_bits;
}

CPKIFBufferPtr CPKIFKeyUsage::value() const 
{
    CPKIFBufferPtr rv = m_impl->m_value;
    if(m_impl->m_value == (CPKIFBuffer*)NULL || m_impl->m_extModified)
    {
        //XXX ENCODE HERE and set rv if necessary 
    }

    return rv;
}

CAC_API std::ostream& operator<<(std::ostream & os, const CPKIFKeyUsagePtr & extension)
{
    return operator<<(os,*extension);
}

CAC_API std::ostream& operator<<(std::ostream & os, const CPKIFKeyUsage & extension)
{
    bool output = false;
    if(extension.CRLSign()) {
        os << "CRL Signing";
        output = true;
    }
    if(extension.DataEncipherment()) {
        if(output) os << endl;
        output = true;
        os << "Data Encipherment ";
    }
    if(extension.DecipherOnly()){
        if(output) os << endl;
        output = true;
        os << "Decipher Only";
    }
    if(extension.DigitalSignature()) {
        if(output) os << endl;
        output = true;
        os << "Digital Signature";
    }
    if(extension.EncipherOnly()) {
        if(output) os << endl;
        output = true;
        os << "Encipher Only";
    }
    if(extension.KeyAgreement()) {
        if(output) os << endl;
        output = true;
        os << "Key Agreement";
    }
    if(extension.KeyCertSign()) {
        if(output) os << endl;
        output = true;
        os << "Certificate Signing";
    }
    if(extension.KeyEncipherment()) {
        if(output) os << endl;
        output = true;
        os << "Key Encipherment";
    }
    if(extension.NonRepudiation()) {
        if(output) os << endl;
        output = true;
        os << "Non Repudiation";
    }
    return os;
}