2 * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
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
10 /* Internal tests for the modes module */
15 #include <openssl/aes.h>
16 #include <openssl/modes.h>
17 #include "../crypto/modes/modes_lcl.h"
19 #include "internal/nelem.h"
20 #include "internal/cryptlib.h"
24 const unsigned char *data;
27 /**********************************************************************
33 /* cts128 test vectors from RFC 3962 */
34 static const unsigned char cts128_test_key[16] = "chicken teriyaki";
35 static const unsigned char cts128_test_input[64] =
36 "I would like the" " General Gau's C"
37 "hicken, please, " "and wonton soup.";
38 static const unsigned char cts128_test_iv[] =
39 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
41 static const unsigned char vector_17[17] = {
42 0xc6, 0x35, 0x35, 0x68, 0xf2, 0xbf, 0x8c, 0xb4,
43 0xd8, 0xa5, 0x80, 0x36, 0x2d, 0xa7, 0xff, 0x7f,
47 static const unsigned char vector_31[31] = {
48 0xfc, 0x00, 0x78, 0x3e, 0x0e, 0xfd, 0xb2, 0xc1,
49 0xd4, 0x45, 0xd4, 0xc8, 0xef, 0xf7, 0xed, 0x22,
50 0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
51 0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5
54 static const unsigned char vector_32[32] = {
55 0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
56 0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8,
57 0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
58 0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84
61 static const unsigned char vector_47[47] = {
62 0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
63 0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
64 0xb3, 0xff, 0xfd, 0x94, 0x0c, 0x16, 0xa1, 0x8c,
65 0x1b, 0x55, 0x49, 0xd2, 0xf8, 0x38, 0x02, 0x9e,
66 0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
67 0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5
70 static const unsigned char vector_48[48] = {
71 0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
72 0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
73 0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
74 0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8,
75 0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
76 0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8
79 static const unsigned char vector_64[64] = {
80 0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
81 0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
82 0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
83 0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8,
84 0x48, 0x07, 0xef, 0xe8, 0x36, 0xee, 0x89, 0xa5,
85 0x26, 0x73, 0x0d, 0xbc, 0x2f, 0x7b, 0xc8, 0x40,
86 0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
87 0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8
90 #define CTS128_TEST_VECTOR(len) \
92 sizeof(vector_##len), vector_##len \
94 static const SIZED_DATA aes_cts128_vectors[] = {
95 CTS128_TEST_VECTOR(17),
96 CTS128_TEST_VECTOR(31),
97 CTS128_TEST_VECTOR(32),
98 CTS128_TEST_VECTOR(47),
99 CTS128_TEST_VECTOR(48),
100 CTS128_TEST_VECTOR(64),
103 static AES_KEY *cts128_encrypt_key_schedule()
105 static int init_key = 1;
109 AES_set_encrypt_key(cts128_test_key, 128, &ks);
115 static AES_KEY *cts128_decrypt_key_schedule()
117 static int init_key = 1;
121 AES_set_decrypt_key(cts128_test_key, 128, &ks);
128 const char *case_name;
129 size_t (*last_blocks_correction)(const unsigned char *in,
130 unsigned char *out, size_t len);
131 size_t (*encrypt_block)(const unsigned char *in,
132 unsigned char *out, size_t len,
133 const void *key, unsigned char ivec[16],
135 size_t (*encrypt_stream)(const unsigned char *in, unsigned char *out,
136 size_t len, const void *key,
137 unsigned char ivec[16], cbc128_f cbc);
138 size_t (*decrypt_block)(const unsigned char *in,
139 unsigned char *out, size_t len,
140 const void *key, unsigned char ivec[16],
142 size_t (*decrypt_stream)(const unsigned char *in, unsigned char *out,
143 size_t len, const void *key,
144 unsigned char ivec[16], cbc128_f cbc);
147 static size_t last_blocks_correction(const unsigned char *in,
148 unsigned char *out, size_t len)
152 memcpy(out, in, len);
153 if ((tail = len % 16) == 0)
160 static size_t last_blocks_correction_nist(const unsigned char *in,
161 unsigned char *out, size_t len)
165 if ((tail = len % 16) == 0)
168 memcpy(out, in, len);
169 /* flip two last blocks */
170 memcpy(out + len, in + len + 16, tail);
171 memcpy(out + len + tail, in + len, 16);
178 static int execute_cts128(const CTS128_FIXTURE *fixture, int num)
180 const unsigned char *test_iv = cts128_test_iv;
181 size_t test_iv_len = sizeof(cts128_test_iv);
182 const unsigned char *orig_vector = aes_cts128_vectors[num].data;
183 size_t len = aes_cts128_vectors[num].size;
184 const unsigned char *test_input = cts128_test_input;
185 const AES_KEY *encrypt_key_schedule = cts128_encrypt_key_schedule();
186 const AES_KEY *decrypt_key_schedule = cts128_decrypt_key_schedule();
187 unsigned char iv[16];
188 /* The largest test inputs are = 64 bytes. */
189 unsigned char cleartext[64], ciphertext[64], vector[64];
192 TEST_info("%s_vector_%lu", fixture->case_name, (unsigned long)len);
194 tail = fixture->last_blocks_correction(orig_vector, vector, len);
196 /* test block-based encryption */
197 memcpy(iv, test_iv, test_iv_len);
198 if (!TEST_size_t_eq(fixture->encrypt_block(test_input, ciphertext, len,
199 encrypt_key_schedule, iv,
200 (block128_f)AES_encrypt), len)
201 || !TEST_mem_eq(ciphertext, len, vector, len)
202 || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
205 /* test block-based decryption */
206 memcpy(iv, test_iv, test_iv_len);
207 size = fixture->decrypt_block(ciphertext, cleartext, len,
208 decrypt_key_schedule, iv,
209 (block128_f)AES_decrypt);
210 if (!TEST_true(len == size || len + 16 == size)
211 || !TEST_mem_eq(cleartext, len, test_input, len)
212 || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
215 /* test streamed encryption */
216 memcpy(iv, test_iv, test_iv_len);
217 if (!TEST_size_t_eq(fixture->encrypt_stream(test_input, ciphertext, len,
218 encrypt_key_schedule, iv,
219 (cbc128_f) AES_cbc_encrypt),
221 || !TEST_mem_eq(ciphertext, len, vector, len)
222 || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
225 /* test streamed decryption */
226 memcpy(iv, test_iv, test_iv_len);
227 if (!TEST_size_t_eq(fixture->decrypt_stream(ciphertext, cleartext, len,
228 decrypt_key_schedule, iv,
229 (cbc128_f)AES_cbc_encrypt),
231 || !TEST_mem_eq(cleartext, len, test_input, len)
232 || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
238 static int test_aes_cts128(int idx)
240 static const CTS128_FIXTURE fixture_cts128 = {
241 "aes_cts128", last_blocks_correction,
242 CRYPTO_cts128_encrypt_block, CRYPTO_cts128_encrypt,
243 CRYPTO_cts128_decrypt_block, CRYPTO_cts128_decrypt
246 return execute_cts128(&fixture_cts128, idx);
249 static int test_aes_cts128_nist(int idx)
251 static const CTS128_FIXTURE fixture_cts128_nist = {
252 "aes_cts128_nist", last_blocks_correction_nist,
253 CRYPTO_nistcts128_encrypt_block, CRYPTO_nistcts128_encrypt,
254 CRYPTO_nistcts128_decrypt_block, CRYPTO_nistcts128_decrypt
257 return execute_cts128(&fixture_cts128_nist, idx);
267 static const u8 K1[16], P1[] = { 0 }, A1[] = { 0 }, IV1[12], C1[] = { 0 };
268 static const u8 T1[] = {
269 0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, 0x30, 0x61,
270 0x36, 0x7f, 0x1d, 0x57, 0xa4, 0xe7, 0x45, 0x5a
277 static const u8 P2[16];
278 static const u8 C2[] = {
279 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92,
280 0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78
283 static const u8 T2[] = {
284 0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd,
285 0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf
290 static const u8 K3[] = {
291 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
292 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
295 static const u8 P3[] = {
296 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
297 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
298 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
299 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
300 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
301 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
302 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
303 0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
306 static const u8 IV3[] = {
307 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
308 0xde, 0xca, 0xf8, 0x88
311 static const u8 C3[] = {
312 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
313 0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
314 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
315 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
316 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
317 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
318 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
319 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85
322 static const u8 T3[] = {
323 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6,
324 0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4
330 static const u8 P4[] = {
331 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
332 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
333 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
334 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
335 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
336 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
337 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
338 0xba, 0x63, 0x7b, 0x39
341 static const u8 A4[] = {
342 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
343 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
344 0xab, 0xad, 0xda, 0xd2
347 static const u8 C4[] = {
348 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
349 0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
350 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
351 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
352 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
353 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
354 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
355 0x3d, 0x58, 0xe0, 0x91
358 static const u8 T4[] = {
359 0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
360 0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47
367 static const u8 IV5[] = {
368 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad
371 static const u8 C5[] = {
372 0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a,
373 0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55,
374 0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8,
375 0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23,
376 0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2,
377 0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42,
378 0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07,
379 0xc2, 0x3f, 0x45, 0x98
382 static const u8 T5[] = {
383 0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85,
384 0x56, 0x1b, 0xe1, 0x4a, 0xac, 0xa2, 0xfc, 0xcb
391 static const u8 IV6[] = {
392 0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
393 0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
394 0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
395 0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
396 0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
397 0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
398 0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
399 0xa6, 0x37, 0xb3, 0x9b
402 static const u8 C6[] = {
403 0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6,
404 0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94,
405 0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8,
406 0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7,
407 0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90,
408 0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f,
409 0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03,
410 0x4c, 0x34, 0xae, 0xe5
413 static const u8 T6[] = {
414 0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa,
415 0x46, 0x2a, 0xf4, 0x3c, 0x16, 0x99, 0xd0, 0x50
419 static const u8 K7[24], P7[] = { 0 }, A7[] = { 0 }, IV7[12], C7[] = { 0 };
420 static const u8 T7[] = {
421 0xcd, 0x33, 0xb2, 0x8a, 0xc7, 0x73, 0xf7, 0x4b,
422 0xa0, 0x0e, 0xd1, 0xf3, 0x12, 0x57, 0x24, 0x35
429 static const u8 P8[16];
430 static const u8 C8[] = {
431 0x98, 0xe7, 0x24, 0x7c, 0x07, 0xf0, 0xfe, 0x41,
432 0x1c, 0x26, 0x7e, 0x43, 0x84, 0xb0, 0xf6, 0x00
435 static const u8 T8[] = {
436 0x2f, 0xf5, 0x8d, 0x80, 0x03, 0x39, 0x27, 0xab,
437 0x8e, 0xf4, 0xd4, 0x58, 0x75, 0x14, 0xf0, 0xfb
442 static const u8 K9[] = {
443 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
444 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
445 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c
448 static const u8 P9[] = {
449 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
450 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
451 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
452 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
453 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
454 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
455 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
456 0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
459 static const u8 IV9[] = {
460 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
461 0xde, 0xca, 0xf8, 0x88
464 static const u8 C9[] = {
465 0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
466 0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
467 0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
468 0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
469 0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
470 0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
471 0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
472 0xcc, 0xda, 0x27, 0x10, 0xac, 0xad, 0xe2, 0x56
475 static const u8 T9[] = {
476 0x99, 0x24, 0xa7, 0xc8, 0x58, 0x73, 0x36, 0xbf,
477 0xb1, 0x18, 0x02, 0x4d, 0xb8, 0x67, 0x4a, 0x14
483 static const u8 P10[] = {
484 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
485 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
486 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
487 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
488 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
489 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
490 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
491 0xba, 0x63, 0x7b, 0x39
494 static const u8 A10[] = {
495 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
496 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
497 0xab, 0xad, 0xda, 0xd2
500 static const u8 C10[] = {
501 0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
502 0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
503 0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
504 0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
505 0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
506 0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
507 0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
508 0xcc, 0xda, 0x27, 0x10
511 static const u8 T10[] = {
512 0x25, 0x19, 0x49, 0x8e, 0x80, 0xf1, 0x47, 0x8f,
513 0x37, 0xba, 0x55, 0xbd, 0x6d, 0x27, 0x61, 0x8c
520 static const u8 IV11[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
522 static const u8 C11[] = {
523 0x0f, 0x10, 0xf5, 0x99, 0xae, 0x14, 0xa1, 0x54,
524 0xed, 0x24, 0xb3, 0x6e, 0x25, 0x32, 0x4d, 0xb8,
525 0xc5, 0x66, 0x63, 0x2e, 0xf2, 0xbb, 0xb3, 0x4f,
526 0x83, 0x47, 0x28, 0x0f, 0xc4, 0x50, 0x70, 0x57,
527 0xfd, 0xdc, 0x29, 0xdf, 0x9a, 0x47, 0x1f, 0x75,
528 0xc6, 0x65, 0x41, 0xd4, 0xd4, 0xda, 0xd1, 0xc9,
529 0xe9, 0x3a, 0x19, 0xa5, 0x8e, 0x8b, 0x47, 0x3f,
530 0xa0, 0xf0, 0x62, 0xf7
533 static const u8 T11[] = {
534 0x65, 0xdc, 0xc5, 0x7f, 0xcf, 0x62, 0x3a, 0x24,
535 0x09, 0x4f, 0xcc, 0xa4, 0x0d, 0x35, 0x33, 0xf8
542 static const u8 IV12[] = {
543 0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
544 0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
545 0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
546 0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
547 0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
548 0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
549 0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
550 0xa6, 0x37, 0xb3, 0x9b
553 static const u8 C12[] = {
554 0xd2, 0x7e, 0x88, 0x68, 0x1c, 0xe3, 0x24, 0x3c,
555 0x48, 0x30, 0x16, 0x5a, 0x8f, 0xdc, 0xf9, 0xff,
556 0x1d, 0xe9, 0xa1, 0xd8, 0xe6, 0xb4, 0x47, 0xef,
557 0x6e, 0xf7, 0xb7, 0x98, 0x28, 0x66, 0x6e, 0x45,
558 0x81, 0xe7, 0x90, 0x12, 0xaf, 0x34, 0xdd, 0xd9,
559 0xe2, 0xf0, 0x37, 0x58, 0x9b, 0x29, 0x2d, 0xb3,
560 0xe6, 0x7c, 0x03, 0x67, 0x45, 0xfa, 0x22, 0xe7,
561 0xe9, 0xb7, 0x37, 0x3b
564 static const u8 T12[] = {
565 0xdc, 0xf5, 0x66, 0xff, 0x29, 0x1c, 0x25, 0xbb,
566 0xb8, 0x56, 0x8f, 0xc3, 0xd3, 0x76, 0xa6, 0xd9
570 static const u8 K13[32], P13[] = { 0 }, A13[] = { 0 }, IV13[12], C13[] = { 0 };
571 static const u8 T13[] = {
572 0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9,
573 0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b
579 static const u8 P14[16], IV14[12];
580 static const u8 C14[] = {
581 0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e,
582 0x07, 0x4e, 0xc5, 0xd3, 0xba, 0xf3, 0x9d, 0x18
585 static const u8 T14[] = {
586 0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0,
587 0x26, 0x5b, 0x98, 0xb5, 0xd4, 0x8a, 0xb9, 0x19
592 static const u8 K15[] = {
593 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
594 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
595 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
596 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
599 static const u8 P15[] = {
600 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
601 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
602 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
603 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
604 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
605 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
606 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
607 0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
610 static const u8 IV15[] = {
611 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
612 0xde, 0xca, 0xf8, 0x88
615 static const u8 C15[] = {
616 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
617 0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
618 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
619 0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
620 0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
621 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
622 0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
623 0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
626 static const u8 T15[] = {
627 0xb0, 0x94, 0xda, 0xc5, 0xd9, 0x34, 0x71, 0xbd,
628 0xec, 0x1a, 0x50, 0x22, 0x70, 0xe3, 0xcc, 0x6c
634 static const u8 P16[] = {
635 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
636 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
637 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
638 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
639 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
640 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
641 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
642 0xba, 0x63, 0x7b, 0x39
645 static const u8 A16[] = {
646 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
647 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
648 0xab, 0xad, 0xda, 0xd2
651 static const u8 C16[] = {
652 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
653 0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
654 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
655 0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
656 0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
657 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
658 0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
659 0xbc, 0xc9, 0xf6, 0x62
662 static const u8 T16[] = {
663 0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68,
664 0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b
671 static const u8 IV17[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
673 static const u8 C17[] = {
674 0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32,
675 0xae, 0x47, 0xc1, 0x3b, 0xf1, 0x98, 0x44, 0xcb,
676 0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
677 0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0,
678 0xfe, 0xb5, 0x82, 0xd3, 0x39, 0x34, 0xa4, 0xf0,
679 0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
680 0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99,
681 0xf4, 0x7c, 0x9b, 0x1f
684 static const u8 T17[] = {
685 0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4,
686 0x5e, 0x45, 0x49, 0x13, 0xfe, 0x2e, 0xa8, 0xf2
693 static const u8 IV18[] = {
694 0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
695 0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
696 0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
697 0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
698 0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
699 0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
700 0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
701 0xa6, 0x37, 0xb3, 0x9b
704 static const u8 C18[] = {
705 0x5a, 0x8d, 0xef, 0x2f, 0x0c, 0x9e, 0x53, 0xf1,
706 0xf7, 0x5d, 0x78, 0x53, 0x65, 0x9e, 0x2a, 0x20,
707 0xee, 0xb2, 0xb2, 0x2a, 0xaf, 0xde, 0x64, 0x19,
708 0xa0, 0x58, 0xab, 0x4f, 0x6f, 0x74, 0x6b, 0xf4,
709 0x0f, 0xc0, 0xc3, 0xb7, 0x80, 0xf2, 0x44, 0x45,
710 0x2d, 0xa3, 0xeb, 0xf1, 0xc5, 0xd8, 0x2c, 0xde,
711 0xa2, 0x41, 0x89, 0x97, 0x20, 0x0e, 0xf8, 0x2e,
712 0x44, 0xae, 0x7e, 0x3f
715 static const u8 T18[] = {
716 0xa4, 0x4a, 0x82, 0x66, 0xee, 0x1c, 0x8e, 0xb0,
717 0xc8, 0xb5, 0xd4, 0xcf, 0x5a, 0xe9, 0xf1, 0x9a
725 static const u8 A19[] = {
726 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
727 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
728 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
729 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
730 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
731 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
732 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
733 0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55,
734 0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
735 0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
736 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
737 0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
738 0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
739 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
740 0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
741 0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
744 static const u8 T19[] = {
745 0x5f, 0xea, 0x79, 0x3a, 0x2d, 0x6f, 0x97, 0x4d,
746 0x37, 0xe6, 0x8e, 0x0c, 0xb8, 0xff, 0x94, 0x92
752 /* this results in 0xff in counter LSB */
753 static const u8 IV20[64] = { 0xff, 0xff, 0xff, 0xff };
755 static const u8 P20[288];
756 static const u8 C20[] = {
757 0x56, 0xb3, 0x37, 0x3c, 0xa9, 0xef, 0x6e, 0x4a,
758 0x2b, 0x64, 0xfe, 0x1e, 0x9a, 0x17, 0xb6, 0x14,
759 0x25, 0xf1, 0x0d, 0x47, 0xa7, 0x5a, 0x5f, 0xce,
760 0x13, 0xef, 0xc6, 0xbc, 0x78, 0x4a, 0xf2, 0x4f,
761 0x41, 0x41, 0xbd, 0xd4, 0x8c, 0xf7, 0xc7, 0x70,
762 0x88, 0x7a, 0xfd, 0x57, 0x3c, 0xca, 0x54, 0x18,
763 0xa9, 0xae, 0xff, 0xcd, 0x7c, 0x5c, 0xed, 0xdf,
764 0xc6, 0xa7, 0x83, 0x97, 0xb9, 0xa8, 0x5b, 0x49,
765 0x9d, 0xa5, 0x58, 0x25, 0x72, 0x67, 0xca, 0xab,
766 0x2a, 0xd0, 0xb2, 0x3c, 0xa4, 0x76, 0xa5, 0x3c,
767 0xb1, 0x7f, 0xb4, 0x1c, 0x4b, 0x8b, 0x47, 0x5c,
768 0xb4, 0xf3, 0xf7, 0x16, 0x50, 0x94, 0xc2, 0x29,
769 0xc9, 0xe8, 0xc4, 0xdc, 0x0a, 0x2a, 0x5f, 0xf1,
770 0x90, 0x3e, 0x50, 0x15, 0x11, 0x22, 0x13, 0x76,
771 0xa1, 0xcd, 0xb8, 0x36, 0x4c, 0x50, 0x61, 0xa2,
772 0x0c, 0xae, 0x74, 0xbc, 0x4a, 0xcd, 0x76, 0xce,
773 0xb0, 0xab, 0xc9, 0xfd, 0x32, 0x17, 0xef, 0x9f,
774 0x8c, 0x90, 0xbe, 0x40, 0x2d, 0xdf, 0x6d, 0x86,
775 0x97, 0xf4, 0xf8, 0x80, 0xdf, 0xf1, 0x5b, 0xfb,
776 0x7a, 0x6b, 0x28, 0x24, 0x1e, 0xc8, 0xfe, 0x18,
777 0x3c, 0x2d, 0x59, 0xe3, 0xf9, 0xdf, 0xff, 0x65,
778 0x3c, 0x71, 0x26, 0xf0, 0xac, 0xb9, 0xe6, 0x42,
779 0x11, 0xf4, 0x2b, 0xae, 0x12, 0xaf, 0x46, 0x2b,
780 0x10, 0x70, 0xbe, 0xf1, 0xab, 0x5e, 0x36, 0x06,
781 0x87, 0x2c, 0xa1, 0x0d, 0xee, 0x15, 0xb3, 0x24,
782 0x9b, 0x1a, 0x1b, 0x95, 0x8f, 0x23, 0x13, 0x4c,
783 0x4b, 0xcc, 0xb7, 0xd0, 0x32, 0x00, 0xbc, 0xe4,
784 0x20, 0xa2, 0xf8, 0xeb, 0x66, 0xdc, 0xf3, 0x64,
785 0x4d, 0x14, 0x23, 0xc1, 0xb5, 0x69, 0x90, 0x03,
786 0xc1, 0x3e, 0xce, 0xf4, 0xbf, 0x38, 0xa3, 0xb6,
787 0x0e, 0xed, 0xc3, 0x40, 0x33, 0xba, 0xc1, 0x90,
788 0x27, 0x83, 0xdc, 0x6d, 0x89, 0xe2, 0xe7, 0x74,
789 0x18, 0x8a, 0x43, 0x9c, 0x7e, 0xbc, 0xc0, 0x67,
790 0x2d, 0xbd, 0xa4, 0xdd, 0xcf, 0xb2, 0x79, 0x46,
791 0x13, 0xb0, 0xbe, 0x41, 0x31, 0x5e, 0xf7, 0x78,
792 0x70, 0x8a, 0x70, 0xee, 0x7d, 0x75, 0x16, 0x5c
795 static const u8 T20[] = {
796 0x8b, 0x30, 0x7f, 0x6b, 0x33, 0x28, 0x6d, 0x0a,
797 0xb0, 0x26, 0xa9, 0xed, 0x3f, 0xe1, 0xe8, 0x5f
800 #define GCM128_TEST_VECTOR(n) \
802 {sizeof(K##n), K##n}, \
803 {sizeof(IV##n), IV##n}, \
804 {sizeof(A##n), A##n}, \
805 {sizeof(P##n), P##n}, \
806 {sizeof(C##n), C##n}, \
807 {sizeof(T##n), T##n} \
809 static struct gcm128_data {
816 } gcm128_vectors[] = {
817 GCM128_TEST_VECTOR(1),
818 GCM128_TEST_VECTOR(2),
819 GCM128_TEST_VECTOR(3),
820 GCM128_TEST_VECTOR(4),
821 GCM128_TEST_VECTOR(5),
822 GCM128_TEST_VECTOR(6),
823 GCM128_TEST_VECTOR(7),
824 GCM128_TEST_VECTOR(8),
825 GCM128_TEST_VECTOR(9),
826 GCM128_TEST_VECTOR(10),
827 GCM128_TEST_VECTOR(11),
828 GCM128_TEST_VECTOR(12),
829 GCM128_TEST_VECTOR(13),
830 GCM128_TEST_VECTOR(14),
831 GCM128_TEST_VECTOR(15),
832 GCM128_TEST_VECTOR(16),
833 GCM128_TEST_VECTOR(17),
834 GCM128_TEST_VECTOR(18),
835 GCM128_TEST_VECTOR(19),
836 GCM128_TEST_VECTOR(20)
839 static int test_gcm128(int idx)
841 unsigned char out[512];
842 SIZED_DATA K = gcm128_vectors[idx].K;
843 SIZED_DATA IV = gcm128_vectors[idx].IV;
844 SIZED_DATA A = gcm128_vectors[idx].A;
845 SIZED_DATA P = gcm128_vectors[idx].P;
846 SIZED_DATA C = gcm128_vectors[idx].C;
847 SIZED_DATA T = gcm128_vectors[idx].T;
851 /* Size 1 inputs are special-cased to signal NULL. */
859 AES_set_encrypt_key(K.data, K.size * 8, &key);
861 CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);
862 CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
863 memset(out, 0, P.size);
865 CRYPTO_gcm128_aad(&ctx, A.data, A.size);
867 CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size);
868 if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
870 && !TEST_mem_eq(out, P.size, C.data, P.size)))
873 CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
874 memset(out, 0, P.size);
876 CRYPTO_gcm128_aad(&ctx, A.data, A.size);
878 CRYPTO_gcm128_decrypt(&ctx, C.data, out, P.size);
879 if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
881 && !TEST_mem_eq(out, P.size, P.data, P.size)))
887 static void benchmark_gcm128(const unsigned char *K, size_t Klen,
888 const unsigned char *IV, size_t IVlen)
890 #ifdef OPENSSL_CPUID_OBJ
893 uint32_t start, gcm_t, ctr_t;
899 AES_set_encrypt_key(K, Klen * 8, &key);
900 CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);
901 CRYPTO_gcm128_setiv(&ctx, IV, IVlen);
903 CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
904 start = OPENSSL_rdtsc();
905 CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
906 gcm_t = OPENSSL_rdtsc() - start;
908 CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
909 &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
910 (block128_f) AES_encrypt);
911 start = OPENSSL_rdtsc();
912 CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
913 &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
914 (block128_f) AES_encrypt);
915 ctr_t = OPENSSL_rdtsc() - start;
917 printf("%.2f-%.2f=%.2f\n",
918 gcm_t / (double)sizeof(buf),
919 ctr_t / (double)sizeof(buf),
920 (gcm_t - ctr_t) / (double)sizeof(buf));
923 void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
924 const u8 *inp, size_t len) = ctx.ghash;
926 GHASH((&ctx), buf.c, sizeof(buf));
927 start = OPENSSL_rdtsc();
928 for (i = 0; i < 100; ++i)
929 GHASH((&ctx), buf.c, sizeof(buf));
930 gcm_t = OPENSSL_rdtsc() - start;
931 printf("%.2f\n", gcm_t / (double)sizeof(buf) / (double)i);
936 "Benchmarking of modes isn't available on this platform\n");
940 int setup_tests(void)
942 if (test_has_option("-h")) {
943 printf("-h\tThis help\n");
944 printf("-b\tBenchmark gcm128 in addition to the tests\n");
948 ADD_ALL_TESTS(test_aes_cts128, OSSL_NELEM(aes_cts128_vectors));
949 ADD_ALL_TESTS(test_aes_cts128_nist, OSSL_NELEM(aes_cts128_vectors));
950 ADD_ALL_TESTS(test_gcm128, OSSL_NELEM(gcm128_vectors));
954 void cleanup_tests(void)
956 if (test_has_option("-b"))
957 benchmark_gcm128(K1, sizeof(K1), IV1, sizeof(IV1));