ClientWriteCallback.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: ClientWriteCallback.cc,v 1.4 2004/05/19 15:56:51 mmarsh Exp $
//
// $Log: ClientWriteCallback.cc,v $
// Revision 1.4  2004/05/19 15:56:51  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/04 22:15:00  mmarsh
// General code cleanup and reorganization.  The signed ElGamal public key
// was moved to CODEX_Server, decoupling that package from CODEX_Client.
// Since CODEX_Server no longer knows about the cryptosystem used by
// the client, switching between cryptosystems is handled locally by
// CODEX_KeyService.
//
//

#include "ClientWriteCallback.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 "SupportedClientResponse.h"
#include "CODEX_Server/SignRequestEvent.h"
#include "ClientDelegation.h"
#include "VerifyWriteCallback.h"

#include "timing.h"

using namespace CODEX_KeyService;

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

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

bool
ClientWriteCallback::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::kApproveClientRequest != 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() )
      {
         typedef CODEX_Client::KeyStoredMsg RespType;
         typedef CODEX_Client::SignedWriteKeyMsg ReqType;
         RespType ksMsg( m_request.message().name(),
                         m_request.signature() );
         const CODEX_Server::ServerState::LSType::LabelType& label =
            serverState->defaultSignatureLabel();

         SupportedClientResponse< RespType, ReqType > resp( ksMsg,
                                                            m_request,
                                                            m_evidence,
                                                            label );
         unsigned char* seqNum = serverState->newSequenceNumber();
         stateInfo->registerSequenceNumber( seqNum, m_clientAct );
         VerifyWriteCallback* cb = new VerifyWriteCallback( m_deadPile,
                                                            m_queue,
                                                            m_destination,
                                                            m_clientAct,
                                                            ksMsg,
                                                            seqNum );

         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( CODEX_Client::kKeyStoredMsg );
         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;
   }
}

---