timing_client.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: timing_client.cc,v 1.6 2005/01/21 19:44:16 mmarsh Exp $
//
// $Log: timing_client.cc,v $
// Revision 1.6  2005/01/21 19:44:16  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.5  2004/05/19 15:56:46  mmarsh
// *** empty log message ***
//
// Revision 1.4  2003/11/06 21:45:51  mmarsh
// Added a sample configuration file.
//
// Revision 1.3  2003/11/06 18:12:47  mmarsh
// Added doxygen comments.
//
// Revision 1.2  2003/11/04 22:07:36  mmarsh
// General code cleanup and reorganization.
//
//

#include <unistd.h>
#include <openssl/ssl.h>
#include <openssl/conf.h>
#include <iostream>

#include "CODEX_Client/Client.h"

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

   int arg = 0;
   string config_file;
   string config_section;
   string usage_string =
      "Usage: example_client -c <config_file> [-s <section>]";
   while ( -1 != arg )
   {
      arg = getopt(argc,argv,"c:s:");
      switch(arg)
      {
         case 'c' :
            config_file = optarg;
            break;
         case 's' :
            config_section = optarg;
            break;
         case ':' :
         case '?' :
            cerr << usage_string << endl;
            ::exit(1);
      }
   }
   if ( 0 == config_file.size() )
   {
      cerr << usage_string << endl;
      ::exit(1);
   }
   CONF* conf = NCONF_new(NCONF_default());
   if ( 0 == NCONF_load(conf,config_file.c_str(),0) )
   {
      cerr << "Cannot open " << config_file << endl;
      ::exit(1);
   }
   const char* sec = config_section.c_str();

   long dummy;
   if ( ! NCONF_get_number_e(conf,sec,"remote_port",&dummy) )
   {
      cerr << "remote_port not defined in " << config_file << endl;
      ::exit(1);
   }
   unsigned long remote_port = dummy;
   const char* remote_host = NCONF_get_string(conf,sec,"remote_host");
   if ( 0 == remote_host )
   {
      cerr << "remote_host not defined in " << config_file << endl;
      ::exit(1);
   }
   CODEX_Client::Client client;
   client.setRemoteServer( remote_host , remote_port );


   // Get the certificate and public key
   CODEX_ASN1::Certificate* clientCert = new CODEX_ASN1::Certificate;
   clientCert->fromPEMFile( NCONF_get_string(conf,sec,"client_cert_file") );

   CODEX_Ciphers::RSAPublicKey pubKey( clientCert->value() );


   // Get the private key
   CODEX_Ciphers::RSAPrivateKey* privKey = new CODEX_Ciphers::RSAPrivateKey;
   string private_file = NCONF_get_string(conf,sec,"client_private_file");
   string private_pwd = NCONF_get_string(conf,sec,"private_key_passwd");
   privKey->fromPEMFile( private_file.data(), private_pwd.data() );


   // This takes ownership of the memory.
   client.setKeyPair( clientCert, privKey );

   // Initialize the service's public key.
   CODEX_ASN1::Certificate serviceCert;
   serviceCert.fromPEMFile( NCONF_get_string(conf,sec,"service_cert_file") );
   CODEX_Ciphers::RSAPublicKey* serviceKey =
      new CODEX_Ciphers::RSAPublicKey( serviceCert.value() );
   client.setServiceKey( serviceKey );

   // Create a policy
   CODEX_Ciphers::Policy* policy = client.createPolicy( pubKey, *privKey );

   // Pause for awhile to allow transients to settle out on the servers.
   sleep(300);

   // Now loop a number of times to collect statistics.
   for ( unsigned char i = 0 ; i < 110 ; ++i )
   {
      // Begin by waiting, to space the requests out and avoid overloading
      // the network.
      sleep(30);
      cout << (unsigned int)i << endl;

      CODEX_ASN1::ustring keyName;
      keyName += i;

      CODEX_Client::SignedBoundNameMsg boundNameMsg;

      if ( ! client.createKey( keyName,
                               *clientCert,
                               *policy,
                               *policy,
                               boundNameMsg ) )
      {
         cerr << "error in createKey" << endl;
         return 1;
      }

      const BIGNUM * keyVal = privKey->d().value();
      CODEX_Ciphers::Credentials* credentials =
         client.issueCredentials( pubKey, *privKey );
      if ( ! client.writeKey( keyName,
                              keyVal,
                              *credentials,
                              *privKey,
                              boundNameMsg ) )
      {
         cerr << "error in writeKey" << endl;
         return 1;
      }

      BIGNUM * pKeyVal;
      if ( ! client.readKey( keyName,
                             *credentials,
                             *privKey,
                             &pKeyVal ) )
      {
         cerr << "error in readKey" << endl;
         return 1;
      }
      if ( 0 != BN_cmp( keyVal, pKeyVal ) )
      {
         cerr << "values do not match!" << endl;
         return 1;
      }
   }

   return 0;
}

---