087115b242de7a657c4bb35c1e9d8af3cb71f3d0
[openssl.git] / test / modes_internal_test.c
1 /*
2  * Copyright 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 /* Internal tests for the modes module */
11
12 #include <stdio.h>
13 #include <string.h>
14
15 #include <openssl/aes.h>
16 #include <openssl/modes.h>
17 #include "../crypto/modes/modes_lcl.h"
18 #include "testutil.h"
19 #include "test_main_custom.h"
20 #include "e_os.h"
21
22 typedef struct {
23     size_t size;
24     const unsigned char *data;
25 }  SIZED_DATA;
26
27 /**********************************************************************
28  *
29  * Test of cts128
30  *
31  ***/
32
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 };
40
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,
44     0x97
45 };
46
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
52 };
53
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
59 };
60
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
68 };
69
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
77 };
78
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
88 };
89
90 #define CTS128_TEST_VECTOR(len)                 \
91     {                                           \
92         sizeof(vector_##len), vector_##len      \
93     }
94 static const SIZED_DATA 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),
101 };
102
103 static AES_KEY *cts128_encrypt_key_schedule()
104 {
105     static int init_key = 1;
106     static AES_KEY ks;
107
108     if (init_key) {
109         AES_set_encrypt_key(cts128_test_key, 128, &ks);
110         init_key = 0;
111     }
112     return &ks;
113 }
114
115 static AES_KEY *cts128_decrypt_key_schedule()
116 {
117     static int init_key = 1;
118     static AES_KEY ks;
119
120     if (init_key) {
121         AES_set_decrypt_key(cts128_test_key, 128, &ks);
122         init_key = 0;
123     }
124     return &ks;
125 }
126
127 typedef struct {
128     const char *case_name;
129     int num;
130     size_t (*transform_output)(const unsigned char *in, unsigned char *out,
131                                size_t len);
132     size_t (*encrypt_block)(const unsigned char *in,
133                             unsigned char *out, size_t len,
134                             const void *key, unsigned char ivec[16],
135                             block128_f block);
136     size_t (*encrypt)(const unsigned char *in, unsigned char *out,
137                       size_t len, const void *key,
138                       unsigned char ivec[16], cbc128_f cbc);
139     size_t (*decrypt_block)(const unsigned char *in,
140                             unsigned char *out, size_t len,
141                             const void *key, unsigned char ivec[16],
142                             block128_f block);
143     size_t (*decrypt)(const unsigned char *in, unsigned char *out,
144                       size_t len, const void *key,
145                       unsigned char ivec[16], cbc128_f cbc);
146 } CTS128_FIXTURE;
147
148
149 static CTS128_FIXTURE setup_cts128(const char *const test_case_name)
150 {
151     CTS128_FIXTURE fixture;
152     fixture.case_name = test_case_name;
153     return fixture;
154 }
155
156 static size_t transform_output(const unsigned char *in, unsigned char *out,
157                                size_t len)
158 {
159     size_t tail;
160
161     memcpy(out, in, len);
162     if ((tail = len % 16) == 0)
163         tail = 16;
164     tail += 16;
165
166     return tail;
167 }
168
169 static size_t transform_output_nist(const unsigned char *in, unsigned char *out,
170                                     size_t len)
171 {
172     size_t tail;
173
174     if ((tail = len % 16) == 0)
175         tail = 16;
176     len -= 16 + tail;
177     memcpy(out, in, len);
178     /* flip two last blocks */
179     memcpy(out + len, in + len + 16, tail);
180     memcpy(out + len + tail, in + len, 16);
181     len += 16 + tail;
182     tail = 16;
183
184     return tail;
185 }
186
187 static int execute_cts128(CTS128_FIXTURE fixture)
188 {
189     const unsigned char *test_iv = cts128_test_iv;
190     size_t test_iv_len = sizeof(cts128_test_iv);
191     const unsigned char *orig_vector = cts128_vectors[fixture.num].data;
192     size_t len = cts128_vectors[fixture.num].size;
193     const unsigned char *test_input = cts128_test_input;
194     const AES_KEY *encrypt_key_schedule = cts128_encrypt_key_schedule();
195     const AES_KEY *decrypt_key_schedule = cts128_decrypt_key_schedule();
196     unsigned char iv[16];
197     /* The largest test inputs are = 64 bytes. */
198     unsigned char cleartext[64], ciphertext[64], vector[64];
199     size_t tail;
200
201     TEST_info("%s_vector_%lu", fixture.case_name, (unsigned long)len);
202
203     tail = fixture.transform_output(orig_vector, vector, len);
204
205     /* test block-based encryption */
206     memcpy(iv, test_iv, test_iv_len);
207     fixture.encrypt_block(test_input, ciphertext, len,
208                           encrypt_key_schedule, iv,
209                           (block128_f)AES_encrypt);
210     if (!TEST_mem_eq(ciphertext, len, vector, len))
211         return 0;
212
213     if (!TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
214         return 0;
215
216     /* test block-based decryption */
217     memcpy(iv, test_iv, test_iv_len);
218     fixture.decrypt_block(ciphertext, cleartext, len,
219                           decrypt_key_schedule, iv,
220                           (block128_f)AES_decrypt);
221     if (!TEST_mem_eq(cleartext, len, test_input, len))
222         return 0;
223     if (!TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
224         return 0;
225
226     /* test streamed encryption */
227     memcpy(iv, test_iv, test_iv_len);
228     fixture.encrypt(test_input, ciphertext, len, encrypt_key_schedule,
229                     iv, (cbc128_f) AES_cbc_encrypt);
230     if (!TEST_mem_eq(ciphertext, len, vector, len))
231         return 0;
232     if (!TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
233         return 0;
234
235     /* test streamed decryption */
236     memcpy(iv, test_iv, test_iv_len);
237     fixture.decrypt(ciphertext, cleartext, len, decrypt_key_schedule, iv,
238                     (cbc128_f)AES_cbc_encrypt);
239     if (!TEST_mem_eq(cleartext, len, test_input, len))
240         return 0;
241     if (!TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
242         return 0;
243
244     return 1;
245 }
246
247 static int test_cts128(int idx)
248 {
249     SETUP_TEST_FIXTURE(CTS128_FIXTURE, setup_cts128);
250     fixture.transform_output = transform_output;
251     fixture.encrypt_block = CRYPTO_cts128_encrypt_block;
252     fixture.encrypt = CRYPTO_cts128_encrypt;
253     fixture.decrypt_block = CRYPTO_cts128_decrypt_block;
254     fixture.decrypt = CRYPTO_cts128_decrypt;
255     fixture.case_name = "cts128";
256     fixture.num = idx;
257     EXECUTE_TEST_NO_TEARDOWN(execute_cts128);
258 }
259
260 static int test_cts128_nist(int idx)
261 {
262     SETUP_TEST_FIXTURE(CTS128_FIXTURE, setup_cts128);
263     fixture.transform_output = transform_output_nist;
264     fixture.encrypt_block = CRYPTO_nistcts128_encrypt_block;
265     fixture.encrypt = CRYPTO_nistcts128_encrypt;
266     fixture.decrypt_block = CRYPTO_nistcts128_decrypt_block;
267     fixture.decrypt = CRYPTO_nistcts128_decrypt;
268     fixture.case_name = "cts128_nist";
269     fixture.num = idx;
270     EXECUTE_TEST_NO_TEARDOWN(execute_cts128);
271 }
272
273 /*
274  *
275  * Test of gcm128
276  *
277  */
278
279 /* Test Case 1 */
280 static const u8 K1[16], P1[] = { 0 }, A1[] = { 0 }, IV1[12], C1[] = { 0 };
281 static const u8 T1[] = {
282     0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, 0x30, 0x61,
283     0x36, 0x7f, 0x1d, 0x57, 0xa4, 0xe7, 0x45, 0x5a
284 };
285
286 /* Test Case 2 */
287 # define K2 K1
288 # define A2 A1
289 # define IV2 IV1
290 static const u8 P2[16];
291 static const u8 C2[] = {
292     0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92,
293     0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78
294 };
295
296 static const u8 T2[] = {
297     0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd,
298     0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf
299 };
300
301 /* Test Case 3 */
302 # define A3 A2
303 static const u8 K3[] = {
304     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
305     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
306 };
307
308 static const u8 P3[] = {
309     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
310     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
311     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
312     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
313     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
314     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
315     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
316     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
317 };
318
319 static const u8 IV3[] = {
320     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
321     0xde, 0xca, 0xf8, 0x88
322 };
323
324 static const u8 C3[] = {
325     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
326     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
327     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
328     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
329     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
330     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
331     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
332     0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85
333 };
334
335 static const u8 T3[] = {
336     0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6,
337     0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4
338 };
339
340 /* Test Case 4 */
341 # define K4 K3
342 # define IV4 IV3
343 static const u8 P4[] = {
344     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
345     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
346     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
347     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
348     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
349     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
350     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
351     0xba, 0x63, 0x7b, 0x39
352 };
353
354 static const u8 A4[] = {
355     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
356     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
357     0xab, 0xad, 0xda, 0xd2
358 };
359
360 static const u8 C4[] = {
361     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
362     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
363     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
364     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
365     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
366     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
367     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
368     0x3d, 0x58, 0xe0, 0x91
369 };
370
371 static const u8 T4[] = {
372     0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
373     0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47
374 };
375
376 /* Test Case 5 */
377 # define K5 K4
378 # define P5 P4
379 # define A5 A4
380 static const u8 IV5[] = {
381     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad
382 };
383
384 static const u8 C5[] = {
385     0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a,
386     0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55,
387     0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8,
388     0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23,
389     0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2,
390     0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42,
391     0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07,
392     0xc2, 0x3f, 0x45, 0x98
393 };
394
395 static const u8 T5[] = {
396     0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85,
397     0x56, 0x1b, 0xe1, 0x4a, 0xac, 0xa2, 0xfc, 0xcb
398 };
399
400 /* Test Case 6 */
401 # define K6 K5
402 # define P6 P5
403 # define A6 A5
404 static const u8 IV6[] = {
405     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
406     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
407     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
408     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
409     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
410     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
411     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
412     0xa6, 0x37, 0xb3, 0x9b
413 };
414
415 static const u8 C6[] = {
416     0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6,
417     0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94,
418     0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8,
419     0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7,
420     0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90,
421     0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f,
422     0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03,
423     0x4c, 0x34, 0xae, 0xe5
424 };
425
426 static const u8 T6[] = {
427     0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa,
428     0x46, 0x2a, 0xf4, 0x3c, 0x16, 0x99, 0xd0, 0x50
429 };
430
431 /* Test Case 7 */
432 static const u8 K7[24], P7[] = { 0 }, A7[] = { 0 }, IV7[12], C7[] = { 0 };
433 static const u8 T7[] = {
434     0xcd, 0x33, 0xb2, 0x8a, 0xc7, 0x73, 0xf7, 0x4b,
435     0xa0, 0x0e, 0xd1, 0xf3, 0x12, 0x57, 0x24, 0x35
436 };
437
438 /* Test Case 8 */
439 # define K8 K7
440 # define IV8 IV7
441 # define A8 A7
442 static const u8 P8[16];
443 static const u8 C8[] = {
444     0x98, 0xe7, 0x24, 0x7c, 0x07, 0xf0, 0xfe, 0x41,
445     0x1c, 0x26, 0x7e, 0x43, 0x84, 0xb0, 0xf6, 0x00
446 };
447
448 static const u8 T8[] = {
449     0x2f, 0xf5, 0x8d, 0x80, 0x03, 0x39, 0x27, 0xab,
450     0x8e, 0xf4, 0xd4, 0x58, 0x75, 0x14, 0xf0, 0xfb
451 };
452
453 /* Test Case 9 */
454 # define A9 A8
455 static const u8 K9[] = {
456     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
457     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
458     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c
459 };
460
461 static const u8 P9[] = {
462     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
463     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
464     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
465     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
466     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
467     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
468     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
469     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
470 };
471
472 static const u8 IV9[] = {
473     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
474     0xde, 0xca, 0xf8, 0x88
475 };
476
477 static const u8 C9[] = {
478     0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
479     0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
480     0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
481     0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
482     0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
483     0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
484     0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
485     0xcc, 0xda, 0x27, 0x10, 0xac, 0xad, 0xe2, 0x56
486 };
487
488 static const u8 T9[] = {
489     0x99, 0x24, 0xa7, 0xc8, 0x58, 0x73, 0x36, 0xbf,
490     0xb1, 0x18, 0x02, 0x4d, 0xb8, 0x67, 0x4a, 0x14
491 };
492
493 /* Test Case 10 */
494 # define K10 K9
495 # define IV10 IV9
496 static const u8 P10[] = {
497     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
498     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
499     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
500     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
501     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
502     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
503     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
504     0xba, 0x63, 0x7b, 0x39
505 };
506
507 static const u8 A10[] = {
508     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
509     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
510     0xab, 0xad, 0xda, 0xd2
511 };
512
513 static const u8 C10[] = {
514     0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
515     0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
516     0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
517     0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
518     0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
519     0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
520     0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
521     0xcc, 0xda, 0x27, 0x10
522 };
523
524 static const u8 T10[] = {
525     0x25, 0x19, 0x49, 0x8e, 0x80, 0xf1, 0x47, 0x8f,
526     0x37, 0xba, 0x55, 0xbd, 0x6d, 0x27, 0x61, 0x8c
527 };
528
529 /* Test Case 11 */
530 # define K11 K10
531 # define P11 P10
532 # define A11 A10
533 static const u8 IV11[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
534
535 static const u8 C11[] = {
536     0x0f, 0x10, 0xf5, 0x99, 0xae, 0x14, 0xa1, 0x54,
537     0xed, 0x24, 0xb3, 0x6e, 0x25, 0x32, 0x4d, 0xb8,
538     0xc5, 0x66, 0x63, 0x2e, 0xf2, 0xbb, 0xb3, 0x4f,
539     0x83, 0x47, 0x28, 0x0f, 0xc4, 0x50, 0x70, 0x57,
540     0xfd, 0xdc, 0x29, 0xdf, 0x9a, 0x47, 0x1f, 0x75,
541     0xc6, 0x65, 0x41, 0xd4, 0xd4, 0xda, 0xd1, 0xc9,
542     0xe9, 0x3a, 0x19, 0xa5, 0x8e, 0x8b, 0x47, 0x3f,
543     0xa0, 0xf0, 0x62, 0xf7
544 };
545
546 static const u8 T11[] = {
547     0x65, 0xdc, 0xc5, 0x7f, 0xcf, 0x62, 0x3a, 0x24,
548     0x09, 0x4f, 0xcc, 0xa4, 0x0d, 0x35, 0x33, 0xf8
549 };
550
551 /* Test Case 12 */
552 # define K12 K11
553 # define P12 P11
554 # define A12 A11
555 static const u8 IV12[] = {
556     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
557     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
558     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
559     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
560     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
561     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
562     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
563     0xa6, 0x37, 0xb3, 0x9b
564 };
565
566 static const u8 C12[] = {
567     0xd2, 0x7e, 0x88, 0x68, 0x1c, 0xe3, 0x24, 0x3c,
568     0x48, 0x30, 0x16, 0x5a, 0x8f, 0xdc, 0xf9, 0xff,
569     0x1d, 0xe9, 0xa1, 0xd8, 0xe6, 0xb4, 0x47, 0xef,
570     0x6e, 0xf7, 0xb7, 0x98, 0x28, 0x66, 0x6e, 0x45,
571     0x81, 0xe7, 0x90, 0x12, 0xaf, 0x34, 0xdd, 0xd9,
572     0xe2, 0xf0, 0x37, 0x58, 0x9b, 0x29, 0x2d, 0xb3,
573     0xe6, 0x7c, 0x03, 0x67, 0x45, 0xfa, 0x22, 0xe7,
574     0xe9, 0xb7, 0x37, 0x3b
575 };
576
577 static const u8 T12[] = {
578     0xdc, 0xf5, 0x66, 0xff, 0x29, 0x1c, 0x25, 0xbb,
579     0xb8, 0x56, 0x8f, 0xc3, 0xd3, 0x76, 0xa6, 0xd9
580 };
581
582 /* Test Case 13 */
583 static const u8 K13[32], P13[] = { 0 }, A13[] = { 0 }, IV13[12], C13[] = { 0 };
584 static const u8 T13[] = {
585     0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9,
586     0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b
587 };
588
589 /* Test Case 14 */
590 # define K14 K13
591 # define A14 A13
592 static const u8 P14[16], IV14[12];
593 static const u8 C14[] = {
594     0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e,
595     0x07, 0x4e, 0xc5, 0xd3, 0xba, 0xf3, 0x9d, 0x18
596 };
597
598 static const u8 T14[] = {
599     0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0,
600     0x26, 0x5b, 0x98, 0xb5, 0xd4, 0x8a, 0xb9, 0x19
601 };
602
603 /* Test Case 15 */
604 # define A15 A14
605 static const u8 K15[] = {
606     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
607     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
608     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
609     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
610 };
611
612 static const u8 P15[] = {
613     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
614     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
615     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
616     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
617     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
618     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
619     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
620     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
621 };
622
623 static const u8 IV15[] = {
624     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
625     0xde, 0xca, 0xf8, 0x88
626 };
627
628 static const u8 C15[] = {
629     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
630     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
631     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
632     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
633     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
634     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
635     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
636     0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
637 };
638
639 static const u8 T15[] = {
640     0xb0, 0x94, 0xda, 0xc5, 0xd9, 0x34, 0x71, 0xbd,
641     0xec, 0x1a, 0x50, 0x22, 0x70, 0xe3, 0xcc, 0x6c
642 };
643
644 /* Test Case 16 */
645 # define K16 K15
646 # define IV16 IV15
647 static const u8 P16[] = {
648     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
649     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
650     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
651     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
652     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
653     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
654     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
655     0xba, 0x63, 0x7b, 0x39
656 };
657
658 static const u8 A16[] = {
659     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
660     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
661     0xab, 0xad, 0xda, 0xd2
662 };
663
664 static const u8 C16[] = {
665     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
666     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
667     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
668     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
669     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
670     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
671     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
672     0xbc, 0xc9, 0xf6, 0x62
673 };
674
675 static const u8 T16[] = {
676     0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68,
677     0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b
678 };
679
680 /* Test Case 17 */
681 # define K17 K16
682 # define P17 P16
683 # define A17 A16
684 static const u8 IV17[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
685
686 static const u8 C17[] = {
687     0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32,
688     0xae, 0x47, 0xc1, 0x3b, 0xf1, 0x98, 0x44, 0xcb,
689     0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
690     0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0,
691     0xfe, 0xb5, 0x82, 0xd3, 0x39, 0x34, 0xa4, 0xf0,
692     0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
693     0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99,
694     0xf4, 0x7c, 0x9b, 0x1f
695 };
696
697 static const u8 T17[] = {
698     0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4,
699     0x5e, 0x45, 0x49, 0x13, 0xfe, 0x2e, 0xa8, 0xf2
700 };
701
702 /* Test Case 18 */
703 # define K18 K17
704 # define P18 P17
705 # define A18 A17
706 static const u8 IV18[] = {
707     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
708     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
709     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
710     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
711     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
712     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
713     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
714     0xa6, 0x37, 0xb3, 0x9b
715 };
716
717 static const u8 C18[] = {
718     0x5a, 0x8d, 0xef, 0x2f, 0x0c, 0x9e, 0x53, 0xf1,
719     0xf7, 0x5d, 0x78, 0x53, 0x65, 0x9e, 0x2a, 0x20,
720     0xee, 0xb2, 0xb2, 0x2a, 0xaf, 0xde, 0x64, 0x19,
721     0xa0, 0x58, 0xab, 0x4f, 0x6f, 0x74, 0x6b, 0xf4,
722     0x0f, 0xc0, 0xc3, 0xb7, 0x80, 0xf2, 0x44, 0x45,
723     0x2d, 0xa3, 0xeb, 0xf1, 0xc5, 0xd8, 0x2c, 0xde,
724     0xa2, 0x41, 0x89, 0x97, 0x20, 0x0e, 0xf8, 0x2e,
725     0x44, 0xae, 0x7e, 0x3f
726 };
727
728 static const u8 T18[] = {
729     0xa4, 0x4a, 0x82, 0x66, 0xee, 0x1c, 0x8e, 0xb0,
730     0xc8, 0xb5, 0xd4, 0xcf, 0x5a, 0xe9, 0xf1, 0x9a
731 };
732
733 /* Test Case 19 */
734 # define K19 K1
735 # define P19 P1
736 # define IV19 IV1
737 # define C19 C1
738 static const u8 A19[] = {
739     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
740     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
741     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
742     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
743     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
744     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
745     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
746     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55,
747     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
748     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
749     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
750     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
751     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
752     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
753     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
754     0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
755 };
756
757 static const u8 T19[] = {
758     0x5f, 0xea, 0x79, 0x3a, 0x2d, 0x6f, 0x97, 0x4d,
759     0x37, 0xe6, 0x8e, 0x0c, 0xb8, 0xff, 0x94, 0x92
760 };
761
762 /* Test Case 20 */
763 # define K20 K1
764 # define A20 A1
765 /* this results in 0xff in counter LSB */
766 static const u8 IV20[64] = { 0xff, 0xff, 0xff, 0xff };
767
768 static const u8 P20[288];
769 static const u8 C20[] = {
770     0x56, 0xb3, 0x37, 0x3c, 0xa9, 0xef, 0x6e, 0x4a,
771     0x2b, 0x64, 0xfe, 0x1e, 0x9a, 0x17, 0xb6, 0x14,
772     0x25, 0xf1, 0x0d, 0x47, 0xa7, 0x5a, 0x5f, 0xce,
773     0x13, 0xef, 0xc6, 0xbc, 0x78, 0x4a, 0xf2, 0x4f,
774     0x41, 0x41, 0xbd, 0xd4, 0x8c, 0xf7, 0xc7, 0x70,
775     0x88, 0x7a, 0xfd, 0x57, 0x3c, 0xca, 0x54, 0x18,
776     0xa9, 0xae, 0xff, 0xcd, 0x7c, 0x5c, 0xed, 0xdf,
777     0xc6, 0xa7, 0x83, 0x97, 0xb9, 0xa8, 0x5b, 0x49,
778     0x9d, 0xa5, 0x58, 0x25, 0x72, 0x67, 0xca, 0xab,
779     0x2a, 0xd0, 0xb2, 0x3c, 0xa4, 0x76, 0xa5, 0x3c,
780     0xb1, 0x7f, 0xb4, 0x1c, 0x4b, 0x8b, 0x47, 0x5c,
781     0xb4, 0xf3, 0xf7, 0x16, 0x50, 0x94, 0xc2, 0x29,
782     0xc9, 0xe8, 0xc4, 0xdc, 0x0a, 0x2a, 0x5f, 0xf1,
783     0x90, 0x3e, 0x50, 0x15, 0x11, 0x22, 0x13, 0x76,
784     0xa1, 0xcd, 0xb8, 0x36, 0x4c, 0x50, 0x61, 0xa2,
785     0x0c, 0xae, 0x74, 0xbc, 0x4a, 0xcd, 0x76, 0xce,
786     0xb0, 0xab, 0xc9, 0xfd, 0x32, 0x17, 0xef, 0x9f,
787     0x8c, 0x90, 0xbe, 0x40, 0x2d, 0xdf, 0x6d, 0x86,
788     0x97, 0xf4, 0xf8, 0x80, 0xdf, 0xf1, 0x5b, 0xfb,
789     0x7a, 0x6b, 0x28, 0x24, 0x1e, 0xc8, 0xfe, 0x18,
790     0x3c, 0x2d, 0x59, 0xe3, 0xf9, 0xdf, 0xff, 0x65,
791     0x3c, 0x71, 0x26, 0xf0, 0xac, 0xb9, 0xe6, 0x42,
792     0x11, 0xf4, 0x2b, 0xae, 0x12, 0xaf, 0x46, 0x2b,
793     0x10, 0x70, 0xbe, 0xf1, 0xab, 0x5e, 0x36, 0x06,
794     0x87, 0x2c, 0xa1, 0x0d, 0xee, 0x15, 0xb3, 0x24,
795     0x9b, 0x1a, 0x1b, 0x95, 0x8f, 0x23, 0x13, 0x4c,
796     0x4b, 0xcc, 0xb7, 0xd0, 0x32, 0x00, 0xbc, 0xe4,
797     0x20, 0xa2, 0xf8, 0xeb, 0x66, 0xdc, 0xf3, 0x64,
798     0x4d, 0x14, 0x23, 0xc1, 0xb5, 0x69, 0x90, 0x03,
799     0xc1, 0x3e, 0xce, 0xf4, 0xbf, 0x38, 0xa3, 0xb6,
800     0x0e, 0xed, 0xc3, 0x40, 0x33, 0xba, 0xc1, 0x90,
801     0x27, 0x83, 0xdc, 0x6d, 0x89, 0xe2, 0xe7, 0x74,
802     0x18, 0x8a, 0x43, 0x9c, 0x7e, 0xbc, 0xc0, 0x67,
803     0x2d, 0xbd, 0xa4, 0xdd, 0xcf, 0xb2, 0x79, 0x46,
804     0x13, 0xb0, 0xbe, 0x41, 0x31, 0x5e, 0xf7, 0x78,
805     0x70, 0x8a, 0x70, 0xee, 0x7d, 0x75, 0x16, 0x5c
806 };
807
808 static const u8 T20[] = {
809     0x8b, 0x30, 0x7f, 0x6b, 0x33, 0x28, 0x6d, 0x0a,
810     0xb0, 0x26, 0xa9, 0xed, 0x3f, 0xe1, 0xe8, 0x5f
811 };
812
813 #define GCM128_TEST_VECTOR(n)                   \
814     {                                           \
815         {sizeof(K##n), K##n},                   \
816         {sizeof(IV##n), IV##n},                 \
817         {sizeof(A##n), A##n},                   \
818         {sizeof(P##n), P##n},                   \
819         {sizeof(C##n), C##n},                   \
820         {sizeof(T##n), T##n}                    \
821     }
822 static struct gcm128_data {
823     const SIZED_DATA K;
824     const SIZED_DATA IV;
825     const SIZED_DATA A;
826     const SIZED_DATA P;
827     const SIZED_DATA C;
828     const SIZED_DATA T;
829 } gcm128_vectors[] = {
830     GCM128_TEST_VECTOR(1),
831     GCM128_TEST_VECTOR(2),
832     GCM128_TEST_VECTOR(3),
833     GCM128_TEST_VECTOR(4),
834     GCM128_TEST_VECTOR(5),
835     GCM128_TEST_VECTOR(6),
836     GCM128_TEST_VECTOR(7),
837     GCM128_TEST_VECTOR(8),
838     GCM128_TEST_VECTOR(9),
839     GCM128_TEST_VECTOR(10),
840     GCM128_TEST_VECTOR(11),
841     GCM128_TEST_VECTOR(12),
842     GCM128_TEST_VECTOR(13),
843     GCM128_TEST_VECTOR(14),
844     GCM128_TEST_VECTOR(15),
845     GCM128_TEST_VECTOR(16),
846     GCM128_TEST_VECTOR(17),
847     GCM128_TEST_VECTOR(18),
848     GCM128_TEST_VECTOR(19),
849     GCM128_TEST_VECTOR(20)
850 };
851
852 static int test_gcm128(int idx)
853 {
854     unsigned char out[512];
855     SIZED_DATA K = gcm128_vectors[idx].K;
856     SIZED_DATA IV = gcm128_vectors[idx].IV;
857     SIZED_DATA A = gcm128_vectors[idx].A;
858     SIZED_DATA P = gcm128_vectors[idx].P;
859     SIZED_DATA C = gcm128_vectors[idx].C;
860     SIZED_DATA T = gcm128_vectors[idx].T;
861     GCM128_CONTEXT ctx;
862     AES_KEY key;
863
864     /* Size 1 inputs are special-cased to signal NULL. */
865     if (A.size == 1)
866         A.data = NULL;
867     if (P.size == 1)
868         P.data = NULL;
869     if (C.size == 1)
870         C.data = NULL;
871
872     AES_set_encrypt_key(K.data, K.size * 8, &key);
873
874     CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);
875     CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
876     memset(out, 0, P.size);
877     if (A.data != NULL)
878         CRYPTO_gcm128_aad(&ctx, A.data, A.size);
879     if (P.data != NULL)
880         CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size);
881     if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
882             || (C.data != NULL
883                     && !TEST_mem_eq(out, P.size, C.data, P.size)))
884         return 0;
885
886     CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
887     memset(out, 0, P.size);
888     if (A.data != NULL)
889         CRYPTO_gcm128_aad(&ctx, A.data, A.size);
890     if (C.data != NULL)
891         CRYPTO_gcm128_decrypt(&ctx, C.data, out, P.size);
892     if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
893             || (P.data != NULL
894                     && !TEST_mem_eq(out, P.size, P.data, P.size)))
895         return 0;
896
897     return 1;
898 }
899
900 static void benchmark_gcm128(const unsigned char *K, size_t Klen,
901                              const unsigned char *IV, size_t IVlen)
902 {
903 #ifdef OPENSSL_CPUID_OBJ
904     GCM128_CONTEXT ctx;
905     AES_KEY key;
906     size_t start, gcm_t, ctr_t, OPENSSL_rdtsc();
907     union {
908         u64 u;
909         u8 c[1024];
910     } buf;
911
912     AES_set_encrypt_key(K, Klen * 8, &key);
913     CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);
914     CRYPTO_gcm128_setiv(&ctx, IV, IVlen);
915
916     CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
917     start = OPENSSL_rdtsc();
918     CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
919     gcm_t = OPENSSL_rdtsc() - start;
920
921     CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
922                           &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
923                           (block128_f) AES_encrypt);
924     start = OPENSSL_rdtsc();
925     CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
926                           &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
927                           (block128_f) AES_encrypt);
928     ctr_t = OPENSSL_rdtsc() - start;
929
930     printf("%.2f-%.2f=%.2f\n",
931            gcm_t / (double)sizeof(buf),
932            ctr_t / (double)sizeof(buf),
933            (gcm_t - ctr_t) / (double)sizeof(buf));
934 # ifdef GHASH
935     {
936         void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
937                              const u8 *inp, size_t len) = ctx.ghash;
938
939         GHASH((&ctx), buf.c, sizeof(buf));
940         start = OPENSSL_rdtsc();
941         for (i = 0; i < 100; ++i)
942             GHASH((&ctx), buf.c, sizeof(buf));
943         gcm_t = OPENSSL_rdtsc() - start;
944         printf("%.2f\n", gcm_t / (double)sizeof(buf) / (double)i);
945     }
946 # endif
947 #else
948     fprintf(stderr,
949             "Benchmarking of modes isn't available on this platform\n");
950 #endif
951 }
952
953 int test_main(int argc, char **argv)
954 {
955     int result = 0;
956     int iter_argv;
957     int benchmark = 0;
958
959     for (iter_argv = 1; iter_argv < argc; iter_argv++) {
960         if (strcmp(argv[iter_argv], "-b") == 0)
961             benchmark = 1;
962         else if (strcmp(argv[iter_argv], "-h") == 0)
963             goto help;
964     }
965
966     ADD_ALL_TESTS(test_cts128, OSSL_NELEM(cts128_vectors));
967     ADD_ALL_TESTS(test_cts128_nist, OSSL_NELEM(cts128_vectors));
968     ADD_ALL_TESTS(test_gcm128, OSSL_NELEM(gcm128_vectors));
969
970     result = run_tests(argv[0]);
971
972     if (benchmark)
973         benchmark_gcm128(K1, sizeof(K1), IV1, sizeof(IV1));
974
975     return result;
976
977  help:
978     printf("-h\tThis help\n");
979     printf("-b\tBenchmark gcm128 in addition to the tests\n");
980
981     return 0;
982 }