---

StateInfo.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: StateInfo.cc,v 1.3 2004/05/19 15:56:25 mmarsh Exp $
//
// $Log: StateInfo.cc,v $
// Revision 1.3  2004/05/19 15:56:25  mmarsh
// Added copyright and license statements.
//
// Revision 1.2  2003/11/04 22:04:05  mmarsh
// General code cleanup.
//
//

#include <fstream>
#include <sstream>
#include <openssl/conf.h>

#include "StateInfo.h"
#include "CODEX_ThresholdCrypto/ThresholdRSA.h"
#include "CODEX_VSS/ModIntRange.h"
#include "APSSShareCallback.h"
#include "RecoverCallback.h"

#include "CODEX_Exceptions/FileExceptions.h"
#include "CODEX_Server/ConfigurationExceptions.h"
#include "CODEX_Exceptions/POSIXExceptions.h"
#include "Exceptions.h"

using namespace CODEX_APSS;

StateInfo* StateInfo::m_instance = 0;


//=============================================================
// Constructors and destructors
//=============================================================

StateInfo*
StateInfo::instance()
{
   if ( 0 == m_instance )
   {
      m_instance = new StateInfo;
   }
   return m_instance;
}

void
StateInfo::destroy()
{
   if ( 0 != m_instance )
   {
      delete m_instance;
   }
   m_instance = 0;
}

StateInfo::StateInfo() :
   m_domain( 0 ),
   m_refreshInterval( 0 ),
   m_rsaSubshareRange( 0 ),
   m_elgamalSubshareRange( 0 ),
   m_interval( 0 )
{
}

StateInfo::~StateInfo()
{
   if ( 0 != m_rsaSubshareRange ) delete m_rsaSubshareRange;
   if ( 0 != m_elgamalSubshareRange ) delete m_elgamalSubshareRange;
   if ( 0 != m_rsaCallback ) delete m_rsaCallback;
   if ( 0 != m_elgamalCallback ) delete m_elgamalCallback;
}


//=============================================================
// Configuration
//=============================================================

void
StateInfo::configure( const CONF* conf,
                      const char* sec,
                      const string& fname )
{
   // Grab the initial share configuration from the server.
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();


   const unsigned int RSAKeyNum = CODEX_Server::ServerState::RSAKeyNum;

   const LSType::LabelType& defaultRSALabel = serverState->defaultRSALabel();
   const LSType& rsaShares = serverState->rsaShares( defaultRSALabel,
                                                     serverState->hostNum() );
   LSType* rsaBootstrap = new LSType( rsaShares );
   m_secrets[RSAKeyNum].setNum( RSAKeyNum );
   m_secrets[RSAKeyNum].addSharing( rsaBootstrap );
   m_secrets[RSAKeyNum].setWitness( serverState->rsaWitness() );

   const CODEX_Ciphers::RSAPublicKey& pubRSAKey = serverState->serviceKey();
   m_rsaSubshareRange =
      new CODEX_ThresholdCrypto::ThresholdRSASubRange( pubRSAKey.n().value() );
   m_secrets[RSAKeyNum].setSubshareRange( m_rsaSubshareRange );


   const unsigned int EGKeyNum = CODEX_Server::ServerState::EGKeyNum;

   const LSType::LabelType& defaultEGLabel = serverState->defaultEGLabel();
   const LSType& egShares =
      serverState->elgamalShares( defaultEGLabel, serverState->hostNum() );
   LSType* egBootstrap = new LSType( egShares );
   m_secrets[EGKeyNum].setNum( EGKeyNum );
   m_secrets[EGKeyNum].addSharing( egBootstrap );
   m_secrets[EGKeyNum].setWitness( serverState->egWitness() );

   const CODEX_Ciphers::ElGamalPublicKey& pubEGKey =
      serverState->publicEGKey();
   m_elgamalSubshareRange = new CODEX_VSS::ModIntRange( pubEGKey.q() );
   m_secrets[EGKeyNum].setSubshareRange( m_elgamalSubshareRange );

   // Attach the APSS share callback to the server, so that requests for
   // shares will be directed to the APSS package.
   m_rsaCallback = new APSSShareCallback( RSAKeyNum );
   serverState->setShareCallback( RSAKeyNum, m_rsaCallback );

   m_elgamalCallback = new APSSShareCallback( EGKeyNum );
   serverState->setShareCallback( EGKeyNum, m_elgamalCallback );

   // Read the APSS refresh interval from the configuration file, specified
   // in seconds.
   long dummy;
   if ( ! NCONF_get_number_e(conf,sec,"apss_interval",&dummy) )
   {
      throw CODEX_Server::BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                                          fname, "nhosts" );
   }
   if ( dummy < 0 )
   {
      throw CODEX_Server::BCBadValueException( __FILE__ , __LINE__ ,
                                               fname, "apss_interval" );
   }
   m_interval = dummy;

   // For each secret, store the time (to the second) at which the current
   // epoch was entered.
   m_secrets[RSAKeyNum].setEpochTime();
   m_secrets[EGKeyNum].setEpochTime();
}

