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

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

#include "timing.h"

using namespace CODEX_Ciphers;

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

RSAPlaintextPK::RSAPlaintextPK( const CODEX_ASN1::SecureBigNumber& plaintext,
                                const RSAPublicKey& publicKey,
                                const CODEX_ASN1::Base& id,
                                const HashFunction& hashFunc ) :
   CODEX_ASN1::Base( true )
{
   if ( ! ( plaintext.initialized() &&
            publicKey.initialized() &&
            id.initialized() ) )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   int Ln = BN_num_bytes( publicKey.n().value() );
   int ln = BN_num_bits( publicKey.n().value() );
   int Le = BN_num_bytes( publicKey.e().value() );
   int sublen = Le - 1;
   int k = Ln / sublen;

   typedef vector< BIGNUM* > VBNType;
   VBNType vr;

   //const BIGNUM * e         = publicKey.e().value();
   const BIGNUM * n         = publicKey.n().value();
   const BIGNUM * s         = plaintext.value();
   CODEX_ASN1::ustring* str = 0;
   unsigned char* buff      = 0;
   BIGNUM * r               = 0;
   RSACipherText* p1        = 0;
   RSACipherText* es        = 0;
   BIGNUM * c               = 0;
   BIGNUM * p2              = 0;
   BN_CTX * ctx             = 0;
   try
   {
      ctx = BN_CTX_new();
      if ( NULL == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ , __LINE__ );
      }

      for ( int i = 0 ; i < k ; ++i )
      {
         // Choose a random number
         r = BN_new();
         if ( 0 == r )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         do
         {
            if ( ! BN_rand_range( r, (BIGNUM*)n ) )
            {
               throw CODEX_Exceptions::BignumRandRangeException( __FILE__ ,
                                                                 __LINE__ );
            }
         }
         while ( 0 >= BN_cmp( r, BN_value_one() ) ); // r=0,1 are detectable

         p1 = publicKey.encrypt( r );
         vr.push_back( r );
         r = 0;
         m_a.append( p1 );
         p1 = 0;
      }
      if ( vr.size() != k )
      {
         throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
      }
      if ( m_a.size() != k )
      {
         throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
      }

      es = publicKey.encrypt( s );

      unsigned int length = m_a.marshal(0);
      length += es->marshal(0);
      length += id.marshal(0);

      buff = new unsigned char[length];
      unsigned char* pBuff = buff;
      m_a.marshal(&pBuff);
      es->marshal(&pBuff);
      id.marshal(&pBuff);
      str = hashFunc( CODEX_ASN1::ustring(buff,length), ln );
      delete [] buff;
      buff = 0;
      delete es;
      es = 0;
      for ( int i = 0 ; i < k ; ++i )
      {
         c = BN_new();
         if ( 0 == c )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         if ( 0 == BN_bin2bn( str->data()+i*sublen, sublen, c ) )
         {
            throw CODEX_Exceptions::BignumBin2BNException( __FILE__ ,
                                                           __LINE__ );
         }

         p2 = BN_new();
         if ( 0 == p2 )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( p2, s, c, n, ctx ) )
         {
            throw CODEX_Exceptions::BignumModExpException( __FILE__ ,
                                                           __LINE__ );
         }
         if ( ! BN_mod_mul( p2, p2, vr[i], n, ctx ) )
         {
            throw CODEX_Exceptions::BignumModMulException( __FILE__ ,
                                                           __LINE__ );
         }
         m_b.append( new CODEX_ASN1::BigNumber( p2 ) );
         p2 = 0;
         BN_free(c);
         c = 0;
         BN_clear_free(vr[i]);
         vr[i] = 0;
      }
      delete str;
      str = 0;

      BN_CTX_free(ctx);
   }
   catch ( ... )
   {
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != r ) BN_clear_free( r );
      if ( 0 != p1 ) delete p1;
      if ( 0 != es ) delete es;
      if ( 0 != c ) BN_free( c );
      if ( 0 != str ) delete str;
      if ( 0 != buff ) delete [] buff;
      for ( VBNType::iterator itr = vr.begin() ; itr != vr.end() ; ++itr )
      {
         BN_clear_free( *itr );
      }
      throw;
   }
}

