---

StateInfo.h

/*
 * 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.h,v 1.3 2004/05/19 15:56:53 mmarsh Exp $
//
// $Log: StateInfo.h,v $
// Revision 1.3  2004/05/19 15:56:53  mmarsh
// *** empty log message ***
//
// Revision 1.2  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.
//
//

#ifndef __CODEX_KEYSERVICE_STATEINFO_H__
#define __CODEX_KEYSERVICE_STATEINFO_H__

#include <map>
#include <list>

#include "CODEX_ASN1/Base.h"
#include "CODEX_ASN1/OctetString.h"
#include "CODEX_Events/Activity.h"
#include "CODEX_Client/Message.h"
#include "CODEX_Server/ServerState.h"

namespace CODEX_KeyService
{
   class ClientActivity;

   class KeyInfo : public CODEX_ASN1::Base
   {
      public :
         KeyInfo();
         KeyInfo( const CODEX_Client::BoundNameMsg& binding );
         KeyInfo( const CODEX_Client::BoundNameMsg& binding,
                  const CODEX_Ciphers::RSASignature& signature );
         KeyInfo( const CODEX_Client::SignedBoundNameMsg& binding );
         KeyInfo( const CODEX_Client::BoundNameMsg& binding,
                  const CODEX_Ciphers::RSASignature& signature,
                  const CODEX_Client::RequestCipherTextType& keyValue );
         KeyInfo( const CODEX_Client::SignedBoundNameMsg& binding,
                  const CODEX_Client::RequestCipherTextType& keyValue );
         KeyInfo( const KeyInfo& aKI );
         virtual ~KeyInfo();

         void operator=( const KeyInfo& aKI );

         void setBinding( const CODEX_Client::BoundNameMsg& binding );

         void setSignature( const CODEX_Ciphers::RSASignature& signature );

         void setKeyValue(
            const CODEX_Client::RequestCipherTextType& keyValue );

         void setVerified() { m_verified = true; }

         const CODEX_Client::BoundNameMsg& binding() const
         {
            return m_binding;
         }

         const CODEX_Ciphers::RSASignature& signature() const
         {
            return m_signature;
         }

         const CODEX_Client::RequestCipherTextType& keyValue() const
         {
            return m_keyValue;
         }

         bool verified() const { return m_verified; }

         int marshal( unsigned char ** pp ) const;
         void* unmarshal( void* bogus, unsigned char ** pp, long length );

      private :
         CODEX_Client::BoundNameMsg           m_binding;
         CODEX_Ciphers::RSASignature          m_signature;
         CODEX_Client::RequestCipherTextType  m_keyValue;
         bool                                 m_verified;
   };


   template< class CT , class ST > class CryptoSystem;

   template< class ST >
   class CryptoSystem< CODEX_Ciphers::RSACipherText , ST >
   {
      public :
         typedef CODEX_ThresholdCrypto::ThresholdRSACrypto< ST > ThresholdType;
   };

   template< class ST >
   class CryptoSystem< CODEX_Ciphers::ElGamalCipherText , ST >
   {
      public :
         typedef CODEX_ThresholdCrypto::ThresholdElGamalCrypto< ST >
         ThresholdType;
   };

   template< class ST >
   class CryptoSystem< CODEX_Ciphers::VarRSACipherText , ST >
   {
      public :
         typedef CODEX_ThresholdCrypto::ThresholdVarRSACrypto< ST >
         ThresholdType;
   };


   class StateInfo
   {
         //==========================================================
         // CONFIGURATION
         //==========================================================

      public :

         enum SynchronyState
         {
            kFailed,
            kWrote,
            kRead
         };


         //==========================================================
         // TYPEDEFs
         //==========================================================

         typedef map< CODEX_Events::Activity* , ClientActivity* > ClientMap;

         typedef map< const unsigned char* ,
            CODEX_Events::Activity* ,
            CODEX_Quorum::memless< CODEX_Server::ServerState::nMID > >
         RequestMap;

         typedef map< CODEX_ASN1::ustring , KeyInfo* > KeyMap;

         typedef CODEX_Server::ServerState::ShareType  ShareType;

         typedef CODEX_Server::ServerState::LSType  LSType;

         typedef CryptoSystem< CODEX_Client::CipherTextType, ShareType >
         CryptoSystemType;

         typedef
         CryptoSystemType::ThresholdType  ThresholdDecryptionType;


         //==========================================================
         // UNIQUE INSTANCE
         //==========================================================
         
         static StateInfo* instance();

         static void destroy();


         //==========================================================
         // KEY SERVICE CONFIGURATION
         //==========================================================

         void configure( const CONF* conf,
                         const char* sec,
                         const string& fname );

         void setMessageDomain( unsigned char d ) {m_messageDomain = d;}

         void setDelegationDomain( unsigned char d ) {m_delegationDomain = d;}

         unsigned char messageDomain() { return m_messageDomain; }

         unsigned char delegationDomain() { return m_delegationDomain; }


         //==========================================================
         // CLIENT MANAGEMENT
         //==========================================================

         long clientPort() const { return m_clientPort; }

         bool addClient( ClientActivity* clientAct );

         ClientActivity*
         getClient( CODEX_Events::Activity* clientAct ) const;

         bool removeClient( CODEX_Events::Activity* clientAct );

         bool registerSequenceNumber( const unsigned char* seqNum,
                                      CODEX_Events::Activity* clientAct );

         CODEX_Events::Activity* getActFromSeqNum(
            const unsigned char* seqNum ) const;

         bool removeSequenceNumber( const unsigned char* seqNum );


         //==========================================================
         // STORED KEYS
         //==========================================================

         bool addKeyName( const CODEX_ASN1::ustring& name,
                          const CODEX_Client::SignedBoundNameMsg& binding );

         bool addKeyName( const CODEX_ASN1::ustring& name,
                          const CODEX_Client::BoundNameMsg& binding );

         const KeyInfo* getKeyInfo( const CODEX_ASN1::ustring& name ) const;

         bool addKeySignature( const CODEX_ASN1::ustring& name,
                               const CODEX_Ciphers::RSASignature& signature );

         bool replaceKeyBinding(
            const CODEX_ASN1::ustring& name,
            const CODEX_Client::SignedBoundNameMsg& binding );

         bool addKeyValue(
            const CODEX_ASN1::ustring& name,
            const CODEX_Client::RequestCipherTextType& keyValue );

         bool verifyKeyValue( const CODEX_ASN1::ustring& name );


         //==========================================================
         // MISCELLANEOUS
         //==========================================================

         const LSType& decryptionShares( const LSType::LabelType& label,
                                         unsigned int server ) const;

         const LSType::LabelType& defaultDecryptionLabel() const;

         const ThresholdDecryptionType& thresholdDecryption() const;

         template< class T > const LSType& shareTemplate(
            const LSType::LabelType& label,
            unsigned int server) const;

         template< class T > const LSType::LabelType& labelTemplate() const;

         template< class T > const T& thresholdTemplate() const;

         unsigned int ppkSecurityParam() const { return m_ppkSecurityParam; }

         SynchronyState synchronize(const char* fname, bool force_read=false);


      protected :
         StateInfo();

         virtual ~StateInfo();

         static StateInfo* m_instance;

      private :

         long                     m_clientPort;

         ClientMap   m_clientMap;
         RequestMap  m_requestMap;
         KeyMap      m_keyMap; // to stable storage

         unsigned int  m_ppkSecurityParam;

         unsigned char  m_messageDomain;
         unsigned char  m_delegationDomain;
   };

   template<>
   const StateInfo::LSType&
   StateInfo::shareTemplate< CODEX_Ciphers::RSACipherText >(
      const LSType::LabelType& label,
      unsigned int server) const;

   template<>
   const StateInfo::LSType&
   StateInfo::shareTemplate< CODEX_Ciphers::ElGamalCipherText >(
      const LSType::LabelType& label,
      unsigned int server) const;

   template<>
   const StateInfo::LSType&
   StateInfo::shareTemplate< CODEX_Ciphers::VarRSACipherText >(
      const LSType::LabelType& label,
      unsigned int server) const;


   template<>
   const StateInfo::LSType::LabelType&
   StateInfo::labelTemplate< CODEX_Ciphers::RSACipherText >() const;

   template<>
   const StateInfo::LSType::LabelType&
   StateInfo::labelTemplate< CODEX_Ciphers::ElGamalCipherText >() const;

   template<>
   const StateInfo::LSType::LabelType&
   StateInfo::labelTemplate< CODEX_Ciphers::VarRSACipherText >() const;


   template<>
   const CODEX_Server::ServerState::ThresholdRSAType&
   StateInfo::thresholdTemplate< CODEX_Server::ServerState::ThresholdRSAType >() const;

   template<>
   const CODEX_Server::ServerState::ThresholdElGamalType&
   StateInfo::thresholdTemplate< CODEX_Server::ServerState::ThresholdElGamalType >() const;

   template<>
   const CODEX_Server::ServerState::ThresholdVarRSAType&
   StateInfo::thresholdTemplate< CODEX_Server::ServerState::ThresholdVarRSAType >() const;

}

#endif /* __CODEX_KEYSERVICE_STATEINFO_H__ */

---