t_secret_squirrel.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_secret_string                                                *
*  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/chaos.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <crypto/secret_string.h>
#include <data_struct/static_memory_gremlin.h>
#include <loggers/file_logger.h>
#include <opsystem/filename.h>
#include <opsystem/path_configuration.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/byte_format.h>
#include <textual/string_manipulation.h>

HOOPLE_STARTUP_CODE;

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

const int TEST_ITERATIONS = 100000;

// 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
};

istring get_base(const istring &to_strip)
{
  filename ted = filename(to_strip);
  return ted.basename().raw();
}

SAFE_STATIC(istring_object, APP_NAME,
    (get_base(portable::application_name())) )

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);
    secret_string encryptor(the_key);

    istring to_encrypt_1("I solely forged the permaderm butter arch, man.");
    istring enco = encryptor.encrypt_string(to_encrypt_1);
    LOG("test 1: encoded form...");
    LOG(enco);
    byte_array just_bytes;
    byte_format::string_to_bytes(enco, just_bytes);
    just_bytes += byte(0);
    LOG("test 1: encrypted shown as text...");
    LOG((char *)just_bytes.observe());

    istring deco = encryptor.decrypt_string(enco);
    if (deco != to_encrypt_1)
      deadly_error(APP_NAME(), 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);
    secret_string encryptor(the_key);

    istring to_encrypt_2("Jubel toasted a smarmadillo over the open fame.");
    istring enco = encryptor.encrypt_string(to_encrypt_2);
    LOG("test 2: encoded form...");
    LOG(enco);
    byte_array just_bytes;
    byte_format::string_to_bytes(enco, just_bytes);
    just_bytes += byte(0);
    LOG("test 2: encrypted shown as text...");
    LOG((char *)just_bytes.observe());

    istring deco = encryptor.decrypt_string(enco);
    if (deco != to_encrypt_2) 
      deadly_error(APP_NAME(), GROUP, "the decrypted data is erroneous");
    #undef GROUP
  }
  {
    // test group 3: random keys and random encodings.
    #define GROUP "test group 3: random keys"

    LOG(istring("starting--") + GROUP);

    chaos randomizer;

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

      // 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));

      secret_string encryptor(the_key);

      // pick something to encode.
      istring jughead = string_manipulation::make_random_name(100, 1000);

      // now encode it.
      istring enco = encryptor.encrypt_string(jughead);

      // now, with little ado, decode it.
      istring deco = encryptor.decrypt_string(enco);

      if (deco != jughead)
        deadly_error(APP_NAME(), GROUP, "the decrypted data is erroneous");
      #undef GROUP
    }
  }

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

  return 0;
}

---