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

#include "timing.h"

using namespace CODEX_Ciphers;
using namespace CODEX_Exceptions;
using CODEX_ASN1::BigNumber;
using CODEX_ASN1::SecureBigNumber;

VarRSAPrivateKey::VarRSAPrivateKey( const RSAPrivateKey& aKey ) :
   m_key( aKey )
{
}

VarRSAPrivateKey::~VarRSAPrivateKey()
{
}

BIGNUM *
VarRSAPrivateKey::decrypt( const VarRSACipherText& cipherText,
                           const HashFunction& hashFunc ) const
{
   BIGNUM * retVal = 0;
   BIGNUM * c1d = 0;
   BIGNUM * temp = 0;
   BN_CTX * ctx = 0;
   CODEX_ASN1::ustring* tempStr = 0;
   unsigned char* buff = 0;
   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw BignumContextException( __FILE__ , __LINE__ );
      }

      retVal = BN_new();
      if ( 0 == retVal )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }

      // exponentiate first part
      c1d = exponentiate( cipherText.c1().value() );

      // hash it
      CODEX_ASN1::SecureBigNumber c1dbn( c1d );
      c1d = 0;
      int length = c1dbn.marshal(0);
      buff = new unsigned char[length];
      unsigned char* pBuff = buff;
      c1dbn.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(), retVal ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( temp, retVal, n().value(), ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = 0;
      delete [] buff;
      buff = 0;

      // xor with second part
      BIGNUM_xor( retVal, temp, cipherText.c2().value() );

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

VarRSABlindPlainText*
VarRSAPrivateKey::decryptBlind( const VarRSABlindCipherText& cipherText ) const
{
   return new VarRSABlindPlainText( exponentiate( cipherText.c1().value() ),
                                    cipherText.c2() );
}

---