]>
git.ipfire.org Git - thirdparty/openssl.git/blob - test/igetest.c
2 * Copyright 2006-2017 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (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
10 /* The AES_ige_* functions are deprecated, so we suppress warnings about them */
11 #define OPENSSL_SUPPRESS_DEPRECATED
13 #include <openssl/crypto.h>
14 #include <openssl/aes.h>
15 #include <openssl/rand.h>
18 #include "internal/nelem.h"
21 #ifndef OPENSSL_NO_DEPRECATED_3_0
23 # define TEST_SIZE 128
24 # define BIG_TEST_SIZE 10240
26 # if BIG_TEST_SIZE < TEST_SIZE
27 # error BIG_TEST_SIZE is smaller than TEST_SIZE
30 static unsigned char rkey
[16];
31 static unsigned char rkey2
[16];
32 static unsigned char plaintext
[BIG_TEST_SIZE
];
33 static unsigned char saved_iv
[AES_BLOCK_SIZE
* 4];
35 # define MAX_VECTOR_SIZE 64
38 const unsigned char key
[16];
39 const unsigned char iv
[32];
40 const unsigned char in
[MAX_VECTOR_SIZE
];
41 const unsigned char out
[MAX_VECTOR_SIZE
];
46 static struct ige_test
const ige_test_vectors
[] = {
47 {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
48 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key */
49 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
50 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
51 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
52 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* iv */
53 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
55 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
56 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
57 {0x1a, 0x85, 0x19, 0xa6, 0x55, 0x7b, 0xe6, 0x52,
58 0xe9, 0xda, 0x8e, 0x43, 0xda, 0x4e, 0xf4, 0x45,
59 0x3c, 0xf4, 0x56, 0xb4, 0xca, 0x48, 0x8a, 0xa3,
60 0x83, 0xc7, 0x9c, 0x98, 0xb3, 0x47, 0x97, 0xcb}, /* out */
61 32, AES_ENCRYPT
}, /* test vector 0 */
63 {{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
64 0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65}, /* key */
65 {0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
66 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x47, 0x45,
67 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f,
68 0x72, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x53}, /* iv */
69 {0x4c, 0x2e, 0x20, 0x4c, 0x65, 0x74, 0x27, 0x73,
70 0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x42, 0x65,
71 0x6e, 0x20, 0x67, 0x6f, 0x74, 0x20, 0x69, 0x74,
72 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x21, 0x0a}, /* in */
73 {0x99, 0x70, 0x64, 0x87, 0xa1, 0xcd, 0xe6, 0x13,
74 0xbc, 0x6d, 0xe0, 0xb6, 0xf2, 0x4b, 0x1c, 0x7a,
75 0xa4, 0x48, 0xc8, 0xb9, 0xc3, 0x40, 0x3e, 0x34,
76 0x67, 0xa8, 0xca, 0xd8, 0x93, 0x40, 0xf5, 0x3b}, /* out */
77 32, AES_DECRYPT
}, /* test vector 1 */
81 const unsigned char key1
[32];
82 const unsigned char key2
[32];
83 const unsigned char iv
[64];
84 const unsigned char in
[MAX_VECTOR_SIZE
];
85 const unsigned char out
[MAX_VECTOR_SIZE
];
91 static struct bi_ige_test
const bi_ige_test_vectors
[] = {
92 {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
93 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key1 */
94 {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
95 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* key2 */
96 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
97 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
98 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
99 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
100 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
101 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
102 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
103 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f}, /* iv */
104 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
105 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
108 {0x14, 0x40, 0x6f, 0xae, 0xa2, 0x79, 0xf2, 0x56,
109 0x1f, 0x86, 0xeb, 0x3b, 0x7d, 0xff, 0x53, 0xdc,
110 0x4e, 0x27, 0x0c, 0x03, 0xde, 0x7c, 0xe5, 0x16,
111 0x6a, 0x9c, 0x20, 0x33, 0x9d, 0x33, 0xfe, 0x12}, /* out */
112 16, 32, AES_ENCRYPT
}, /* test vector 0 */
113 {{0x58, 0x0a, 0x06, 0xe9, 0x97, 0x07, 0x59, 0x5c,
114 0x9e, 0x19, 0xd2, 0xa7, 0xbb, 0x40, 0x2b, 0x7a,
115 0xc7, 0xd8, 0x11, 0x9e, 0x4c, 0x51, 0x35, 0x75,
116 0x64, 0x28, 0x0f, 0x23, 0xad, 0x74, 0xac, 0x37}, /* key1 */
117 {0xd1, 0x80, 0xa0, 0x31, 0x47, 0xa3, 0x11, 0x13,
118 0x86, 0x26, 0x9e, 0x6d, 0xff, 0xaf, 0x72, 0x74,
119 0x5b, 0xa2, 0x35, 0x81, 0xd2, 0xa6, 0x3d, 0x21,
120 0x67, 0x7b, 0x58, 0xa8, 0x18, 0xf9, 0x72, 0xe4}, /* key2 */
121 {0x80, 0x3d, 0xbd, 0x4c, 0xe6, 0x7b, 0x06, 0xa9,
122 0x53, 0x35, 0xd5, 0x7e, 0x71, 0xc1, 0x70, 0x70,
123 0x74, 0x9a, 0x00, 0x28, 0x0c, 0xbf, 0x6c, 0x42,
124 0x9b, 0xa4, 0xdd, 0x65, 0x11, 0x77, 0x7c, 0x67,
125 0xfe, 0x76, 0x0a, 0xf0, 0xd5, 0xc6, 0x6e, 0x6a,
126 0xe7, 0x5e, 0x4c, 0xf2, 0x7e, 0x9e, 0xf9, 0x20,
127 0x0e, 0x54, 0x6f, 0x2d, 0x8a, 0x8d, 0x7e, 0xbd,
128 0x48, 0x79, 0x37, 0x99, 0xff, 0x27, 0x93, 0xa3}, /* iv */
129 {0xf1, 0x54, 0x3d, 0xca, 0xfe, 0xb5, 0xef, 0x1c,
130 0x4f, 0xa6, 0x43, 0xf6, 0xe6, 0x48, 0x57, 0xf0,
131 0xee, 0x15, 0x7f, 0xe3, 0xe7, 0x2f, 0xd0, 0x2f,
132 0x11, 0x95, 0x7a, 0x17, 0x00, 0xab, 0xa7, 0x0b,
133 0xbe, 0x44, 0x09, 0x9c, 0xcd, 0xac, 0xa8, 0x52,
134 0xa1, 0x8e, 0x7b, 0x75, 0xbc, 0xa4, 0x92, 0x5a,
135 0xab, 0x46, 0xd3, 0x3a, 0xa0, 0xd5, 0x35, 0x1c,
136 0x55, 0xa4, 0xb3, 0xa8, 0x40, 0x81, 0xa5, 0x0b}, /* in */
137 {0x42, 0xe5, 0x28, 0x30, 0x31, 0xc2, 0xa0, 0x23,
138 0x68, 0x49, 0x4e, 0xb3, 0x24, 0x59, 0x92, 0x79,
139 0xc1, 0xa5, 0xcc, 0xe6, 0x76, 0x53, 0xb1, 0xcf,
140 0x20, 0x86, 0x23, 0xe8, 0x72, 0x55, 0x99, 0x92,
141 0x0d, 0x16, 0x1c, 0x5a, 0x2f, 0xce, 0xcb, 0x51,
142 0xe2, 0x67, 0xfa, 0x10, 0xec, 0xcd, 0x3d, 0x67,
143 0xa5, 0xe6, 0xf7, 0x31, 0x26, 0xb0, 0x0d, 0x76,
144 0x5e, 0x28, 0xdc, 0x7f, 0x01, 0xc5, 0xa5, 0x4c}, /* out */
145 32, 64, AES_ENCRYPT
}, /* test vector 1 */
149 static int test_ige_vectors(int n
)
151 const struct ige_test
*const v
= &ige_test_vectors
[n
];
153 unsigned char buf
[MAX_VECTOR_SIZE
];
154 unsigned char iv
[AES_BLOCK_SIZE
* 2];
157 if (!TEST_int_le(v
->length
, MAX_VECTOR_SIZE
))
160 if (v
->encrypt
== AES_ENCRYPT
)
161 AES_set_encrypt_key(v
->key
, 8 * sizeof(v
->key
), &key
);
163 AES_set_decrypt_key(v
->key
, 8 * sizeof(v
->key
), &key
);
164 memcpy(iv
, v
->iv
, sizeof(iv
));
165 AES_ige_encrypt(v
->in
, buf
, v
->length
, &key
, iv
, v
->encrypt
);
167 if (!TEST_mem_eq(v
->out
, v
->length
, buf
, v
->length
)) {
168 TEST_info("IGE test vector %d failed", n
);
169 test_output_memory("key", v
->key
, sizeof(v
->key
));
170 test_output_memory("iv", v
->iv
, sizeof(v
->iv
));
171 test_output_memory("in", v
->in
, v
->length
);
175 /* try with in == out */
176 memcpy(iv
, v
->iv
, sizeof(iv
));
177 memcpy(buf
, v
->in
, v
->length
);
178 AES_ige_encrypt(buf
, buf
, v
->length
, &key
, iv
, v
->encrypt
);
180 if (!TEST_mem_eq(v
->out
, v
->length
, buf
, v
->length
)) {
181 TEST_info("IGE test vector %d failed (with in == out)", n
);
182 test_output_memory("key", v
->key
, sizeof(v
->key
));
183 test_output_memory("iv", v
->iv
, sizeof(v
->iv
));
184 test_output_memory("in", v
->in
, v
->length
);
191 static int test_bi_ige_vectors(int n
)
193 const struct bi_ige_test
*const v
= &bi_ige_test_vectors
[n
];
196 unsigned char buf
[MAX_VECTOR_SIZE
];
198 if (!TEST_int_le(v
->length
, MAX_VECTOR_SIZE
))
201 if (v
->encrypt
== AES_ENCRYPT
) {
202 AES_set_encrypt_key(v
->key1
, 8 * v
->keysize
, &key1
);
203 AES_set_encrypt_key(v
->key2
, 8 * v
->keysize
, &key2
);
205 AES_set_decrypt_key(v
->key1
, 8 * v
->keysize
, &key1
);
206 AES_set_decrypt_key(v
->key2
, 8 * v
->keysize
, &key2
);
209 AES_bi_ige_encrypt(v
->in
, buf
, v
->length
, &key1
, &key2
, v
->iv
,
212 if (!TEST_mem_eq(v
->out
, v
->length
, buf
, v
->length
)) {
213 test_output_memory("key 1", v
->key1
, sizeof(v
->key1
));
214 test_output_memory("key 2", v
->key2
, sizeof(v
->key2
));
215 test_output_memory("iv", v
->iv
, sizeof(v
->iv
));
216 test_output_memory("in", v
->in
, v
->length
);
223 static int test_ige_enc_dec(void)
226 unsigned char iv
[AES_BLOCK_SIZE
* 4];
227 unsigned char ciphertext
[BIG_TEST_SIZE
];
228 unsigned char checktext
[BIG_TEST_SIZE
];
230 memcpy(iv
, saved_iv
, sizeof(iv
));
231 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
232 AES_ige_encrypt(plaintext
, ciphertext
, TEST_SIZE
, &key
, iv
, AES_ENCRYPT
);
234 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
235 memcpy(iv
, saved_iv
, sizeof(iv
));
236 AES_ige_encrypt(ciphertext
, checktext
, TEST_SIZE
, &key
, iv
, AES_DECRYPT
);
238 return TEST_mem_eq(checktext
, TEST_SIZE
, plaintext
, TEST_SIZE
);
241 static int test_ige_enc_chaining(void)
244 unsigned char iv
[AES_BLOCK_SIZE
* 4];
245 unsigned char ciphertext
[BIG_TEST_SIZE
];
246 unsigned char checktext
[BIG_TEST_SIZE
];
248 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
249 memcpy(iv
, saved_iv
, sizeof(iv
));
250 AES_ige_encrypt(plaintext
, ciphertext
, TEST_SIZE
/ 2, &key
, iv
,
252 AES_ige_encrypt(plaintext
+ TEST_SIZE
/ 2,
253 ciphertext
+ TEST_SIZE
/ 2, TEST_SIZE
/ 2,
254 &key
, iv
, AES_ENCRYPT
);
256 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
257 memcpy(iv
, saved_iv
, sizeof(iv
));
258 AES_ige_encrypt(ciphertext
, checktext
, TEST_SIZE
, &key
, iv
, AES_DECRYPT
);
260 return TEST_mem_eq(checktext
, TEST_SIZE
, plaintext
, TEST_SIZE
);
263 static int test_ige_dec_chaining(void)
266 unsigned char iv
[AES_BLOCK_SIZE
* 4];
267 unsigned char ciphertext
[BIG_TEST_SIZE
];
268 unsigned char checktext
[BIG_TEST_SIZE
];
270 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
271 memcpy(iv
, saved_iv
, sizeof(iv
));
272 AES_ige_encrypt(plaintext
, ciphertext
, TEST_SIZE
/ 2, &key
, iv
,
274 AES_ige_encrypt(plaintext
+ TEST_SIZE
/ 2,
275 ciphertext
+ TEST_SIZE
/ 2, TEST_SIZE
/ 2,
276 &key
, iv
, AES_ENCRYPT
);
278 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
279 memcpy(iv
, saved_iv
, sizeof(iv
));
280 AES_ige_encrypt(ciphertext
, checktext
, TEST_SIZE
/ 2, &key
, iv
,
282 AES_ige_encrypt(ciphertext
+ TEST_SIZE
/ 2,
283 checktext
+ TEST_SIZE
/ 2, TEST_SIZE
/ 2, &key
, iv
,
286 return TEST_mem_eq(checktext
, TEST_SIZE
, plaintext
, TEST_SIZE
);
289 static int test_ige_garble_forwards(void)
292 unsigned char iv
[AES_BLOCK_SIZE
* 4];
293 unsigned char ciphertext
[BIG_TEST_SIZE
];
294 unsigned char checktext
[BIG_TEST_SIZE
];
297 const size_t ctsize
= sizeof(checktext
);
300 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
301 memcpy(iv
, saved_iv
, sizeof(iv
));
302 AES_ige_encrypt(plaintext
, ciphertext
, sizeof(plaintext
), &key
, iv
,
305 /* corrupt halfway through */
306 ++ciphertext
[sizeof(ciphertext
) / 2];
307 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
308 memcpy(iv
, saved_iv
, sizeof(iv
));
309 AES_ige_encrypt(ciphertext
, checktext
, sizeof(checktext
), &key
, iv
,
313 for (n
= 0; n
< sizeof(checktext
); ++n
)
314 if (checktext
[n
] == plaintext
[n
])
317 /* Fail if there is more than 51% matching bytes */
318 if (!TEST_size_t_le(matches
, ctsize
/ 2 + ctsize
/ 100))
321 /* Fail if the garble goes backwards */
322 if (!TEST_size_t_gt(matches
, ctsize
/ 2))
327 static int test_bi_ige_enc_dec(void)
330 unsigned char iv
[AES_BLOCK_SIZE
* 4];
331 unsigned char ciphertext
[BIG_TEST_SIZE
];
332 unsigned char checktext
[BIG_TEST_SIZE
];
334 memcpy(iv
, saved_iv
, sizeof(iv
));
335 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
336 AES_set_encrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
337 AES_bi_ige_encrypt(plaintext
, ciphertext
, TEST_SIZE
, &key
, &key2
, iv
,
340 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
341 AES_set_decrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
342 AES_bi_ige_encrypt(ciphertext
, checktext
, TEST_SIZE
, &key
, &key2
, iv
,
345 return TEST_mem_eq(checktext
, TEST_SIZE
, plaintext
, TEST_SIZE
);
348 static int test_bi_ige_garble1(void)
351 unsigned char iv
[AES_BLOCK_SIZE
* 4];
352 unsigned char ciphertext
[BIG_TEST_SIZE
];
353 unsigned char checktext
[BIG_TEST_SIZE
];
357 memcpy(iv
, saved_iv
, sizeof(iv
));
358 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
359 AES_set_encrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
360 AES_ige_encrypt(plaintext
, ciphertext
, sizeof(plaintext
), &key
, iv
,
363 /* corrupt halfway through */
364 ++ciphertext
[sizeof(ciphertext
) / 2];
365 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
366 AES_set_decrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
367 AES_ige_encrypt(ciphertext
, checktext
, sizeof(checktext
), &key
, iv
,
371 for (n
= 0; n
< sizeof(checktext
); ++n
)
372 if (checktext
[n
] == plaintext
[n
])
375 /* Fail if there is more than 1% matching bytes */
376 return TEST_size_t_le(matches
, sizeof(checktext
) / 100);
379 static int test_bi_ige_garble2(void)
382 unsigned char iv
[AES_BLOCK_SIZE
* 4];
383 unsigned char ciphertext
[BIG_TEST_SIZE
];
384 unsigned char checktext
[BIG_TEST_SIZE
];
388 memcpy(iv
, saved_iv
, sizeof(iv
));
389 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
390 AES_set_encrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
391 AES_ige_encrypt(plaintext
, ciphertext
, sizeof(plaintext
), &key
, iv
,
394 /* corrupt right at the end */
395 ++ciphertext
[sizeof(ciphertext
) - 1];
396 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
397 AES_set_decrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
398 AES_ige_encrypt(ciphertext
, checktext
, sizeof(checktext
), &key
, iv
,
402 for (n
= 0; n
< sizeof(checktext
); ++n
)
403 if (checktext
[n
] == plaintext
[n
])
406 /* Fail if there is more than 1% matching bytes */
407 return TEST_size_t_le(matches
, sizeof(checktext
) / 100);
410 static int test_bi_ige_garble3(void)
413 unsigned char iv
[AES_BLOCK_SIZE
* 4];
414 unsigned char ciphertext
[BIG_TEST_SIZE
];
415 unsigned char checktext
[BIG_TEST_SIZE
];
419 memcpy(iv
, saved_iv
, sizeof(iv
));
420 AES_set_encrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
421 AES_set_encrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
422 AES_ige_encrypt(plaintext
, ciphertext
, sizeof(plaintext
), &key
, iv
,
425 /* corrupt right at the start */
427 AES_set_decrypt_key(rkey
, 8 * sizeof(rkey
), &key
);
428 AES_set_decrypt_key(rkey2
, 8 * sizeof(rkey2
), &key2
);
429 AES_ige_encrypt(ciphertext
, checktext
, sizeof(checktext
), &key
, iv
,
433 for (n
= 0; n
< sizeof(checktext
); ++n
)
434 if (checktext
[n
] == plaintext
[n
])
437 /* Fail if there is more than 1% matching bytes */
438 return TEST_size_t_le(matches
, sizeof(checktext
) / 100);
442 int setup_tests(void)
444 #ifndef OPENSSL_NO_DEPRECATED_3_0
445 RAND_bytes(rkey
, sizeof(rkey
));
446 RAND_bytes(rkey2
, sizeof(rkey2
));
447 RAND_bytes(plaintext
, sizeof(plaintext
));
448 RAND_bytes(saved_iv
, sizeof(saved_iv
));
450 ADD_TEST(test_ige_enc_dec
);
451 ADD_TEST(test_ige_enc_chaining
);
452 ADD_TEST(test_ige_dec_chaining
);
453 ADD_TEST(test_ige_garble_forwards
);
454 ADD_TEST(test_bi_ige_enc_dec
);
455 ADD_TEST(test_bi_ige_garble1
);
456 ADD_TEST(test_bi_ige_garble2
);
457 ADD_TEST(test_bi_ige_garble3
);
458 ADD_ALL_TESTS(test_ige_vectors
, OSSL_NELEM(ige_test_vectors
));
459 ADD_ALL_TESTS(test_bi_ige_vectors
, OSSL_NELEM(bi_ige_test_vectors
));