ElGamalCipherText.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: ElGamalCipherText.cc,v 1.3 2004/05/19 15:56:47 mmarsh Exp $
//
// $Log: ElGamalCipherText.cc,v $
// Revision 1.3  2004/05/19 15:56:47  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:31:47  mmarsh
// *** empty log message ***
//
//

#include "ElGamal.h"
#include "CODEX_Exceptions/BignumExceptions.h"

using namespace CODEX_Ciphers;

ElGamalCipherText::ElGamalCipherText() :
   CODEX_ASN1::Base( false )
{
}

ElGamalCipherText::ElGamalCipherText( BIGNUM * c1, BIGNUM * c2 ) :
   CODEX_ASN1::Base( true ),
   m_c1( c1 ),
   m_c2( c2 )
{
}

ElGamalCipherText::ElGamalCipherText( const CODEX_ASN1::BigNumber& c1,
                                      const CODEX_ASN1::BigNumber& c2 ) :
   CODEX_ASN1::Base( true ),
   m_c1( c1 ),
   m_c2( c2 )
{
}

ElGamalCipherText::ElGamalCipherText( const ElGamalCipherText& aCT ) :
   CODEX_ASN1::Base( aCT.m_initialized ),
   m_c1( aCT.m_c1 ),
   m_c2( aCT.m_c2 )
{
}

ElGamalCipherText::~ElGamalCipherText()
{
}

void
ElGamalCipherText::operator=( const ElGamalCipherText& aCT )
{
   m_initialized = aCT.m_initialized;
   m_c1 = aCT.m_c1;
   m_c2 = aCT.m_c2;
}

bool
ElGamalCipherText::operator<( const ElGamalCipherText& aCT ) const
{
   // The ordering is well-defined but arbitrary.
   // Test on the first part of the ciphertext, and only consider the
   // second if the first parts are equal.
   if ( m_c1 < aCT.c1() ) return true;
   if ( aCT.c1() < m_c1 ) return false;
   if ( m_c2 < aCT.c2() ) return true;
   return false;
}

bool
ElGamalCipherText::operator==( const ElGamalCipherText& aCT ) const
{
   if ( m_c1 != aCT.c1() ) return false;
   if ( m_c2 != aCT.c2() ) return false;
   return true;
}

bool
ElGamalCipherText::operator!=( const ElGamalCipherText& aCT ) const
{
   return ( ! operator==(aCT) );
}


ElGamalCipherText*
ElGamalCipherText::blind( const ElGamalCipherText& aOther,
                          const CODEX_ASN1::BigNumber& modulus ) const
{
   ElGamalCipherText* retVal = 0;

   const BIGNUM * kc1 = m_c1.value();
   const BIGNUM * kc2 = m_c2.value();

   const BIGNUM * bc1 = aOther.m_c1.value();
   const BIGNUM * bc2 = aOther.m_c2.value();

   const BIGNUM * n = modulus.value();

   BIGNUM * bk1 = 0;
   BIGNUM * bk2 = 0;
   BN_CTX * ctx = 0;
   try
   {
      ctx = BN_CTX_new();
      if ( 0 == ctx )
      {
         throw CODEX_Exceptions::BignumContextException( __FILE__ , __LINE__ );
      }

      bk1 = BN_new();
      if ( 0 == bk1 )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( bk1, bc1, kc1, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModMulException( __FILE__ , __LINE__ );
      }

      bk2 = BN_new();
      if ( 0 == bk2 )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( bk2, bc2, kc2, n, ctx ) )
      {
         throw CODEX_Exceptions::BignumModMulException( __FILE__ , __LINE__ );
      }

      retVal = new ElGamalCipherText( bk1, bk2 );
      bk1 = 0;
      bk2 = 0;
      BN_CTX_free( ctx );
      ctx = 0;
      return retVal;
   }
   catch ( ... )
   {
      if ( 0 != ctx ) BN_CTX_free( ctx );
      if ( 0 != bk1 ) BN_free( bk1 );
      if ( 0 != bk2 ) BN_free( bk2 );
      throw;
   }
}

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

   ret += m_c1.marshal(0);
   ret += m_c2.marshal(0);
   M_ASN1_I2D_seq_total();
   m_c1.marshal(&p);
   m_c2.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
ElGamalCipherText::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_c1.unmarshal);
   M_ASN1_D2I_get(i, m_c2.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

---