test/igetest.c

   1 /*
   2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/crypto.h>
  11 #include <openssl/aes.h>
  12 #include <openssl/rand.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include "e_os.h"
  16 #include "testutil.h"
  17
  18 #define TEST_SIZE       128
  19 #define BIG_TEST_SIZE 10240
  20
  21 #if BIG_TEST_SIZE < TEST_SIZE
  22 #error BIG_TEST_SIZE is smaller than TEST_SIZE
  23 #endif
  24
  25 static unsigned char rkey[16];
  26 static unsigned char rkey2[16];
  27 static unsigned char plaintext[BIG_TEST_SIZE];
  28 static unsigned char saved_iv[AES_BLOCK_SIZE * 4];
  29
  30 #define MAX_VECTOR_SIZE 64
  31
  32 struct ige_test {
  33     const unsigned char key[16];
  34     const unsigned char iv[32];
  35     const unsigned char in[MAX_VECTOR_SIZE];
  36     const unsigned char out[MAX_VECTOR_SIZE];
  37     const size_t length;
  38     const int encrypt;
  39 };
  40
  41 static struct ige_test const ige_test_vectors[] = {
  42     {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  43       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key */
  44      {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  45       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  46       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  47       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* iv */
  48      {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  49       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  50       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  51       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
  52      {0x1a, 0x85, 0x19, 0xa6, 0x55, 0x7b, 0xe6, 0x52,
  53       0xe9, 0xda, 0x8e, 0x43, 0xda, 0x4e, 0xf4, 0x45,
  54       0x3c, 0xf4, 0x56, 0xb4, 0xca, 0x48, 0x8a, 0xa3,
  55       0x83, 0xc7, 0x9c, 0x98, 0xb3, 0x47, 0x97, 0xcb}, /* out */
  56      32, AES_ENCRYPT},          /* test vector 0 */
  57
  58     {{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
  59       0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65}, /* key */
  60      {0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
  61       0x6e, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x47, 0x45,
  62       0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f,
  63       0x72, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x53}, /* iv */
  64      {0x4c, 0x2e, 0x20, 0x4c, 0x65, 0x74, 0x27, 0x73,
  65       0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x42, 0x65,
  66       0x6e, 0x20, 0x67, 0x6f, 0x74, 0x20, 0x69, 0x74,
  67       0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x21, 0x0a}, /* in */
  68      {0x99, 0x70, 0x64, 0x87, 0xa1, 0xcd, 0xe6, 0x13,
  69       0xbc, 0x6d, 0xe0, 0xb6, 0xf2, 0x4b, 0x1c, 0x7a,
  70       0xa4, 0x48, 0xc8, 0xb9, 0xc3, 0x40, 0x3e, 0x34,
  71       0x67, 0xa8, 0xca, 0xd8, 0x93, 0x40, 0xf5, 0x3b}, /* out */
  72      32, AES_DECRYPT},          /* test vector 1 */
  73 };
  74
  75 struct bi_ige_test {
  76     const unsigned char key1[32];
  77     const unsigned char key2[32];
  78     const unsigned char iv[64];
  79     const unsigned char in[MAX_VECTOR_SIZE];
  80     const unsigned char out[MAX_VECTOR_SIZE];
  81     const size_t keysize;
  82     const size_t length;
  83     const int encrypt;
  84 };
  85
  86 static struct bi_ige_test const bi_ige_test_vectors[] = {
  87     {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  88       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key1 */
  89      {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  90       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* key2 */
  91      {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  92       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  93       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  94       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  95       0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  96       0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  97       0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  98       0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f}, /* iv */
  99      {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 100       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 101       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 102       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
 103      {0x14, 0x40, 0x6f, 0xae, 0xa2, 0x79, 0xf2, 0x56,
 104       0x1f, 0x86, 0xeb, 0x3b, 0x7d, 0xff, 0x53, 0xdc,
 105       0x4e, 0x27, 0x0c, 0x03, 0xde, 0x7c, 0xe5, 0x16,
 106       0x6a, 0x9c, 0x20, 0x33, 0x9d, 0x33, 0xfe, 0x12}, /* out */
 107      16, 32, AES_ENCRYPT},      /* test vector 0 */
 108     {{0x58, 0x0a, 0x06, 0xe9, 0x97, 0x07, 0x59, 0x5c,
 109       0x9e, 0x19, 0xd2, 0xa7, 0xbb, 0x40, 0x2b, 0x7a,
 110       0xc7, 0xd8, 0x11, 0x9e, 0x4c, 0x51, 0x35, 0x75,
 111       0x64, 0x28, 0x0f, 0x23, 0xad, 0x74, 0xac, 0x37}, /* key1 */
 112      {0xd1, 0x80, 0xa0, 0x31, 0x47, 0xa3, 0x11, 0x13,
 113       0x86, 0x26, 0x9e, 0x6d, 0xff, 0xaf, 0x72, 0x74,
 114       0x5b, 0xa2, 0x35, 0x81, 0xd2, 0xa6, 0x3d, 0x21,
 115       0x67, 0x7b, 0x58, 0xa8, 0x18, 0xf9, 0x72, 0xe4}, /* key2 */
 116      {0x80, 0x3d, 0xbd, 0x4c, 0xe6, 0x7b, 0x06, 0xa9,
 117       0x53, 0x35, 0xd5, 0x7e, 0x71, 0xc1, 0x70, 0x70,
 118       0x74, 0x9a, 0x00, 0x28, 0x0c, 0xbf, 0x6c, 0x42,
 119       0x9b, 0xa4, 0xdd, 0x65, 0x11, 0x77, 0x7c, 0x67,
 120       0xfe, 0x76, 0x0a, 0xf0, 0xd5, 0xc6, 0x6e, 0x6a,
 121       0xe7, 0x5e, 0x4c, 0xf2, 0x7e, 0x9e, 0xf9, 0x20,
 122       0x0e, 0x54, 0x6f, 0x2d, 0x8a, 0x8d, 0x7e, 0xbd,
 123       0x48, 0x79, 0x37, 0x99, 0xff, 0x27, 0x93, 0xa3}, /* iv */
 124      {0xf1, 0x54, 0x3d, 0xca, 0xfe, 0xb5, 0xef, 0x1c,
 125       0x4f, 0xa6, 0x43, 0xf6, 0xe6, 0x48, 0x57, 0xf0,
 126       0xee, 0x15, 0x7f, 0xe3, 0xe7, 0x2f, 0xd0, 0x2f,
 127       0x11, 0x95, 0x7a, 0x17, 0x00, 0xab, 0xa7, 0x0b,
 128       0xbe, 0x44, 0x09, 0x9c, 0xcd, 0xac, 0xa8, 0x52,
 129       0xa1, 0x8e, 0x7b, 0x75, 0xbc, 0xa4, 0x92, 0x5a,
 130       0xab, 0x46, 0xd3, 0x3a, 0xa0, 0xd5, 0x35, 0x1c,
 131       0x55, 0xa4, 0xb3, 0xa8, 0x40, 0x81, 0xa5, 0x0b}, /* in */
 132      {0x42, 0xe5, 0x28, 0x30, 0x31, 0xc2, 0xa0, 0x23,
 133       0x68, 0x49, 0x4e, 0xb3, 0x24, 0x59, 0x92, 0x79,
 134       0xc1, 0xa5, 0xcc, 0xe6, 0x76, 0x53, 0xb1, 0xcf,
 135       0x20, 0x86, 0x23, 0xe8, 0x72, 0x55, 0x99, 0x92,
 136       0x0d, 0x16, 0x1c, 0x5a, 0x2f, 0xce, 0xcb, 0x51,
 137       0xe2, 0x67, 0xfa, 0x10, 0xec, 0xcd, 0x3d, 0x67,
 138       0xa5, 0xe6, 0xf7, 0x31, 0x26, 0xb0, 0x0d, 0x76,
 139       0x5e, 0x28, 0xdc, 0x7f, 0x01, 0xc5, 0xa5, 0x4c}, /* out */
 140      32, 64, AES_ENCRYPT},      /* test vector 1 */
 141
 142 };
 143
 144 static int test_ige_vectors(int n)
 145 {
 146     const struct ige_test *const v = &ige_test_vectors[n];
 147     AES_KEY key;
 148     unsigned char buf[MAX_VECTOR_SIZE];
 149     unsigned char iv[AES_BLOCK_SIZE * 2];
 150     int testresult = 1;
 151
 152     if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
 153         return 0;
 154
 155     if (v->encrypt == AES_ENCRYPT)
 156         AES_set_encrypt_key(v->key, 8 * sizeof v->key, &key);
 157     else
 158         AES_set_decrypt_key(v->key, 8 * sizeof v->key, &key);
 159     memcpy(iv, v->iv, sizeof iv);
 160     AES_ige_encrypt(v->in, buf, v->length, &key, iv, v->encrypt);
 161
 162     if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
 163         TEST_info("IGE test vector %d failed", n);
 164         test_output_memory("key", v->key, sizeof v->key);
 165         test_output_memory("iv", v->iv, sizeof v->iv);
 166         test_output_memory("in", v->in, v->length);
 167         testresult = 0;
 168     }
 169
 170     /* try with in == out */
 171     memcpy(iv, v->iv, sizeof iv);
 172     memcpy(buf, v->in, v->length);
 173     AES_ige_encrypt(buf, buf, v->length, &key, iv, v->encrypt);
 174
 175     if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
 176         TEST_info("IGE test vector %d failed (with in == out)", n);
 177         test_output_memory("key", v->key, sizeof v->key);
 178         test_output_memory("iv", v->iv, sizeof v->iv);
 179         test_output_memory("in", v->in, v->length);
 180         testresult = 0;
 181     }
 182
 183     return testresult;
 184 }
 185
 186 static int test_bi_ige_vectors(int n)
 187 {
 188     const struct bi_ige_test *const v = &bi_ige_test_vectors[n];
 189     AES_KEY key1;
 190     AES_KEY key2;
 191     unsigned char buf[MAX_VECTOR_SIZE];
 192
 193         if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
 194             return 0;
 195
 196     if (v->encrypt == AES_ENCRYPT) {
 197         AES_set_encrypt_key(v->key1, 8 * v->keysize, &key1);
 198         AES_set_encrypt_key(v->key2, 8 * v->keysize, &key2);
 199     } else {
 200         AES_set_decrypt_key(v->key1, 8 * v->keysize, &key1);
 201         AES_set_decrypt_key(v->key2, 8 * v->keysize, &key2);
 202     }
 203
 204     AES_bi_ige_encrypt(v->in, buf, v->length, &key1, &key2, v->iv,
 205                        v->encrypt);
 206
 207     if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
 208         test_output_memory("key 1", v->key1, sizeof v->key1);
 209         test_output_memory("key 2", v->key2, sizeof v->key2);
 210         test_output_memory("iv", v->iv, sizeof v->iv);
 211         test_output_memory("in", v->in, v->length);
 212         return 0;
 213     }
 214
 215     return 1;
 216 }
 217
 218 static int test_ige_enc_dec(void)
 219 {
 220     AES_KEY key;
 221     unsigned char iv[AES_BLOCK_SIZE * 4];
 222     unsigned char ciphertext[BIG_TEST_SIZE];
 223     unsigned char checktext[BIG_TEST_SIZE];
 224
 225     memcpy(iv, saved_iv, sizeof iv);
 226     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 227     AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, iv, AES_ENCRYPT);
 228
 229     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 230     memcpy(iv, saved_iv, sizeof iv);
 231     AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);
 232
 233     return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
 234 }
 235
 236 static int test_ige_enc_chaining(void)
 237 {
 238     AES_KEY key;
 239     unsigned char iv[AES_BLOCK_SIZE * 4];
 240     unsigned char ciphertext[BIG_TEST_SIZE];
 241     unsigned char checktext[BIG_TEST_SIZE];
 242
 243     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 244     memcpy(iv, saved_iv, sizeof iv);
 245     AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
 246                     AES_ENCRYPT);
 247     AES_ige_encrypt(plaintext + TEST_SIZE / 2,
 248                     ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
 249                     &key, iv, AES_ENCRYPT);
 250
 251     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 252     memcpy(iv, saved_iv, sizeof iv);
 253     AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);
 254
 255     return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
 256 }
 257
 258 static int test_ige_dec_chaining(void)
 259 {
 260     AES_KEY key;
 261     unsigned char iv[AES_BLOCK_SIZE * 4];
 262     unsigned char ciphertext[BIG_TEST_SIZE];
 263     unsigned char checktext[BIG_TEST_SIZE];
 264
 265     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 266     memcpy(iv, saved_iv, sizeof iv);
 267     AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
 268                     AES_ENCRYPT);
 269     AES_ige_encrypt(plaintext + TEST_SIZE / 2,
 270                     ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
 271                     &key, iv, AES_ENCRYPT);
 272
 273     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 274     memcpy(iv, saved_iv, sizeof iv);
 275     AES_ige_encrypt(ciphertext, checktext, TEST_SIZE / 2, &key, iv,
 276                     AES_DECRYPT);
 277     AES_ige_encrypt(ciphertext + TEST_SIZE / 2,
 278                     checktext + TEST_SIZE / 2, TEST_SIZE / 2, &key, iv,
 279                     AES_DECRYPT);
 280
 281     return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
 282 }
 283
 284 static int test_ige_garble_forwards(void)
 285 {
 286     AES_KEY key;
 287     unsigned char iv[AES_BLOCK_SIZE * 4];
 288     unsigned char ciphertext[BIG_TEST_SIZE];
 289     unsigned char checktext[BIG_TEST_SIZE];
 290     unsigned int n;
 291     int testresult = 1;
 292     const size_t ctsize = sizeof(checktext);
 293     size_t matches;
 294
 295     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 296     memcpy(iv, saved_iv, sizeof iv);
 297     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
 298                     AES_ENCRYPT);
 299
 300     /* corrupt halfway through */
 301     ++ciphertext[sizeof ciphertext / 2];
 302     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 303     memcpy(iv, saved_iv, sizeof iv);
 304     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
 305                     AES_DECRYPT);
 306
 307     matches = 0;
 308     for (n = 0; n < sizeof checktext; ++n)
 309         if (checktext[n] == plaintext[n])
 310             ++matches;
 311
 312     /* Fail if there is more than 51% matching bytes */
 313     if (!TEST_size_t_le(matches, ctsize / 2 + ctsize / 100))
 314         testresult = 0;
 315
 316     /* Fail if the garble goes backwards */
 317     if (!TEST_size_t_gt(matches, ctsize / 2))
 318         testresult = 0;
 319     return testresult;
 320 }
 321
 322 static int test_bi_ige_enc_dec(void)
 323 {
 324     AES_KEY key, key2;
 325     unsigned char iv[AES_BLOCK_SIZE * 4];
 326     unsigned char ciphertext[BIG_TEST_SIZE];
 327     unsigned char checktext[BIG_TEST_SIZE];
 328
 329     memcpy(iv, saved_iv, sizeof iv);
 330     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 331     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 332     AES_bi_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, &key2, iv,
 333                        AES_ENCRYPT);
 334
 335     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 336     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 337     AES_bi_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, &key2, iv,
 338                        AES_DECRYPT);
 339
 340     return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
 341 }
 342
 343 static int test_bi_ige_garble1(void)
 344 {
 345     AES_KEY key, key2;
 346     unsigned char iv[AES_BLOCK_SIZE * 4];
 347     unsigned char ciphertext[BIG_TEST_SIZE];
 348     unsigned char checktext[BIG_TEST_SIZE];
 349     unsigned int n;
 350     size_t matches;
 351
 352     memcpy(iv, saved_iv, sizeof iv);
 353     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 354     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 355     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
 356                     AES_ENCRYPT);
 357
 358     /* corrupt halfway through */
 359     ++ciphertext[sizeof ciphertext / 2];
 360     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 361     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 362     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
 363                     AES_DECRYPT);
 364
 365     matches = 0;
 366     for (n = 0; n < sizeof checktext; ++n)
 367         if (checktext[n] == plaintext[n])
 368             ++matches;
 369
 370     /* Fail if there is more than 1% matching bytes */
 371     return TEST_size_t_le(matches, sizeof checktext / 100);
 372 }
 373
 374 static int test_bi_ige_garble2(void)
 375 {
 376     AES_KEY key, key2;
 377     unsigned char iv[AES_BLOCK_SIZE * 4];
 378     unsigned char ciphertext[BIG_TEST_SIZE];
 379     unsigned char checktext[BIG_TEST_SIZE];
 380     unsigned int n;
 381     size_t matches;
 382
 383     memcpy(iv, saved_iv, sizeof iv);
 384     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 385     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 386     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
 387                     AES_ENCRYPT);
 388
 389     /* corrupt right at the end */
 390     ++ciphertext[sizeof ciphertext - 1];
 391     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 392     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 393     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
 394                     AES_DECRYPT);
 395
 396     matches = 0;
 397     for (n = 0; n < sizeof checktext; ++n)
 398         if (checktext[n] == plaintext[n])
 399             ++matches;
 400
 401     /* Fail if there is more than 1% matching bytes */
 402     return TEST_size_t_le(matches, sizeof checktext / 100);
 403 }
 404
 405 static int test_bi_ige_garble3(void)
 406 {
 407     AES_KEY key, key2;
 408     unsigned char iv[AES_BLOCK_SIZE * 4];
 409     unsigned char ciphertext[BIG_TEST_SIZE];
 410     unsigned char checktext[BIG_TEST_SIZE];
 411     unsigned int n;
 412     size_t matches;
 413
 414     memcpy(iv, saved_iv, sizeof iv);
 415     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
 416     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 417     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
 418                     AES_ENCRYPT);
 419
 420     /* corrupt right at the start */
 421     ++ciphertext[0];
 422     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
 423     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
 424     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
 425                     AES_DECRYPT);
 426
 427     matches = 0;
 428     for (n = 0; n < sizeof checktext; ++n)
 429         if (checktext[n] == plaintext[n])
 430             ++matches;
 431
 432     /* Fail if there is more than 1% matching bytes */
 433     return TEST_size_t_le(matches, sizeof checktext / 100);
 434 }
 435
 436 void register_tests(void)
 437 {
 438     RAND_bytes(rkey, sizeof rkey);
 439     RAND_bytes(rkey2, sizeof rkey2);
 440     RAND_bytes(plaintext, sizeof plaintext);
 441     RAND_bytes(saved_iv, sizeof saved_iv);
 442
 443     ADD_TEST(test_ige_enc_dec);
 444     ADD_TEST(test_ige_enc_chaining);
 445     ADD_TEST(test_ige_dec_chaining);
 446     ADD_TEST(test_ige_garble_forwards);
 447     ADD_TEST(test_bi_ige_enc_dec);
 448     ADD_TEST(test_bi_ige_garble1);
 449     ADD_TEST(test_bi_ige_garble2);
 450     ADD_TEST(test_bi_ige_garble3);
 451     ADD_ALL_TESTS(test_ige_vectors, OSSL_NELEM(ige_test_vectors));
 452     ADD_ALL_TESTS(test_bi_ige_vectors, OSSL_NELEM(bi_ige_test_vectors));
 453 }