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

#include <fstream>
#include <openssl/pem.h>
#include "RSA.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;

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

RSAPrivateKey::RSAPrivateKey( BIGNUM * p,
                              BIGNUM * q,
                              BIGNUM * d,
                              BIGNUM * n,
                              BIGNUM * phi ) :
   CODEX_ASN1::Base( true ),
   m_p( p ),
   m_q( q ),
   m_d( d ),
   m_n( n ),
   m_phi( phi )
{
   BN_CTX * ctx = 0;
   BIGNUM * temp1 = 0;
   BIGNUM * temp2 = 0;
   bool ownN = false;
   bool ownPhi = false;
   try
   {
      if ( 0 == n )
      {
         if ( 0 == ctx )
         {
            ctx = BN_CTX_new();
            if ( 0 == ctx )
            {
               throw BignumContextException( __FILE__ , __LINE__ );
            }
         }
         n = BN_new();
         if ( 0 == n )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         ownN = true;
         if ( ! BN_mul( n, p, q, ctx ) )
         {
            throw BignumMulException( __FILE__ , __LINE__ );
         }
         m_n = CODEX_ASN1::SecureBigNumber( n );
      }
      if ( 0 == phi )
      {
         if ( 0 == ctx )
         {
            ctx = BN_CTX_new();
            if ( 0 == ctx )
            {
               throw BignumContextException( __FILE__ , __LINE__ );
            }
         }
         phi = BN_new();
         if ( 0 == phi )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         ownPhi = true;
         temp1 = BN_new();
         if ( 0 == temp1 )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         temp2 = BN_new();
         if ( 0 == temp2 )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         if ( ! BN_sub( temp1, p, BN_value_one() ) )
         {
            throw BignumSubException( __FILE__ , __LINE__ );
         }
         if ( ! BN_sub( temp2, q, BN_value_one() ) )
         {
            throw BignumSubException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mul( phi, temp1, temp2, ctx ) )
         {
            throw BignumMulException( __FILE__ , __LINE__ );
         }
         m_phi = CODEX_ASN1::SecureBigNumber( phi );
      }
   }
   catch ( ... )
   {
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != temp1 ) BN_clear_free( temp1 );
      if ( 0 != temp2 ) BN_clear_free( temp2 );
      if ( ownN ) BN_clear_free( n );
      if ( ownPhi ) BN_clear_free( phi );
      throw;
   }
   if ( 0 != ctx   ) BN_CTX_free( ctx );
   if ( 0 != temp1 ) BN_clear_free( temp1 );
   if ( 0 != temp2 ) BN_clear_free( temp2 );
}

RSAPrivateKey::RSAPrivateKey( const CODEX_ASN1::BigNumber& p,
                              const CODEX_ASN1::BigNumber& q,
                              const CODEX_ASN1::BigNumber& d ) :
   CODEX_ASN1::Base( true ),
   m_p( p ),
   m_q( q ),
   m_d( d )
{
   BN_CTX * ctx = 0;
   BIGNUM * temp1 = 0;
   BIGNUM * temp2 = 0;
   BIGNUM * nbn = 0;
   BIGNUM * phibn = 0;
   const BIGNUM * pbn = p.value();
   const BIGNUM * qbn = q.value();

   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw BignumContextException( __FILE__ , __LINE__ );
      }
      nbn = BN_new();
      if ( 0 == nbn )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mul( nbn, pbn, qbn, ctx ) )
      {
         throw BignumMulException( __FILE__ , __LINE__ );
      }
      m_n = CODEX_ASN1::SecureBigNumber( nbn );

      phibn = BN_new();
      if ( 0 == phibn )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp1 = BN_new();
      if ( 0 == temp1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp2 = BN_new();
      if ( 0 == temp2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( temp1, pbn, BN_value_one() ) )
      {
            throw BignumSubException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( temp2, qbn, BN_value_one() ) )
      {
         throw BignumSubException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mul( phibn, temp1, temp2, ctx ) )
      {
         throw BignumMulException( __FILE__ , __LINE__ );
      }
      m_phi = CODEX_ASN1::SecureBigNumber( phibn );
   }
   catch ( ... )
   {
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != temp1 ) BN_clear_free( temp1 );
      if ( 0 != temp2 ) BN_clear_free( temp2 );
      if ( 0 != nbn ) BN_free( nbn );
      if ( 0 != phibn ) BN_clear_free( phibn );
      throw;
   }
   if ( 0 != ctx ) BN_CTX_free( ctx );
   if ( 0 != temp1 ) BN_clear_free( temp1 );
   if ( 0 != temp2 ) BN_clear_free( temp2 );
}

RSAPrivateKey::RSAPrivateKey( const RSAPrivateKey& aKey ) :
   CODEX_ASN1::Base( aKey.m_initialized ),
   m_p( aKey.m_p ),
   m_q( aKey.m_q ),
   m_d( aKey.m_d ),
   m_n( aKey.m_n ),
   m_phi( aKey.m_phi )
{
}

RSAPrivateKey::~RSAPrivateKey()
{
}

void
RSAPrivateKey::operator=( const RSAPrivateKey& aKey )
{
   m_initialized = aKey.m_initialized;
   m_p           = aKey.m_p;
   m_q           = aKey.m_q;
   m_d           = aKey.m_d;
   m_n           = aKey.m_n;
   m_phi         = aKey.m_phi;
}

