DLProof.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: DLProof.cc,v 1.3 2004/05/19 15:57:00 mmarsh Exp $
//
// $Log: DLProof.cc,v $
// Revision 1.3  2004/05/19 15:57:00  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:21:34  mmarsh
// General code cleanup.
//
//

#include "DLProof.h"
#include "CODEX_VSS/ModExpFunctional.h"
#include "CODEX_Exceptions/BignumExceptions.h"

#include "timing.h"

using namespace CODEX_ThresholdCrypto;

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

DLProof::DLProof( const BIGNUM * g1,
                  const BIGNUM * g2,
                  const BIGNUM * n,
                  const BIGNUM * max,
                  const BIGNUM * x,
                  const CODEX_Ciphers::HashFunction& H ) :
   CODEX_ASN1::Base( true )
{
   if ( ( 0 == g1  ) ||
        ( 0 == g2  ) ||
        ( 0 == n   ) ||
        ( 0 == max ) ||
        ( 0 == x   ) )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }

#ifdef TIMING
   DLProofTimer.start();
#endif

   BIGNUM * maxBN = (BIGNUM*) max; // CAST

   BIGNUM * r1  = 0;
   BIGNUM * r2  = 0;
   BIGNUM * t   = 0;
   BIGNUM * k   = 0;
   BIGNUM * hBN = 0;
   BIGNUM * xh  = 0;
   BN_CTX * ctx = 0;

   unsigned char* buff = 0;
   CODEX_ASN1::ustring* str = 0;

   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ , __LINE__ );
      }
      k = BN_new();
      if ( 0 == k )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      do
      {
         if ( ! BN_rand_range( k, maxBN ) )
         {
         throw CODEX_Exceptions::BignumRandRangeException( __FILE__ ,
                                                           __LINE__ );
         }
      } while ( 0 >= BN_cmp( k , BN_value_one() ) );

      r1 = BN_new();
      if ( 0 == r1 )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_exp( r1, g1, k, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ , __LINE__ );
      }
      m_r1 = CODEX_ASN1::BigNumber( r1 );
      r1 = 0;

      r2 = BN_new();
      if ( 0 == r2 )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_exp( r2, g2, k, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ , __LINE__ );
      }
      m_r2 = CODEX_ASN1::BigNumber( r2 );
      r2 = 0;

      int length = 0;
      length += m_r1.marshal(0);
      length += m_r2.marshal(0);
      buff = new unsigned char[ length ];
      unsigned char* pBuff = buff;
      m_r1.marshal(&pBuff);
      m_r2.marshal(&pBuff);
      str = H( CODEX_ASN1::ustring( buff, length ) );
      delete [] buff;
      buff = 0;
      hBN = BN_new();
      if ( 0 == hBN )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( 0 == BN_bin2bn( str->data(), str->length(), hBN ) )
      {
         throw CODEX_Exceptions::BignumBin2BNException( __FILE__ , __LINE__ );
      }
      delete str;
      str = 0;

      // The rest of the calculations are performed over the integers, since
      // we don't a priori know phi(n).  This means t might be negative.
      xh = BN_new();
      if ( 0 == xh )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mul( xh, x, hBN, ctx ) )
      {
         throw CODEX_Exceptions::BignumMulException( __FILE__ , __LINE__ );
      }
      BN_free(hBN);
      hBN = 0;

      t = BN_new();
      if ( 0 == t )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( t, k, xh ) )
      {
         throw CODEX_Exceptions::BignumSubException( __FILE__ , __LINE__ );
      }
      m_t = CODEX_ASN1::BigNumber(t);

      BN_clear_free(k);
      BN_clear_free(xh);
      BN_CTX_free(ctx);
#ifdef TIMING
      DLProofTimer.stop();
#endif
   }
   catch ( ... )
   {
      if ( 0 != r1 ) BN_free(r1);
      if ( 0 != r2 ) BN_free(r2);
      if ( 0 != t ) BN_free(t);
      if ( 0 != k ) BN_clear_free(t);
      if ( 0 != hBN ) BN_free(hBN);
      if ( 0 != xh ) BN_clear_free(xh);
      if ( 0 != ctx ) BN_CTX_free(ctx);
      if ( 0 != buff ) delete [] buff;
      if ( 0 != str ) delete str;
#ifdef TIMING
      DLProofTimer.stop();
#endif
      throw;
   }
}

DLProof::DLProof( const DLProof& aOther ) :
   CODEX_ASN1::Base( aOther.m_initialized ),
   m_r1( aOther.m_r1 ),
   m_r2( aOther.m_r2 ),
   m_t( aOther.m_t)
{
}

DLProof::~DLProof()
{
}

