RSA.h

/*
 * 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: RSA.h,v 1.5 2005/01/21 19:44:16 mmarsh Exp $
//
// $Log: RSA.h,v $
// Revision 1.5  2005/01/21 19:44:16  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.4  2004/05/19 15:56:47  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/04 22:08:54  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_CIPHERS_RSA_H__
#define __CODEX_CIPHERS_RSA_H__

#include <openssl/bn.h>
#include "CODEX_ASN1/Base.h"
#include "CODEX_ASN1/BigNumber.h"
#include "CODEX_ASN1/SecureBigNumber.h"
#include "CODEX_ASN1/Certificate.h"

namespace CODEX_Ciphers
{
   class RSACipherText : public CODEX_ASN1::BigNumber
   {
      public:
         RSACipherText() :
            CODEX_ASN1::BigNumber()
         {}
         RSACipherText( BIGNUM * c ) :
            CODEX_ASN1::BigNumber( c )
         {}
         RSACipherText( const CODEX_ASN1::BigNumber& c ) :
            CODEX_ASN1::BigNumber( c )
         {}
         virtual ~RSACipherText() {}

         RSACipherText* blind( const RSACipherText& aOther,
                               const CODEX_ASN1::BigNumber& modulus ) const;
   };

   class RSASignature : public CODEX_ASN1::BigNumber
   {
      public:
         RSASignature() :
            CODEX_ASN1::BigNumber()
         {}
         RSASignature( BIGNUM * s ) :
            CODEX_ASN1::BigNumber( s )
         {}
         RSASignature( const CODEX_ASN1::BigNumber& s ) :
            CODEX_ASN1::BigNumber( s )
         {}
         virtual ~RSASignature() {}
   };

   class RSAPublicKey : public CODEX_ASN1::Base
   {
      public:
         RSAPublicKey();
         RSAPublicKey( BIGNUM * n, BIGNUM * e );
         RSAPublicKey( const CODEX_ASN1::BigNumber& n,
                       const CODEX_ASN1::BigNumber& e );
         RSAPublicKey( const X509 * cert );
         RSAPublicKey( const RSAPublicKey& aKey );
         virtual ~RSAPublicKey() {}

         void operator=( const RSAPublicKey& aKey );

         virtual const CODEX_ASN1::BigNumber& n() const { return m_n; }
         virtual const CODEX_ASN1::BigNumber& e() const { return m_e; }

         RSACipherText* encrypt( const BIGNUM * message ) const;

         bool verifySignature( const RSASignature& signature,
                               const BIGNUM * message ) const;

         int marshal( unsigned char ** pp ) const;
         void* unmarshal( void* bogus, unsigned char ** pp, long length );

         void toFile(const char* fname) const;

         void* fromFile(const char* fname);

      protected:
         BIGNUM * exponentiate( const BIGNUM * aBN ) const;

      private :
         CODEX_ASN1::BigNumber m_n;
         CODEX_ASN1::BigNumber m_e;
   };

   class RSAPrivateKey : public CODEX_ASN1::Base
   {
      public:
         RSAPrivateKey();
         RSAPrivateKey( BIGNUM * p,
                        BIGNUM * q,
                        BIGNUM * d,
                        BIGNUM * n=0,
                        BIGNUM * phi=0 );
         RSAPrivateKey( const CODEX_ASN1::BigNumber& p,
                        const CODEX_ASN1::BigNumber& q,
                        const CODEX_ASN1::BigNumber& d );
         RSAPrivateKey( const RSAPrivateKey& aKey );
         virtual ~RSAPrivateKey();

         void operator=( const RSAPrivateKey& aKey );

         virtual const CODEX_ASN1::SecureBigNumber& p()   const { return m_p; }
         virtual const CODEX_ASN1::SecureBigNumber& q()   const { return m_q; }
         virtual const CODEX_ASN1::SecureBigNumber& d()   const { return m_d; }
         virtual const CODEX_ASN1::SecureBigNumber& n()   const { return m_n; }
         virtual const CODEX_ASN1::SecureBigNumber& phi() const { return m_phi; }

         BIGNUM * decrypt( const RSACipherText& cipherText ) const;
         RSASignature* sign( const BIGNUM * message ) const;

         int marshal( unsigned char ** pp ) const;
         void* unmarshal( void* bogus, unsigned char ** pp, long length );

         void toFile(const char* fname) const;

         void* fromFile(const char* fname);

         void fromPEMFile(const char* fname, const char* phrase=0);

      protected:
         BIGNUM * exponentiate( const BIGNUM * aBN ) const;

      private:
         CODEX_ASN1::SecureBigNumber m_p;
         CODEX_ASN1::SecureBigNumber m_q;
         CODEX_ASN1::SecureBigNumber m_d;
         CODEX_ASN1::SecureBigNumber m_n;
         CODEX_ASN1::SecureBigNumber m_phi;
   };

   class RSAKeyPairGenerator
   {
      public:
         RSAKeyPairGenerator( long numBits ) : m_numBits( numBits ) {}

         void operator()( RSAPublicKey*& pubKey,
                          RSAPrivateKey*& privKey );

      private:
         long m_numBits;
   };

}

#endif /* __CODEX_CIPHERS_RSA_H__ */

---