---

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.5 2004/05/19 15:56:48 mmarsh Exp $
//
// $Log: Message.h,v $
// Revision 1.5  2004/05/19 15:56:48  mmarsh
// *** empty log message ***
//
// Revision 1.4  2003/11/06 21:46:23  mmarsh
// Use the RSA variant by default.
//
// Revision 1.3  2003/11/04 22:09:57  mmarsh
// The signed ElGamal public key for the service was moved into CODEX_Server.
//
//

#ifndef __CODEX_CLIENT_MESSAGE_H__
#define __CODEX_CLIENT_MESSAGE_H__

#include "CODEX_ASN1/OctetString.h"
#include "CODEX_ASN1/BigNumber.h"
#include "CODEX_ASN1/Certificate.h"
#include "CODEX_Ciphers/ElGamal.h"
#include "CODEX_Ciphers/RSA.h"
#include "CODEX_Ciphers/VarRSA.h"
#include "CODEX_Ciphers/Policy.h"
#include "CODEX_Ciphers/Credentials.h"
#include "CODEX_Ciphers/TranslationCertificate.h"
#include "CODEX_Ciphers/RSAPlaintextPK.h"
#include "CODEX_Ciphers/HashFunction.h"
#include "CODEX_Server/AugmentedEGPublicKey.h"

/* #define ELGAMAL */

namespace CODEX_Client
{

#ifndef ELGAMAL

   typedef CODEX_Ciphers::VarRSACipherText          CipherTextType;
   typedef CipherTextType                           RequestCipherTextType;
   typedef CODEX_Ciphers::RSACipherText             BlindingCipherTextType;
   typedef CODEX_Ciphers::VarRSABlindCipherText     BlindCipherTextType;
   typedef CODEX_Ciphers::VarRSABlindPlainText      BlindPlainTextType;
#else

   typedef CODEX_Ciphers::ElGamalCipherText         CipherTextType;
   typedef CODEX_Ciphers::ElGamalSchnorrCipherText  RequestCipherTextType;
   typedef RequestCipherTextType                    BlindingCipherTextType;
   typedef CipherTextType                           BlindCipherTextType;
   typedef CODEX_ASN1::BigNumber                    BlindPlainTextType;
#endif

   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 NULL;
            }
            if ( (NULL == pp) || (NULL == *pp) )
            {
               return NULL;
            }
            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 NULL;
            }
            *pp=c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return NULL;
         }

      private :
         MT  m_message;
         ST  m_signature;
   };

   class RequestKeyMsg : public Message
   {
      public :
         RequestKeyMsg() : Message( true ) {}

         virtual ~RequestKeyMsg() {}

         void operator=( const RequestKeyMsg& aMsg ) {}

         int marshal( unsigned char ** pp ) const { return 0; }
         void* unmarshal( void* bogus, unsigned char ** pp, long length )
         {
            return this;
         }
   };


   typedef CODEX_Server::SignedAugmentedEGPublicKey SignedPublicKeyMsg;

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

         CreateKeyMsg( const CODEX_ASN1::OctetString& name,
                       const CODEX_ASN1::Certificate& owner,
                       const CODEX_Ciphers::Policy& readP,
                       const CODEX_Ciphers::Policy& writeP );

         CreateKeyMsg( const CreateKeyMsg& aCKM );

         virtual ~CreateKeyMsg() {}

         void operator=( const CreateKeyMsg& aCKM );

         const CODEX_ASN1::OctetString& name() const { return m_name; }

         const CODEX_ASN1::Certificate& owner() const { return m_owner; }

         const CODEX_Ciphers::Policy& readP() const { return m_readP; }

         const CODEX_Ciphers::Policy& writeP() const { return m_writeP; }

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

      private :
         CODEX_ASN1::OctetString  m_name;
         CODEX_ASN1::Certificate  m_owner;
         CODEX_Ciphers::Policy    m_readP;
         CODEX_Ciphers::Policy    m_writeP;
   };

   typedef SignedMessage< CreateKeyMsg, CODEX_Ciphers::RSASignature >
   SignedCreateKeyMsg;

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

         BoundNameMsg( const CODEX_ASN1::OctetString& name,
                       const SignedCreateKeyMsg& request );

         BoundNameMsg( const BoundNameMsg& aBNM );

         virtual ~BoundNameMsg() {}

         void operator=( const BoundNameMsg& aBNM );

         const CODEX_ASN1::OctetString& name() const { return m_name; }

         const SignedCreateKeyMsg& request() const { return m_request; }

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

      private :
         CODEX_ASN1::OctetString  m_name;
         SignedCreateKeyMsg       m_request;
   };

   typedef SignedMessage< BoundNameMsg, CODEX_Ciphers::RSASignature >
   SignedBoundNameMsg;

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

         WriteKeyMsg( const CODEX_ASN1::OctetString& name,
                      const RequestCipherTextType& encryption,
#ifndef ELGAMAL
                      const CODEX_Ciphers::RSAPlaintextPK& proof,
#endif
                      const CODEX_Ciphers::Credentials& credentials,
                      const SignedBoundNameMsg& binding );

         WriteKeyMsg( const WriteKeyMsg& aWKM );

         virtual ~WriteKeyMsg() {}

         void operator=( const WriteKeyMsg& aWKM );

         const CODEX_ASN1::OctetString& name() const { return m_name; }

         const RequestCipherTextType& encryption() const
         {
            return m_encryption;
         }