void
StateInfo::addSharing( LSType* sharing )
{
   if ( 0 == sharing )
   {
      return;
   }
   unsigned int num = sharing->label().num().value();
   checkSecretNum( num );
   m_secrets[num].addSharing( sharing );
}

const LSType&
StateInfo::sharing( const LSType::LabelType& label, unsigned int server ) const
{
   unsigned int num = label.num().value();
   checkSecretNum( num );
   return m_secrets.find(num)->second.sharing( label, server );
}

const WitnessType&
StateInfo::witness( unsigned int num ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.witness();
}

const ShareSetType&
StateInfo::subsharing( const SublabelType& sublabel,
                       unsigned int server ) const
{
   unsigned int num = sublabel.label().num().value();
   checkSecretNum( num );
   return m_secrets.find(num)->second.subsharing( sublabel, server );
}

void
StateInfo::addSubsharing( const SublabelType& sublabel,
                          const ShareType& subsharing )
{
   unsigned int num = sublabel.label().num().value();
   checkSecretNum( num );
   m_secrets[ num ].addSubsharing( sublabel, subsharing );
}

void
StateInfo::recover( const SublabelType& sublabel )
{
   // See if we're already recovering this label
   RecoveryList::const_iterator itr = m_recoverLabels.begin();
   RecoveryList::const_iterator end = m_recoverLabels.end();
   for ( ; itr != end ; ++itr )
   {
      if ( sublabel == *itr )
      {
         return;
      }
   }

   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   StateInfo* stateInfo = StateInfo::instance();

   // Create the request
   unsigned int version = sublabel.label().version().value() + 1;
   RecoverMsg request( version,
                       sublabel,
                       serverState->hostNum(),
                       serverState->hostNum() ); // <-- ignored by verifier

   // Sign the request
   BIGNUM * digest = 0;
   CODEX_Ciphers::RSASignature* signature = 0;
   try
   {
      const CODEX_Ciphers::HashFunction& hashFunc = serverState->hashFunc();
      digest = request.digest( hashFunc );
      if ( 0 == digest )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      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;
      throw;
   }
   SignedRecoverMsg signedRequest( request, *signature );
   delete signature;

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

   // Create the callback
   RecoverCallback* cb =
      new RecoverCallback( version, sublabel );

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

   // Make sure we don't try to recover this label again.
   m_recoverLabels.push_back( sublabel );
}

void
StateInfo::markRecovered( const SublabelType& label )
{
   m_recoverLabels.remove( label );
}

SubshareList&
StateInfo::splittings( const LabelType& label )
{
   unsigned int num = label.num().value();
   checkSecretNum( num );
   return m_secrets[num].splittings( label );
}

const CODEX_VSS::Range&
StateInfo::subshareRange( unsigned int num ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.subshareRange();
}

void
StateInfo::updateExpired()
{
   struct timeval tv;
   int gtod = gettimeofday( &tv, 0 );
   if ( 0 != gtod )
   {
      CODEX_Exceptions::GetTimeOfDayException( __FILE__ , __LINE__ , errno );
   }
   unsigned long currentTime = tv.tv_sec;

   SecretManagementMap::iterator itr = m_secrets.begin();
   SecretManagementMap::iterator end = m_secrets.end();
   for ( ; itr != end ; ++itr )
   {
#if 0
      if ( itr->first != CODEX_Server::ServerState::RSAKeyNum )
      {
         continue;
      }
#endif
      unsigned long elapsed = itr->second.elapsed( currentTime );
      if ( elapsed >= m_interval )
      {
         itr->second.beginRun();
      }
   }
}

