ElGamalSchnorrCipherText.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: ElGamalSchnorrCipherText.cc,v 1.3 2004/05/19 15:56:47 mmarsh Exp $
//
// $Log: ElGamalSchnorrCipherText.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 "ElGamal.h"
#include "CODEX_Exceptions/BignumExceptions.h"

#include "timing.h"

using namespace CODEX_Ciphers;

ElGamalSchnorrCipherText::ElGamalSchnorrCipherText()
{
}

ElGamalSchnorrCipherText::ElGamalSchnorrCipherText( BIGNUM * c1,
                                                    BIGNUM * c2,
                                                    BIGNUM * h,
                                                    BIGNUM * z ) :
   ElGamalCipherText( c1, c2 ),
   m_h( h ),
   m_z( z )
{
}

ElGamalSchnorrCipherText::ElGamalSchnorrCipherText(
   const CODEX_ASN1::BigNumber& c1,
   const CODEX_ASN1::BigNumber& c2,
   const CODEX_ASN1::BigNumber& h,
   const CODEX_ASN1::BigNumber& z ) :
   ElGamalCipherText( c1, c2 ),
   m_h( h ),
   m_z( z )
{
}

ElGamalSchnorrCipherText::ElGamalSchnorrCipherText(
   const ElGamalSchnorrCipherText& aCT ) :
   ElGamalCipherText( aCT ),
   m_h( aCT.m_h ),
   m_z( aCT.m_z )
{
}

ElGamalSchnorrCipherText::~ElGamalSchnorrCipherText()
{
}

void
ElGamalSchnorrCipherText::operator=( const ElGamalSchnorrCipherText& aCT )
{
   ElGamalCipherText::operator=( aCT );
   m_h = aCT.m_h;
   m_z = aCT.m_z;
}

bool
ElGamalSchnorrCipherText::verify( const CODEX_ASN1::BigNumber& g,
                                  const CODEX_ASN1::BigNumber& p,
                                  const CODEX_ASN1::Base& id,
                                  const HashFunction& hashFunc ) const
{
#ifdef TIMING
   SchnorrTimer.start();
#endif
   const BIGNUM * n    = p.value();
   const BIGNUM * gbn  = g.value();
   const BIGNUM * z    = m_z.value();
   const BIGNUM * h    = m_h.value();
   const BIGNUM * c1bn = c1().value();

   BN_CTX *              ctx    = 0;
   BIGNUM *              gzc1mh = 0;
   BIGNUM *              c1mh   = 0;
   unsigned char*        buff   = 0;
   BIGNUM *              cprime = 0;
   CODEX_ASN1::ustring*  str    = 0;
   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ , __LINE__ );
      }

      gzc1mh = BN_new();
      if ( 0 == gzc1mh )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      // gzc1mh = g^m_z c1^(-m_h)
      if ( ! BN_mod_exp( gzc1mh, gbn, z, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ , __LINE__ );
      }
      c1mh = BN_new();
      if ( 0 == c1mh )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_exp( c1mh, c1bn, h, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_inverse( c1mh, c1mh, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModInverseException( __FILE__ ,
                                                            __LINE__ );
      }
      if ( ! BN_mod_mul( gzc1mh, gzc1mh, c1mh, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModMulException( __FILE__ , __LINE__ );
      }
      BN_free(c1mh);
      c1mh = 0;
      CODEX_ASN1::BigNumber a( gzc1mh );
      gzc1mh = 0;

      int length = a.marshal(0);
      length += c1().marshal(0);
      length += c2().marshal(0);
      length += id.marshal(0);
      buff = new unsigned char[length];
      unsigned char* pBuff = buff;
      a.marshal(&pBuff);
      c1().marshal(&pBuff);
      c2().marshal(&pBuff);
      id.marshal(&pBuff);
      str = hashFunc( CODEX_ASN1::ustring(buff,length) );
      delete [] buff;
      buff = 0;

      cprime = BN_new();
      if ( 0 == cprime )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( 0 == BN_bin2bn( str->data(), str->length(), cprime ) )
      {
         throw CODEX_Exceptions::BignumBin2BNException( __FILE__ , __LINE__ );
      }
      delete str;
      str = 0;

      bool retVal = ( 0 == BN_cmp( cprime, m_h.value() ) );

      BN_CTX_free( ctx );
      BN_free(cprime);

#ifdef TIMING
      SchnorrTimer.stop();
#endif
      return retVal;
   }
   catch ( ... )
   {
      if ( 0 != ctx )    BN_CTX_free(ctx);
      if ( 0 != gzc1mh ) BN_free(gzc1mh);
      if ( 0 != c1mh )   BN_free(gzc1mh);
      if ( 0 != buff )   delete [] buff;
      if ( 0 != cprime ) BN_free(cprime);
      if ( 0 != str )    delete str;
#ifdef TIMING
      SchnorrTimer.stop();
#endif
      throw;
   }
}

int
ElGamalSchnorrCipherText::marshal( unsigned char ** pp ) const
{
   typedef ElGamalCipherText  BaseType;
   int r=0;
   int ret=0;
   unsigned char * p;

   ret += BaseType::marshal(0);
   ret += m_h.marshal(0);
   ret += m_z.marshal(0);
   M_ASN1_I2D_seq_total();
   BaseType::marshal(&p);
   m_h.marshal(&p);
   m_z.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
ElGamalSchnorrCipherText::unmarshal( void* bogus,
                                     unsigned char ** pp,
                                     long length )
{
   typedef ElGamalCipherText  BaseType;
   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, BaseType::unmarshal);
   M_ASN1_D2I_get(i, m_h.unmarshal);
   M_ASN1_D2I_get(i, m_z.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

---