CODEX_APSS/Message.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: Message.h,v 1.4 2005/01/21 19:44:15 mmarsh Exp $
//
// $Log: Message.h,v $
// Revision 1.4  2005/01/21 19:44:15  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.3  2004/05/19 15:56:24  mmarsh
// Added copyright and license statements.
//
// Revision 1.2  2003/11/04 22:04:05  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_APSS_MESSAGE_H__
#define __CODEX_APSS_MESSAGE_H__

#include "CODEX_Ciphers/RSA.h"
#include "CODEX_Exceptions/ExceptionBase.h"
#include "Types.h"
#include "CODEX_ASN1/Array.h"

namespace CODEX_APSS
{
   using CODEX_Ciphers::RSASignature;

   class Message : public CODEX_ASN1::Base
   {
      public :
         Message( bool initialized ) :
            Base( initialized )
         {}

         virtual ~Message() {}

         BIGNUM * digest( const CODEX_Ciphers::HashFunction& hf ) const;
   };

   template< class MT, class ST >
   class SignedMessage : public Message
   {
      public :
         SignedMessage() : Message( false ) {}

         SignedMessage( const MT& message, ST signature ) :
            Message( true ),
            m_message( message ),
            m_signature( signature )
         {}

         SignedMessage( const SignedMessage& aMessage ) :
            Message( aMessage.m_initialized ),
            m_message( aMessage.m_message ),
            m_signature( aMessage.m_signature )
         {}

         virtual ~SignedMessage() {}

         void operator=( const SignedMessage& aMessage )
         {
            m_initialized = aMessage.m_initialized;
            m_message     = aMessage.m_message;
            m_signature   = aMessage.m_signature;
         }

         const MT&  message()   const { return m_message; }
         const ST&  signature() const { return m_signature; }

         int marshal( unsigned char ** pp ) const
         {
            int r=0;
            int ret=0;
            unsigned char * p;

            ret += m_message.marshal(0);
            ret += m_signature.marshal(0);
            M_ASN1_I2D_seq_total();
            m_message.marshal(&p);
            m_signature.marshal(&p);
            M_ASN1_I2D_finish();
         }

         void* unmarshal( void* bogus,
                          unsigned char ** pp,
                          long length )
         {
            if ( m_initialized )
            {
               return 0;
            }
            if ( (0 == pp) || (0 == *pp) )
            {
               return 0;
            }
            ASN1_CTX c;
            c.pp = pp;
            c.q = *pp;
            c.error = ERR_R_NESTED_ASN1_ERROR;
            int i;

            M_ASN1_D2I_Init();
            M_ASN1_D2I_start_sequence();
            M_ASN1_D2I_get(i, m_message.unmarshal);
            M_ASN1_D2I_get(i, m_signature.unmarshal);
            if ( !asn1_Finish(&c) )
            {
               return 0;
            }
            *pp=c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return 0;
         }

      private :
         MT  m_message;
         ST  m_signature;
   };

   class InitMsg : public Message
   {
      public :
         InitMsg();

         InitMsg( const CODEX_ASN1::Integer& version,
                  const CODEX_ASN1::Integer& coordinator,
                  const LabelType& label );

         InitMsg( const InitMsg& aOther );

         virtual ~InitMsg() {}

         void operator=( const InitMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; }

         const CODEX_ASN1::Integer& coordinator() const
         {
            return m_coordinator;
         }

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

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

      private :
         CODEX_ASN1::Integer  m_version;
         CODEX_ASN1::Integer  m_coordinator;
         LabelType            m_label;
   };
   typedef SignedMessage< InitMsg, RSASignature >  SignedInitMsg;

   class EstablishMsg : public Message
   {
      public :
         EstablishMsg();

         EstablishMsg( const CODEX_ASN1::Integer& version,
                       const SublabelType& sublabel,
                       const CODEX_ASN1::Integer& establisher,
                       const CODEX_ASN1::Integer& recipient,
                       const ShareType& shares );

