SecretManagement.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: SecretManagement.cc,v 1.3 2004/05/19 15:56:25 mmarsh Exp $
//
// $Log: SecretManagement.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 <sys/time.h>
#include <errno.h>

#include "SecretManagement.h"
#include "StateInfo.h"
#include "InitCallback.h"
#include "Exceptions.h"
#include "CODEX_Exceptions/POSIXExceptions.h"
#include "CODEX_Server/ServerExceptions.h"

#include "timing.h"
#ifdef TIMING
#include <sstream>
#endif

using namespace CODEX_APSS;

SecretManagement::SecretManagement() :
   m_shareCallback( 0 ),
   m_subshareRange( 0 ),
   m_version( 0 ),
   m_num( 0 ),
   m_epochTime( 0 ),
   m_runTime( 0 )
{
}

SecretManagement::~SecretManagement()
{
   if ( 0 != m_shareCallback ) delete m_shareCallback;
   while ( ! m_sharings.empty() )
   {
      SharingList::value_type back = m_sharings.back();
      if ( 0 != back ) delete back;
      m_sharings.pop_back();
   }
   m_subsharings.clear();
   clearEstablishMsgs();
}

void
SecretManagement::setSubshareRange( const CODEX_VSS::Range* subshareRange )
{
   m_subshareRange = subshareRange;
}

const CODEX_VSS::Range&
SecretManagement::subshareRange() const
{
   if ( 0 == m_subshareRange )
   {
      throw MissingRangeException( __FILE__ , __LINE__ );
   }
   return *m_subshareRange;
}

void
SecretManagement::addSharing( LSType* sharing )
{
   if ( 0 == sharing )
   {
      return;
   }

   const CODEX_ASN1::Integer& version = sharing->label().version();
   if ( ! version.initialized() )
   {
      delete sharing;
      return;
   }

   unsigned int vnum = version.value();
   if ( vnum < m_version )
   {
      delete sharing;
      return;
   }

   // Make sure we don't already have a sharing for this version from
   // this coordinator.
   SharingList::const_iterator sItr = m_sharings.begin();
   SharingList::const_iterator sEnd = m_sharings.end();
   for ( ; sItr != sEnd ; ++sItr )
   {
      if ( ( (*sItr)->label().id().value() ==
             sharing->label().id().value() ) &&
           ( (*sItr)->label().version().value() ==
             sharing->label().version().value() ) )
      {
         delete sharing;
         return;
      }
   }
   m_sharings.push_back( sharing );
}

bool
SecretManagement::labelValid( const LabelType& label ) const
{
   for ( unsigned int i = 0 ; i < NumServers ; ++i )
   {
      if ( m_finishedLog[i].initialized() )
      {
         if ( m_finishedLog[i].message().evidence().element(0)->
              message().shareLabel() ==
              label )
         {
            return true;
         }
      }
   }
   return false;
}

const LSType&
SecretManagement::sharing( const LSType::LabelType& label,
                           unsigned int server ) const
{
   unsigned int version = label.version().value();
   if ( version < m_version )
   {
      // this is an expired label -- send stored "finished" messages
      sendFinished( server );
      throw CODEX_Server::InvalidLabelException( __FILE__ , __LINE__ );
   }
   if ( version > m_version )
   {
      // we're not in this epoch
      throw CODEX_Server::KeySharesNotFoundException( __FILE__ , __LINE__ );
   }
   SharingList::const_iterator sItr = m_sharings.begin();
   SharingList::const_iterator sEnd = m_sharings.end();
   for ( ; sItr != sEnd ; ++sItr )
   {
      if ( (*sItr)->label() == label )
      {
         return **sItr;
      }
      else if ( (*sItr)->label().id().value() == label.id().value() )
      {
         // this is a bogus label
         throw CODEX_Server::InvalidLabelException( __FILE__ , __LINE__ );
      }
   }
   if ( ! labelValid( label ) )
   {
      sendFinished( server );
      throw CODEX_Server::InvalidLabelException( __FILE__ , __LINE__ );
   }
   // we haven't seen this label
   throw CODEX_Server::KeySharesNotFoundException( __FILE__ , __LINE__ );
}

