t_blowfish_crypto.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test blowfish encryption                                          *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Exercises the BlowFish encryption methods in the crypto library.         *
*                                                                             *
*******************************************************************************
* Copyright (c) 2005-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include <basis/byte_array.h>
#include <basis/chaos.h>
#include <basis/istring.h>
#include <crypto/blowfish_crypto.h>
#include <data_struct/unique_id.h>
#include <mechanisms/ithread.h>
#include <mechanisms/time_stamp.h>
#include <mechanisms/thread_cabinet.h>
#include <opsystem/application_shell.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/byte_format.h>
#include <textual/string_manipulation.h>

#include <stdio.h>
#include <string.h>

const int TEST_RUNS_PER_KEY = 20;  // encryption test cycles done on each key.

const int THREAD_COUNT = 30;  // number of threads testing blowfish at once.

const int ITERATIONS = 14;  // number of test runs in our testing threads.

const int MAX_STRING = 1000000;  // largest chunk that we'll try to encrypt.


class test_blowfish;  // forward.

class blowfish_thread : public ithread
{
public:
  blowfish_thread(test_blowfish &parent) : ithread(), _parent(parent) {}

  void perform_activity(void *ptr);
    // try out random blowfish keys on randomly chosen chunks of the fodder.

private:
  test_blowfish &_parent;
};


class test_blowfish : public application_shell
{
public:
  test_blowfish()
  : application_shell(static_class_name()),
   _fodder(string_manipulation::make_random_name
        (MAX_STRING + 1, MAX_STRING + 1)) {}
  virtual ~test_blowfish() {}
  IMPLEMENT_CLASS_NAME("test_blowfish");

  int execute();

private:
  istring _fodder;  // chunks taken from this are encrypted and decrypted.
  time_stamp _program_start;  // the time at which we started executing.
  thread_cabinet _threads;  // manages our testing threads.
  friend class blowfish_thread;  // bad practice, but saves time in test app.
};

int test_blowfish::execute()
{
  FUNCDEF("execute");
  int left = THREAD_COUNT;
  while (left--) {
    _threads.add_thread(new blowfish_thread(*this), true, NIL);
  }

  while (_threads.threads()) {
printf("cleaning debris.\n");
    _threads.clean_debris();
    portable::sleep_ms(1000);
  }

  int duration = int(time_stamp().value() - _program_start.value());
  printf("duration for %d keys and encrypt/decrypt=%d ms,\n",
      ITERATIONS * TEST_RUNS_PER_KEY * THREAD_COUNT, duration);
  printf("that comes to %d ms per cycle.\n", int(double(duration
      / TEST_RUNS_PER_KEY / ITERATIONS / THREAD_COUNT)));

  return 0;
}


void blowfish_thread::perform_activity(void *)
{
  FUNCDEF("perform_activity");
  int left = ITERATIONS;
  while (left--) {
    time_stamp key_start;
    blowfish_crypto bc(_parent.randomizer().inclusive
        (blowfish_crypto::minimum_key_size(),
         blowfish_crypto::maximum_key_size()));
    printf("%d bit key has:\n", bc.key_size());
    istring dumped_key = byte_format::text_dump(bc.get_key());
    printf("%s", dumped_key.s());
    int key_dur = int(time_stamp().value() - key_start.value());

    printf("  key generation took %d ms\n", key_dur);

    for (int i = 0; i < TEST_RUNS_PER_KEY; i++) {
      byte_array key;
      byte_array iv;

      int string_start = _parent.randomizer().inclusive(0, MAX_STRING - 1);
      int string_end = _parent.randomizer().inclusive(0, MAX_STRING - 1);
      flip_increasing(string_start, string_end);
      istring ranstring = _parent._fodder.substring(string_start, string_end);
//printf("encoding %s\n", ranstring.s());
//printf("string length encoded: %d\n", ranstring.length());

      byte_array target;

      time_stamp test_start;
      bool worked = bc.encrypt(byte_array(ranstring.length() + 1,
          (byte*)ranstring.s()), target);
      int enc_durat = int(time_stamp().value() - test_start.value());
      if (!worked)
        deadly_error("blowfish_test", "phase 1", "failed to encrypt the string!");

      byte_array recovered;
      test_start.reset();
      worked = bc.decrypt(target, recovered);
      int dec_durat = int(time_stamp().value() - test_start.value());
      if (!worked)
        deadly_error("blowfish_test", "phase 1", "failed to decrypt the string!");
//    printf("original has %d chars, recovered has %d chars\n",
//        ranstring.length(), recovered.length() - 1);

      istring teddro = (char *)recovered.observe();
//printf("decoded %s\n", teddro.s());

      if (teddro != ranstring) {
        printf("error!\toriginal has %d chars, recovered has %d chars\n",
            ranstring.length(), recovered.length() - 1);
        printf("\tencoded %s\n", ranstring.s());
        printf("\tdecoded %s\n", teddro.s());
        deadly_error(class_name(), func, "failed to regenerate the "
            "original string!");
      }

      printf("  encrypt %d ms, decrypt %d ms, data %d bytes\n",
           enc_durat, dec_durat, string_end - string_start + 1);
      portable::sleep_ms(0);  // take a rest.
    }
    portable::sleep_ms(0);  // take a rest.
  }
}

HOOPLE_MAIN(test_blowfish, )

---