AugmentedEGPublicKey.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: AugmentedEGPublicKey.cc,v 1.2 2004/05/19 15:56:57 mmarsh Exp $
//
// $Log: AugmentedEGPublicKey.cc,v $
// Revision 1.2  2004/05/19 15:56:57  mmarsh
// *** empty log message ***
//
// Revision 1.1  2003/11/04 21:56:58  mmarsh
// The ElGamal public key with additional generator, and the signed
// version thereof, are now in the CODEX_Server package rather than
// CODEX_Client, since the generic server should not depend on the
// key service client library.
//
//

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

using namespace CODEX_Server;
using namespace CODEX_ASN1;
using namespace CODEX_Ciphers;

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

AugmentedEGPublicKey::AugmentedEGPublicKey( const ElGamalPublicKey& key,
                                            const BigNumber& h ) :
   CODEX_ASN1::Base( true ),
   m_key( key ),
   m_h( h )
{
}

AugmentedEGPublicKey::AugmentedEGPublicKey(
   const AugmentedEGPublicKey& aAPK ) :
   CODEX_ASN1::Base( aAPK.m_initialized ),
   m_key( aAPK.m_key ),
   m_h( aAPK.m_h )
{
}

void
AugmentedEGPublicKey::operator=( const AugmentedEGPublicKey& aAPK )
{
   m_initialized = aAPK.m_initialized;
   m_key         = aAPK.m_key;
   m_h           = aAPK.m_h;
}

BIGNUM*
AugmentedEGPublicKey::digest( const CODEX_Ciphers::HashFunction& hashFunc )
   const
{
   if ( ! m_initialized )
   {
      return 0;
   }

   unsigned char* buff = NULL;
   BIGNUM * retVal = NULL;
   CODEX_ASN1::ustring* str = NULL;

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

      return retVal;
   }
   catch ( ... )
   {
      if ( NULL != buff ) delete buff;
      if ( NULL != str ) delete str;
      if ( NULL != retVal ) BN_free( retVal );
      throw;
   }
}

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

   ret += m_key.marshal(0);
   ret += m_h.marshal(0);
   M_ASN1_I2D_seq_total();
   m_key.marshal(&p);
   m_h.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
AugmentedEGPublicKey::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_key.unmarshal);
   M_ASN1_D2I_get(i, m_h.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

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

SignedAugmentedEGPublicKey::SignedAugmentedEGPublicKey(
   const AugmentedEGPublicKey& aAPK,
   const CODEX_Ciphers::RSASignature& sig ) :
   CODEX_ASN1::Base( true ),
   m_key( aAPK ),
   m_signature( sig )
{
}

SignedAugmentedEGPublicKey::SignedAugmentedEGPublicKey(
   const AugmentedEGPublicKey& aAPK,
   const CODEX_Ciphers::RSAPrivateKey& key,
   const CODEX_Ciphers::HashFunction& hashFunc ) :
   CODEX_ASN1::Base( true ),
   m_key( aAPK )
{
   BIGNUM * digest = 0;
   CODEX_Ciphers::RSASignature* sig = 0;
   try
   {
      digest = m_key.digest(hashFunc);
      sig = key.sign( digest );
      BN_free( digest );
      digest = 0;
      m_signature = *sig;
      delete sig;
   }
   catch ( ... )
   {
      if ( 0 != digest ) BN_free( digest );
      if ( 0 != sig ) delete sig;
      throw;
   }
}

SignedAugmentedEGPublicKey::SignedAugmentedEGPublicKey(
   const SignedAugmentedEGPublicKey& aOther ) :
   CODEX_ASN1::Base( aOther.m_initialized ),
   m_key( aOther.m_key ),
   m_signature( aOther.m_signature )
{
}

void
SignedAugmentedEGPublicKey::operator=(
   const SignedAugmentedEGPublicKey& aOther )
{
   m_initialized = aOther.m_initialized;
   m_key         = aOther.m_key;
   m_signature   = aOther.m_signature;
}

bool
SignedAugmentedEGPublicKey::verify(
   const CODEX_Ciphers::RSAPublicKey& key,
   const CODEX_Ciphers::HashFunction& hashFunc ) const
{
   BIGNUM * digest = 0;
   try
   {
      digest = m_key.digest( hashFunc );
      bool retval = key.verifySignature( m_signature, digest );
      BN_free( digest );
      return retval;
   }
   catch ( ... )
   {
      if ( 0 != digest ) BN_free( digest );
      throw;
   }
}

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

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

void*
SignedAugmentedEGPublicKey::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_key.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;
}

---