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

using namespace CODEX_Ciphers;

void
VarRSABlindPlainText::operator=( const VarRSABlindPlainText& aOther )
{
   m_initialized = aOther.m_initialized;
   m_b1          = aOther.m_b1;
   m_b2          = aOther.m_b2;
}

BIGNUM *
VarRSABlindPlainText::unblind( const BIGNUM * b,
                               const CODEX_ASN1::BigNumber& modulus,
                               const HashFunction& hashFunc ) const
{
   if ( 0 == b )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   BIGNUM * retVal = 0;
   const BIGNUM * n = modulus.value();
   BIGNUM * db = 0;
   BIGNUM * binv = 0;
   BIGNUM * temp = 0;
   BN_CTX * ctx = 0;
   unsigned char* buff = 0;
   CODEX_ASN1::ustring* tempStr = 0;
   try
   {
      retVal = BN_new();
      if ( 0 == retVal )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }

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

      binv = BN_new();
      if ( 0 == binv )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_inverse( binv, b, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModInverseException( __FILE__ ,
                                                            __LINE__ );
      }

      db = BN_new();
      if ( 0 == db )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( db, m_b1.value(), binv, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModMulException( __FILE__ , __LINE__ );
      }
      CODEX_ASN1::SecureBigNumber dbbn( db );
      db = 0;
      int length = dbbn.marshal(0);
      buff = new unsigned char[length];
      unsigned char* pBuff = buff;
      dbbn.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring(buff,length),
                          BN_num_bits(n) );
      temp = BN_new();
      if ( 0 == temp )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( 0 == BN_bin2bn( tempStr->data(), tempStr->length(), retVal ) )
      {
         throw CODEX_Exceptions::BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( temp, retVal, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = 0;
      delete [] buff;
      buff = 0;

      BIGNUM_xor( retVal, temp, m_b2.value() );

      BN_clear_free( temp );
      temp = 0;
      BN_CTX_free( ctx );
      ctx = 0;
      return retVal;
   }
   catch ( ... )
   {
      if ( 0 != temp ) BN_clear_free( temp );
      if ( 0 != retVal ) BN_clear_free( retVal );
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != binv ) BN_clear_free( binv );
      if ( 0 != db ) BN_free( db );
      if ( 0 != tempStr ) delete tempStr;
      if ( 0 != buff ) delete [] buff;
      throw;
   }
}

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

   ret += m_b1.marshal(0);
   ret += m_b2.marshal(0);
   M_ASN1_I2D_seq_total();
   m_b1.marshal(&p);
   m_b2.marshal(&p);
   M_ASN1_I2D_finish();
}

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

---