blowfish_test.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test blowfish encryption                                          *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Exercises the BlowFish encryption functions from the OpenSSL package.    *
*                                                                             *
*******************************************************************************
* 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/function.h>
#include <basis/istring.h>
#include <mechanisms/time_stamp.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/string_manipulation.h>

#include <openssl/blowfish.h>
#include <openssl/crypto.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/rand.h>

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

HOOPLE_STARTUP_CODE;

const int KEY_SIZE = 402;
  // the size of the BF key that we'll create.

const int TEST_RUNS = 100;
  // the number of cycles of testing.

const int SEED_SIZE = 100;
  // the size of the random seed that we'll use.

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

const int MAX_CHUNK = 1024;
  // the largest chunk of data that we encrypt at a time.

chaos rando;

#define static_class_name() "blowfish_test"

void provide_init_vect(byte_array &new_iv)
{
  new_iv.reset(EVP_MAX_IV_LENGTH);
  for (int i = 0; i < EVP_MAX_IV_LENGTH; i++) new_iv[i] = 214 - i;
}

void generate_key(int size, byte_array &new_key)
{
  new_key.reset(size);
  for (int i = 0; i < size; i++) new_key[i] = rando.inclusive(0, 255);
}

const byte_array &random_seed()
{
  static byte_array seed;
  static bool initted = false;
  if (!initted) {
    for (int i = 0; i < SEED_SIZE; i++) {
      seed += byte(rando.inclusive(0, 255));
    }
    initted = true;
  }
  return seed;
}


bool blowfish_encryption(const byte_array &key, const byte_array &init_vect,
    const byte_array &source, byte_array &target)
{
  FUNCDEF("blowfish_encryption");
  target.reset();
  bool to_return = true;

  // initialize an encoding session.
  EVP_CIPHER_CTX session;
  EVP_CIPHER_CTX_init(&session);
  EVP_EncryptInit(&session, EVP_bf_cbc(), key.observe(), init_vect.observe());
  EVP_CIPHER_CTX_set_key_length(&session, key.length());

  byte_array cipher(MAX_CHUNK + 100);  // temporary space for encrypted data.
  for (int i = 0; i < source.length(); i += MAX_CHUNK) {
    // calculate the extent of what's included.
    int edge = i + MAX_CHUNK - 1;
    if (edge > source.last())
      edge = source.last();
    int next_chunk = edge - i + 1;
    int cipher_len = 0;
    // encrypt the current range.
    int enc_ret = EVP_EncryptUpdate(&session, cipher.access(), &cipher_len,
        &source[i], next_chunk);
    if (enc_ret != 1) {
      continuable_error(static_class_name(), func, "encryption failed.");
      to_return = false;
      break;
    }
    // chop any extra space off.
//    printf("encrypting bytes %d to %d.\n", i, edge);
    cipher.zap(cipher_len, cipher.last());
    target += cipher;
    cipher.reset(MAX_CHUNK + 100);  // reinflate for next cycle.
  }

  // finalize the encryption.
  int pad_len = 0;
  int enc_ret = EVP_EncryptFinal(&session, cipher.access(), &pad_len);
  if (enc_ret != 1) {
    continuable_error(static_class_name(), func, "finalizing encryption failed.");
    to_return = false;
  } else {
//    printf("padding added %d bytes.\n", pad_len);
    cipher.zap(pad_len, cipher.last());
    target += cipher;
  }

  EVP_CIPHER_CTX_cleanup(&session);
  return to_return;
}

bool blowfish_decryption(const byte_array &key, const byte_array &init_vect,
    const byte_array &source, byte_array &target)
{
  FUNCDEF("blowfish_decryption");
  target.reset();
  bool to_return = true;
  EVP_CIPHER_CTX session;
  EVP_CIPHER_CTX_init(&session);
  EVP_DecryptInit(&session, EVP_bf_cbc(), key.observe(), init_vect.observe());
  EVP_CIPHER_CTX_set_key_length(&session, key.length());

  byte_array uncipher(MAX_CHUNK + 100);
  for (int i = 0; i < source.length(); i += MAX_CHUNK) {
    int edge = i + MAX_CHUNK - 1;
    if (edge > source.last())
      edge = source.last();
    int next_chunk = edge - i + 1;
//    printf("decrypting bytes %d to %d.\n", i, edge);
    int uncipher_len = 0;
    int dec_ret = EVP_DecryptUpdate(&session, uncipher.access(), &uncipher_len,
        &source[i], next_chunk);
    if (dec_ret != 1) {
      continuable_error(static_class_name(), func, "decryption failed.");
      to_return = false;
      break;
    }
//    printf("  decrypted size in bytes is %d.\n", uncipher_len);
    uncipher.zap(uncipher_len, uncipher.last());
    target += uncipher;
    uncipher.reset(MAX_CHUNK + 100);
  }

  int pad_len = 0;
  int dec_ret = EVP_DecryptFinal(&session, uncipher.access(), &pad_len);
//  printf("padding added %d bytes.\n", pad_len);
  if (dec_ret != 1) {
    continuable_error(static_class_name(), func, "finalizing decryption failed.");
    to_return = false;
  } else {
    int dec_size = pad_len;
    uncipher.zap(dec_size, uncipher.last());
    target += uncipher;
  }

  EVP_CIPHER_CTX_cleanup(&session);
  return to_return;
}


int main(int formal(argc), char *formal(argv)[])
{
  FUNCDEF("main");
  CRYPTO_malloc_debug_init();

  CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);

  CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);

  RAND_seed(random_seed().observe(), SEED_SIZE);

  istring fodder = string_manipulation::make_random_name(MAX_STRING + 1,
      MAX_STRING + 1);

  time_stamp start;

  for (int i = 0; i < TEST_RUNS; i++) {
    time_stamp start;
    byte_array key;
    byte_array iv;
    provide_init_vect(iv);
    generate_key(KEY_SIZE, key);
    int key_durat = int(time_stamp().value() - start.value());

    int string_start = rando.inclusive(0, MAX_STRING);
    int string_end = rando.inclusive(0, MAX_STRING);
    flip_increasing(string_start, string_end);
    istring ranstring = fodder.substring(string_start, string_end);
//printf("encoding %s\n", ranstring.s());

    byte_array target;

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

    byte_array recovered;
    start.reset();
    worked = blowfish_decryption(key, iv, target, recovered);
    int dec_durat = int(time_stamp().value() - 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)
      deadly_error(static_class_name(), func, "failed to regenerate the original string!");

    printf("key generation: %d ms, encrypt: %d ms, decrypt: %d ms\n",
         key_durat, enc_durat, dec_durat);
    printf("data size: %d bytes\n", string_end - string_start + 1);
    printf("\n");
  }

  int duration = int(time_stamp().value() - start.value());
  printf("duration for %d keys and encrypt/decrypt=%d ms,\n",
      TEST_RUNS, duration);
  printf("that comes to %d ms per cycle.\n", duration / TEST_RUNS);

  CRYPTO_cleanup_all_ex_data();
  ERR_remove_state(0);

  CRYPTO_mem_leaks_fp(stderr);

  return 0;
}

#undef static_class_name

---