test_c_client.c

/*
 * 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: test_c_client.c,v 1.2 2004/05/19 15:56:46 mmarsh Exp $
 *
 * $Log: test_c_client.c,v $
 * Revision 1.2  2004/05/19 15:56:46  mmarsh
 * *** empty log message ***
 *
 * Revision 1.1  2003/11/06 18:16:08  mmarsh
 * New example client written in C.  This is based on timing_client.cc,
 * and has the same functionality.  The intent is to
 * (a) provide sample code for using the C functions in
 *     CODEX_Client/client_functions.h, and
 * (b) test the implementation of the C functions.
 *
 *
 */

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

#include "CODEX_Client/client_functions.h"

void get_cert( CONF* conf,
               const char* sec,
               const char* name,
               X509** cert )
{
   const char* fname;
   FILE* fp;

   fname = NCONF_get_string(conf,sec,name);
   if ( NULL == fname )
   {
      fprintf(stderr,
              "No variable %s found in section %s of %s\n",name,sec,fname);
      exit(1);
   }
   fp = fopen( fname, "r" );
   if ( NULL == fp )
   {
      fprintf(stderr,"Could not open file %s\n",fname);
      exit(1);
   }
   if ( ! PEM_read_X509( fp, cert, NULL, NULL ) )
   {
      fprintf(stderr,"Error reading %s\n",fname);
      fclose(fp);
      exit(1);
   }
   fclose(fp);
}

void get_priv_key( CONF* conf,
                   const char* sec,
                   const char* name,
                   const char* passwd,
                   RSA** key )
{
   const char* fname;
   const char* pwd;
   FILE* fp;

   fname = NCONF_get_string(conf,sec,name);
   pwd = NCONF_get_string(conf,sec,passwd);
   if ( NULL == fname )
   {
      fprintf(stderr,
              "No variable %s found in section %s of %s\n",name,sec,fname);
      exit(1);
   }
   fp = fopen( fname, "r" );
   if ( NULL == fp )
   {
      fprintf(stderr,"Could not open file %s\n",fname);
      exit(1);
   }
   if ( ! PEM_read_RSAPrivateKey( fp,
                                  key,
                                  NULL,
                                  (void*)pwd ) )
   {
      fprintf(stderr,"Error reading %s\n",fname);
      fclose(fp);
      exit(1);
   }
   fclose(fp);
}


int main( int argc, char** argv )
{
   /* variables */
   int arg = 0;
   char* config_file = 0;
   char* config_section = 0;
   const char* usage_string =
      "Usage: example_client -c <config_file> [-s <section>]";
   CONF* conf;
   const char* sec;
   long dummy;
   unsigned long remote_port;
   const char* remote_host;
   X509* client_cert = 0;
   X509* service_cert = 0;
   RSA* client_pub_key;
   RSA* client_priv_key = 0;
   unsigned char i;
   unsigned char* keyName;
   int length;
   codex_binding_t binding;
   codex_policy_t policy;
   const BIGNUM* keyVal;
   codex_credentials_t credentials;
   BIGNUM * pKeyVal;


   /* initialize structures */
   codex_zero_binding(&binding);
   codex_zero_policy(&policy);
   codex_zero_credentials(&credentials);


   /* initialize OpenSSL */
   SSLeay_add_ssl_algorithms();


   /* parse command line */
   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 '?' :
            fprintf(stderr,"%s\n",usage_string);
            return 1;
      }
   }
   if ( ( 0 == config_file ) || ( 0 == strlen(config_file) ) )
   {
      fprintf(stderr,"%s\n",usage_string);
      return 1;
   }
   conf = NCONF_new(NCONF_default());
   if ( 0 == NCONF_load(conf,config_file,0) )
   {
      fprintf(stderr,"Cannot open %s\n",config_file);
      return 1;
   }
   sec = config_section;


   /* get remote server information */
   if ( ! NCONF_get_number_e(conf,sec,"remote_port",&dummy) )
   {
      fprintf(stderr,"remove_port not defined in %s\n",config_file);
      return 1;
   }
   remote_port = dummy;
   remote_host = NCONF_get_string(conf,sec,"remote_host");
   if ( 0 == remote_host )
   {
      fprintf(stderr,"remote_host not defined in %s\n",config_file);
      return 1;
   }

   codex_set_server( remote_host, remote_port );


   /* Get the certificate and public key */
   get_cert(conf,sec,"client_cert_file",&client_cert);
   client_pub_key = EVP_PKEY_get1_RSA(X509_get_pubkey(client_cert));

   /* Get the private key */
   get_priv_key( conf, sec,
                 "client_private_file", "private_key_passwd",
                 &client_priv_key );


   /* This does not take ownership of the memory. */
   codex_set_key_pair( client_cert, client_priv_key );

   /* Initialize the service's public key. */
   get_cert(conf,sec,"service_cert_file",&service_cert);
   codex_set_service_key( service_cert );

   /* Create a policy */
   if ( ! codex_create_policy( client_pub_key,
                               client_priv_key,
                               &policy ) )
   {
      fprintf(stderr,"Error creating policy\n");
      exit(1);
   }

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

   /* Now loop a number of times to collect statistics. */
   for ( i = 0 ; i < 10 ; ++i )
   {
      /* Begin by waiting, to space the requests out and avoid overloading
       * the network.
       */
      sleep(3);
      fprintf(stdout,"%d\n",i);
      fflush(stdout);

      length = 1;
      keyName = (unsigned char*) malloc(length*sizeof(unsigned char));
      keyName[0] = i;

      if ( ! codex_create_key( keyName,
                               length,
                               client_cert,
                               &policy,
                               &policy,
                               &binding ) )
      {
         fprintf(stderr,"error in codex_create_key\n");
         return 1;
      }

      keyVal = client_priv_key->d;
      if ( ! codex_issue_credentials( client_pub_key,
                                      client_priv_key,
                                      &credentials ) )
      {
         fprintf(stderr,"error in codex_issue_credentials\n");
         return 1;
      }
      if ( ! codex_write_key( keyName,
                              length,
                              keyVal,
                              &credentials,
                              client_priv_key,
                              &binding ) )
      {
         fprintf(stderr,"error in codex_write_key\n");
         return 1;
      }

      if ( ! codex_read_key( keyName,
                             length,
                             &credentials,
                             client_priv_key,
                             &pKeyVal ) )
      {
         fprintf(stderr,"error in codex_read_key\n");
         return 1;
      }
      if ( 0 != BN_cmp( keyVal, pKeyVal ) )
      {
         fprintf(stderr,"values do not match!\n");
         return 1;
      }
   }

   return 0;
}

---