CombinatoricThresholdElGamal.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: CombinatoricThresholdElGamal.h,v 1.3 2004/05/19 15:57:00 mmarsh Exp $
//
// $Log: CombinatoricThresholdElGamal.h,v $
// Revision 1.3  2004/05/19 15:57:00  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:31:51  mmarsh
// *** empty log message ***
//
//

#ifndef __CODEX_THRESHOLDCRYPTO_COMBINATORICTHRESHOLDELGAMAL_H__
#define __CODEX_THRESHOLDCRYPTO_COMBINATORICTHRESHOLDELGAMAL_H__

#include <fstream>

#include "ThresholdElGamal.h"
#include "CODEX_VSS/Combinatoric.h"

#include "timing.h"

namespace CODEX_ThresholdCrypto
{
   template< unsigned int NumT , unsigned int ThreshT >
   class ThresholdElGamalCrypto< CODEX_VSS::Combinatoric< NumT , ThreshT > >
   {
      public :
         typedef CODEX_VSS::Combinatoric< NumT , ThreshT >  ShareType;

         typedef CODEX_VSS::ShareSet< ShareType >           SetType;

         typedef CODEX_Ciphers::ElGamalCipherText           CipherTextType;

         ThresholdElGamalCrypto( const CODEX_ASN1::BigNumber& modulus ) :
            m_modulus( modulus )
         {
         }

         void decrypt( const ShareType& shares,
                       const CipherTextType& ciphertext,
                       ShareType& partials ) const
         {
#ifdef TIMING
            PartialDecTimer.start();
#endif
            // We only need to worry about the first part of the ciphertext.
            CODEX_VSS::ModExpFunctional f( ciphertext.c1(), m_modulus );
            shares.apply( f, partials );
#ifdef TIMING
            PartialDecTimer.stop();
#endif
         }

         BIGNUM* thresholdDecrypt( const SetType& partials,
                                   const CipherTextType& ciphertext ) const
         {
#ifdef TIMING
            ThresholdDecTimer.start();
#endif
            for ( unsigned int i = 0 ; i < ShareType::NumShares ; ++i )
            {
               if ( ! partials(i).initialized() )
               {
#ifdef TIMING
                  ThresholdDecTimer.stop();
#endif
                  return 0;
               }
            }
            const BIGNUM * n = m_modulus.value();
            BIGNUM * s = 0;
            BN_CTX * ctx = 0;
            try
            {
               ctx = BN_CTX_new();
               if ( 0 == ctx )
               {
                  throw CODEX_Exceptions::BignumContextException( __FILE__ ,
                                                                  __LINE__ );
               }
               s = BN_new();
               if ( 0 == s )
               {
                  throw CODEX_Exceptions::BignumNullException( __FILE__ ,
                                                               __LINE__ );
               }
               BN_one(s); // This should never fail.
               for ( unsigned int i = 0 ; i < ShareType::NumShares ; ++i )
               {
                  const BIGNUM * share = partials(i).value();
                  if ( ! BN_mod_mul( s, s, share, n, ctx ) )
                  {
                     throw CODEX_Exceptions::BignumModMulException( __FILE__ ,
                                                                    __LINE__ );
                  }
               }

               // s is now c1^x, and the final result we need is c2/(c1^x)
               // We can abuse s to avoid creating further BIGNUMs.
               if ( ! BN_mod_inverse( s, s, n, ctx ) )
               {
                  throw
                     CODEX_Exceptions::BignumModInverseException( __FILE__ ,
                                                                  __LINE__ );
               }
               if ( ! BN_mod_mul( s, s, ciphertext.c2().value(), n, ctx ) )
               {
                  throw CODEX_Exceptions::BignumModMulException( __FILE__ ,
                                                                 __LINE__ );
               }
            }
            catch ( ... )
            {
               if ( 0 != s ) BN_free(s);
               if ( 0 != ctx ) BN_CTX_free(ctx);
#ifdef TIMING
               ThresholdDecTimer.stop();
#endif
               throw;
            }
            BN_CTX_free(ctx);
#ifdef TIMING
            ThresholdDecTimer.stop();
#endif
            return s;
         }

      private :
         CODEX_ASN1::BigNumber  m_modulus;
   };

}

#endif /* __CODEX_THRESHOLDCRYPTO_COMBINATORICTHRESHOLDELGAMAL_H__ */

---