VerifiableBlindKeyMsg.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: VerifiableBlindKeyMsg.h,v 1.5 2005/01/21 19:44:17 mmarsh Exp $
//
// $Log: VerifiableBlindKeyMsg.h,v $
// Revision 1.5  2005/01/21 19:44:17  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.4  2004/05/19 15:56:53  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/04 22:31:49  mmarsh
// *** empty log message ***
//
//

#ifndef __CODEX_KEYSERVICE_VERIFIABLEBLINDKEYMSG_H__
#define __CODEX_KEYSERVICE_VERIFIABLEBLINDKEYMSG_H__

#include "CODEX_Client/Message.h"
#include "CODEX_ThresholdCrypto/DLProof.h"
#include "CODEX_Server/ServerState.h"

namespace CODEX_KeyService
{
   class VerifiableBlindKeyMsg : public CODEX_Client::BlindKeyMsg
   {
      public :
         static const unsigned int
         NumProofs = CODEX_Server::ServerState::ShareType::NumShares;

         typedef CODEX_Server::ServerState::ShareType::ValueType  ValueType;

         typedef CODEX_Server::ServerState::LSType::LabelType  LabelType;

         typedef CODEX_ThresholdCrypto::DLProof  DLProof;

         typedef CODEX_Client::CipherTextType  CipherTextType;

         typedef CODEX_Client::BlindCipherTextType  BlindCipherTextType;

         typedef CODEX_Client::BlindPlainTextType  BlindPlainTextType;

         VerifiableBlindKeyMsg();

         VerifiableBlindKeyMsg(
            const CODEX_ASN1::OctetString& name,
            const BlindPlainTextType& blindedKey,
            const CODEX_Ciphers::RSASignature& requestSignature,
#ifdef ELGAMAL
            const LabelType& label,
            const CODEX_Server::ServerState::ShareSetType& partials,
            const vector< DLProof >& proofs,
#endif /* ELGAMAL */
            const BlindCipherTextType& blindCipher );

         VerifiableBlindKeyMsg( const VerifiableBlindKeyMsg& aBKM );

         virtual ~VerifiableBlindKeyMsg() {}

         void operator=( const VerifiableBlindKeyMsg& aBKM );

         CODEX_Client::BlindKeyMsg upcast() const
         {
            return CODEX_Client::BlindKeyMsg(*this);
         }

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

         const BlindCipherTextType& blindCipher() const
         {
            return m_blindCipher;
         }

#ifdef ELGAMAL

         const LabelType& label() const { return m_label; }

         const ValueType& partial( unsigned int i ) const
         {
            if ( i >= NumProofs )
            {
               throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                              __LINE__ );
            }
            return m_partials[i];
         }

         const DLProof& proof( unsigned int i ) const
         {
            if ( i >= NumProofs )
            {
               throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                              __LINE__ );
            }
            return m_proofs[i];
         }
#endif /* ELGAMAL */

      private :
#ifdef ELGAMAL
         LabelType            m_label;
         ValueType            m_partials[NumProofs];
         DLProof              m_proofs[NumProofs];
#endif /* ELGAMAL */
         BlindCipherTextType  m_blindCipher;
   };

}

#endif /* __CODEX_KEYSERVICE_VERIFIABLEBLINDKEYMSG_H__ */

---