RSAPlaintextPK::RSAPlaintextPK( const RSAPlaintextPK& aPPK ) :
   CODEX_ASN1::Base( aPPK.m_initialized ),
   m_a( aPPK.m_a ),
   m_b( aPPK.m_b )
{
}

RSAPlaintextPK::~RSAPlaintextPK()
{
}

void
RSAPlaintextPK::operator=( const RSAPlaintextPK& aPPK )
{
   m_initialized = aPPK.m_initialized;
   m_a           = aPPK.m_a;
   m_b           = aPPK.m_b;
}

bool
RSAPlaintextPK::verify( const RSACipherText& ciphertext,
                        const RSAPublicKey& publicKey,
                        const CODEX_ASN1::Base& id,
                        const HashFunction& hashFunc ) const
{
   if ( ! ( ciphertext.initialized() &&
            publicKey.initialized() &&
            id.initialized() ) )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }

   int Ln = BN_num_bytes( publicKey.n().value() );
   int ln = BN_num_bits( publicKey.n().value() );
   int Le = BN_num_bytes( publicKey.e().value() );
   int sublen = Le - 1;
   int k = Ln / sublen;

   if ( m_a.size() != k )
   {
      return false;
   }
   if ( m_b.size() != k )
   {
      return false;
   }

   for ( int i = 0 ; i < k ; ++i )
   {
      if ( BN_is_zero( m_a.element(i)->value() ) )
      {
         return false;
      }
   }

#ifdef TIMING
   RSAPPKTimer.start();
#endif
   const BIGNUM * e         = publicKey.e().value();
   const BIGNUM * n         = publicKey.n().value();
   const BIGNUM * ct        = ciphertext.value();
   CODEX_ASN1::ustring* str = 0;
   unsigned char* buff      = 0;
   BIGNUM * c               = 0;
   BIGNUM * ep2             = 0;
   BIGNUM * ecp1            = 0;
   BN_CTX * ctx             = 0;
   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ , __LINE__ );
      }

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

      bool retVal = true;
      for ( int i = 0 ;
            retVal && ( i < k ) ;
            ++i )
      {
         c = BN_new();
         if ( 0 == c )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         if ( 0 == BN_bin2bn( str->data()+i*sublen, sublen, c ) )
         {
            throw CODEX_Exceptions::BignumBin2BNException( __FILE__ ,
                                                           __LINE__ );
         }

         ep2 = BN_new();
         if ( 0 == ep2 )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( ep2, m_b.element(i)->value(), e, n, ctx ) )
         {
            throw CODEX_Exceptions::BignumModExpException( __FILE__ ,
                                                           __LINE__ );
         }

         ecp1 = BN_new();
         if ( 0 == ecp1 )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( ecp1, ct, c, n, ctx ) )
         {
            throw CODEX_Exceptions::BignumModExpException( __FILE__ ,
                                                           __LINE__ );
         }
         if ( ! BN_mod_mul( ecp1, ecp1, m_a.element(i)->value(), n, ctx ) )
         {
            throw CODEX_Exceptions::BignumModMulException( __FILE__ ,
                                                           __LINE__ );
         }
         BN_free( c );
         c = 0;

         if ( 0 != BN_cmp( ep2, ecp1 ) )
         {
            retVal = false;
         }
         BN_free( ep2 ); ep2 = 0;
         BN_free( ecp1 ); ecp1 = 0;
      }

      delete str;
      str = 0;
      BN_CTX_free( ctx );
#ifdef TIMING
      RSAPPKTimer.stop();
#endif
      return retVal;
   }
   catch ( ... )
   {
      if ( 0 != ctx  ) BN_CTX_free( ctx );
      if ( 0 != str  ) delete str;
      if ( 0 != buff ) delete [] buff;
      if ( 0 != c    ) BN_free( c );
      if ( 0 != ep2  ) BN_free( ep2 );
      if ( 0 != ecp1 ) BN_free( ecp1 );
#ifdef TIMING
      RSAPPKTimer.stop();
#endif
      throw;
   }
}

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

   ret += m_a.marshal(0);
   ret += m_b.marshal(0);
   M_ASN1_I2D_seq_total();
   m_a.marshal(&p);
   m_b.marshal(&p);
   M_ASN1_I2D_finish();
}

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

---