void
SecretManagement::addSubsharing( const SublabelType& label,
                                 const ShareType& subsharing )
{
   const CODEX_ASN1::Integer& version = label.label().version();
   if ( ! version.initialized() )
   {
      return;
   }

   unsigned int vnum = version.value();
   if ( vnum < m_version )
   {
      return;
   }
   m_subsharings[label].addShare( subsharing );
}

const ShareSetType&
SecretManagement::subsharing( const SublabelType& sublabel,
                              unsigned int server ) const
{
   unsigned int vnum = sublabel.label().version().value();
   if ( vnum < m_version )
   {
      // this is an expired label -- send stored "finished" messages
      sendFinished( server );
      throw CODEX_Server::KeySharesNotFoundException( __FILE__ , __LINE__ );
   }
   SubsharingMap::const_iterator sItr = m_subsharings.find( sublabel );
   if ( sItr == m_subsharings.end() )
   {
      // not found
      throw CODEX_Server::KeySharesNotFoundException( __FILE__ , __LINE__ );
   }
   return sItr->second;
}

SubshareList&
SecretManagement::splittings( const LabelType& label )
{
   return m_splittings[ label ];
}

bool
SecretManagement::addInitMsg( const SignedInitMsg& im )
{
   unsigned int coord = im.message().coordinator().value();
   int version = im.message().version().value();
   const InitMsg& stored = m_initLog[coord].request();
   // If there is no stored message, just add the new message.
   if ( ! stored.initialized() )
   {
      m_initLog[coord].addRequest(im.message());
      return true;
   }
   // If the stored message is from a previous epoch, just replace it.
   if ( version > stored.version().value() )
   {
      m_initLog[coord].addRequest(im.message());
      return true;
   }

   // The message must now be:
   // 1) a repeat,
   // 2) a bogus message, or
   // 3) from an earlier epoch
   if ( im.message().label() == stored.label() )
   {
      // Duplicate -- just return
      return false;
   }

   // The message is bad -- flag the error
   throw InitMsgConflictException( __FILE__ ,
                                   __LINE__ ,
                                   coord,
                                   im.message().label(),
                                   stored.label() );
   return false;
}

bool
SecretManagement::addEstablishMsg( const SignedEstablishMsg& em )
{
   unsigned int estab = em.message().establisher().value();
   unsigned int snum = em.message().sublabel().id().value();
   EstablishRecord& er =
      m_establishLog[ estab ][ snum ][ em.message().sublabel().label() ];
   bool retVal = false;
   if ( ! er.request().initialized() )
   {
      retVal = true;
   }
   else
   {
      if ( er.request().sublabel() != em.message().sublabel() )
      {
         throw EstablishMsgConflictException(
            __FILE__ , __LINE__ , estab, em.message().sublabel(),
            er.request().sublabel() );
      }
   }
   if (retVal)
   {
      // The version of the message stored should not have the actual
      // subshares in it, which makes maintenance considerably easier.
      er.addRequest( EstablishMsg( em.message().version(),
                                   em.message().sublabel(),
                                   em.message().establisher(),
                                   em.message().recipient(),
                                   ShareType() ) );
      addSubsharing( em.message().sublabel(), em.message().shares() );
   }
   return retVal;
}

bool
SecretManagement::addComputeMsg( const SignedComputeMsg& cm )
{
   unsigned int coord = cm.message().coordinator().value();
   int version = cm.message().subshareLabel(0).label().version().value();
   const ComputeMsg& stored = m_computeLog[coord].request();
   // If there is no stored message, just add the new message.
   if ( ! stored.initialized() )
   {
      m_computeLog[coord].addRequest(cm.message());
      return true;
   }
   // If the stored message is from a previous epoch, just replace it.
   if ( version > stored.subshareLabel(0).label().version().value() )
   {
      m_computeLog[coord].addRequest(cm.message());
      return true;
   }

   // The message must now be:
   // 1) a repeat,
   // 2) a bogus message, or
   // 3) from an earlier epoch
   for ( unsigned int i = 0 ; i < NumShares ; ++i )
   {
      if ( cm.message().subshareLabel(i) != stored.subshareLabel(i) )
      {
         // The message is bad -- flag the error
         throw ComputeMsgConflictException( __FILE__ , __LINE__ , coord,
                                            cm.message(), stored );
      }
   }
   // Duplicate
   return false;
}

