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

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

#include "timing.h"

using namespace CODEX_VSS;

ModExpFunctional::ModExpFunctional( const ArgType& base,
                                    const ArgType& modulus ) :
   ShareFunctional(),
   m_base( base ),
   m_modulus( modulus )
{
}

ModExpFunctional::ModExpFunctional( const CtorArgs& args ) :
   ShareFunctional(),
   m_base( args.base() ),
   m_modulus( args.modulus() )
{
}

ModExpFunctional::~ModExpFunctional()
{
}

void
ModExpFunctional::operator()( const CODEX_ASN1::SecureBigNumber& operand,
                              CODEX_ASN1::BigNumber& result ) const
{
   if ( ! m_modulus.initialized() )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   if ( ! m_base.initialized() )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   if ( ! operand.initialized() )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
#ifdef TIMING
   OneWayTimer.start();
#endif
   // If the operand is negative, we will need to take special actions.
   const BIGNUM * op = operand.value();
   bool negativeExponent = false;
   BIGNUM * temp = 0;
   if ( operand.value()->neg )
   {
//      temp = BN_dup(op);
//      if ( 0 == temp )
//      {
//         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
//      }
//      temp->neg = 0;
//      op = temp;
      ((BIGNUM*)op)->neg = 0;
      negativeExponent = true;
   }
   const BIGNUM * n = m_modulus.value();
   const BIGNUM * b = m_base.value();
   BIGNUM * r = 0;
   BN_CTX * ctx = 0;
   try
   {
      r = BN_new();
      if ( 0 == r )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ ,
                                                         __LINE__ );
      }
      if ( ! BN_mod_exp( r, b, op, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModExpException( __FILE__ ,
                                                        __LINE__ );
      }
      if ( negativeExponent )
      {
         if ( ! BN_mod_inverse( r, r, n, ctx ) )
         {
            throw CODEX_Exceptions::BignumModInverseException( __FILE__ ,
                                                               __LINE__ );
         }
      }
      BN_CTX_free( ctx );
//      if ( negativeExponent ) BN_free( temp );
      if ( negativeExponent ) ((BIGNUM*)op)->neg = 1;
   }
   catch ( ... )
   {
      if ( 0 != r ) BN_free(r);
      if ( 0 != ctx ) BN_CTX_free(ctx);
//      if ( negativeExponent ) BN_free( temp );
      if ( negativeExponent ) ((BIGNUM*)op)->neg = 1;
#ifdef TIMING
      OneWayTimer.cancel();
#endif
      throw;
   }
   result = r;
#ifdef TIMING
   OneWayTimer.stop();
#endif
}


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

ModExpFunctionalArgs::ModExpFunctionalArgs(
   const CODEX_ASN1::BigNumber& base,
   const CODEX_ASN1::BigNumber& modulus ) :
   CODEX_ASN1::Base( true ),
   m_base( base ),
   m_modulus( modulus )
{
}

ModExpFunctionalArgs::ModExpFunctionalArgs(
   const ModExpFunctionalArgs& aOther ) :
   CODEX_ASN1::Base( aOther.m_initialized ),
   m_base( aOther.m_base ),
   m_modulus( aOther.m_modulus )
{
}

ModExpFunctionalArgs::~ModExpFunctionalArgs()
{
}

void
ModExpFunctionalArgs::operator=( const ModExpFunctionalArgs& aOther )
{
   m_initialized = aOther.m_initialized;
   m_base = aOther.m_base;
   m_modulus = aOther.m_modulus;
}

int
ModExpFunctionalArgs::marshal( unsigned char ** pp ) const
{
   if ( ! m_base.initialized() ) return 0;
   if ( ! m_modulus.initialized() ) return 0;
   int r=0;
   int ret=0;
   unsigned char * p;

   ret += m_base.marshal(0);
   ret += m_modulus.marshal(0);
   M_ASN1_I2D_seq_total();
   m_base.marshal(&p);
   m_modulus.marshal(&p);
   M_ASN1_I2D_finish();
}

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

---