lib/silcacc/tests/test_softacc_cipher2.c

   1 /*
   2
   3   test_softacc_cipher2.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2008 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 /* Test that the software accelerated cipher encrypts and decrypts
  21    correctly. */
  22
  23 #include "silccrypto.h"
  24 #include "softacc.h"
  25
  26 #define ENC_LEN 799             /* enc data len */
  27 #define ENC_ROUND 10000         /* enc rounds */
  28
  29 SilcCipher enc_cipher, enc_acc_cipher;
  30 SilcCipher dec_cipher, dec_acc_cipher;
  31
  32 int main(int argc, char **argv)
  33 {
  34   SilcBool success = FALSE;
  35   unsigned char *data, iv[SILC_CIPHER_MAX_IV_SIZE];
  36   SilcUInt32 i, k;
  37
  38   silc_runtime_init();
  39   silc_crypto_init(NULL);
  40
  41   if (argc > 1 && !strcmp(argv[1], "-d")) {
  42     silc_log_debug(TRUE);
  43     silc_log_debug_hexdump(TRUE);
  44     silc_log_set_debug_string("*acc*,*cipher*,*twofish*");
  45   }
  46
  47   if (!silc_acc_init(SILC_SOFTACC, (void *)0x01, "min_threads", 2,
  48                      "max_threads", 8, NULL))
  49     exit(1);
  50
  51   data = malloc(ENC_LEN * sizeof(*data));
  52   if (!data)
  53     exit(1);
  54
  55   /* Plaintext */
  56   for (i = 0; i < ENC_LEN; i++)
  57     data[i] = i % 255;
  58   SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
  59
  60   /* IV */
  61   for (i = 0; i < SILC_CIPHER_MAX_IV_SIZE; i++)
  62     iv[i] = i % 255;
  63
  64   SILC_LOG_HEXDUMP(("IV"), iv, SILC_CIPHER_MAX_IV_SIZE);
  65
  66   for (i = 0; silc_default_ciphers[i].name; i++) {
  67     if (!silc_cipher_alloc(silc_default_ciphers[i].name, &enc_cipher)) {
  68       fprintf(stderr, "Error allocating %s\n", silc_default_ciphers[i].name);
  69       exit(1);
  70     }
  71     if (!silc_cipher_alloc(silc_default_ciphers[i].name, &dec_cipher)) {
  72       fprintf(stderr, "Error allocating %s\n", silc_default_ciphers[i].name);
  73       exit(1);
  74     }
  75
  76     enc_acc_cipher = silc_acc_cipher(SILC_SOFTACC, enc_cipher);
  77     if (!enc_acc_cipher)
  78       continue;
  79     dec_acc_cipher = silc_acc_cipher(SILC_SOFTACC, dec_cipher);
  80     if (!dec_acc_cipher)
  81       continue;
  82
  83     SILC_LOG_DEBUG(("Allocated cipher %s", silc_default_ciphers[i].name));
  84
  85     SILC_LOG_DEBUG(("Set key"));
  86     silc_cipher_set_key(enc_acc_cipher, data,
  87                         silc_cipher_get_key_len(enc_cipher),
  88                         TRUE);
  89     silc_cipher_set_key(dec_acc_cipher, data,
  90                         silc_cipher_get_key_len(dec_cipher),
  91                         FALSE);
  92
  93
  94     SILC_LOG_DEBUG(("Set IV"));
  95     silc_cipher_set_iv(enc_acc_cipher, iv);
  96
  97     SILC_LOG_DEBUG(("Encrypt with accelerated cipher"));
  98     for (k = 0; k < ENC_ROUND; k++)
  99       silc_cipher_encrypt(enc_acc_cipher, data, data, ENC_LEN, NULL);
 100     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 101
 102     SILC_LOG_DEBUG(("Set IV"));
 103     silc_cipher_set_iv(dec_cipher, iv);
 104
 105     SILC_LOG_DEBUG(("Decrypt with associated cipher"));
 106     for (k = 0; k < ENC_ROUND; k++)
 107       silc_cipher_decrypt(dec_cipher, data, data, ENC_LEN, NULL);
 108     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 109
 110     /* Verify */
 111     SILC_LOG_DEBUG(("Verify"));
 112     for (k = 0; k < ENC_LEN; k++)
 113       if (data[k] != k % 255)
 114         goto err;
 115     SILC_LOG_DEBUG(("Ok"));
 116
 117
 118     SILC_LOG_DEBUG(("Set IV"));
 119     silc_cipher_set_iv(enc_cipher, iv);
 120
 121     SILC_LOG_DEBUG(("Encrypt with associated cipher"));
 122     for (k = 0; k < ENC_ROUND; k++)
 123       silc_cipher_encrypt(enc_cipher, data, data, ENC_LEN, NULL);
 124     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 125
 126     SILC_LOG_DEBUG(("Set IV"));
 127     silc_cipher_set_iv(dec_acc_cipher, iv);
 128
 129     SILC_LOG_DEBUG(("Decrypt with accelerated cipher"));
 130     for (k = 0; k < ENC_ROUND; k++)
 131       silc_cipher_decrypt(dec_acc_cipher, data, data, ENC_LEN, NULL);
 132     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 133
 134     /* Verify */
 135     SILC_LOG_DEBUG(("Verify"));
 136     for (k = 0; k < ENC_LEN; k++)
 137       if (data[k] != k % 255)
 138         goto err;
 139     SILC_LOG_DEBUG(("Ok"));
 140
 141
 142     SILC_LOG_DEBUG(("Set IV"));
 143     silc_cipher_set_iv(enc_acc_cipher, iv);
 144
 145     SILC_LOG_DEBUG(("Encrypt with accelerated cipher"));
 146     for (k = 0; k < ENC_ROUND; k++)
 147       silc_cipher_encrypt(enc_acc_cipher, data, data, ENC_LEN, NULL);
 148     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 149
 150     SILC_LOG_DEBUG(("Set IV"));
 151     silc_cipher_set_iv(dec_acc_cipher, iv);
 152
 153     SILC_LOG_DEBUG(("Decrypt with accelerated cipher"));
 154     for (k = 0; k < ENC_ROUND; k++)
 155       silc_cipher_decrypt(dec_acc_cipher, data, data, ENC_LEN, NULL);
 156     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 157
 158     /* Verify */
 159     SILC_LOG_DEBUG(("Verify"));
 160     for (k = 0; k < ENC_LEN; k++)
 161       if (data[k] != k % 255)
 162         goto err;
 163     SILC_LOG_DEBUG(("Ok"));
 164
 165
 166     SILC_LOG_DEBUG(("Set IV"));
 167     silc_cipher_set_iv(enc_cipher, iv);
 168
 169     SILC_LOG_DEBUG(("Encrypt with associated cipher"));
 170     for (k = 0; k < ENC_ROUND; k++)
 171       silc_cipher_encrypt(enc_cipher, data, data, ENC_LEN, NULL);
 172     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 173
 174     SILC_LOG_DEBUG(("Set IV"));
 175     silc_cipher_set_iv(dec_cipher, iv);
 176
 177     SILC_LOG_DEBUG(("Decrypt with associated cipher"));
 178     for (k = 0; k < ENC_ROUND; k++)
 179       silc_cipher_decrypt(dec_cipher, data, data, ENC_LEN, NULL);
 180     SILC_LOG_HEXDUMP(("data"), data, ENC_LEN);
 181
 182     /* Verify */
 183     SILC_LOG_DEBUG(("Verify"));
 184     for (k = 0; k < ENC_LEN; k++)
 185       if (data[k] != k % 255)
 186         goto err;
 187     SILC_LOG_DEBUG(("Ok"));
 188
 189
 190     silc_cipher_free(enc_acc_cipher);
 191     silc_cipher_free(enc_cipher);
 192     silc_cipher_free(dec_acc_cipher);
 193     silc_cipher_free(dec_cipher);
 194   }
 195
 196   silc_acc_uninit(SILC_SOFTACC);
 197
 198   success = TRUE;
 199
 200  err:
 201   SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
 202   fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");
 203
 204   silc_crypto_uninit();
 205   silc_runtime_uninit();
 206
 207   return !success;
 208 }