RSAPublicKey.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: RSAPublicKey.cc,v 1.4 2004/05/19 15:56:47 mmarsh Exp $
//
// $Log: RSAPublicKey.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 "RSA.h"
#include "CODEX_Exceptions/BignumExceptions.h"
#include "CODEX_Exceptions/FileExceptions.h"

#include "timing.h"

using namespace CODEX_Ciphers;
using namespace CODEX_Exceptions;

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

RSAPublicKey::RSAPublicKey( BIGNUM * n,
                            BIGNUM * e ) :
   CODEX_ASN1::Base( true ),
   m_n( n ),
   m_e( e )
{
}

RSAPublicKey::RSAPublicKey( const CODEX_ASN1::BigNumber& n,
                            const CODEX_ASN1::BigNumber& e ) :
   CODEX_ASN1::Base( true ),
   m_n( n ),
   m_e( e )
{
}

RSAPublicKey::RSAPublicKey( const X509 * cert ) :
   CODEX_ASN1::Base( true )
{
   EVP_PKEY * pkey = 0;
   RSA * rsaPublic = 0;
   try
   {
      pkey = X509_get_pubkey( (X509*)cert );
      rsaPublic = EVP_PKEY_get1_RSA( pkey );
      m_n = CODEX_ASN1::BigNumber( BN_dup( rsaPublic->n ) );
      m_e = CODEX_ASN1::BigNumber( BN_dup( rsaPublic->e ) );
      EVP_PKEY_free( pkey );
      RSA_free( rsaPublic );
   }
   catch ( ... )
   {
      if ( 0 != pkey ) EVP_PKEY_free( pkey );
      if ( 0 != rsaPublic ) RSA_free( rsaPublic );
      throw;
   }
}

RSAPublicKey::RSAPublicKey( const RSAPublicKey& aKey ) :
   CODEX_ASN1::Base( aKey.m_initialized ),
   m_n( aKey.m_n ),
   m_e( aKey.m_e )
{
}

void
RSAPublicKey::operator=( const RSAPublicKey& aKey )
{
   m_initialized = aKey.m_initialized;
   m_n = aKey.m_n;
   m_e = aKey.m_e;
}

RSACipherText*
RSAPublicKey::encrypt( const BIGNUM * message ) const
{
   return new RSACipherText( exponentiate( message ) );
}

bool
RSAPublicKey::verifySignature( const RSASignature& signature,
                               const BIGNUM * message ) const
{
   if ( 0 == message )
   {
      throw BignumNullException( __FILE__ , __LINE__ );
   }
   if ( ! signature.initialized() )
   {
      throw BignumNullException( __FILE__ , __LINE__ );
   }

#ifdef TIMING
   SignVerifyTimer.start();
#endif

   BIGNUM * s = exponentiate( signature.value() );

   bool retVal = ( 0 == BN_cmp( message, s ) );
   BN_free( s );

#ifdef TIMING
   SignVerifyTimer.stop();
#endif

   return retVal;
}

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

   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, e().value(), n().value(), ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      if ( 0 != ctx ) BN_CTX_free( ctx );
      return retVal;
   }
   catch ( ... )
   {
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != retVal ) BN_free( retVal );
      throw;
   }
}

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

   ret += m_n.marshal(0);
   ret += m_e.marshal(0);
   M_ASN1_I2D_seq_total();
   m_n.marshal(&p);
   m_e.marshal(&p);
   M_ASN1_I2D_finish();
}

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

void
RSAPublicKey::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*
RSAPublicKey::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;
}

---