ServerState.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: ServerState.h,v 1.5 2005/01/21 19:44:18 mmarsh Exp $
//
// $Log: ServerState.h,v $
// Revision 1.5  2005/01/21 19:44:18  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.4  2004/05/19 15:56:59  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/04 22:19:55  mmarsh
// The ElGamal public key is handled here, not in CODEX_Client.  All
// black magic relating to switching between cryptosystems used for
// key service decryption has been moved to CODEX_KeyService, where
// it belongs.  This package is no longer dependent on CODEX_Client.
//
//

#ifndef __CODEX_SERVER_SERVERSTATE_H__
#define __CODEX_SERVER_SERVERSTATE_H__

#include <map>
#include <list>

#include <openssl/conf.h>

#include "CODEX_Quorum/StaticByzantineQuorumSystem.h"
#include "CODEX_Quorum/SocketBuilder.h"
#include "CODEX_Quorum/LoopbackSocket.h"
#include "CODEX_SSL/SSLSocket.h"

#include "CODEX_ASN1/Base.h"
#include "CODEX_ASN1/OctetString.h"
#include "CODEX_ASN1/Certificate.h"

#include "CODEX_Events/Activity.h"
#include "CODEX_Quorum/LocalServer.h"

#include "CODEX_Ciphers/SHA1HashFunction.h"
#include "CODEX_Ciphers/RSA.h"
#include "CODEX_Ciphers/ElGamal.h"

#include "CODEX_ThresholdCrypto/CombinatoricThresholdRSA.h"
#include "CODEX_ThresholdCrypto/CombinatoricThresholdElGamal.h"
#include "CODEX_ThresholdCrypto/CombinatoricThresholdVarRSA.h"
#include "CODEX_VSS/Combinatoric.h"
#include "CODEX_VSS/CombinatoricFeldman.h"
#include "ShareCallback.h"

#include "AugmentedEGPublicKey.h"

namespace CODEX_Server
{
   class ShareLabelChallenge;

   class ServerState
   {
         //==========================================================
         // CONFIGURATION
         //==========================================================

      public :
         static const unsigned int  nServers = 4;
         static const unsigned int  nFaults = 1;

         static const size_t  nSID = 1;
         static const size_t  nMID = 8;

         static const unsigned char  OutgoingMask = 0x80;

         static const unsigned int  RSAKeyNum = 0;

         static const unsigned int  EGKeyNum = 1;

      private :
         typedef
         CODEX_Quorum::StaticByzantineQuorumSystem< nServers, nFaults >
         QSType;

         typedef CODEX_Ciphers::SHA1HashFunction HashType;

         typedef CODEX_Quorum::SocketBuilder ClientSocketBuilderType;
         typedef CODEX_SSL::SSLSocketBuilder ServerSocketBuilderType;

      public :

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

         typedef list< CODEX_Quorum::LocalServer* > ServerList;

         typedef CODEX_VSS::Combinatoric< nServers , nFaults+1 >  ShareType;

         typedef CODEX_VSS::ModExpFunctional  OneWay;

         typedef CODEX_VSS::LabeledShare< ShareType , OneWay >  LSType;

         typedef CODEX_VSS::SecretWitness< ShareType , OneWay >  WitnessType;

         typedef CODEX_VSS::ShareSet< ShareType >  ShareSetType;

         typedef CODEX_ThresholdCrypto::ThresholdRSACrypto< ShareType >
         ThresholdRSAType;

         typedef CODEX_ThresholdCrypto::ThresholdElGamalCrypto< ShareType >
         ThresholdElGamalType;

         typedef CODEX_ThresholdCrypto::ThresholdVarRSACrypto< ShareType >
         ThresholdVarRSAType;

         typedef ThresholdRSAType  ThresholdSignatureType;

         typedef ShareCallbackBase< ShareType , OneWay >  ShareCallback;

         typedef vector< ShareLabelChallenge* >  ChallengeVector;

         typedef map< const unsigned char* ,
            ChallengeVector ,
            CODEX_Quorum::memless< CODEX_Server::ServerState::nMID > >
         ChallengeMap;

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

