1 /* 2 * Copyright 2006-2017 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 "internal/nelem.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 int setup_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 return 1; 454 } 455