bool
SecretManagement::addFinishedMsg( const SignedFinishedMsg& fm )
{
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();

   unsigned int coord = fm.message().coordinator().value();
   unsigned int version = fm.message().version().value();

   if ( coord >= NumServers )
   {
      throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
   }

   // Does this message belong to a previous epoch?
   if ( version < m_version )
   {
      return false;
   }

   // Store the message.
   m_finishedLog[coord] = fm;

   // Are we beginning a new epoch?
   if ( version > m_version )
   {
      // If so:
      //  - set the new version number
      //  - clear the old logged message
      //  - delete the old shares
      //  - delete the old subshares

      m_version = version;

      for ( unsigned int i = 0 ; i < NumServers ; ++i )
      {
         if ( m_finishedLog[i].initialized() && ( i != coord ) )
         {
            m_finishedLog[i] = SignedFinishedMsg();
         }
      }

      SharingList::iterator slItr = m_sharings.begin();
      SharingList::iterator slEnd = m_sharings.end();
      SharingList tempList;
      for ( ; slItr != slEnd ; ++slItr )
      {
         unsigned int slVers = (*slItr)->label().version().value();
         if ( slVers >= m_version )
         {
            tempList.push_back( *slItr );
         }
         else
         {
            delete (*slItr);
         }
      }
      m_sharings = tempList;

      SubsharingMap::iterator sslItr = m_subsharings.begin();
      SubsharingMap::iterator sslEnd = m_subsharings.end();
      SubsharingMap tempMap;
//      for ( ; sslItr != m_subsharings.end() ; ++sslItr )
      for ( ; sslItr != sslEnd ; ++sslItr )
      {
         // currently-relevant subshares have the previous version number.
         unsigned int sslVers = sslItr->first.label().version().value() + 1;
         if ( sslVers >= m_version )
         {
            tempMap.insert( *sslItr );
//            SubsharingMap::iterator temp = sslItr;
//            --sslItr;
//            m_subsharings.erase( temp );
         }
      }
      m_subsharings = tempMap;

      SplittingMap::iterator smItr = m_splittings.begin();
      SplittingMap::iterator smEnd = m_splittings.end();
      SplittingMap tempSMap;
      for ( ; smItr != smEnd ; ++smItr )
      {
         unsigned int smVers = smItr->first.version().value() + 1;
         if ( smVers >= m_version )
         {
            tempSMap.insert( *smItr );
         }
      }
      m_splittings = tempSMap;

      for ( unsigned int i = 0 ; i < NumServers ; ++i )
      {
         for ( unsigned int j = 0 ; j < NumShares ; ++j )
         {
            EstablishMap tempEMap;
            EstablishMap::iterator emItr = m_establishLog[i][j].begin();
            EstablishMap::iterator emEnd = m_establishLog[i][j].end();
            for ( ; emItr != emEnd ; ++emItr )
            {
               unsigned int eVers = emItr->first.version().value() + 1;
               if ( eVers >= m_version )
               {
                  tempEMap.insert( *emItr );
               }
            }
            m_establishLog[i][j] = tempEMap;
         }
      }

      struct timeval tv;
      int gtod = gettimeofday( &tv, 0 );
      if ( 0 != gtod )
      {
         CODEX_Exceptions::GetTimeOfDayException( __FILE__ , __LINE__ ,
                                                  errno );
      }
      cout << "entering epoch " << m_version
           << " (" << tv.tv_sec - m_runTime
           << ")" << endl;

      setEpochTime();

#ifdef TIMING
      if ( serverState->hostNum() == coord )
      {
         APSSTimer[m_num].stop();
      }

      // Now output the timing information
      ActiveTimer.print(cout);
      SSLTimer.print(cout);
      OneWayTimer.print(cout);
      SignTimer.print(cout);
      SignVerifyTimer.print(cout);
      APSSTimer[m_num].print(cout);
      InitTimer[m_num].print(cout);
      InitIdleTimer[m_num].print(cout);
      InitActTimer[m_num].print(cout);
      InitActIdleTimer[m_num].print(cout);
      ComputeTimer[m_num].print(cout);
      ComputeIdleTimer[m_num].print(cout);

      ActiveTimer.clear();
      SSLTimer.clear();
      OneWayTimer.clear();
      SignTimer.clear();
      SignVerifyTimer.clear();
      APSSTimer[m_num].clear();
      InitTimer[m_num].clear();
      InitIdleTimer[m_num].clear();
      InitActTimer[m_num].clear();
      InitActIdleTimer[m_num].clear();
      ComputeTimer[m_num].clear();
      ComputeIdleTimer[m_num].clear();
#endif /* TIMING */

   }

   // See if this establishes the sharing to be used as the default.
   // By choosing the default sharing by coordinator rather than by
   // order received we decrease the likelihood of multiple sharings.
   for ( unsigned int i = 0 ; i < NumServers ; ++i )
   {
      // This will grab the lowest-numbered coordinator which has
      // established a new sharing.
      if ( m_finishedLog[i].initialized() )
      {
         if ( i == coord )
         {
            const SignedComputedMsg& ev =
               *(m_finishedLog[i].message().evidence().element(0));
            serverState->setDefaultLabel( &(ev.message().shareLabel()) );
         }
         break;
      }         
   }

   return true;
}

