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

#include "ClientCreateCallback.h"
#include "CODEX_Events/Event.h"
#include "CODEX_Client/Message.h"
#include "SupportedClientResponse.h"
#include "CODEX_Server/SignRequestEvent.h"
#include "ClientDelegation.h"
#include "SignCreateCallback.h"

#include "CODEX_Server/ServerExceptions.h"
#include "Exceptions.h"

#include "timing.h"

using namespace CODEX_KeyService;

ClientCreateCallback::ClientCreateCallback(
   CODEX_Events::DeadPileType& deadPile,
   CODEX_Events::QType& eventQueue,
   CODEX_Server::SignRequestHandler* destination,
   ClientResponseHandler* clientAct,
   const CODEX_Client::SignedCreateKeyMsg& req,
   const unsigned char* seqNum ) :
   ResponseCallback( seqNum ),
   CODEX_Events::Activity( deadPile, eventQueue ),
   m_destination( destination ),
   m_clientAct( clientAct ),
   m_request( req ),
   m_complete( false )
{
   if ( ! m_request.initialized() )
   {
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   m_digest =
      m_request.digest( CODEX_Server::ServerState::instance()->hashFunc() );
}

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

bool
ClientCreateCallback::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;
   }

   // Sanity check -- is there now a binding for this name from a
   // different request?  This would indicate that a supported response
   // was received from another delegate.
   const KeyInfo* keyInfo =
      stateInfo->getKeyInfo( m_request.message().name().value() );
   if ( NULL == keyInfo )
   {
#ifdef TIMING
      ActiveTimer.stop();
#endif
      throw KeyNotFoundException( __FILE__ , __LINE__ );
   }
   if ( ! m_request.signature().initialized() )
   {
#ifdef TIMING
      ActiveTimer.stop();
#endif
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   if ( ! ( keyInfo->binding().initialized() &&
            keyInfo->binding().request().initialized() &&
            keyInfo->binding().request().signature().initialized() ) )
   {
#ifdef TIMING
      ActiveTimer.stop();
#endif
      throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
   }
   if ( 0 != BN_cmp( m_request.signature().value(),
                     keyInfo->binding().request().signature().value() ) )
   {
      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::BoundNameMsg RespType;
         typedef CODEX_Client::SignedCreateKeyMsg ReqType;
         RespType bnMsg( m_request.message().name(),
                         m_request );
         const CODEX_Server::ServerState::LSType::LabelType& label =
            serverState->defaultSignatureLabel();

         SupportedClientResponse< RespType, ReqType > resp( bnMsg,
                                                            m_request,
                                                            m_evidence,
                                                            label );
         unsigned char* seqNum = serverState->newSequenceNumber();
         stateInfo->registerSequenceNumber( seqNum, m_clientAct );
         SignCreateCallback* cb = new SignCreateCallback( 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( CODEX_Client::kBoundNameMsg );
         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;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      // We'll never be able to make progress, so re-throw.
      throw;
   }
   catch ( ... )
   {
      if ( NULL != servSig ) delete servSig;
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return false;
   }
}

---