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

#ifndef __CODEX_CIPHERS_VARRSA_H__
#define __CODEX_CIPHERS_VARRSA_H__

#include <openssl/bn.h>
#include "RSA.h"
#include "HashFunction.h"

// NOTES: The ciphertext must be changed to a pair of BIGNUMs.
//        It also needs (un)serialization implemented.
//        The blind ciphertext and plaintext need to be implemented.

namespace CODEX_Ciphers
{
   // Forward declaration
   class VarRSABlindCipherText;

   class VarRSACipherText : public CODEX_ASN1::Base
   {
      public:
         VarRSACipherText() :
            CODEX_ASN1::Base( false )
         {}
         VarRSACipherText( BIGNUM * c1, BIGNUM * c2 ) :
            CODEX_ASN1::Base( true ),
            m_c1( c1 ),
            m_c2( c2 )
         {}
         VarRSACipherText( const CODEX_ASN1::BigNumber& c1,
                           const CODEX_ASN1::BigNumber& c2 ) :
            CODEX_ASN1::Base( true ),
            m_c1( c1 ),
            m_c2( c2 )
         {}
         VarRSACipherText( const VarRSACipherText& aOther ) :
            CODEX_ASN1::Base( aOther.m_initialized ),
            m_c1( aOther.m_c1 ),
            m_c2( aOther.m_c2 )
         {
         }
         virtual ~VarRSACipherText() {}

         void operator=( const VarRSACipherText& aOther );

         bool operator==( const VarRSACipherText& aBN ) const;

         bool operator!=( const VarRSACipherText& aBN ) const;

         const CODEX_ASN1::BigNumber& c1() const { return m_c1; }
         const CODEX_ASN1::BigNumber& c2() const { return m_c2; }

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

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

      private :
         CODEX_ASN1::BigNumber  m_c1;
         CODEX_ASN1::BigNumber  m_c2;
   };

   class VarRSABlindCipherText : public CODEX_ASN1::Base
   {
      public:
         VarRSABlindCipherText() :
            CODEX_ASN1::Base( false )
         {}
         VarRSABlindCipherText( BIGNUM * c1, BIGNUM * c2 ) :
            CODEX_ASN1::Base( true ),
            m_c1( c1 ),
            m_c2( c2 )
         {}
         VarRSABlindCipherText( const CODEX_ASN1::BigNumber& c1,
                                const CODEX_ASN1::BigNumber& c2 ) :
            CODEX_ASN1::Base( true ),
            m_c1( c1 ),
            m_c2( c2 )
         {}
         VarRSABlindCipherText( const VarRSABlindCipherText& aOther ) :
            CODEX_ASN1::Base( aOther.m_initialized ),
            m_c1( aOther.m_c1 ),
            m_c2( aOther.m_c2 )
         {
         }
         virtual ~VarRSABlindCipherText() {}

         void operator=( const VarRSABlindCipherText& aOther );

         bool operator<( const VarRSABlindCipherText& aOther ) const;

         const CODEX_ASN1::BigNumber& c1() const { return m_c1; }
         const CODEX_ASN1::BigNumber& c2() const { return m_c2; }

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

      private :
         CODEX_ASN1::BigNumber  m_c1;
         CODEX_ASN1::BigNumber  m_c2;
   };

   class VarRSABlindPlainText : public CODEX_ASN1::Base
   {
      public:
         VarRSABlindPlainText() :
            CODEX_ASN1::Base( false )
         {}
         VarRSABlindPlainText( BIGNUM * b1, BIGNUM * b2 ) :
            CODEX_ASN1::Base( true ),
            m_b1( b1 ),
            m_b2( b2 )
         {}
         VarRSABlindPlainText( const CODEX_ASN1::BigNumber& b1,
                               const CODEX_ASN1::BigNumber& b2 ) :
            CODEX_ASN1::Base( true ),
            m_b1( b1 ),
            m_b2( b2 )
         {}
         VarRSABlindPlainText( const VarRSABlindPlainText& aOther ) :
            CODEX_ASN1::Base( aOther.m_initialized ),
            m_b1( aOther.m_b1 ),
            m_b2( aOther.m_b2 )
         {
         }
         virtual ~VarRSABlindPlainText() {}

         void operator=( const VarRSABlindPlainText& aOther );

         const CODEX_ASN1::BigNumber& b1() const { return m_b1; }
         const CODEX_ASN1::BigNumber& b2() const { return m_b2; }

         BIGNUM * unblind( const BIGNUM * b,
                           const CODEX_ASN1::BigNumber& modulus,
                           const HashFunction& hashFunc ) const;

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

      private :
         CODEX_ASN1::BigNumber  m_b1;
         CODEX_ASN1::BigNumber  m_b2;
   };

   typedef RSASignature VarRSASignature;

   class VarRSAPublicKey : public RSAPublicKey
   {
      public:
         VarRSAPublicKey( const RSAPublicKey& aKey );

         virtual ~VarRSAPublicKey() {}

         const CODEX_ASN1::BigNumber& n() const { return m_key.n(); }
         const CODEX_ASN1::BigNumber& e() const { return m_key.e(); }

         VarRSACipherText* encrypt( const BIGNUM * message,
                                    const HashFunction& hashFunc,
                                    BIGNUM * r=0 ) const;

         bool verifySignature( const VarRSASignature& signature,
                               const BIGNUM * message ) const
         {
            return m_key.verifySignature( signature, message );
         }

      private:
         const RSAPublicKey&  m_key;
   };

   class VarRSAPrivateKey : public RSAPrivateKey
   {
      public:
         VarRSAPrivateKey( const RSAPrivateKey& aKey );

         virtual ~VarRSAPrivateKey();

         const CODEX_ASN1::SecureBigNumber& p()   const { return m_key.p(); }
         const CODEX_ASN1::SecureBigNumber& q()   const { return m_key.q(); }
         const CODEX_ASN1::SecureBigNumber& d()   const { return m_key.d(); }
         const CODEX_ASN1::SecureBigNumber& n()   const { return m_key.n(); }
         const CODEX_ASN1::SecureBigNumber& phi() const { return m_key.phi(); }

         BIGNUM * decrypt( const VarRSACipherText& cipherText,
                           const HashFunction& hashFunc ) const;
         VarRSABlindPlainText* decryptBlind(
            const VarRSABlindCipherText& cipherText ) const;
         VarRSASignature* sign( const BIGNUM * message ) const
         {
            return m_key.sign( message );
         }

      private:
         const RSAPrivateKey&  m_key;
   };

}

#endif /* __CODEX_CIPHERS_VARRSA_H__ */

---