verify_private_keys.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: verify_private_keys.cc,v 1.5 2005/01/21 19:44:16 mmarsh Exp $
//
// $Log: verify_private_keys.cc,v $
// Revision 1.5  2005/01/21 19:44:16  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.4  2004/05/19 15:56:46  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/06 18:11:51  mmarsh
// Cleaned up doxygen page label and title.
//
// Revision 1.2  2003/11/04 22:07:36  mmarsh
// General code cleanup and reorganization.
//
//

#include <fstream>
#include <sstream>
#include <openssl/ssl.h>
#include <openssl/conf.h>
#include <unistd.h>

#include "CODEX_Ciphers/RSA.h"
#include "CODEX_Ciphers/ElGamal.h"
#include "CODEX_Ciphers/SHA1HashFunction.h"
#include "CODEX_Server/ConfigurationExceptions.h"
#include "CODEX_Server/ServerState.h"
#include "CODEX_ThresholdCrypto/CombinatoricThresholdRSA.h"

using namespace CODEX_Server;

int main( int argc, char** argv )
{
   SSLeay_add_ssl_algorithms();

   int arg = 0;
   string fname;
   string config_section;
   string usage_string(
      "Usage: split_private_keys -c <config_file> [-s <section>]");
   while ( -1 != arg )
   {
      arg = getopt(argc,argv,"c:s:");
      switch(arg)
      {
         case 'c' :
            fname = optarg;
            break;
         case 's' :
            config_section = optarg;
            break;
         case ':' :
         case '?' :
            cerr << usage_string << endl;
            ::exit(1);
      }
   }
   if ( 0 == fname.size() )
   {
      cerr << usage_string << endl;
      ::exit(1);
   }

   unsigned int nerror = 0;
   try
   {
      CONF* conf = NCONF_new(NCONF_default());
      if ( 0 == NCONF_load(conf,fname.c_str(),0) )
      {
         throw CODEX_Exceptions::FileCannotOpenException( __FILE__ ,
                                                          __LINE__ ,
                                                          fname );
      }
      char* section = (char*) config_section.c_str();

      const unsigned int N = ServerState::nServers;
      const unsigned int T = 1 + ServerState::nFaults;

      long dummy;
      if ( ! NCONF_get_number_e(conf,section,"nhosts",&dummy) )
      {
         throw BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                               fname, "nhosts" );
      }
      if ( N != dummy )
      {
         throw BCBadValueException( __FILE__ , __LINE__ , fname, "nhosts" );
      }
      if ( ! NCONF_get_number_e(conf,section,"nfaults",&dummy) )
      {
         throw BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                               fname, "nfaults" );
      }
      if ( (T-1) != dummy )
      {
         throw BCBadValueException( __FILE__ , __LINE__ , fname, "nfaults" );
      }

      const char* privKeyFile =
         NCONF_get_string(conf,section,"private_key_file");
      if ( 0 == privKeyFile )
      {
         throw BCBadValueException( __FILE__ , __LINE__ ,
                                    fname, "private_key_file" );
      }
      const char* privKeyPasswd =
         NCONF_get_string(conf,section,"private_key_passwd");
      CODEX_Ciphers::RSAPrivateKey privKey;
      privKey.fromPEMFile( privKeyFile, privKeyPasswd );

      const char* pubEGKeyFile =
         NCONF_get_string(conf,section,"public_eg_key_file");
      if ( 0 == pubEGKeyFile )
      {
         throw BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                               fname, "public_eg_key_file" );
      }
      const char* privEGKeyFile =
         NCONF_get_string(conf,section,"private_eg_key_file");
      if ( 0 == privEGKeyFile )
      {
         throw BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                               fname, "private_eg_key_file" );
      }
      CODEX_Server::SignedAugmentedEGPublicKey pubEGKey;
      ifstream is(pubEGKeyFile);
      if ( ! is.is_open() )
      {
         throw CODEX_Exceptions::FileCannotOpenException( __FILE__ ,
                                                          __LINE__ ,
                                                          pubEGKeyFile );
      }
      string s;
      char ch;
      while ( is.get(ch) )
      {
         s.push_back(ch);
      }
      //basic_string<unsigned char> s;
      //is >> s;
      unsigned int length = s.length();
      //unsigned char* p = (unsigned char*)s.data();
      unsigned char* p = new unsigned char[length];
      unsigned char* pOrig = p;
      for ( unsigned int i = 0 ; i < length ; ++i )
      {
         p[i] = s.data()[i];
      }
      if ( 0 == pubEGKey.unmarshal(0,&p,length) )
      {
         delete [] pOrig;
         throw PublicKeyNotFoundException( __FILE__ , __LINE__ );
      }
      delete [] pOrig;
      CODEX_Ciphers::ElGamalPrivateKey privEGKey;
      privEGKey.fromFile( privEGKeyFile );

      typedef CODEX_VSS::ModExpFunctional                     OneWay;
      typedef CODEX_VSS::Combinatoric< N , T >                ShareType;
      typedef CODEX_VSS::LabeledShare< ShareType , OneWay >   LSType;
      typedef CODEX_VSS::SecretWitness< ShareType , OneWay >  WitnessType;

      const char* output_dir =
         NCONF_get_string(conf,section,"output_directory");
      if ( 0 == output_dir )
      {
         throw BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                               fname, "output_directory" );
      }

      WitnessType rsaWitness;
      ostringstream rwstr;
      rwstr << output_dir << "/rsa.witness\0";
      rsaWitness.fromFile( rwstr.str().c_str() );

      WitnessType egWitness;
      ostringstream ewstr;
      ewstr << output_dir << "/elgamal.witness\0";
      egWitness.fromFile( ewstr.str().c_str() );

      LSType rsaSharings[N];
      LSType elgamalSharings[N];
      for ( unsigned int i = 0 ; i < N ; ++i )
      {
         ostringstream rstr;
         rstr << output_dir << "/rsa." << i << ".shares" << '\0';
         rsaSharings[i].fromFile( rstr.str().c_str() );
         ostringstream estr;
         estr << output_dir << "/elgamal." << i << ".shares" << '\0';
         elgamalSharings[i].fromFile( estr.str().c_str() );
      }

      // Check consistency of each share
      const unsigned int nShares = ShareType::NumShares;
      ShareType fullRSA;
      ShareType fullElGamal;
      OneWay rsaOneWay( rsaWitness.args() );
      OneWay egOneWay( egWitness.args() );
      for ( unsigned int i = 0 ; i < N ; ++i )
      {
         if ( ! ( rsaSharings[i].label().verify( rsaWitness.witness(),
                                                 rsaOneWay ) &&
                  rsaSharings[i].label().check( rsaSharings[i].share(),
                                                rsaOneWay ) ) )
         {
            cerr << "RSA shares for " << i << " inconsistent" << endl;
            ++nerror;
         }
         fullRSA += rsaSharings[i].share();
         if ( ! ( elgamalSharings[i].label().verify( egWitness.witness(),
                                                     egOneWay ) &&
                  elgamalSharings[i].label().check( elgamalSharings[i].share(),
                                                    egOneWay ) ) )
         {
            cerr << "ElGamal shares for " << i << " inconsistent" << endl;
            ++nerror;
         }
         fullElGamal += elgamalSharings[i].share();
      }
      for ( unsigned int i = 0 ; i < N ; ++i )
      {
         for ( unsigned int j = 0 ; j < nShares ; ++j )
         {
            if ( rsaSharings[i].share().share(j).initialized() )
            {
               if ( 0 != BN_cmp( rsaSharings[i].share().share(j).value(),
                                 fullRSA.share(j).value() ) )
               {
                  cerr << "disagreement in RSA share " << j << endl;
                  ++nerror;
               }
            }
            if ( elgamalSharings[i].share().share(j).initialized() )
            {
               if ( 0 != BN_cmp( elgamalSharings[i].share().share(j).value(),
                                 fullElGamal.share(j).value() ) )
               {
                  cerr << "disagreement in ElGamal share " << j << endl;
                  ++nerror;
               }
            }
         }
      }

      // Now recover the private keys from the sharings.
      CODEX_ASN1::SecureBigNumber d;
      fullRSA.recover( d );
      if ( 0 != BN_cmp( privKey.d().value(), d.value() ) )
      {
         cerr << "disagreement recovering RSA key" << endl;
         ++nerror;
      }
      CODEX_ASN1::SecureBigNumber x;
      fullElGamal.recover( x );
      if ( 0 != BN_cmp( privEGKey.x().value(), x.value() ) )
      {
         cerr << "disagreement recovering ElGamal key" << endl;
         ++nerror;
      }

      // Now test threshold cryptography
      BIGNUM * two = BN_new();
      BN_add( two, BN_value_one(), BN_value_one() );
      CODEX_ThresholdCrypto::ThresholdRSACrypto< ShareType >
         tRSA( privKey.n() );
      ShareType rsaSigShares;
      tRSA.sign( fullRSA, two, rsaSigShares );
      CODEX_VSS::ShareSet< ShareType > rsaSigSet;
      for ( unsigned int i = 0 ; i < nShares ; ++i )
      {
         rsaSigSet.setShare(i, rsaSigShares.share(i));
      }
      BIGNUM * rsaSig1 = tRSA.threshold(rsaSigSet);
      CODEX_Ciphers::RSASignature* rsaSig2 = privKey.sign(two);
      if ( 0 != BN_cmp( rsaSig1 , rsaSig2->value() ) )
      {
         cerr << "threshold RSA signature bad" << endl;
         ++nerror;
      }
   }
   catch ( CODEX_Exceptions::ExceptionBase& e )
   {
      e.report();
      return 1;
   }

   cout << nerror << " errors detected" << endl;
   return 0;
}

---