void
StateInfo::updateAll()
{
   SecretManagementMap::iterator itr = m_secrets.begin();
   SecretManagementMap::iterator end = m_secrets.end();
   for ( ; itr != end ; ++itr )
   {
      itr->second.beginRun();
   }
}

bool
StateInfo::addInitMsg( const SignedInitMsg& im )
{
   unsigned int num = im.message().label().num().value();
   checkSecretNum( num );
   return m_secrets[num].addInitMsg( im );
}

bool
StateInfo::addEstablishMsg( const SignedEstablishMsg& em )
{
   unsigned int num = em.message().sublabel().label().num().value();
   checkSecretNum( num );
   return m_secrets[num].addEstablishMsg( em );
}

bool
StateInfo::addComputeMsg( const SignedComputeMsg& cm )
{
   unsigned int num = cm.message().subshareLabel(0).label().num().value();
   checkSecretNum( num );
   return m_secrets[num].addComputeMsg( cm );
}

bool
StateInfo::addFinishedMsg( const SignedFinishedMsg& fm )
{
   unsigned int num =
      fm.message().evidence().element(0)->message().shareLabel().num().value();
   checkSecretNum( num );
   bool retVal = m_secrets[num].addFinishedMsg( fm );
   return retVal;
}

bool
StateInfo::addInitResponse( const SignedContributeMsg& cm )
{
   const SignedEstablishedMsg& sem = *(cm.message().evidence().element(0));
   unsigned int num = sem.message().sublabel().label().num().value();
   checkSecretNum( num );
   return m_secrets[num].addInitResponse( cm );
}

bool
StateInfo::addEstablishResponse( const SignedEstablishedMsg& em )
{
   unsigned int num = em.message().sublabel().label().num().value();
   checkSecretNum( num );
   return m_secrets[num].addEstablishResponse( em );
}

bool
StateInfo::addComputeResponse( const SignedComputedMsg& cm )
{
   unsigned int num = cm.message().shareLabel().num().value();
   checkSecretNum( num );
   return m_secrets[num].addComputeResponse( cm );
}

void
StateInfo::clearEstablishMsgs( unsigned int num )
{
   checkSecretNum( num );
   m_secrets[num].clearEstablishMsgs();
}

void
StateInfo::clearEstablishMsgs( unsigned int num, unsigned int establisher )
{
   checkSecretNum( num );
   m_secrets[num].clearEstablishMsgs( establisher );
}

unsigned long
StateInfo::version( unsigned int num ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.version();
}

const InitRecord&
StateInfo::initRecord( unsigned int num, unsigned int i ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.initRecord(i);
}

const EstablishRecord&
StateInfo::establishRecord( unsigned int num,
                            unsigned int establisher,
                            unsigned int shareNum,
                            const LabelType& label ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.establishRecord( establisher,
                                                       shareNum,
                                                       label );
}

const ComputeRecord&
StateInfo::computeRecord( unsigned int num, unsigned int i ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.computeRecord(i);
}

const SignedFinishedMsg&
StateInfo::finishedMsg( unsigned int num, unsigned int i ) const
{
   checkSecretNum( num );
   return m_secrets.find(num)->second.finishedMsg(i);
}

void
StateInfo::sendFinished( unsigned int num, unsigned int server ) const
{
   checkSecretNum( num );
   m_secrets.find(num)->second.sendFinished( server );
}

void
StateInfo::sendFinished( unsigned int num,
                         unsigned int coord,
                         unsigned int server ) const
{
   checkSecretNum( num );
   m_secrets.find(num)->second.sendFinished( coord, server );
}

void
StateInfo::sendTo( unsigned int server, const CODEX_Quorum::Message& message )
{
   if ( 0 != m_deliverer )
   {
      m_deliverer->sendTo( server, message );
   }
}

void
StateInfo::broadcast( const CODEX_Quorum::Message& message,
                      CODEX_Quorum::ResponseCallback* cb )
{
   if ( 0 != m_deliverer )
   {
      m_deliverer->broadcast( message, cb );
   }
}

void
StateInfo::checkSecretNum( unsigned int num ) const
{
   SecretManagementMap::const_iterator itr = m_secrets.find(num);
   if ( m_secrets.end() == itr )
   {
      throw BadSecretNumberException( __FILE__ , __LINE__ );
   }
}

---