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

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

using namespace CODEX_Ciphers;
using namespace CODEX_Exceptions;

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

TranslationCertificate::TranslationCertificate(
   const ElGamalPublicKey& pubKeyRecipient,
   const ElGamalPrivateKey& privKeyCreator,
   const CODEX_ASN1::BigNumber& h,
   const BIGNUM * k,
   const ElGamalCipherText& cipherTextCreator,
   const HashFunction& hashFunc ) :
   CODEX_ASN1::Base( true )
{
   int length;
   unsigned char* buff = NULL;
   unsigned char* pBuff;
   CODEX_ASN1::ustring* tempStr = NULL;

   const BIGNUM * p = pubKeyRecipient.p().value();
   // Jakobsson uses q where he should use p-1.  We will duplicate this
   // error in notation, though not in computation.
   BIGNUM * q = (BIGNUM*)pubKeyRecipient.p1();
   const BIGNUM * g = pubKeyRecipient.g().value();
   const BIGNUM * y = pubKeyRecipient.y().value();
   const BIGNUM * x = privKeyCreator.value();
   const BIGNUM * c1 = cipherTextCreator.c1().value();
   const BIGNUM * hbn = h.value();
   BIGNUM * b1 = NULL;
   BIGNUM * b2 = NULL;
   BIGNUM * temp = NULL;
   BIGNUM * temp2 = NULL;
   BIGNUM * temp3 = NULL;
   BIGNUM * temp4 = NULL;
   BN_CTX * ctx = NULL;

   try
   {
      ctx = BN_CTX_new();
      if ( NULL == ctx )
      {
         throw BignumContextException( __FILE__ , __LINE__ );
      }
      // We will use these BIGNUMs as much as possible, to reduce the need
      // to allocate memory.
      temp = BN_new();
      if ( NULL == temp )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp2 = BN_new();
      if ( NULL == temp2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp3 = BN_new();
      if ( NULL == temp3 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp4 = BN_new();
      if ( NULL == temp4 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }

      // h^x mod p
      if ( ! BN_mod_exp( temp, hbn, x, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      m_z1bar = CODEX_ASN1::BigNumber( BN_dup(temp) );

      // h^(-k) mod p
      if ( ! BN_mod_exp( temp, hbn, k, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_inverse( temp, temp, p, ctx ) )
      {
         throw BignumModInverseException( __FILE__ , __LINE__ );
      }
      m_z2bar = CODEX_ASN1::BigNumber( BN_dup(temp) );

      // select temp random in [2,q)
      do
      {
         if ( ! BN_rand_range( temp, q ) )
         {
            throw BignumRandRangeException( __FILE__ , __LINE__ );
         }
      } while ( 0 >= BN_cmp( temp, BN_value_one() ) );

      // G = hash( g^temp mod p )
      if ( ! BN_mod_exp( temp2, g, temp, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      CODEX_ASN1::BigNumber galpha( BN_dup(temp2) );
      length = galpha.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      galpha.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring(buff, length) );
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), temp2 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }    
      if ( ! BN_mod( temp2, temp2, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_G = CODEX_ASN1::BigNumber( BN_dup(temp2) );
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;

      // H = hash( h^temp mod p )
      if ( ! BN_mod_exp( temp2, hbn, temp, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      CODEX_ASN1::BigNumber halpha( BN_dup(temp2) );
      length = halpha.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      halpha.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring(buff, length) );
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), temp2 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }    
      if ( ! BN_mod( temp2, temp2, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_H = CODEX_ASN1::BigNumber( BN_dup(temp2) );
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;

      // delta = temp + hash(G,H,2)*k - hash(G,H,1)*x mod q
      length = 1; // we're going to add a byte at the end
      length += m_G.marshal(0);
      length += m_H.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      m_G.marshal(&pBuff);
      m_H.marshal(&pBuff);
      buff[length-1] = 1;
      tempStr = hashFunc( CODEX_ASN1::ustring(buff, length) );
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), temp2 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }    
      if ( ! BN_mod( temp2, temp2, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = NULL;
      buff[length-1] = 2;
      tempStr = hashFunc( CODEX_ASN1::ustring(buff, length) );
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), temp3 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }    
      if ( ! BN_mod( temp3, temp3, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;
      if ( ! BN_mod_mul( temp2, temp2, x, q, ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( temp3, temp3, k, q, ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }
      if ( ! BN_add( temp3, temp, temp3 ) )
      {
         throw BignumAddException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( temp4, temp3, temp2 ) )
      {
         throw BignumSubException( __FILE__ , __LINE__ );
      }
      if ( ! BN_add( temp4, temp4, q ) )
      {
         throw BignumAddException( __FILE__ , __LINE__ );
      }
      // We can re-use temp now -- we're done with the random number.
      if ( ! BN_mod( temp, temp4, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_delta = CODEX_ASN1::BigNumber( BN_dup(temp) );

      // select temp random in [2,q)
      do
      {
         if ( ! BN_rand_range( temp, q ) )
         {
            throw BignumRandRangeException( __FILE__ , __LINE__ );
         }
      } while ( 0 >= BN_cmp( temp, BN_value_one() ) );
      // select temp2 random in [2,q)
      do
      {
         if ( ! BN_rand_range( temp2, q ) )
         {
            throw BignumRandRangeException( __FILE__ , __LINE__ );
         }
      } while ( 0 >= BN_cmp( temp2, BN_value_one() ) );

      // temp3 = g^temp mod p
      if ( ! BN_mod_exp( temp3, g, temp, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      // temp4 = h^temp2 mod p
      if ( ! BN_mod_exp( temp4, hbn, temp2, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      // temp3 = temp3 * temp4 mod p = g^temp h^temp2 mod p
      if ( ! BN_mod_mul( temp3, temp3, temp4, p, ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }
      CODEX_ASN1::BigNumber fhash( BN_dup(temp3) );
      length = fhash.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      fhash.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
      b1 = BN_new();
      if ( NULL == b1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( b1, b1, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_F = CODEX_ASN1::BigNumber( b1 );
      b1 = NULL;
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;

      // temp3 = b_1^temp mod p
      if ( ! BN_mod_exp( temp3, c1, temp, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      // temp4 = y_2^temp2 mod p
      if ( ! BN_mod_exp( temp4, y, temp2, p, ctx ) )
      {
         throw BignumModExpException( __FILE__ , __LINE__ );
      }
      // temp3 = temp3 * temp4 mod p
      if ( ! BN_mod_mul( temp3, temp3, temp4, p, ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }
      CODEX_ASN1::BigNumber mhash( BN_dup(temp3) );
      length = mhash.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      mhash.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
      b1 = BN_new();
      if ( NULL == b1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( b1, b1, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_M = CODEX_ASN1::BigNumber( b1 );
      b1 = NULL;
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;

      length = 0;
      length += m_F.marshal(0);
      length += m_M.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      m_F.marshal(&pBuff);
      m_M.marshal(&pBuff);
      tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
      b1 = BN_new();
      if ( NULL == b1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( b1, b1, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;

      if ( ! BN_mod_mul( temp3, b1, x, q, ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }
      if ( ! BN_sub( temp4, temp, temp3 ) )
      {
         throw BignumSubException( __FILE__ , __LINE__ );
      }
      if ( ! BN_add( temp4, temp4, q ) ) // make sure it's positive
      {
         throw BignumAddException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( temp4, temp4, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_d1 = CODEX_ASN1::BigNumber( BN_dup(temp4) );

      if ( ! BN_mod_mul( temp3, b1, k, q, ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }
      if ( ! BN_add( temp3, temp2, temp3 ) )
      {
         throw BignumAddException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( temp3, temp3, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      m_d2 = CODEX_ASN1::BigNumber( BN_dup(temp3) );

      BN_free( b1 );
      b1 = NULL;

      // Final cleanup.
      if ( NULL != b1 )
      {
         BN_free( b1 );
      }
      if ( NULL != b2 )
      {
         BN_free( b2 );
      }
      if ( NULL != temp )
      {
         BN_free( temp );
      }
      if ( NULL != temp2 )
      {
         BN_free( temp2 );
      }
      if ( NULL != temp3 )
      {
         BN_free( temp3 );
      }
      if ( NULL != temp4 )
      {
         BN_free( temp4 );
      }
      if ( NULL != ctx )
      {
         BN_CTX_free( ctx );
      }
      if ( NULL != buff )
      {
         delete [] buff;
      }
      if ( NULL != tempStr )
      {
         delete tempStr;
      }
   }
   catch( ... )
   {
      // All memory cleanup from exceptions is done here.
      if ( NULL != b1 ) BN_free( b1 );
      if ( NULL != b2 ) BN_free( b2 );
      if ( NULL != temp ) BN_free( temp );
      if ( NULL != temp2 ) BN_free( temp2 );
      if ( NULL != temp3 ) BN_free( temp3 );
      if ( NULL != temp4 ) BN_free( temp4 );
      if ( NULL != ctx ) BN_CTX_free( ctx );
      if ( NULL != buff ) delete [] buff;
      if ( NULL != tempStr ) delete tempStr;
      throw;
   }
}

TranslationCertificate::TranslationCertificate(
   const CODEX_ASN1::BigNumber& z1bar,
   const CODEX_ASN1::BigNumber& z2bar,
   const CODEX_ASN1::BigNumber& G,
   const CODEX_ASN1::BigNumber& H,
   const CODEX_ASN1::BigNumber& delta,
   const CODEX_ASN1::BigNumber& F,
   const CODEX_ASN1::BigNumber& M,
   const CODEX_ASN1::BigNumber& d1,
   const CODEX_ASN1::BigNumber& d2 ) :
   CODEX_ASN1::Base( true ),
   m_z1bar( z1bar ),
   m_z2bar( z2bar ),
   m_G( G ),
   m_H( H ),
   m_delta( delta ),
   m_F( F ),
   m_M( M ),
   m_d1( d1 ),
   m_d2( d2 )
{
}

TranslationCertificate::TranslationCertificate(
   const TranslationCertificate& aCert ) :
   CODEX_ASN1::Base( aCert.m_initialized ),
   m_z1bar( aCert.m_z1bar ),
   m_z2bar( aCert.m_z2bar ),
   m_G( aCert.m_G ),
   m_H( aCert.m_H ),
   m_delta( aCert.m_delta ),
   m_F( aCert.m_F ),
   m_M( aCert.m_M ),
   m_d1( aCert.m_d1 ),
   m_d2( aCert.m_d2 )
{
}

void
TranslationCertificate::operator=( const TranslationCertificate& aCert )
{
   m_initialized = aCert.m_initialized;
   m_z1bar       = aCert.m_z1bar;
   m_z2bar       = aCert.m_z2bar;
   m_G           = aCert.m_G;
   m_H           = aCert.m_H;
   m_delta       = aCert.m_delta;
   m_F           = aCert.m_F;
   m_M           = aCert.m_M;
   m_d1          = aCert.m_d1;
   m_d2          = aCert.m_d2;
}

bool
TranslationCertificate::verify( const CODEX_ASN1::BigNumber& yCreator,
                                const ElGamalPublicKey& pubKeyRecipient,
                                const ElGamalCipherText& cipherTextCreator,
                                const ElGamalCipherText& cipherTextRecipient,
                                const CODEX_ASN1::BigNumber& h,
                                const HashFunction& hashFunc ) const
{
   bool retVal = true;
   int length;
   unsigned char* buff = NULL;
   unsigned char* pBuff;
   CODEX_ASN1::ustring* tempStr = NULL;

   // We're going to use Jakobsson's notation here, so that it's easier
   // to match the operations to the math in the paper.
   const BIGNUM * p     = pubKeyRecipient.p().value();
   const BIGNUM * g     = pubKeyRecipient.g().value();
   const BIGNUM * q     = NULL;
   const BIGNUM * hbn   = h.value();
   const BIGNUM * z1    = yCreator.value();
   BIGNUM       * z2    = NULL;
   const BIGNUM * mu1   = cipherTextCreator.c1().value();
   const BIGNUM * mu2   = pubKeyRecipient.y().value();
   BIGNUM       * sigma = NULL;
   const BIGNUM * z1Bar = m_z1bar.value();
   const BIGNUM * z2Bar = m_z2bar.value();
   const BIGNUM * Gbn   = m_G.value();
   const BIGNUM * Hbn   = m_H.value();
   const BIGNUM * Delta = m_delta.value();
   const BIGNUM * Fbn   = m_F.value();
   const BIGNUM * Mbn   = m_M.value();
   const BIGNUM * d1bn  = m_d1.value();
   const BIGNUM * d2bn  = m_d2.value();

   BIGNUM * e1    = NULL;
   BIGNUM * e2    = NULL;
   BIGNUM * temp1 = NULL;
   BIGNUM * temp2 = NULL;
   BIGNUM * temp3 = NULL;
   BIGNUM * temp4 = NULL;
   BIGNUM * b1    = NULL;
   BIGNUM * b2    = NULL;
   BN_CTX * ctx   = NULL;

   try
   {
      // Jakobsson uses q where he should use p-1.  We will duplicate
      // this error in notation, though not in computation.
      q = pubKeyRecipient.p1();

      ctx = BN_CTX_new();
      if ( NULL == ctx )
      {
         throw BignumContextException( __FILE__ , __LINE__ );
      }

      z2 = BN_new();
      if ( NULL == z2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_inverse( z2,
                             cipherTextRecipient.c1().value(),
                             p,
                             ctx ) )
      {
         throw BignumModInverseException( __FILE__ , __LINE__ );
      }

      sigma = BN_new();
      if ( NULL == sigma )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_inverse( sigma,
                             cipherTextRecipient.c2().value(),
                             p,
                             ctx ) )
      {
         throw BignumModInverseException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod_mul( sigma,
                         sigma,
                         cipherTextCreator.c2().value(),
                         p,
                         ctx ) )
      {
         throw BignumModMulException( __FILE__ , __LINE__ );
      }

      // Create temporary variables
      temp1 = BN_new();
      if ( NULL == temp1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp2 = BN_new();
      if ( NULL == temp2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp3 = BN_new();
      if ( NULL == temp3 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      temp4 = BN_new();
      if ( NULL == temp4 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }

      // compute e1,e2
      length = 1; // we're going to add a byte at the end
      length += m_G.marshal(0);
      length += m_H.marshal(0);
      buff = new unsigned char[length];
      pBuff = buff;
      m_G.marshal(&pBuff);
      m_H.marshal(&pBuff);
      buff[length-1] = 1;
      tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
      e1 = BN_new();
      if ( NULL == e1 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), e1 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( e1, e1, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = NULL;
      buff[length-1] = 2;
      tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
      e2 = BN_new();
      if ( NULL == e2 )
      {
         throw BignumNullException( __FILE__ , __LINE__ );
      }
      if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), e2 ) )
      {
         throw BignumBin2BNException( __FILE__ , __LINE__ );
      }
      if ( ! BN_mod( e2, e2, q, ctx ) )
      {
         throw BignumModException( __FILE__ , __LINE__ );
      }
      delete tempStr;
      tempStr = NULL;
      delete [] buff;
      buff = NULL;
      if ( retVal )
      {
         // test G
         if ( ! BN_mod_exp( temp1, g, Delta, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( temp2, z1, e1, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( temp3, z2, e2, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp1, temp1, temp2, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp1, temp1, temp3, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         CODEX_ASN1::BigNumber thing( BN_dup(temp1) );
         length = thing.marshal(0);
         buff = new unsigned char[length];
         pBuff = buff;
         thing.marshal(&pBuff);
         tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
         b1 = BN_new();
         if ( NULL == b1 )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
         {
            throw BignumBin2BNException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod( b1, b1, q, ctx ) )
         {
            throw BignumModException( __FILE__ , __LINE__ );
         }
         delete tempStr;
         tempStr = NULL;
         delete [] buff;
         buff = NULL;
         if ( 0 != BN_cmp( Gbn, b1 ) )
         {
            retVal = false;
         }
         BN_free( b1 );
         b1 = NULL;
      }
      if ( retVal )
      {
         // test H
         if ( ! BN_mod_exp( temp1, hbn, Delta, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( temp2, z1Bar, e1, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( temp3, z2Bar, e2, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp1, temp1, temp2, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp1, temp1, temp3, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         CODEX_ASN1::BigNumber thing( BN_dup(temp1) );
         length = thing.marshal(0);
         buff = new unsigned char[length];
         pBuff = buff;
         thing.marshal(&pBuff);
         tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
         b1 = BN_new();
         if ( NULL == b1 )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
         {
            throw BignumBin2BNException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod( b1, b1, q, ctx ) )
         {
            throw BignumModException( __FILE__ , __LINE__ );
         }
         delete tempStr;
         tempStr = NULL;
         delete [] buff;
         buff = NULL;
         if ( 0 != BN_cmp( Hbn, b1 ) )
         {
            retVal = false;
         }
         BN_free( b1 );
         b1 = NULL;
      }
      BN_free( e1 );
      e1 = NULL;
      BN_free( e2 );
      e2 = NULL;

      if ( retVal )
      {
         // compute e1
         length = 0;
         length += m_F.marshal(0);
         length += m_M.marshal(0);
         buff = new unsigned char[length];
         pBuff = buff;
         m_F.marshal(&pBuff);
         m_M.marshal(&pBuff);
         tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
         e1 = BN_new();
         if ( NULL == e1 )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), e1 ) )
         {
            throw BignumBin2BNException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod( e1, e1, q, ctx ) )
         {
            throw BignumModException( __FILE__ , __LINE__ );
         }
         delete tempStr;
         tempStr = NULL;
         delete [] buff;
         buff = NULL;

         // test F
         if ( ! BN_mod_exp( temp1, g, d1bn, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( temp2, hbn, d2bn, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp3, z1, z2Bar, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_exp( temp4, temp3, e1, p, ctx ) )
         {
            throw BignumModExpException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp1, temp1, temp2, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod_mul( temp1, temp1, temp4, p, ctx ) )
         {
            throw BignumModMulException( __FILE__ , __LINE__ );
         }
         CODEX_ASN1::BigNumber thing( BN_dup(temp1) );
         length = thing.marshal(0);
         buff = new unsigned char[length];
         pBuff = buff;
         thing.marshal(&pBuff);
         tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
         b1 = BN_new();
         if ( NULL == b1 )
         {
            throw BignumNullException( __FILE__ , __LINE__ );
         }
         if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
         {
            throw BignumBin2BNException( __FILE__ , __LINE__ );
         }
         if ( ! BN_mod( b1, b1, q, ctx ) )
         {
            throw BignumModException( __FILE__ , __LINE__ );
         }
         delete tempStr;
         tempStr = NULL;
         delete [] buff;
         buff = NULL;
         if ( 0 != BN_cmp( Fbn, b1 ) )
         {
            retVal = false;
         }
         BN_free( b1 );
         b1 = NULL;
         if ( retVal )
         {
            // test M
            if ( ! BN_mod_exp( temp1, mu1, d1bn, p, ctx ) )
            {
               throw BignumModExpException( __FILE__ , __LINE__ );
            }
            if ( ! BN_mod_exp( temp2, mu2, d2bn, p, ctx ) )
            {
               throw BignumModExpException( __FILE__ , __LINE__ );
            }
            if ( ! BN_mod_exp( temp3, sigma, e1, p, ctx ) )
            {
               throw BignumModExpException( __FILE__ , __LINE__ );
            }
            if ( ! BN_mod_mul( temp1, temp1, temp2, p, ctx ) )
            {
               throw BignumModMulException( __FILE__ , __LINE__ );
            }
            if ( ! BN_mod_mul( temp1, temp1, temp3, p, ctx ) )
            {
               throw BignumModMulException( __FILE__ , __LINE__ );
            }
            CODEX_ASN1::BigNumber thing2( BN_dup(temp1) );
            length = thing2.marshal(0);
            buff = new unsigned char[length];
            pBuff = buff;
            thing2.marshal(&pBuff);
            tempStr = hashFunc( CODEX_ASN1::ustring( buff, length ) );
            b1 = BN_new();
            if ( NULL == b1 )
            {
               throw BignumNullException( __FILE__ , __LINE__ );
            }
            if ( NULL == BN_bin2bn( tempStr->data(), tempStr->length(), b1 ) )
            {
               throw BignumBin2BNException( __FILE__ , __LINE__ );
            }
            if ( ! BN_mod( b1, b1, q, ctx ) )
            {
               throw BignumModException( __FILE__ , __LINE__ );
            }
            delete tempStr;
            tempStr = NULL;
            delete [] buff;
            buff = NULL;
            if ( 0 != BN_cmp( Mbn, b1 ) )
            {
               retVal = false;
            }
            BN_free( b1 );
            b1 = NULL;
         }
         BN_free( e1 );
         e1 = NULL;
      }

      // Final cleanup
      if ( NULL != buff ) delete [] buff;
      if ( NULL != tempStr ) delete tempStr;

      if ( NULL != z2    ) BN_free( z2    );
      if ( NULL != sigma ) BN_free( sigma );
      if ( NULL != e1    ) BN_free( e1    );
      if ( NULL != e2    ) BN_free( e2    );
      if ( NULL != temp1 ) BN_free( temp1 );
      if ( NULL != temp2 ) BN_free( temp2 );
      if ( NULL != temp3 ) BN_free( temp3 );
      if ( NULL != temp4 ) BN_free( temp4 );
      if ( NULL != b1    ) BN_free( b1    );
      if ( NULL != b2    ) BN_free( b2    );
      if ( NULL != ctx   ) BN_CTX_free( ctx );

      return retVal;
   }
   catch ( ... )
   {
      // All memory cleanup from exceptions is done here.
      if ( NULL != buff ) delete [] buff;
      if ( NULL != tempStr ) delete tempStr;

      if ( NULL != z2    ) BN_free( z2    );
      if ( NULL != sigma ) BN_free( sigma );
      if ( NULL != e1    ) BN_free( e1    );
      if ( NULL != e2    ) BN_free( e2    );
      if ( NULL != temp1 ) BN_free( temp1 );
      if ( NULL != temp2 ) BN_free( temp2 );
      if ( NULL != temp3 ) BN_free( temp3 );
      if ( NULL != temp4 ) BN_free( temp4 );
      if ( NULL != b1    ) BN_free( b1    );
      if ( NULL != b2    ) BN_free( b2    );
      if ( NULL != ctx   ) BN_CTX_free( ctx );
      throw;
   }
}

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

   ret += m_z1bar.marshal(0);
   ret += m_z2bar.marshal(0);
   ret += m_G.marshal(0);
   ret += m_H.marshal(0);
   ret += m_delta.marshal(0);
   ret += m_F.marshal(0);
   ret += m_M.marshal(0);
   ret += m_d1.marshal(0);
   ret += m_d2.marshal(0);
   M_ASN1_I2D_seq_total();
   m_z1bar.marshal(&p);
   m_z2bar.marshal(&p);
   m_G.marshal(&p);
   m_H.marshal(&p);
   m_delta.marshal(&p);
   m_F.marshal(&p);
   m_M.marshal(&p);
   m_d1.marshal(&p);
   m_d2.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
TranslationCertificate::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_z1bar.unmarshal);
   M_ASN1_D2I_get(i, m_z2bar.unmarshal);
   M_ASN1_D2I_get(i, m_G.unmarshal);
   M_ASN1_D2I_get(i, m_H.unmarshal);
   M_ASN1_D2I_get(i, m_delta.unmarshal);
   M_ASN1_D2I_get(i, m_F.unmarshal);
   M_ASN1_D2I_get(i, m_M.unmarshal);
   M_ASN1_D2I_get(i, m_d1.unmarshal);
   M_ASN1_D2I_get(i, m_d2.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

---