InitCallback.cc

/*
 * 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: InitCallback.cc,v 1.3 2004/05/19 15:56:24 mmarsh Exp $
//
// $Log: InitCallback.cc,v $
// Revision 1.3  2004/05/19 15:56:24  mmarsh
// Added copyright and license statements.
//
// Revision 1.2  2003/11/04 22:31:45  mmarsh
// *** empty log message ***
//
//

#include "InitCallback.h"
#include "ComputeCallback.h"
#include "StateInfo.h"
#include "CODEX_Server/ServerState.h"

#include "CODEX_Exceptions/BignumExceptions.h"
#include "CODEX_Server/ServerExceptions.h"

#include "timing.h"

using namespace CODEX_APSS;

InitCallback::InitCallback( unsigned int version, const LabelType& label ) :
   m_version( version ),
   m_label( label ),
   m_completed( false )
{
}

InitCallback::~InitCallback()
{
}

bool
InitCallback::operator()( unsigned int server, CODEX_Quorum::Message* msg )
{
   if ( m_completed )
   {
      if ( 0 != msg ) delete msg;
      return true;
   }

   if ( 0 == msg )
   {
      return false;
   }

#ifdef TIMING
   ActiveTimer.start();
#endif
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   if ( 0 == serverState )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }

   StateInfo* stateInfo = StateInfo::instance();
   if ( 0 == stateInfo )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }

   CODEX_Quorum::QuorumSystem* qs = serverState->quorumSystem();
   if ( 0 == qs )
   {
#ifdef TIMING
      ActiveTimer.stop();
#endif
      throw CODEX_Server::NoQuorumSystemException( __FILE__ , __LINE__ );
   }

   // See if we're already in the next epoch.
   const unsigned long epoch = stateInfo->version( m_label.num().value() );
   if ( epoch >= m_version )
   {
      delete msg;
      m_completed = true;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   // Unmarshal the message.
   unsigned char* data = (unsigned char*)msg->buffer();
   int length = msg->length();

   if ( length < 2 )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }

   if ( stateInfo->domain() != data[0] )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }
   ++data;
   --length;

   if ( ( kContributeMsg | SignatureMask ) != data[0] )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }
   ++data;
   --length;

   SignedContributeMsg signedResponse;
   if ( 0 == signedResponse.unmarshal( 0, &data, length ) )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }
   delete msg;

   // Make sure the response is valid.
   const ContributeMsg& response = signedResponse.message();

   unsigned int contributor = response.contributor().value();
   if ( contributor != server )
   {
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }

   // Check the signature.
   BIGNUM * digest = 0;
   try
   {
      digest = response.digest( serverState->hashFunc() );
      if ( 0 == digest )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! serverState->publicKey(server).verifySignature(
         signedResponse.signature(),
         digest ) )
      {
         throw CODEX_Server::SignatureVerificationFailedException( __FILE__ ,
                                                                   __LINE__ );
      }
      BN_free(digest);
   }
   catch ( ... )
   {
      if ( 0 != digest ) BN_free(digest);
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }

   // Check the validity of all the established messages.
   unsigned int coordinator = serverState->hostNum();
   unsigned int num = m_label.num().value();
   OneWay oneWay( stateInfo->witness(num).args() );
   const EstablishedArray& evidence = response.evidence();
   EstablishedArray::ArrayItr itr = evidence.begin();
   EstablishedArray::ArrayItr end = evidence.end();
   SublabelType currentSublabel;
   unsigned int shareIndex = 0;
   unsigned int sublabelCount = 0;
   bool badSublabel = true; // Initial sublabel is uninitialized
   for ( ; itr != end ; ++itr )
   {
      const SublabelType& sl = (*itr)->message().sublabel();
      if ( sl != currentSublabel )
      {
         badSublabel = false;
         currentSublabel = sl;
         sublabelCount = 0;
         shareIndex = sl.id().value();
         if ( shareIndex >= ShareType::NumShares )
         {
#ifdef TIMING
            ActiveTimer.stop();
#endif
            throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                           __LINE__ );
         }
         // Test the validity of the subsharing w.r.t. the purported share.
         if ( ! sl.verify( oneWay ) )
         {
            badSublabel = true;
         }
      }

      if ( badSublabel )
      {
         continue;
      }

      // Have we already selected a subsharing for this share?
      if ( m_subshareLabels[ shareIndex ].initialized() )
      {
         continue;
      }

      // Check validity of this message (version and signature)
      unsigned int slVersion = (*itr)->message().version().value();
      if ( slVersion != m_version )
      {
         continue;
      }

      digest = 0;
      try
      {
         digest = (*itr)->message().digest( serverState->hashFunc() );
         if ( 0 == digest )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
         if ( ! serverState->publicKey(
            (*itr)->message().recipient().value()).verifySignature(
            (*itr)->signature(),
            digest ) )
         {
            throw
               CODEX_Server::SignatureVerificationFailedException( __FILE__ ,
                                                                   __LINE__ );
         }
         BN_free(digest);
      }
      catch ( ... )
      {
         if ( 0 != digest ) BN_free(digest);
         continue;
      }

      ++sublabelCount;
      if ( sublabelCount >= qs->quorumSize() )
      {
         m_subshareLabels[ shareIndex ] = currentSublabel;
      }
   }

   // This is equivalent to testing for T+1 valid responses.
   bool haveAll = true;
   for ( unsigned int i = 0 ;
         haveAll && ( i < ShareType::NumShares ) ;
         ++i )
   {
      // See if any share does not yet have a selected subsharing.
      if ( ! m_subshareLabels[i].initialized() )
      {
         haveAll = false;
      }
   }

   if ( haveAll )
   {
      // Compute the new label.
      LabelType::VType::ValueType labelVals[ ShareType::NumShares ];
      LabelType::VType vr( oneWay );
      for ( unsigned int i = 0 ; i < ShareType::NumShares ; ++i )
      {
         // Compute the label
         LabelType::VType::ValueType sublabelVals[ ShareType::NumShares ];
         for ( unsigned int j = 0 ; j < ShareType::NumShares ; ++j )
         {
            sublabelVals[j] = m_subshareLabels[j].vc(i);
         }
         vr( sublabelVals, labelVals[i] );
      }
      LabelType newLabel( num, m_version, coordinator, labelVals );

      // Compose the finished message.
      ComputeMsg cm( coordinator, m_subshareLabels );

      // Sign the finished message.
      digest = 0;
      CODEX_Ciphers::RSASignature* signature = 0;
      try
      {
         const CODEX_Ciphers::HashFunction& hashFunc = serverState->hashFunc();
         digest = cm.digest( hashFunc );
         const CODEX_Ciphers::RSAPrivateKey& key = serverState->privateKey();
         signature = key.sign( digest );
         BN_free(digest);
         digest = 0;
         if ( 0 == signature )
         {
            throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
         }
      }
      catch ( ... )
      {
         if ( 0 != digest ) BN_free( digest );
         if ( 0 != signature ) delete signature;
#ifdef TIMING
         ActiveTimer.stop();
#endif
         throw;
      }
      SignedComputeMsg signedCM( cm, *signature );
      delete signature;

      // Create the marshalled message.
      CODEX_Quorum::Message m;
      m.fill( serverState->hostNum() |
              CODEX_Server::ServerState::OutgoingMask );
      const unsigned char* seqNum = serverState->newSequenceNumber();
      m.fill( seqNum, CODEX_Server::ServerState::nMID );
      m.fill( stateInfo->domain() );
      m.fill( kComputeMsg | SignatureMask );
      int length = signedCM.marshal(0);
      unsigned char* buffer = new unsigned char[length];
      unsigned char* pBuffer = buffer;
      signedCM.marshal(&pBuffer);
      m.fill( buffer, length );
      delete [] buffer;

      ComputeCallback* cb = new ComputeCallback( newLabel );

      // Broadcast compute message.
      stateInfo->broadcast( m, cb );

      m_completed = true;

#ifdef TIMING
      InitTimer[num].stop();
      ComputeTimer[num].start();
#endif

   }

#ifdef TIMING
   ActiveTimer.stop();
#endif
   return true;
}

---