split_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: split_private_keys.cc,v 1.5 2005/01/21 19:44:16 mmarsh Exp $
//
// $Log: split_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_VSS/Combinatoric.h"
#include "CODEX_VSS/CombinatoricFeldman.h"
#include "CODEX_Server/ConfigurationExceptions.h"
#include "CODEX_Server/ServerState.h"
#include "CODEX_ThresholdCrypto/ThresholdRSA.h"
#include "CODEX_VSS/ModIntRange.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);
   }

   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" );
      }
      unsigned long uDummy = dummy;
      if ( N != uDummy )
      {
         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::Combinatoric< N , T >                ShareType;
      typedef CODEX_VSS::ShareSet< ShareType >                SetType;
      typedef CODEX_ThresholdCrypto::ThresholdRSARange        RSARangeType;
      typedef CODEX_VSS::ModIntRange                          EGRangeType;
      typedef CODEX_VSS::ShareSplitting< ShareType >          SplitType;
      typedef CODEX_VSS::ModExpFunctional                     OneWay;
      typedef CODEX_VSS::ShareLabel< ShareType , OneWay >     LabelType;
      typedef CODEX_VSS::LabeledShare< ShareType , OneWay >   LSType;
      typedef CODEX_VSS::SecretWitness< ShareType , OneWay >  WitnessType;
      typedef LabelType::VType::ValueType                     ValueType;

      // Use a trick -- Integer and BigNumber use the same ASN.1 representation
      long gen;
      if ( ! NCONF_get_number_e(conf,section,"rsa_generator",&gen ) )
      {
         throw BCParameterNotDefinedException( __FILE__ , __LINE__ ,
                                               fname, "rsa_generator" );
      }
      if ( gen < 3 ) // minimal value
      {
         throw BCBadValueException( __FILE__ , __LINE__ ,
                                    fname , "rsa_generator" );
      }
      CODEX_ASN1::Integer generator(gen);
      CODEX_ASN1::BigNumber bigGenerator( generator.asn1() );

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

      SetType   rsaShareSet;
      RSARangeType rsaRange( privKey.n().value(), ShareType::NumShares );
      SplitType::split( privKey.d().value(), rsaShareSet, rsaRange );
      OneWay::CtorArgs rsaArgs( bigGenerator, privKey.n() );
      OneWay rsaOneWay( rsaArgs );
      LabelType rsaLabel(ServerState::RSAKeyNum,0,0,rsaShareSet,rsaOneWay);
      ValueType vcrsa;
      rsaOneWay( privKey.d(), vcrsa );
      WitnessType rsaWitness( vcrsa, rsaArgs );
      ostringstream rwstr;
      rwstr << output_dir << "/rsa.witness\0";
      rsaWitness.toFile( rwstr.str().c_str() );

      SetType   egShareSet;
      EGRangeType egRange( pubEGKey.key().key().q() );
      SplitType::split(  privEGKey.x().value(), egShareSet, egRange );
      OneWay::CtorArgs egArgs( pubEGKey.key().key().g(),
                               pubEGKey.key().key().p() );
      OneWay egOneWay( egArgs );
      LabelType egLabel(ServerState::EGKeyNum,0,0,egShareSet,egOneWay);
      ValueType vceg;
      egOneWay( privEGKey.x(), vceg );
      WitnessType egWitness( vceg, egArgs );
      ostringstream ewstr;
      ewstr << output_dir << "/elgamal.witness\0";
      egWitness.toFile( ewstr.str().c_str() );

      for ( unsigned int i = 0 ; i < N ; ++i )
      {
         ShareType rsaShare( rsaShareSet, i );
         LSType labeledRSA( rsaShare, rsaLabel );
         ostringstream rstr;
         rstr << output_dir << "/rsa." << i << ".shares" << '\0';
         labeledRSA.toFile( rstr.str().c_str() );

         ShareType egShare( egShareSet, i );
         LSType labeledEG( egShare, egLabel );
         ostringstream estr;
         estr << output_dir << "/elgamal." << i << ".shares" << '\0';
         labeledEG.toFile( estr.str().c_str() );
      }
   }
   catch ( CODEX_Exceptions::ExceptionBase& e )
   {
      e.report();
      return 1;
   }

   return 0;
}

---