ElGamal.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: ElGamal.h,v 1.4 2005/01/21 19:44:16 mmarsh Exp $
//
// $Log: ElGamal.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:47  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:08:54  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_CIPHERS_ELGAMAL_H__
#define __CODEX_CIPHERS_ELGAMAL_H__

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

namespace CODEX_Ciphers
{
   class ElGamalCipherText : public CODEX_ASN1::Base
   {
      public:
         ElGamalCipherText();
         ElGamalCipherText( BIGNUM * c1, BIGNUM * c2 );
         ElGamalCipherText( const CODEX_ASN1::BigNumber& c1,
                            const CODEX_ASN1::BigNumber& c2 );
         ElGamalCipherText( const ElGamalCipherText& aCT );
         virtual ~ElGamalCipherText();

         void operator=( const ElGamalCipherText& aCT );

         bool operator<( const ElGamalCipherText& aCT ) const;

         bool operator==( const ElGamalCipherText& aCT ) const;

         bool operator!=( const ElGamalCipherText& aCT ) const;

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

         ElGamalCipherText* blind(
            const ElGamalCipherText& 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 ElGamalSchnorrCipherText : public ElGamalCipherText
   {
      public:
         ElGamalSchnorrCipherText();
         ElGamalSchnorrCipherText( BIGNUM * c1, BIGNUM * c2,
                                   BIGNUM * h, BIGNUM * z );
         ElGamalSchnorrCipherText( const CODEX_ASN1::BigNumber& c1,
                                   const CODEX_ASN1::BigNumber& c2,
                                   const CODEX_ASN1::BigNumber& h,
                                   const CODEX_ASN1::BigNumber& z );
         ElGamalSchnorrCipherText( const ElGamalSchnorrCipherText& aCT );
         virtual ~ElGamalSchnorrCipherText();

         void operator=( const ElGamalSchnorrCipherText& aCT );

         const CODEX_ASN1::BigNumber& h() const { return m_h; }
         const CODEX_ASN1::BigNumber& z() const { return m_z; }

         bool verify( const CODEX_ASN1::BigNumber& g,
                      const CODEX_ASN1::BigNumber& p,
                      const CODEX_ASN1::Base& id,
                      const HashFunction& hashFunc ) const;

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

      private:
         CODEX_ASN1::BigNumber m_h;
         CODEX_ASN1::BigNumber m_z;
   };

   class ElGamalSignature : public CODEX_ASN1::Base
   {
      public:
         ElGamalSignature();
         ElGamalSignature( BIGNUM * r, BIGNUM * s );
         ElGamalSignature( const CODEX_ASN1::BigNumber& r,
                           const CODEX_ASN1::BigNumber& s );
         ElGamalSignature( const ElGamalSignature& aSig );
         virtual ~ElGamalSignature();

         void operator=( const ElGamalSignature& aSig );

         const CODEX_ASN1::BigNumber& r() const { return m_r; }
         const CODEX_ASN1::BigNumber& s() const { return m_s; }

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

      private:
         CODEX_ASN1::BigNumber m_r; 
         CODEX_ASN1::BigNumber m_s; 
   };

   class ElGamalPublicKey : public CODEX_ASN1::Base
   {
      public:
         ElGamalPublicKey();
         ElGamalPublicKey( BIGNUM * p, BIGNUM * g, BIGNUM * y );
         ElGamalPublicKey( const CODEX_ASN1::BigNumber& p,
                           const CODEX_ASN1::BigNumber& g,
                           const CODEX_ASN1::BigNumber& y );
         ElGamalPublicKey( const ElGamalPublicKey& aKey );
         virtual ~ElGamalPublicKey();

         void operator=( const ElGamalPublicKey& aKey );

         const CODEX_ASN1::BigNumber& p() const { return m_p; }
         const CODEX_ASN1::BigNumber& g() const { return m_g; }
         const CODEX_ASN1::BigNumber& y() const { return m_y; }
         const BIGNUM * p1() const;
         const BIGNUM * q() const;

         ElGamalCipherText* encrypt( const BIGNUM * message,
                                     BIGNUM * k=0 ) const;

         ElGamalSchnorrCipherText* encryptS( const BIGNUM * message,
                                             const CODEX_ASN1::Base& id,
                                             const HashFunction& hashFunc,
                                             BIGNUM * k=0 ) const;

         bool verifySignature( const ElGamalSignature& 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 :
         void encryptVals( const BIGNUM * message ,
                           BIGNUM * k ,
                           BIGNUM * c1 ,
                           BIGNUM * c2 ) const;

      private:
         CODEX_ASN1::BigNumber m_p;
         CODEX_ASN1::BigNumber m_g;
         CODEX_ASN1::BigNumber m_y;
         mutable BIGNUM *      m_p1; // useful at times
         mutable BIGNUM *      m_q;  // useful at times
   };

   class ElGamalPrivateKey : public CODEX_ASN1::SecureBigNumber
   {
      public:
         ElGamalPrivateKey();
         ElGamalPrivateKey( BIGNUM * x );
         ElGamalPrivateKey( const CODEX_ASN1::BigNumber& x );
         ElGamalPrivateKey( const ElGamalPrivateKey& aKey );
         virtual ~ElGamalPrivateKey();

         const CODEX_ASN1::SecureBigNumber& x() const { return *this; }

         BIGNUM * decrypt( const ElGamalCipherText& cipherText,
                           const ElGamalPublicKey& publicKey ) const;
         ElGamalSignature* sign( const BIGNUM * message,
                                 const ElGamalPublicKey& publicKey ) const;

         void toFile(const char* fname) const;

         void* fromFile(const char* fname);
   };

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

         void operator()( ElGamalPublicKey*& pubKey,
                          ElGamalPrivateKey*& privKey,
                          BIGNUM * p=0,
                          BIGNUM * g=0 );

      private:
         long m_numBits;
   };

}

#endif /* __CODEX_CIPHERS_ELGAMAL_H__ */

---