---

VerifyWriteCallback.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: VerifyWriteCallback.cc,v 1.4 2004/05/19 15:56:54 mmarsh Exp $
//
// $Log: VerifyWriteCallback.cc,v $
// Revision 1.4  2004/05/19 15:56:54  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/04 22:31:49  mmarsh
// *** empty log message ***
//
//

#include "VerifyWriteCallback.h"
#include "CODEX_Events/Event.h"
#include "CODEX_Server/ServerExceptions.h"
#include "CODEX_Server/ServerState.h"
#include "StateInfo.h"
#include "CODEX_Client/Message.h"
#include "SupportedKeyStoredMsg.h"
#include "CODEX_Server/SignRequestEvent.h"
#include "ClientDelegation.h"
#include "SignWriteCallback.h"

#include "timing.h"

using namespace CODEX_KeyService;

VerifyWriteCallback::VerifyWriteCallback(
   CODEX_Events::DeadPileType& deadPile,
   CODEX_Events::QType& eventQueue,
   CODEX_Server::SignRequestHandler* destination,
   ClientResponseHandler* clientAct,
   const CODEX_Client::KeyStoredMsg& resp,
   const unsigned char* seqNum ) :
   ResponseCallback( seqNum ),
   CODEX_Events::Activity( deadPile, eventQueue ),
   m_destination( destination ),
   m_clientAct( clientAct ),
   m_response( resp ),
   m_complete( false )
{
   m_digest =
      m_response.digest( CODEX_Server::ServerState::instance()->hashFunc() );
}

VerifyWriteCallback::~VerifyWriteCallback()
{
   if ( NULL != m_digest ) BN_free( m_digest );
}

bool
VerifyWriteCallback::operator()( unsigned int server,
                                 CODEX_Quorum::Message* msg )
{
   if ( NULL == msg )
   {
      return false;
   }

   if ( m_complete )
   {
      delete msg;
      return true;
   }

#ifdef TIMING
   ActiveTimer.start();
#endif

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

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

   // Sanity check -- is the client still connected?
   if ( NULL == stateInfo->getActFromSeqNum( seqNum() ) )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }

   unsigned char* data = (unsigned char*)msg->buffer();
   int length = msg->length();

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

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

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

   // Check that it unmarshalls.
   CODEX_Ciphers::RSASignature signature;
   if ( NULL == signature.unmarshal( NULL, &data, length ) )
   {
      delete msg;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }
   delete msg;

   CODEX_Server::ServerSignature* servSig = NULL;
   try
   {
      // Verify the signature.
      if ( ! serverState->publicKey(server).verifySignature(
         signature, m_digest ) )
      {
         throw CODEX_Server::SignatureVerificationFailedException( __FILE__ ,
                                                                   __LINE__ );
      }

      // Create a new ServerSignature.
      servSig = new CODEX_Server::ServerSignature( server, signature );

      // Add to the evidence set.
      m_evidence.append( servSig );

      // See if we have enough responses to create the threshold signature
      // request.
      CODEX_Quorum::QuorumSystem* qs = serverState->quorumSystem();
      if ( NULL == qs )
      {
         throw CODEX_Server::NoQuorumSystemException( __FILE__ , __LINE__ );
      }
      if ( m_evidence.size() >= qs->quorumSize() )
      {
         const CODEX_Server::ServerState::LSType::LabelType& label =
            serverState->defaultSignatureLabel();

         SupportedKeyStoredMsg resp( m_response, m_evidence, label );
         unsigned char* seqNum = serverState->newSequenceNumber();
         stateInfo->registerSequenceNumber( seqNum, m_clientAct );
         SignWriteCallback* cb = new SignWriteCallback( m_deadPile,
                                                        m_queue,
                                                        m_clientAct,
                                                        resp,
                                                        seqNum,
                                                        m_destination );

         CODEX_Quorum::Message request;
         unsigned char self = serverState->hostNum();
         request.fill( self | CODEX_Server::ServerState::OutgoingMask );
         request.fill( seqNum, CODEX_Server::ServerState::nMID );
         request.fill( stateInfo->delegationDomain() );
         request.fill( ClientDelegation::kRequestSignature );
         request.fill( ClientDelegation::kSupportedKeyStoredMsg );
         int reqLen = resp.marshal(0);
         unsigned char* reqBuff = new unsigned char[reqLen];
         unsigned char* pReqBuff = reqBuff;
         resp.marshal(&pReqBuff);
         request.fill( reqBuff, reqLen );
         delete [] reqBuff;

         CODEX_Server::SignRequestEvent* event =
            new CODEX_Server::SignRequestEvent(this,
                                               m_destination,
                                               request,
                                               cb);
         sendEvent( event, 0 ); // no need to acknowledge
         m_complete = true;
      }
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }
   // This is a particularly bad error
   catch ( CODEX_Server::NoQuorumSystemException& e )
   {
      if ( NULL != servSig ) delete servSig;
      // We'll never be able to make progress, so re-throw.
#ifdef TIMING
      ActiveTimer.stop();
#endif
      throw;
   }
   catch ( ... )
   {
      if ( NULL != servSig ) delete servSig;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }
}

---