void
DLProof::operator=( const DLProof& aOther )
{
   m_initialized = aOther.m_initialized;
   m_r1 = aOther.m_r1;
   m_r2 = aOther.m_r2;
   m_t = aOther.m_t;
}

bool
DLProof::verify( const BIGNUM * g1,
                 const BIGNUM * g2,
                 const BIGNUM * y1,
                 const BIGNUM * y2,
                 const BIGNUM * n,
                 const CODEX_Ciphers::HashFunction& H ) const
{
   if ( ( 0 == g1 ) ||
        ( 0 == g2 ) ||
        ( 0 == y1 ) ||
        ( 0 == y2 ) ||
        ( 0 == n  ) )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }

#ifdef TIMING
   DLProofVerifyTimer.start();
#endif

   // We will exploit the fact that ModExpFunctional treats negative exponents
   // correctly and not duplicate the code.
   CODEX_VSS::ModExpFunctional f1(BN_dup(g1),BN_dup(n));
   CODEX_VSS::ModExpFunctional f2(BN_dup(g2),BN_dup(n));
   CODEX_ASN1::SecureBigNumber g1t;
   CODEX_ASN1::SecureBigNumber g2t;

   BIGNUM * h   = 0;
   BIGNUM * y1h = 0;
   BIGNUM * y2h = 0;
   BIGNUM * r1  = 0;
   BIGNUM * r2  = 0;
   BN_CTX * ctx = 0;

   unsigned char* buff = 0;
   CODEX_ASN1::ustring* str = 0;

   try
   {
      bool retVal = true;

      int length = 0;
      length += m_r1.marshal(0);
      length += m_r2.marshal(0);
      buff = new unsigned char[ length ];
      unsigned char* pBuff = buff;
      m_r1.marshal(&pBuff);
      m_r2.marshal(&pBuff);
      str = H( CODEX_ASN1::ustring( buff, length ) );
      delete [] buff;
      buff = 0;
      h = BN_new();
      if ( 0 == h )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( 0 == BN_bin2bn( str->data(), str->length(), h ) )
      {
         throw CODEX_Exceptions::BignumBin2BNException( __FILE__ , __LINE__ );
      }
      delete str;
      str = 0;

      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ , __LINE__ );
      }

      y1h = BN_new();
      if ( 0 == y1h )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_exp( y1h, y1, h, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ , __LINE__ );
      }

      y2h = BN_new();
      if ( 0 == y2h )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_exp( y2h, y2, h, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ , __LINE__ );
      }

      BN_free(h);
      h = 0;

      f1( m_t, g1t );
      f2( m_t, g2t );

      r1 = BN_new();
      if ( 0 == r1 )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( r1, y1h, g1t.value(), n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModMulException( __FILE__ , __LINE__ );
      }
      BN_free(y1h);
      y1h = 0;

      r2 = BN_new();
      if ( 0 == r2 )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( r2, y2h, g2t.value(), n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModMulException( __FILE__ , __LINE__ );
      }
      BN_free(y2h);
      y2h = 0;

      BN_CTX_free(ctx);
      ctx = 0;

      if ( 0 != BN_cmp( r1, m_r1.value() ) ) retVal = false;
      if ( 0 != BN_cmp( r2, m_r2.value() ) ) retVal = false;
      BN_free(r1);
      BN_free(r2);

#ifdef TIMING
      DLProofVerifyTimer.stop();
#endif
      return retVal;
   }
   catch ( ... )
   {
      if ( 0 != h ) BN_free(h);
      if ( 0 != y1h ) BN_free(y1h);
      if ( 0 != y2h ) BN_free(y2h);
      if ( 0 != r1 ) BN_free(r1);
      if ( 0 != r2 ) BN_free(r2);
      if ( 0 != ctx ) BN_CTX_free(ctx);
      if ( 0 != buff ) delete [] buff;
      if ( 0 != str ) delete str;
#ifdef TIMING
      DLProofVerifyTimer.stop();
#endif
      throw;
   }
}

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

   ret += m_r1.marshal(0);
   ret += m_r2.marshal(0);
   ret += m_t.marshal(0);
   M_ASN1_I2D_seq_total();
   m_r1.marshal(&p);
   m_r2.marshal(&p);
   m_t.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
DLProof::unmarshal( void* bogus, unsigned char ** pp, long length )
{
   if ( m_initialized )
   {
      return 0;
   }
   if ( (0 == pp) || (0 == *pp) )
   {
      return 0;
   }
   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_r1.unmarshal);
   M_ASN1_D2I_get(i, m_r2.unmarshal);
   M_ASN1_D2I_get(i, m_t.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return 0;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return 0;
}

---