         EstablishMsg( const EstablishMsg& aOther );

         virtual ~EstablishMsg() {}

         void operator=( const EstablishMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; }

         const SublabelType& sublabel() const { return m_sublabel; }

         const CODEX_ASN1::Integer& establisher() const
         {
            return m_establisher;
         }

         const CODEX_ASN1::Integer& recipient() const { return m_recipient; }

         const ShareType& shares() const { return m_shares; }

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

      private :
         CODEX_ASN1::Integer  m_version;
         SublabelType         m_sublabel;
         CODEX_ASN1::Integer  m_establisher;
         CODEX_ASN1::Integer  m_recipient;
         ShareType            m_shares;
   };
   typedef SignedMessage< EstablishMsg, RSASignature >  SignedEstablishMsg;

   class EstablishedMsg : public Message
   {
      public :
         EstablishedMsg();

         EstablishedMsg( const EstablishMsg& request );

         EstablishedMsg( const EstablishedMsg& aOther );

         virtual ~EstablishedMsg() {}

         void operator=( const EstablishedMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; }

         const SublabelType& sublabel() const { return m_sublabel; }

         const CODEX_ASN1::Integer& recipient() const { return m_recipient; }

         const CODEX_ASN1::Integer& establisher() const
         {
            return m_establisher;
         }

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

      private :
         CODEX_ASN1::Integer  m_version;
         SublabelType         m_sublabel;
         CODEX_ASN1::Integer  m_recipient;
         CODEX_ASN1::Integer  m_establisher;
   };
   typedef SignedMessage< EstablishedMsg, RSASignature >  SignedEstablishedMsg;
   typedef CODEX_ASN1::Array< SignedEstablishedMsg >      EstablishedArray;

   class ContributeMsg : public Message
   {
      public :
         ContributeMsg();

         ContributeMsg( const CODEX_ASN1::Integer& version,
                        const CODEX_ASN1::Integer& coordinator,
                        const CODEX_ASN1::Integer& contributor,
                        const EstablishedArray& evidence );

         ContributeMsg( const ContributeMsg& aOther );

         virtual ~ContributeMsg() {}

         void operator=( const ContributeMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; };

         const CODEX_ASN1::Integer& coordinator() const
         {
            return m_coordinator;
         }

         const CODEX_ASN1::Integer& contributor() const
         {
            return m_contributor;
         }

         const EstablishedArray& evidence() const { return m_evidence; }

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

      private :
         CODEX_ASN1::Integer   m_version;
         CODEX_ASN1::Integer   m_coordinator;
         CODEX_ASN1::Integer   m_contributor;
         EstablishedArray      m_evidence;
   };
   typedef SignedMessage< ContributeMsg, RSASignature >  SignedContributeMsg;

   class ComputeMsg : public Message
   {
      public :
         const static unsigned int  NumShares = ShareType::NumShares;

         ComputeMsg();

         ComputeMsg( const CODEX_ASN1::Integer& coordinator,
                     const SublabelType subshareLabels[ NumShares ] );

         ComputeMsg( const ComputeMsg& aOther );

         virtual ~ComputeMsg() {}

         void operator=( const ComputeMsg& aOther );

         const CODEX_ASN1::Integer& coordinator() const
         {
            return m_coordinator;
         }

         const SublabelType& subshareLabel( unsigned int i ) const
         {
            if ( i >= NumShares )
            {
               throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                              __LINE__ );
            }
            return m_subshareLabels[ i ];
         }

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

