VarRSAPublicKey.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: VarRSAPublicKey.cc,v 1.3 2004/05/19 15:56:48 mmarsh Exp $
//
// $Log: VarRSAPublicKey.cc,v $
// Revision 1.3  2004/05/19 15:56:48  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:31:48  mmarsh
// *** empty log message ***
//
//

#include <fstream>
#include "VarRSA.h"
#include "BIGNUM_xor.h"
#include "CODEX_Exceptions/BignumExceptions.h"

#include "timing.h"

using namespace CODEX_Ciphers;
using namespace CODEX_Exceptions;

VarRSAPublicKey::VarRSAPublicKey( const RSAPublicKey& aKey ) :
   m_key( aKey )
{
}

VarRSACipherText*
VarRSAPublicKey::encrypt( const BIGNUM * message,
                          const HashFunction& hashFunc,
                          BIGNUM * r ) const
{
   if ( 0 == message )
   {
      throw BignumNullException( __FILE__ , __LINE__ );
   }

   BIGNUM * c1 = 0;
   BIGNUM * c2 = 0;
   bool ownR = false;
   BIGNUM * temp = 0;
   BN_CTX * ctx = 0;
   unsigned char* buff = 0;
   CODEX_ASN1::ustring* tempStr = 0;
   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw BignumContextException( __FILE__ , __LINE__ );
      }

      if ( 0 == r )
      {
         ownR = true;
         r = BN_new();
         if ( 0 == r )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
      }
      // Choose a random number
      do
      {
         if ( ! BN_rand_range( r, (BIGNUM*)(n().value()) ) )
         {
            throw BignumRandRangeException( __FILE__ , __LINE__ );
         }
      }
      while ( 0 >= BN_cmp( r, BN_value_one() ) ); // r=0,1 are detectable

      // Exponentiate the random number
      c1 = exponentiate( r );
      CODEX_ASN1::SecureBigNumber rbn( BN_dup(r) );
      if ( ownR )
      {
         BN_clear_free( r );
         r = 0;
      }

      // Hash and XOR with the message
      c2 = BN_new();
      if ( 0 == c2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      int length = rbn.marshal(0);
      buff = new unsigned char[length];
      unsigned char* pBuff = buff;
      rbn.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring(buff,length),
                          BN_num_bits(n().value()) );
      temp = BN_new();
      if ( 0 == temp )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( 0 == BN_bin2bn( tempStr->data(), tempStr->length(), c2 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( temp, c2, n().value(), ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = 0;
      delete [] buff;
      buff = 0;

      BIGNUM_xor( c2, temp, message );
      BN_clear_free( temp );
      BN_CTX_free( ctx );

      // Create the object to return
      return new VarRSACipherText( c1, c2 );
   }
   catch ( ... )
   {
      if ( 0 != c1 ) BN_free( c1 );
      if ( 0 != c2 ) BN_free( c2 );
      if ( ownR && r ) BN_clear_free( r );
      if ( 0 != temp ) BN_clear_free( temp );
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != tempStr ) delete tempStr;
      if ( 0 != buff ) delete [] buff;
      throw;
   }
}

---