#ifndef ELGAMAL

         const CODEX_Ciphers::RSAPlaintextPK& proof() const
         {
            return m_proof;
         }
#endif

         const CODEX_Ciphers::Credentials& credentials() const
         {
            return m_credentials;
         }

         const SignedBoundNameMsg& binding() const { return m_binding; }

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

      private :
         CODEX_ASN1::OctetString        m_name;
         RequestCipherTextType            m_encryption;
#ifndef ELGAMAL
         CODEX_Ciphers::RSAPlaintextPK  m_proof;
#endif
         CODEX_Ciphers::Credentials     m_credentials;
         SignedBoundNameMsg             m_binding;
   };

   typedef SignedMessage< WriteKeyMsg, CODEX_Ciphers::RSASignature >
   SignedWriteKeyMsg;

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

         KeyStoredMsg( const CODEX_ASN1::OctetString& name,
                       const CODEX_Ciphers::RSASignature& requestSignature );

         KeyStoredMsg( const KeyStoredMsg& aKSM );

         virtual ~KeyStoredMsg() {}

         void operator=( const KeyStoredMsg& aKSM );

         const CODEX_ASN1::OctetString& name() const { return m_name; }

         const CODEX_Ciphers::RSASignature& requestSignature() const
         {
            return m_requestSignature;
         }

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

      private :
         CODEX_ASN1::OctetString      m_name;
         CODEX_Ciphers::RSASignature  m_requestSignature;
   };

   typedef SignedMessage< KeyStoredMsg, CODEX_Ciphers::RSASignature >
   SignedKeyStoredMsg;

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

         ReadKeyMsg( const CODEX_ASN1::OctetString& name,
                     const BlindingCipherTextType& blinding,
#ifndef ELGAMAL
                     const CODEX_Ciphers::RSAPlaintextPK& proof,
#endif
                     const CODEX_Ciphers::Credentials& credentials );

         ReadKeyMsg( const ReadKeyMsg& aRKM );

         virtual ~ReadKeyMsg() {}

         void operator=( const ReadKeyMsg& aRKM );

         const CODEX_ASN1::OctetString& name() const { return m_name; }

         const BlindingCipherTextType& blinding() const
         {
            return m_blinding;
         }

#ifndef ELGAMAL

         const CODEX_Ciphers::RSAPlaintextPK& proof() const
         {
            return m_proof;
         }
#endif

         const CODEX_Ciphers::Credentials& credentials() const
         {
            return m_credentials;
         }

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

      private :
         CODEX_ASN1::OctetString        m_name;
         BlindingCipherTextType         m_blinding;
#ifndef ELGAMAL
         CODEX_Ciphers::RSAPlaintextPK  m_proof;
#endif
         CODEX_Ciphers::Credentials     m_credentials;
   };

   typedef SignedMessage< ReadKeyMsg, CODEX_Ciphers::RSASignature >
   SignedReadKeyMsg;

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

         BlindKeyMsg( const CODEX_ASN1::OctetString& name,
                      const BlindPlainTextType& blindedKey,
                      const CODEX_Ciphers::RSASignature& requestSignature );

         BlindKeyMsg( const BlindKeyMsg& aBKM );

         virtual ~BlindKeyMsg() {}

         void operator=( const BlindKeyMsg& aBKM );

         const CODEX_ASN1::OctetString& name() const { return m_name; }

         const BlindPlainTextType& blindedKey() const
         {
            return m_blindedKey;
         }

         const CODEX_Ciphers::RSASignature& requestSignature() const
         {
            return m_requestSignature;
         }

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

      private :
         CODEX_ASN1::OctetString      m_name;
         BlindPlainTextType           m_blindedKey;
         CODEX_Ciphers::RSASignature  m_requestSignature;
   };

   typedef SignedMessage< BlindKeyMsg, CODEX_Ciphers::RSASignature >
   SignedBlindKeyMsg;

   enum MessageType
   {
      kRequestKeyMsg,
      kPublicKeyMsg,
      kCreateKeyMsg,
      kBoundNameMsg,
      kWriteKeyMsg,
      kKeyStoredMsg,
      kReadKeyMsg,
      kBlindKeyMsg
   };

   const unsigned char SignatureMask = 0x80;
}

#endif /* __CODEX_CLIENT_MESSAGE_H__ */

---