PolCredBase.cc

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: PolCredBase.cc,v 1.3 2004/05/19 15:56:47 mmarsh Exp $
//
// $Log: PolCredBase.cc,v $
// Revision 1.3  2004/05/19 15:56:47  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:31:47  mmarsh
// *** empty log message ***
//
//

#include "PolCredBase.h"
#include "CODEX_Exceptions/BignumExceptions.h"

using namespace CODEX_Ciphers;
using namespace CODEX_Exceptions;

PolCredBase::PolCredBase() :
   CODEX_ASN1::Base( false )
{
}

PolCredBase::PolCredBase( const RSAPublicKey& publicKey,
                          const RSASignature& signature ) :
   CODEX_ASN1::Base( true ),
   m_publicKey( publicKey ),
   m_signature( signature )
{
}

PolCredBase::PolCredBase( const RSAPublicKey& publicKey,
                          const RSAPrivateKey& signingKey,
                          const HashFunction& hashFunc ) :
   CODEX_ASN1::Base( true ),
   m_publicKey( publicKey )
{
   BIGNUM * pubKeyBN = NULL;
   RSASignature* signature = NULL;

   try
   {
      pubKeyBN = digest( m_publicKey, hashFunc );
      signature = signingKey.sign( pubKeyBN );
      BN_free( pubKeyBN );
      pubKeyBN = NULL;
      m_signature = *signature;
      delete signature;
      signature = NULL;
   }
   catch ( ... )
   {
      if ( NULL != pubKeyBN ) BN_free( pubKeyBN );
      if ( NULL != signature ) delete signature;
      throw;
   }
}

PolCredBase::PolCredBase( const PolCredBase& aCred ) :
   CODEX_ASN1::Base( aCred.m_initialized ),
   m_publicKey( aCred.m_publicKey ),
   m_signature( aCred.m_signature )
{
}

void
PolCredBase::operator=( const PolCredBase& aCred )
{
   m_initialized = aCred.m_initialized;
   m_publicKey   = aCred.m_publicKey;
   m_signature   = aCred.m_signature;
}

bool
PolCredBase::verify( const RSAPublicKey& delegator,
                     const HashFunction& hashFunc ) const
{
   BIGNUM * pkDigest = NULL;

   try
   {
      pkDigest = digest( m_publicKey, hashFunc );
      bool retVal = delegator.verifySignature( m_signature, pkDigest );
      BN_free( pkDigest );
      pkDigest = NULL;
      return retVal;
   }
   catch ( ... )
   {
      if ( NULL != pkDigest ) BN_free( pkDigest );
      throw;
   }
}

int
PolCredBase::marshal( unsigned char ** pp ) const
{
   int r=0;
   int ret=0;
   unsigned char * p;

   ret += m_publicKey.marshal(0);
   ret += m_signature.marshal(0);
   M_ASN1_I2D_seq_total();
   m_publicKey.marshal(&p);
   m_signature.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
PolCredBase::unmarshal( void* bogus, unsigned char ** pp, long length )
{
   if ( m_initialized )
   {
      return NULL;
   }
   if ( (NULL == pp) || (NULL == *pp) )
   {
      return NULL;
   }

   ASN1_CTX c;
   c.pp = pp;
   c.q = *pp;
   c.error = ERR_R_NESTED_ASN1_ERROR;
   int i;

   M_ASN1_D2I_Init();
   M_ASN1_D2I_start_sequence();
   M_ASN1_D2I_get(i, m_publicKey.unmarshal);
   M_ASN1_D2I_get(i, m_signature.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

BIGNUM *
PolCredBase::digest( const RSAPublicKey& publicKey,
                     const HashFunction& hashFunc )
{
   unsigned char* buff = NULL;
   CODEX_ASN1::ustring* str = NULL;
   BIGNUM * pubKeyBN = NULL;

   try
   {
      int length = publicKey.marshal(0);
      buff = new unsigned char[ length ];
      unsigned char* pBuff = buff;
      publicKey.marshal(&pBuff);
      str = hashFunc( CODEX_ASN1::ustring( buff, length ) );
      delete [] buff;
      buff = NULL;
      pubKeyBN = BN_new();
      if ( NULL == pubKeyBN )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( NULL == BN_bin2bn( str->data(), str->length(), pubKeyBN ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      delete str;
      str = NULL;
      return pubKeyBN;
   }
   catch ( ... )
   {
      if ( NULL != buff ) delete buff;
      if ( NULL != str ) delete str;
      if ( NULL != pubKeyBN ) BN_free( pubKeyBN );
      throw;
   }
}

---