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