CombinatoricFeldman.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: CombinatoricFeldman.h,v 1.3 2004/05/19 15:57:00 mmarsh Exp $
//
// $Log: CombinatoricFeldman.h,v $
// Revision 1.3  2004/05/19 15:57:00  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:23:07  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_VSS_COMBINATORICFELDMAN_H__
#define __CODEX_VSS_COMBINATORICFELDMAN_H__

#include "Combinatoric.h"
#include "ModExpFunctional.h"
#include "ShareLabel.h"
#include "VRecon.h"

namespace CODEX_VSS
{
   template< unsigned int N , unsigned int T >
   class VRecon< Combinatoric< N , T > , ModExpFunctional >
   {
      public :
         typedef Combinatoric< N , T >  ShareType;

         typedef ModExpFunctional       OneWay;

         typedef CODEX_ASN1::BigNumber  ValueType;

         static const unsigned int      NumShares = ShareType::NumShares;

         VRecon( const OneWay& func ) : m_modulus( func.modulus() ) {}

         void operator()( const ValueType vc[ NumShares ], ValueType& result )
         {
            const BIGNUM * n = m_modulus.value();
            BIGNUM * product = 0;
            BN_CTX * ctx = 0;
            try
            {
               product = BN_dup( BN_value_one() );
               if ( 0 == product )
               {
                  throw CODEX_Exceptions::BignumNullException( __FILE__ ,
                                                               __LINE__ );
               }
               ctx = BN_CTX_new();
               if ( 0 == ctx )
               {
                  throw CODEX_Exceptions::BignumContextException( __FILE__ ,
                                                                  __LINE__ );
               }
               for ( unsigned int i = 0 ; i < NumShares ; ++i )
               {
                  if ( ! vc[i].initialized() )
                  {
                     throw CODEX_Exceptions::BignumNullException( __FILE__ ,
                                                                  __LINE__ );
                  }
                  const BIGNUM * w = vc[i].value();
                  if ( ! BN_mod_mul( product, product, w, n, ctx ) )
                  {
                     throw CODEX_Exceptions::BignumModMulException( __FILE__ ,
                                                                    __LINE__ );
                  }
               }
               result = ValueType( product );
               BN_CTX_free(ctx);
            }
            catch ( ... )
            {
               if ( 0 != product ) BN_free(product);
               if ( 0 != ctx ) BN_CTX_free(ctx);
               throw;
            }
         }

         bool checkShare( const ValueType checks[ NumShares ],
                          const ShareType& share,
                          const OneWay& func )
         {
            ValueType vc;
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               if ( ! share.share(i).initialized() )
               {
                  continue;
               }

               func( share.share(i), vc );
               if ( checks[i] != vc ) return false;
            }
            return true;
         }

      private :
         ValueType  m_modulus;
   };

   template< unsigned int N >
   struct factorial
   {
         static const unsigned int value = N*factorial<N-1>::value;
   };

   template<>
   struct factorial<0>
   {
         static const unsigned int value = 1;
   };

   template<>
   struct factorial<1>
   {
         static const unsigned int value = 1;
   };

}

#endif /* __CODEX_VSS_COMBINATORICFELDMAN_H__ */

---