BIGNUM *
RSAPrivateKey::decrypt( const RSACipherText& cipherText ) const
{
   return exponentiate( cipherText.value() );
}

RSASignature*
RSAPrivateKey::sign( const BIGNUM * message ) const
{
   return new RSASignature( exponentiate( message ) );
}

BIGNUM *
RSAPrivateKey::exponentiate( const BIGNUM * aBN ) const
{
   if ( 0 == aBN )
   {
      throw BignumNullException( __FILE__ , __LINE__ );
   }

#ifdef TIMING
   SignTimer.start();
#endif

   BN_CTX * ctx = 0;
   BIGNUM * retVal = 0;

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

      retVal = BN_new();
      if ( 0 == retVal )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_exp( retVal, aBN, d().value(), n().value(), ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
   }
   catch ( ... )
   {
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != retVal ) BN_free( retVal );
      throw;
   }

   if ( 0 != ctx ) BN_CTX_free( ctx );

#ifdef TIMING
   SignTimer.stop();
#endif

   return retVal;
}

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

   ret += m_p.marshal(0);
   ret += m_q.marshal(0);
   ret += m_d.marshal(0);
   ret += m_n.marshal(0);
   ret += m_phi.marshal(0);
   M_ASN1_I2D_seq_total();
   m_p.marshal(&p);
   m_q.marshal(&p);
   m_d.marshal(&p);
   m_n.marshal(&p);
   m_phi.marshal(&p);
   M_ASN1_I2D_finish();
}

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

void
RSAPrivateKey::toFile(const char* fname) const
{
   int length = marshal(0);
   if ( 0 == length ) return;
   unsigned char* buff = new unsigned char[length];
   unsigned char* p = buff;
   marshal(&p);
   ofstream os(fname);
   if ( ! os.is_open() )
   {
      delete [] buff;
      throw FileCannotCreateException( __FILE__ , __LINE__ , fname );
   }
   for ( int i = 0 ; i < length ; ++i )
   {
      os << buff[i];
   }
   os.close();
   delete [] buff;
}

void*
RSAPrivateKey::fromFile(const char* fname)
{
   ifstream is(fname);
   if ( ! is.is_open() )
   {
      throw FileCannotOpenException( __FILE__ , __LINE__ , fname );
   }
   string s;
   char ch;
   while ( is.get(ch) )
   {
      s.push_back(ch);
   }
   //basic_string<unsigned char> s;
   //is >> s;
   unsigned int length = s.length();
   unsigned char* p = new unsigned char[ length ];
   unsigned char* pOrig = p;
   //unsigned char* p = (unsigned char*)s.data();
   for ( unsigned int i = 0 ; i < length ; ++i )
   {
      p[i] = s.data()[i];
   }
   void* retVal = unmarshal(0,&p,length);
   delete [] pOrig;
   return retVal;
}

void
RSAPrivateKey::fromPEMFile(const char* fname, const char* phrase)
{
   FILE* fp = 0;
   RSA * key = 0;
   BIGNUM * phibn = 0;
   BIGNUM * temp1 = 0;
   BIGNUM * temp2 = 0;
   BN_CTX * ctx = 0;

   try
   {
      fp = fopen( fname, "r" );
      if ( 0 == fp )
      {
         throw FileCannotOpenException( __FILE__ , __LINE__ , fname );
      }
      if ( ! PEM_read_RSAPrivateKey( fp, &key, 0, (void*)phrase ) )
      {
         throw FileCannotOpenException( __FILE__ , __LINE__ , fname );
      }
      fclose( fp );
      fp = 0;
      m_p = CODEX_ASN1::SecureBigNumber( BN_dup( key->p ) );
      m_q = CODEX_ASN1::SecureBigNumber( BN_dup( key->q ) );
      m_d = CODEX_ASN1::SecureBigNumber( BN_dup( key->d ) );
      m_n = CODEX_ASN1::SecureBigNumber( BN_dup( key->n ) );

      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw BignumContextException( __FILE__ , __LINE__ );
      }
      phibn = BN_new();
      if ( 0 == phibn )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp1 = BN_new();
      if ( 0 == temp1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp2 = BN_new();
      if ( 0 == temp2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( temp1, key->p, BN_value_one() ) )
      {
            throw BignumSubException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( temp2, key->q, BN_value_one() ) )
      {
         throw BignumSubException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mul( phibn, temp1, temp2, ctx ) )
      {
         throw BignumMulException( __FILE__ , __LINE__ );
      }
      m_phi = CODEX_ASN1::SecureBigNumber( phibn );

      m_initialized = true;

      RSA_free( key ); key = 0;
      BN_CTX_free( ctx ); ctx = 0;
      BN_clear_free(temp1); temp1 = 0;
      BN_clear_free(temp2); temp2 = 0;
   }
   catch ( ... )
   {
      if ( 0 != fp ) fclose(fp);
      if ( 0 != key ) RSA_free( key );
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != phibn ) BN_clear_free( phibn );
      if ( 0 != temp1 ) BN_clear_free( temp1 );
      if ( 0 != temp2 ) BN_clear_free( temp2 );
      throw;
   }
}

---