      private :
         CODEX_ASN1::Integer  m_coordinator;
         SublabelType         m_subshareLabels[ NumShares ];
   };
   typedef SignedMessage< ComputeMsg, RSASignature >  SignedComputeMsg;

   class ComputedMsg : public Message
   {
      public :
         ComputedMsg();

         ComputedMsg( const LabelType& shareLabel,
                      const CODEX_ASN1::Integer& computor );

         ComputedMsg( const ComputedMsg& aOther );

         virtual ~ComputedMsg() {}

         void operator=( const ComputedMsg& aOther );

         const LabelType& shareLabel() const { return m_shareLabel; }

         const CODEX_ASN1::Integer& computor() const { return m_computor; };

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

      private :
         LabelType            m_shareLabel;
         CODEX_ASN1::Integer  m_computor;
   };
   typedef SignedMessage< ComputedMsg, RSASignature >  SignedComputedMsg;
   typedef CODEX_ASN1::Array< SignedComputedMsg >      ComputedArray;

   class FinishedMsg : public Message
   {
      public :
         FinishedMsg();

         FinishedMsg( const CODEX_ASN1::Integer& version,
                      const CODEX_ASN1::Integer& coordinator,
                      const ComputedArray& evidence );

         FinishedMsg( const FinishedMsg& aOther );

         virtual ~FinishedMsg() {}

         void operator=( const FinishedMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; };

         const CODEX_ASN1::Integer& coordinator() const
         {
            return m_coordinator;
         }

         const ComputedArray& evidence() const { return m_evidence; }

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

      private :
         CODEX_ASN1::Integer  m_version;
         CODEX_ASN1::Integer  m_coordinator;
         ComputedArray        m_evidence;
   };
   typedef SignedMessage< FinishedMsg, RSASignature >  SignedFinishedMsg;

   class RecoverMsg : public Message
   {
      public :
         RecoverMsg();

         RecoverMsg( const CODEX_ASN1::Integer& version,
                     const SublabelType& sublabel,
                     const CODEX_ASN1::Integer& requester,
                     const CODEX_ASN1::Integer& responder );

         RecoverMsg( const RecoverMsg& aOther );

         virtual ~RecoverMsg() {}

         void operator=( const RecoverMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; };

         const SublabelType& sublabel() const { return m_sublabel; }

         const CODEX_ASN1::Integer& requester() const { return m_requester; }

         const CODEX_ASN1::Integer& responder() const { return m_responder; }

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

      private :
         CODEX_ASN1::Integer  m_version;
         SublabelType         m_sublabel;
         CODEX_ASN1::Integer  m_requester;
         CODEX_ASN1::Integer  m_responder;
   };
   typedef SignedMessage< RecoverMsg, RSASignature >  SignedRecoverMsg;

   class RecoveredMsg : public Message
   {
      public :
         RecoveredMsg();

         RecoveredMsg( const RecoverMsg& request,
                       const ShareType& shareset );

         RecoveredMsg( const RecoveredMsg& aOther );

         virtual ~RecoveredMsg() {}

         void operator=( const RecoveredMsg& aOther );

         const CODEX_ASN1::Integer& version() const { return m_version; };

         const SublabelType& sublabel() const { return m_sublabel; }

         const CODEX_ASN1::Integer& responder() const
         {
            return m_responder;
         }

         const ShareType& shares() const { return m_shares; }

         const CODEX_ASN1::Integer& requester() const
         {
            return m_requester;
         }

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

      private :
         CODEX_ASN1::Integer  m_version;
         SublabelType         m_sublabel;
         CODEX_ASN1::Integer  m_responder;
         ShareType            m_shares;
         CODEX_ASN1::Integer  m_requester;
   };
   typedef SignedMessage< RecoveredMsg, RSASignature >  SignedRecoveredMsg;

   enum MessageType
   {
      kInitMsg,
      kEstablishMsg,
      kEstablishedMsg,
      kContributeMsg,
      kComputeMsg,
      kComputedMsg,
      kFinishedMsg,
      kRecoverMsg,
      kRecoveredMsg,
      kBadRequest
   };

   const unsigned char SignatureMask = 0x80;
}

#endif /* __CODEX_APSS_MESSAGE_H__ */

---