bool
SecretManagement::addInitResponse( const SignedContributeMsg& cm )
{
   unsigned int coord = cm.message().coordinator().value();
   if ( ! m_initLog[coord].request().initialized() )
   {
      return false;
   }
   if ( m_initLog[coord].request().version().value() !=
        cm.message().version().value() )
   {
      return false;
   }
   m_initLog[coord].addResponse( cm );
   return true;
}

bool
SecretManagement::addEstablishResponse( const SignedEstablishedMsg& em )
{
   unsigned int estab = em.message().establisher().value();
   unsigned int snum = em.message().sublabel().id().value();
   EstablishRecord& er =
      m_establishLog[ estab ][ snum ][ em.message().sublabel().label() ];
   if ( ! er.request().initialized() )
   {
      return false;
   }
   if ( er.request().version().value() != em.message().version().value() )
   {
      return false;
   }
   er.addResponse( em );
   return true;
}

bool
SecretManagement::addComputeResponse( const SignedComputedMsg& cm )
{
   unsigned int coord = cm.message().shareLabel().id().value();
   if ( ! m_computeLog[ coord ].request().initialized() )
   {
      return false;
   }
   if (
      m_computeLog[coord].request().subshareLabel(0).label().version().value()
      != (cm.message().shareLabel().version().value()-1)
      )
   {
      return false;
   }
   m_computeLog[ coord ].addResponse( cm );
   return true;
}

void
SecretManagement::clearEstablishMsgs()
{
   for ( unsigned int i = 0 ; i < NumServers ; ++i )
   {
      for ( unsigned int j = 0 ; j < NumShares ; ++j )
      {
         m_establishLog[i][j].clear();
      }
   }
}

void
SecretManagement::clearEstablishMsgs( unsigned int establisher )
{
   for ( unsigned int i = 0 ; i < NumShares ; ++i )
   {
      m_establishLog[establisher][i].clear();
   }
}

const InitRecord&
SecretManagement::initRecord( unsigned int i ) const
{
   if ( i >= NumServers )
   {
      throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
   }
   return m_initLog[i];
}

const EstablishRecord&
SecretManagement::establishRecord( unsigned int establisher,
                                   unsigned int shareNum,
                                   const LabelType& label ) const
{
   if ( establisher >= NumServers )
   {
      throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
   }
   if ( shareNum >= NumShares )
   {
      throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
   }
   return m_establishLog[establisher][shareNum][label];
}

const ComputeRecord&
SecretManagement::computeRecord( unsigned int i ) const
{
   if ( i >= NumServers )
   {
      throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
   }
   return m_computeLog[i];
}

