---

VerifiableBlindKeyMsg.cc

/*
 * 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.cc,v 1.4 2004/05/19 15:56:53 mmarsh Exp $
//
// $Log: VerifiableBlindKeyMsg.cc,v $
// 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 ***
//
//

#include "VerifiableBlindKeyMsg.h"

using namespace CODEX_KeyService;

VerifiableBlindKeyMsg::VerifiableBlindKeyMsg()
{
}

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
   const BlindCipherTextType& blindCipher ) :
   CODEX_Client::BlindKeyMsg( name, blindedKey, requestSignature ),
#ifdef ELGAMAL
   m_label( label ),
#endif
   m_blindCipher( blindCipher )
{
#ifdef ELGAMAL
   for ( unsigned int i = 0 ; i < NumProofs ; ++i )
   {
      m_partials[i] = partials(i);
      m_proofs[i] = proofs[i];
   }
#endif
}

VerifiableBlindKeyMsg::VerifiableBlindKeyMsg(
   const VerifiableBlindKeyMsg& aBKM ) :
   CODEX_Client::BlindKeyMsg( aBKM ),
#ifdef ELGAMAL
   m_label( aBKM.m_label ),
#endif
   m_blindCipher( aBKM.m_blindCipher )
{
#ifdef ELGAMAL
   for ( unsigned int i = 0 ; i < NumProofs ; ++i )
   {
      m_partials[i] = aBKM.m_partials[i];
      m_proofs[i] = aBKM.m_proofs[i];
   }
#endif
}

void
VerifiableBlindKeyMsg::operator=( const VerifiableBlindKeyMsg& aBKM )
{
   CODEX_Client::BlindKeyMsg::operator=( aBKM );
#ifdef ELGAMAL
   m_label = aBKM.m_label;
   for ( unsigned int i = 0 ; i < NumProofs ; ++i )
   {
      m_partials[i] = aBKM.m_partials[i];
      m_proofs[i] = aBKM.m_proofs[i];
   }
#endif
   m_blindCipher = aBKM.m_blindCipher;
}

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

   ret += CODEX_Client::BlindKeyMsg::marshal(0);
#ifdef ELGAMAL
   ret += m_label.marshal(0);
   for ( unsigned int count = 0 ; count < NumProofs ; ++count )
   {
      ret += m_partials[count].marshal(0);
      ret += m_proofs[count].marshal(0);
   }
#endif
   ret += m_blindCipher.marshal(0);
   M_ASN1_I2D_seq_total();
   CODEX_Client::BlindKeyMsg::marshal(&p);
#ifdef ELGAMAL
   m_label.marshal(&p);
   for ( unsigned int count = 0 ; count < NumProofs ; ++count )
   {
      m_partials[count].marshal(&p);
      m_proofs[count].marshal(&p);
   }
#endif
   m_blindCipher.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
VerifiableBlindKeyMsg::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, CODEX_Client::BlindKeyMsg::unmarshal);
#ifdef ELGAMAL
   M_ASN1_D2I_get(i, m_label.unmarshal);
   for ( unsigned int count = 0 ; count < NumProofs ; ++count )
   {
      M_ASN1_D2I_get(i, m_partials[count].unmarshal);
      M_ASN1_D2I_get(i, m_proofs[count].unmarshal);
   }
#endif
   M_ASN1_D2I_get(i, m_blindCipher.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

---