t_ice_key.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_ice_key                                                      *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1996-$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/guards.h>
#include <basis/istring.h>
#include <crypto/ice_key.h>
#include <loggers/file_logger.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/byte_format.h>

HOOPLE_STARTUP_CODE;

#define LOG(s) program_wide_logger().log(s)

// define the specific keys that we use.
byte TEST_KEY_1[] = {
  0x28, 0x94, 0x32, 0x99, 0xFE, 0x2B, 0x9F, 0x75,
  0x47, 0x26, 0xC8, 0x37, 0xED, 0x59, 0x8E, 0x1B
};

byte TEST_KEY_2[] = {
  0x92, 0x18, 0x2C, 0xF8, 0xCE, 0xEE, 0x34, 0xD0,
  0x91, 0x23, 0x85, 0x5C, 0xBB, 0x7A, 0x98, 0x85,
  0x12, 0x02, 0xF0, 0xE8, 0x14, 0x83, 0x9E, 0x3D,
  0x38, 0x23, 0xB0, 0x9D, 0x7D, 0x3D, 0x92, 0x94
};

#define PROGRAM "ice_key tester"

const int TEST_ITERATIONS = 8;

int main(int formal(argc), char *formal(argv)[])
{
  SET_DEFAULT_COMBO_LOGGER;

  {
    // test group 1: test using a particular key.
    #define GROUP "test group 1: specific key"

    byte_array the_key(sizeof(TEST_KEY_1), TEST_KEY_1);
    ice_key encryptor(sizeof(TEST_KEY_1) / 8);
    encryptor.set(the_key);

    istring to_encrypt_1("I solely forged the permaderm butter arch, man.");
    byte_array tmp1(to_encrypt_1.length() + 1, (byte *)to_encrypt_1.s());
    byte_array encrypted1;
    encryptor.encrypt(tmp1, encrypted1);
    LOG("test 1: encoded form...");
    istring dumped_1a = byte_format::text_dump(encrypted1.observe(), encrypted1.length());
    LOG(dumped_1a);

    byte_array decoded1;
    encryptor.decrypt(encrypted1, decoded1);
    if (tmp1.length() != decoded1.length())
      deadly_error(PROGRAM, GROUP, "the length of the returned data "
          "is incorrect");
    istring got_back_1((char *)decoded1.observe());
    if (got_back_1 != to_encrypt_1) 
      deadly_error(PROGRAM, GROUP, "the decrypted data is erroneous");
    #undef GROUP
  }

  {
    // test group 2: using a longer key.
    #define GROUP "test group 2: longer key"

    byte_array the_key(sizeof(TEST_KEY_2), TEST_KEY_2);
    ice_key encryptor(sizeof(TEST_KEY_2) / 8);
    encryptor.set(the_key);

    istring to_encrypt_2("I solely forged the permaderm butter arch, man.");
    byte_array tmp2(to_encrypt_2.length() + 1, (byte *)to_encrypt_2.s());
    byte_array encrypted2;
    encryptor.encrypt(tmp2, encrypted2);
    LOG("test 2: encoded form...");
    istring dumped_2a = byte_format::text_dump(encrypted2.observe(), encrypted2.length());
    LOG(dumped_2a);

    byte_array decoded2;
    encryptor.decrypt(encrypted2, decoded2);
    if (tmp2.length() != decoded2.length())
      deadly_error(PROGRAM, GROUP, "the length of the returned data "
          "is incorrect");
    istring got_back_2((char *)decoded2.observe());
    if (got_back_2 != to_encrypt_2) 
      deadly_error(PROGRAM, GROUP, "the decrypted data is erroneous");
    #undef GROUP
  }
  {
    // test group 3: random keys and random encodings.
    #define GROUP "test group 3: random keys"

    chaos randomizer;

    for (int outer = 0; outer < TEST_ITERATIONS; outer++) {
      // pick a random key size.
      int key_size = randomizer.inclusive(1, 6);
      ice_key encryptor(key_size);

      // pick a random key.
      byte_array the_key(key_size * 8);
      int i;  // loop variable used in multiple loops.
      for (i = 0; i < the_key.length(); i++)
        the_key[i] = byte(randomizer.inclusive(0, 255));

      encryptor.set(the_key);

      // pick something to encode.
      byte_array to_encode(randomizer.inclusive(50, 53849));
      for (i = 0; i < to_encode.length(); i++)
        to_encode[i] = byte(randomizer.inclusive(0, 255));

      // now encode it.
      byte_array encoded_form;
      encryptor.encrypt(to_encode, encoded_form);

      // now, with little ado, decode it.
      byte_array decoded_form;
      encryptor.decrypt(encoded_form, decoded_form);

      if (to_encode.length() != decoded_form.length())
        deadly_error(PROGRAM, GROUP, "the length of the returned data "
            "is incorrect");
      for (i = 0; i < decoded_form.length(); i++)
        if (to_encode[i] != decoded_form[i]) 
          deadly_error(PROGRAM, GROUP, "the decrypted data is erroneous");
      #undef GROUP
    }
    
  }

  istring to_print("ice_key:: works for those functions tested.");
  guards::alert_message(to_print.s());

  return 0;
}

---