         static void destroy();

         const CODEX_Ciphers::HashFunction& hashFunc() const
         {
            return m_hashFunc;
         }


         //==========================================================
         // SERVER CONFIGURATION
         //==========================================================

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


         //==========================================================
         // LOCAL SERVERS
         //==========================================================

         void addServer( CODEX_Quorum::LocalServer* server );

         void removeServer( CODEX_Quorum::LocalServer* server );

         ServerList::const_iterator serverListBegin()
         {
            return m_serverList.begin();
         }

         ServerList::const_iterator serverListEnd()
         {
            return m_serverList.end();
         }

         int serverListSize() { return m_serverList.size(); }

         void cleanServer( CODEX_Quorum::LocalServer* server );

         void garbageCollectServers();


         //==========================================================
         // SERVER KEYS
         //==========================================================

         const CODEX_ASN1::Certificate& serverCert() const
         {
            return m_serverCerts[m_hostNum];
         }

         const CODEX_ASN1::Certificate& serverCert( unsigned int i ) const;

         const CODEX_Ciphers::RSAPublicKey& publicKey();

         const CODEX_Ciphers::RSAPublicKey& publicKey( unsigned int i );

         const CODEX_Ciphers::RSAPrivateKey& privateKey() const
         {
            return m_privateKey;
         }


         //==========================================================
         // CERTIFICATION AUTHORITY
         //==========================================================

         const CODEX_ASN1::Certificate& caCert() const { return m_caCert; }

         const EVP_PKEY* caKey();


         //==========================================================
         // SERVICE KEYS
         //==========================================================

         const CODEX_Ciphers::RSAPublicKey& serviceKey();

         const CODEX_Ciphers::ElGamalPublicKey& publicEGKey() const
         {
            return m_signedEGKey.key().key();
         }

         const CODEX_ASN1::BigNumber& h() const {
            return m_signedEGKey.key().h();
         }

         const SignedAugmentedEGPublicKey& signedEGKey() const
         {
            return m_signedEGKey;
         }


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

         const LSType::LabelType& defaultRSALabel() const;

         void setRSAShareCallback( const ShareCallback* cb )
         {
            // Setting the callback should clear the default shares.
            if ( m_rsaShares.initialized() )
            {
               m_rsaShares = LSType();
            }
            m_rsaShareCallback = cb;
         }

         void setRSADefaultLabel( const LSType::LabelType* label )
         {
            m_rsaDefaultLabel = label;
         }

         const ThresholdRSAType& thresholdRSA() const
         {
            return m_thresholdRSA;
         }

         const ThresholdVarRSAType& thresholdVarRSA() const
         {
            return m_thresholdVarRSA;
         }

         const WitnessType& rsaWitness() const
         {
            return m_rsaWitness;
         }


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

         const LSType::LabelType& defaultEGLabel() const;

         void setEGShareCallback( const ShareCallback* cb )
         {
            // Setting the callback should clear the default shares.
            if ( m_elgamalShares.initialized() )
            {
               m_elgamalShares = LSType();
            }
            m_egShareCallback = cb;
         }

         void setEGDefaultLabel( const LSType::LabelType* label )
         {
            m_egDefaultLabel = label;
         }

         const ThresholdElGamalType& thresholdEG() const
         {
            return m_thresholdEG;
         }

         const WitnessType& egWitness() const
         {
            return m_egWitness;
         }


         const LSType::LabelType& defaultLabel( unsigned int num ) const;

         void setShareCallback( unsigned int num, const ShareCallback* cb );

         void setDefaultLabel( const LSType::LabelType* label );


         const LSType& signatureShares( const LSType::LabelType& label,
                                        unsigned int server ) const
         {
            return rsaShares( label, server );
         }

         const LSType::LabelType& defaultSignatureLabel() const
         {
            return defaultRSALabel();
         }

         const ThresholdSignatureType& thresholdSignature() const;

         void rationalizeSharings( const vector< ShareType* >& sharings,
                                   ShareSetType& result ) const;

         BIGNUM* thresholdOperation( const vector< ShareType* >& sharings,
                                     const BIGNUM * operand ) const;