const SignedFinishedMsg&
SecretManagement::finishedMsg( unsigned int i ) const
{
   if ( i >= NumServers )
   {
      throw CODEX_Exceptions::IllegalIndexException( __FILE__ , __LINE__ );
   }
   return m_finishedLog[i];
}

void
SecretManagement::setEpochTime()
{
   struct timeval tv;
   int gtod = gettimeofday( &tv, 0 );
   if ( 0 != gtod )
   {
      CODEX_Exceptions::GetTimeOfDayException( __FILE__ , __LINE__ , errno );
   }
   m_epochTime = tv.tv_sec;
}

void
SecretManagement::setRunTime()
{
   struct timeval tv;
   int gtod = gettimeofday( &tv, 0 );
   if ( 0 != gtod )
   {
      CODEX_Exceptions::GetTimeOfDayException( __FILE__ , __LINE__ , errno );
   }
   m_runTime = tv.tv_sec;
}

unsigned long
SecretManagement::elapsed( unsigned long current ) const
{
   if ( m_epochTime > current )
   {
      return 0;
   }
   return ( current - m_epochTime );
}

void
SecretManagement::beginRun()
{
   // Are we already in a run?  If so, we do *not* start a new one.
   if ( m_runTime >= m_epochTime )
   {
      return;
   }

   cout << "starting a run" << endl;

#ifdef TIMING
   APSSTimer[m_num].start();
   InitTimer[m_num].start();
   ActiveTimer.start();
#endif

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

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

   unsigned int version = m_version + 1;
   unsigned int coordinator = serverState->hostNum();
   const LabelType& label = serverState->defaultLabel( m_num );
   CODEX_ASN1::Integer versionInt( version );
   CODEX_ASN1::Integer coordInt( coordinator );
   InitMsg request( version, coordinator, label );

   BIGNUM * digest = 0;
   CODEX_Ciphers::RSASignature* signature = 0;
   try
   {
      const CODEX_Ciphers::HashFunction& hashFunc = serverState->hashFunc();
      digest = request.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;
   }
   SignedInitMsg signedRequest( request, *signature );
   delete signature;

   // Send the signed request
   CODEX_Quorum::Message m;

   // Fill message headers.
   m.fill( coordinator | CODEX_Server::ServerState::OutgoingMask );
   m.fill( serverState->newSequenceNumber(), CODEX_Server::ServerState::nMID );
   m.fill( stateInfo->domain() );
   m.fill( kInitMsg | 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 callback
   InitCallback* cb = new InitCallback( version, label );

   // Mark the beginning of the run
   setRunTime();
   stateInfo->broadcast( m, cb );
#ifdef TIMING
   ActiveTimer.stop();
#endif
}

void
SecretManagement::sendFinished( unsigned int server ) const
{
   for ( unsigned int i = 0 ; i < NumServers ; ++i )
   {
      if ( m_finishedLog[i].initialized() )
      {
         sendFinished( i, server );
         return;
      }
   }
   // throw an exception if we get here?
}

void
SecretManagement::sendFinished( unsigned int coord, unsigned int server ) const
{
   const SignedFinishedMsg& fm = m_finishedLog[coord];
   if ( ! fm.initialized() )
   {
      return;
   }

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

   CODEX_Quorum::Message m;

   // Set the server ID, with "outgoing" mask.
   unsigned char self = serverState->hostNum();
   m.fill( self | CODEX_Server::ServerState::OutgoingMask );

   // This sequence number isn't actually used for anything.
   const unsigned char* seqNum = serverState->newSequenceNumber();
   m.fill( seqNum, CODEX_Server::ServerState::nMID );

   // Set the domain information.
   m.fill( stateInfo->domain() );
   m.fill( kFinishedMsg | SignatureMask );

   // Marshal the message.
   int length = fm.marshal(0);
   unsigned char* buffer = new unsigned char[length];
   unsigned char* pBuffer = buffer;
   fm.marshal(&pBuffer);
   m.fill( buffer, length );
   delete [] buffer;

   stateInfo->sendTo( server, m );
}

---