         //==========================================================
         // SEQUENCE NUMBERS
         //==========================================================

         unsigned char* newSequenceNumber();

         void addChallenge( const unsigned char* request,
                            ShareLabelChallenge* challenge );

         const ServerState::ChallengeMap& challengeMap()
         {
            return m_challengeMap;
         }

         void removeChallenge( const unsigned char* request );


         //==========================================================
         // QUORUM SYSTEM MANAGEMENT
         //==========================================================

         CODEX_Quorum::QuorumSystem* quorumSystem() const
         {
            return m_quorumSystem;
         }

         long hostNum() const { return m_hostNum; }

         const string& hostName( long i );

         long serverPort() const { return m_serverPorts[ m_hostNum ]; }

         long serverPort( long i );
         
         bool addQuorumServer(
            int host,
            CODEX_Quorum::AsynchronousRemoteServer* server );

         const CODEX_Quorum::RemoteServer* getQuorumServer( int host );

         bool haveQuorumServer( int host ) const;


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

         const CODEX_Quorum::SocketBuilder& clientSocketBuilder() const
         {
            return m_clientSocketBuilder;
         }

         const CODEX_Quorum::SocketBuilder& serverOutSocketBuilder() const
         {
            //return m_clientSocketBuilder;
            return *m_serverOutSocketBuilder;
         }

         const CODEX_Quorum::SocketBuilder& serverInSocketBuilder() const
         {
            //return m_clientSocketBuilder;
            return *m_serverInSocketBuilder;
         }


      protected :
         ServerState();

         virtual ~ServerState();

         static ServerState* m_instance;

         void readPrivateKey( const char* fname, const char* passwd=NULL );

         void readCACert( const char* fname );

         void readServiceCert( const char* fname );

         void readPublicEGKey( const char* fname );

         void readRSAShares( const char* fname );

         void readElGamalShares( const char* fname );

      private :

         QSType*  m_quorumSystem;

         ClientSocketBuilderType              m_clientSocketBuilder;
         ServerSocketBuilderType*             m_serverOutSocketBuilder;
         ServerSocketBuilderType*             m_serverInSocketBuilder;
         CODEX_Quorum::LoopbackSocketBuilder  m_loopbackSocketBuilder;

         unsigned char  m_seqNum[nMID];
         ChallengeMap   m_challengeMap;

         long                     m_hostNum;
         string                   m_hostnames[nServers];
         long                     m_serverPorts[nServers];
         CODEX_ASN1::Certificate  m_serverCerts[nServers];

         HashType  m_hashFunc;

         // Server key information.
         CODEX_Ciphers::RSAPublicKey   m_publicKeys[nServers];
         RSA*                          m_rsa;
         CODEX_Ciphers::RSAPrivateKey  m_privateKey;
         LSType                        m_rsaShares;
         ThresholdRSAType              m_thresholdRSA;
         ThresholdVarRSAType           m_thresholdVarRSA;
         ShareCallback*                m_defaultRSAShareCB;
         const ShareCallback*          m_rsaShareCallback;
         const LSType::LabelType*      m_rsaDefaultLabel;
         LSType::LabelType             m_rsaInitialLabel;
         WitnessType                   m_rsaWitness;
         LSType                        m_elgamalShares;
         ThresholdElGamalType          m_thresholdEG;
         ShareCallback*                m_defaultEGShareCB;
         const ShareCallback*          m_egShareCallback;
         const LSType::LabelType*      m_egDefaultLabel;
         LSType::LabelType             m_egInitialLabel;
         WitnessType                   m_egWitness;

         ServerList  m_serverList;
         ServerList  m_deadServerList;

         CODEX_ASN1::Certificate  m_caCert;
         EVP_PKEY *               m_caKey;

         CODEX_ASN1::Certificate      m_serviceCert;
         CODEX_Ciphers::RSAPublicKey  m_serviceKey;

         SignedAugmentedEGPublicKey  m_signedEGKey;
   };

}

#endif /* __CODEX_SERVER_SERVERSTATE_H__ */

---