[CRYPTO]: Add cipher speed tests
[linux-2.6.git] / crypto / tcrypt.h
1 /*
2  * Quick & dirty crypto testing module.
3  *
4  * This will only exist until we have a better testing mechanism
5  * (e.g. a char device).
6  *
7  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 2 of the License, or (at your option)
13  * any later version.
14  *
15  * 2004-08-09 Cipher speed tests by Reyk Floeter <reyk@vantronix.net>
16  * 2003-09-14 Changes by Kartikey Mahendra Bhatt
17  *
18  */
19 #ifndef _CRYPTO_TCRYPT_H
20 #define _CRYPTO_TCRYPT_H
21
22 #define MAX_DIGEST_SIZE         64
23 #define MAX_TAP                 8
24
25 #define MAX_KEYLEN              56
26 #define MAX_IVLEN               32
27
28 struct hash_testvec {
29         char plaintext[128];
30         unsigned char psize;
31         char digest[MAX_DIGEST_SIZE];
32         unsigned char np;
33         unsigned char tap[MAX_TAP];
34         char key[128]; /* only used with keyed hash algorithms */
35         unsigned char ksize;
36 };
37
38 struct hmac_testvec {
39         char key[128];
40         unsigned char ksize;
41         char plaintext[128];
42         unsigned char psize;
43         char digest[MAX_DIGEST_SIZE];
44         unsigned char np;
45         unsigned char tap[MAX_TAP];
46 };
47
48 struct cipher_testvec {
49         unsigned char fail;
50         unsigned char wk; /* weak key flag */
51         char key[MAX_KEYLEN];
52         unsigned char klen;
53         char iv[MAX_IVLEN];
54         char input[48];
55         unsigned char ilen;
56         char result[48];
57         unsigned char rlen;
58         int np;
59         unsigned char tap[MAX_TAP];
60 };
61
62 struct cipher_speed {
63         unsigned char klen;
64         unsigned int blen;
65 };
66
67 /*
68  * MD4 test vectors from RFC1320
69  */
70 #define MD4_TEST_VECTORS        7
71
72 static struct hash_testvec md4_tv_template [] = {
73         {
74                 .plaintext = "",
75                 .digest = { 0x31, 0xd6, 0xcf, 0xe0, 0xd1, 0x6a, 0xe9, 0x31,
76                             0xb7, 0x3c, 0x59, 0xd7, 0xe0, 0xc0, 0x89, 0xc0 },
77         }, {
78                 .plaintext = "a",
79                 .psize  = 1,
80                 .digest = { 0xbd, 0xe5, 0x2c, 0xb3, 0x1d, 0xe3, 0x3e, 0x46,
81                             0x24, 0x5e, 0x05, 0xfb, 0xdb, 0xd6, 0xfb, 0x24 },
82         }, {
83                 .plaintext = "abc",
84                 .psize  = 3,
85                 .digest = { 0xa4, 0x48, 0x01, 0x7a, 0xaf, 0x21, 0xd8, 0x52,
86                             0x5f, 0xc1, 0x0a, 0xe8, 0x7a, 0xa6, 0x72, 0x9d },
87         }, {
88                 .plaintext = "message digest",
89                 .psize  = 14,
90                 .digest = { 0xd9, 0x13, 0x0a, 0x81, 0x64, 0x54, 0x9f, 0xe8,
91                             0x18, 0x87, 0x48, 0x06, 0xe1, 0xc7, 0x01, 0x4b },
92         }, {
93                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
94                 .psize  = 26,
95                 .digest = { 0xd7, 0x9e, 0x1c, 0x30, 0x8a, 0xa5, 0xbb, 0xcd,
96                             0xee, 0xa8, 0xed, 0x63, 0xdf, 0x41, 0x2d, 0xa9 },
97                 .np     = 2,
98                 .tap    = { 13, 13 },
99         }, {
100                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
101                 .psize  = 62,
102                 .digest = { 0x04, 0x3f, 0x85, 0x82, 0xf2, 0x41, 0xdb, 0x35,
103                             0x1c, 0xe6, 0x27, 0xe1, 0x53, 0xe7, 0xf0, 0xe4 },
104         }, {
105                 .plaintext = "123456789012345678901234567890123456789012345678901234567890123"
106                              "45678901234567890",
107                 .psize  = 80,
108                 .digest = { 0xe3, 0x3b, 0x4d, 0xdc, 0x9c, 0x38, 0xf2, 0x19,
109                             0x9c, 0x3e, 0x7b, 0x16, 0x4f, 0xcc, 0x05, 0x36 },
110         },
111 };
112
113 /*
114  * MD5 test vectors from RFC1321
115  */
116 #define MD5_TEST_VECTORS        7
117
118 static struct hash_testvec md5_tv_template[] = {
119         {
120                 .digest = { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
121                             0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e },
122         }, {
123                 .plaintext = "a",
124                 .psize  = 1,
125                 .digest = { 0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8,
126                             0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 },
127         }, {
128                 .plaintext = "abc",
129                 .psize  = 3,
130                 .digest = { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
131                             0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 },
132         }, {
133                 .plaintext = "message digest",
134                 .psize  = 14,
135                 .digest = { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d,
136                             0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 },
137         }, {
138                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
139                 .psize  = 26,
140                 .digest = { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00,
141                             0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b },
142                 .np     = 2,
143                 .tap    = {13, 13}
144         }, {
145                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
146                 .psize  = 62,
147                 .digest = { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5,
148                             0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f },
149         }, {
150                 .plaintext = "12345678901234567890123456789012345678901234567890123456789012"
151                              "345678901234567890",
152                 .psize  = 80,
153                 .digest = { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55,
154                             0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a },
155         }
156 };
157
158 /*
159  * SHA1 test vectors  from from FIPS PUB 180-1
160  */
161 #define SHA1_TEST_VECTORS       2
162
163 static struct hash_testvec sha1_tv_template[] = {
164         {
165                 .plaintext = "abc",
166                 .psize  = 3,
167                 .digest = { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e,
168                             0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d },
169         }, {
170                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
171                 .psize  = 56,
172                 .digest = { 0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2, 0x6e, 0xba, 0xae,
173                             0x4a, 0xa1, 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1 },
174                 .np     = 2,
175                 .tap    = { 28, 28 }
176         }
177 };
178
179 /*
180  * SHA256 test vectors from from NIST
181  */
182 #define SHA256_TEST_VECTORS     2
183
184 static struct hash_testvec sha256_tv_template[] = {
185         {
186                 .plaintext = "abc",
187                 .psize  = 3,
188                 .digest = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
189                             0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
190                             0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
191                             0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad },
192         }, {
193                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
194                 .psize  = 56,
195                 .digest = { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
196                             0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
197                             0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
198                             0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 },
199                 .np     = 2,
200                 .tap    = { 28, 28 }
201         },
202 };
203
204 /*
205  * SHA384 test vectors from from NIST and kerneli
206  */
207 #define SHA384_TEST_VECTORS     4
208
209 static struct hash_testvec sha384_tv_template[] = {
210         {
211                 .plaintext= "abc",
212                 .psize  = 3,
213                 .digest = { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
214                             0xb5, 0xa0, 0x3d, 0x69, 0x9a, 0xc6, 0x50, 0x07,
215                             0x27, 0x2c, 0x32, 0xab, 0x0e, 0xde, 0xd1, 0x63,
216                             0x1a, 0x8b, 0x60, 0x5a, 0x43, 0xff, 0x5b, 0xed,
217                             0x80, 0x86, 0x07, 0x2b, 0xa1, 0xe7, 0xcc, 0x23,
218                             0x58, 0xba, 0xec, 0xa1, 0x34, 0xc8, 0x25, 0xa7 },
219         }, {
220                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
221                 .psize  = 56,
222                 .digest = { 0x33, 0x91, 0xfd, 0xdd, 0xfc, 0x8d, 0xc7, 0x39,
223                             0x37, 0x07, 0xa6, 0x5b, 0x1b, 0x47, 0x09, 0x39,
224                             0x7c, 0xf8, 0xb1, 0xd1, 0x62, 0xaf, 0x05, 0xab,
225                             0xfe, 0x8f, 0x45, 0x0d, 0xe5, 0xf3, 0x6b, 0xc6,
226                             0xb0, 0x45, 0x5a, 0x85, 0x20, 0xbc, 0x4e, 0x6f,
227                             0x5f, 0xe9, 0x5b, 0x1f, 0xe3, 0xc8, 0x45, 0x2b},
228         }, {
229                 .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
230                              "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
231                 .psize  = 112,
232                 .digest = { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8,
233                             0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47,
234                             0x53, 0x11, 0x1b, 0x17, 0x3b, 0x3b, 0x05, 0xd2,
235                             0x2f, 0xa0, 0x80, 0x86, 0xe3, 0xb0, 0xf7, 0x12,
236                             0xfc, 0xc7, 0xc7, 0x1a, 0x55, 0x7e, 0x2d, 0xb9,
237                             0x66, 0xc3, 0xe9, 0xfa, 0x91, 0x74, 0x60, 0x39  },
238         }, {
239                 .plaintext = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
240                              "efghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
241                 .psize  = 104,
242                 .digest = { 0x3d, 0x20, 0x89, 0x73, 0xab, 0x35, 0x08, 0xdb,
243                             0xbd, 0x7e, 0x2c, 0x28, 0x62, 0xba, 0x29, 0x0a,
244                             0xd3, 0x01, 0x0e, 0x49, 0x78, 0xc1, 0x98, 0xdc,
245                             0x4d, 0x8f, 0xd0, 0x14, 0xe5, 0x82, 0x82, 0x3a,
246                             0x89, 0xe1, 0x6f, 0x9b, 0x2a, 0x7b, 0xbc, 0x1a,
247                             0xc9, 0x38, 0xe2, 0xd1, 0x99, 0xe8, 0xbe, 0xa4 },
248                 .np     = 4,
249                 .tap    = { 26, 26, 26, 26 }
250         },
251 };
252
253 /*
254  * SHA512 test vectors from from NIST and kerneli
255  */
256 #define SHA512_TEST_VECTORS     4
257
258 static struct hash_testvec sha512_tv_template[] = {
259         {
260                 .plaintext = "abc",
261                 .psize  = 3,
262                 .digest = { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
263                             0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31,
264                             0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
265                             0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a,
266                             0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
267                             0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
268                             0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e,
269                             0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f },
270         }, {
271                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
272                 .psize  = 56,
273                 .digest = { 0x20, 0x4a, 0x8f, 0xc6, 0xdd, 0xa8, 0x2f, 0x0a,
274                             0x0c, 0xed, 0x7b, 0xeb, 0x8e, 0x08, 0xa4, 0x16,
275                             0x57, 0xc1, 0x6e, 0xf4, 0x68, 0xb2, 0x28, 0xa8,
276                             0x27, 0x9b, 0xe3, 0x31, 0xa7, 0x03, 0xc3, 0x35,
277                             0x96, 0xfd, 0x15, 0xc1, 0x3b, 0x1b, 0x07, 0xf9,
278                             0xaa, 0x1d, 0x3b, 0xea, 0x57, 0x78, 0x9c, 0xa0,
279                             0x31, 0xad, 0x85, 0xc7, 0xa7, 0x1d, 0xd7, 0x03,
280                             0x54, 0xec, 0x63, 0x12, 0x38, 0xca, 0x34, 0x45 },
281         }, {
282                 .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
283                              "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
284                 .psize  = 112,
285                 .digest = { 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda,
286                             0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f,
287                             0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1,
288                             0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18,
289                             0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4,
290                             0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a,
291                             0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54,
292                             0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09 },
293         }, {
294                 .plaintext = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
295                              "efghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
296                 .psize  = 104,
297                 .digest = { 0x93, 0x0d, 0x0c, 0xef, 0xcb, 0x30, 0xff, 0x11,
298                             0x33, 0xb6, 0x89, 0x81, 0x21, 0xf1, 0xcf, 0x3d,
299                             0x27, 0x57, 0x8a, 0xfc, 0xaf, 0xe8, 0x67, 0x7c,
300                             0x52, 0x57, 0xcf, 0x06, 0x99, 0x11, 0xf7, 0x5d,
301                             0x8f, 0x58, 0x31, 0xb5, 0x6e, 0xbf, 0xda, 0x67,
302                             0xb2, 0x78, 0xe6, 0x6d, 0xff, 0x8b, 0x84, 0xfe,
303                             0x2b, 0x28, 0x70, 0xf7, 0x42, 0xa5, 0x80, 0xd8,
304                             0xed, 0xb4, 0x19, 0x87, 0x23, 0x28, 0x50, 0xc9 },
305                 .np     = 4,
306                 .tap    = { 26, 26, 26, 26 }
307         },
308 };
309
310
311 /*
312  * WHIRLPOOL test vectors from Whirlpool package
313  * by Vincent Rijmen and Paulo S. L. M. Barreto as part of the NESSIE
314  * submission
315  */
316 #define WP512_TEST_VECTORS      8
317
318 static struct hash_testvec wp512_tv_template[] = {
319         {
320                 .plaintext = "",
321                 .psize  = 0,
322                 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
323                             0x9B, 0x44, 0xE3, 0x9C, 0x1D, 0x2E, 0x17, 0x26,
324                             0xC5, 0x30, 0x23, 0x21, 0x30, 0xD4, 0x07, 0xF8,
325                             0x9A, 0xFE, 0xE0, 0x96, 0x49, 0x97, 0xF7, 0xA7,
326                             0x3E, 0x83, 0xBE, 0x69, 0x8B, 0x28, 0x8F, 0xEB,
327                             0xCF, 0x88, 0xE3, 0xE0, 0x3C, 0x4F, 0x07, 0x57,
328                             0xEA, 0x89, 0x64, 0xE5, 0x9B, 0x63, 0xD9, 0x37,
329                             0x08, 0xB1, 0x38, 0xCC, 0x42, 0xA6, 0x6E, 0xB3 },
330
331
332         }, {
333                 .plaintext = "a",
334                 .psize  = 1,
335                 .digest = { 0x8A, 0xCA, 0x26, 0x02, 0x79, 0x2A, 0xEC, 0x6F,
336                             0x11, 0xA6, 0x72, 0x06, 0x53, 0x1F, 0xB7, 0xD7,
337                             0xF0, 0xDF, 0xF5, 0x94, 0x13, 0x14, 0x5E, 0x69,
338                             0x73, 0xC4, 0x50, 0x01, 0xD0, 0x08, 0x7B, 0x42,
339                             0xD1, 0x1B, 0xC6, 0x45, 0x41, 0x3A, 0xEF, 0xF6,
340                             0x3A, 0x42, 0x39, 0x1A, 0x39, 0x14, 0x5A, 0x59,
341                             0x1A, 0x92, 0x20, 0x0D, 0x56, 0x01, 0x95, 0xE5,
342                             0x3B, 0x47, 0x85, 0x84, 0xFD, 0xAE, 0x23, 0x1A },
343         }, {
344                 .plaintext = "abc",
345                 .psize  = 3,
346                 .digest = { 0x4E, 0x24, 0x48, 0xA4, 0xC6, 0xF4, 0x86, 0xBB,
347                             0x16, 0xB6, 0x56, 0x2C, 0x73, 0xB4, 0x02, 0x0B,
348                             0xF3, 0x04, 0x3E, 0x3A, 0x73, 0x1B, 0xCE, 0x72,
349                             0x1A, 0xE1, 0xB3, 0x03, 0xD9, 0x7E, 0x6D, 0x4C,
350                             0x71, 0x81, 0xEE, 0xBD, 0xB6, 0xC5, 0x7E, 0x27,
351                             0x7D, 0x0E, 0x34, 0x95, 0x71, 0x14, 0xCB, 0xD6,
352                             0xC7, 0x97, 0xFC, 0x9D, 0x95, 0xD8, 0xB5, 0x82,
353                             0xD2, 0x25, 0x29, 0x20, 0x76, 0xD4, 0xEE, 0xF5 },
354         }, {
355                 .plaintext = "message digest",
356                 .psize  = 14,
357                 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
358                             0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
359                             0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
360                             0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
361                             0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
362                             0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6,
363                             0x92, 0xED, 0x92, 0x00, 0x52, 0x83, 0x8F, 0x33,
364                             0x62, 0xE8, 0x6D, 0xBD, 0x37, 0xA8, 0x90, 0x3E },
365         }, {
366                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
367                 .psize  = 26,
368                 .digest = { 0xF1, 0xD7, 0x54, 0x66, 0x26, 0x36, 0xFF, 0xE9,
369                             0x2C, 0x82, 0xEB, 0xB9, 0x21, 0x2A, 0x48, 0x4A,
370                             0x8D, 0x38, 0x63, 0x1E, 0xAD, 0x42, 0x38, 0xF5,
371                             0x44, 0x2E, 0xE1, 0x3B, 0x80, 0x54, 0xE4, 0x1B,
372                             0x08, 0xBF, 0x2A, 0x92, 0x51, 0xC3, 0x0B, 0x6A,
373                             0x0B, 0x8A, 0xAE, 0x86, 0x17, 0x7A, 0xB4, 0xA6,
374                             0xF6, 0x8F, 0x67, 0x3E, 0x72, 0x07, 0x86, 0x5D,
375                             0x5D, 0x98, 0x19, 0xA3, 0xDB, 0xA4, 0xEB, 0x3B },
376         }, {
377                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
378                              "abcdefghijklmnopqrstuvwxyz0123456789",
379                 .psize  = 62,
380                 .digest = { 0xDC, 0x37, 0xE0, 0x08, 0xCF, 0x9E, 0xE6, 0x9B,
381                             0xF1, 0x1F, 0x00, 0xED, 0x9A, 0xBA, 0x26, 0x90,
382                             0x1D, 0xD7, 0xC2, 0x8C, 0xDE, 0xC0, 0x66, 0xCC,
383                             0x6A, 0xF4, 0x2E, 0x40, 0xF8, 0x2F, 0x3A, 0x1E,
384                             0x08, 0xEB, 0xA2, 0x66, 0x29, 0x12, 0x9D, 0x8F,
385                             0xB7, 0xCB, 0x57, 0x21, 0x1B, 0x92, 0x81, 0xA6,
386                             0x55, 0x17, 0xCC, 0x87, 0x9D, 0x7B, 0x96, 0x21,
387                             0x42, 0xC6, 0x5F, 0x5A, 0x7A, 0xF0, 0x14, 0x67 },
388         }, {
389                 .plaintext = "1234567890123456789012345678901234567890"
390                              "1234567890123456789012345678901234567890",
391                 .psize  = 80,
392                 .digest = { 0x46, 0x6E, 0xF1, 0x8B, 0xAB, 0xB0, 0x15, 0x4D,
393                             0x25, 0xB9, 0xD3, 0x8A, 0x64, 0x14, 0xF5, 0xC0,
394                             0x87, 0x84, 0x37, 0x2B, 0xCC, 0xB2, 0x04, 0xD6,
395                             0x54, 0x9C, 0x4A, 0xFA, 0xDB, 0x60, 0x14, 0x29,
396                             0x4D, 0x5B, 0xD8, 0xDF, 0x2A, 0x6C, 0x44, 0xE5,
397                             0x38, 0xCD, 0x04, 0x7B, 0x26, 0x81, 0xA5, 0x1A,
398                             0x2C, 0x60, 0x48, 0x1E, 0x88, 0xC5, 0xA2, 0x0B,
399                             0x2C, 0x2A, 0x80, 0xCF, 0x3A, 0x9A, 0x08, 0x3B },
400         }, {
401                 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
402                 .psize  = 32,
403                 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
404                             0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
405                             0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
406                             0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
407                             0x16, 0xBD, 0xC8, 0x03, 0x1B, 0xC5, 0xBE, 0x1B,
408                             0x7B, 0x94, 0x76, 0x39, 0xFE, 0x05, 0x0B, 0x56,
409                             0x93, 0x9B, 0xAA, 0xA0, 0xAD, 0xFF, 0x9A, 0xE6,
410                             0x74, 0x5B, 0x7B, 0x18, 0x1C, 0x3B, 0xE3, 0xFD },
411         },
412 };
413
414 #define WP384_TEST_VECTORS      8
415
416 static struct hash_testvec wp384_tv_template[] = {
417         {
418                 .plaintext = "",
419                 .psize  = 0,
420                 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
421                             0x9B, 0x44, 0xE3, 0x9C, 0x1D, 0x2E, 0x17, 0x26,
422                             0xC5, 0x30, 0x23, 0x21, 0x30, 0xD4, 0x07, 0xF8,
423                             0x9A, 0xFE, 0xE0, 0x96, 0x49, 0x97, 0xF7, 0xA7,
424                             0x3E, 0x83, 0xBE, 0x69, 0x8B, 0x28, 0x8F, 0xEB,
425                             0xCF, 0x88, 0xE3, 0xE0, 0x3C, 0x4F, 0x07, 0x57 },
426
427
428         }, {
429                 .plaintext = "a",
430                 .psize  = 1,
431                 .digest = { 0x8A, 0xCA, 0x26, 0x02, 0x79, 0x2A, 0xEC, 0x6F,
432                             0x11, 0xA6, 0x72, 0x06, 0x53, 0x1F, 0xB7, 0xD7,
433                             0xF0, 0xDF, 0xF5, 0x94, 0x13, 0x14, 0x5E, 0x69,
434                             0x73, 0xC4, 0x50, 0x01, 0xD0, 0x08, 0x7B, 0x42,
435                             0xD1, 0x1B, 0xC6, 0x45, 0x41, 0x3A, 0xEF, 0xF6,
436                             0x3A, 0x42, 0x39, 0x1A, 0x39, 0x14, 0x5A, 0x59 },
437         }, {
438                 .plaintext = "abc",
439                 .psize  = 3,
440                 .digest = { 0x4E, 0x24, 0x48, 0xA4, 0xC6, 0xF4, 0x86, 0xBB,
441                             0x16, 0xB6, 0x56, 0x2C, 0x73, 0xB4, 0x02, 0x0B,
442                             0xF3, 0x04, 0x3E, 0x3A, 0x73, 0x1B, 0xCE, 0x72,
443                             0x1A, 0xE1, 0xB3, 0x03, 0xD9, 0x7E, 0x6D, 0x4C,
444                             0x71, 0x81, 0xEE, 0xBD, 0xB6, 0xC5, 0x7E, 0x27,
445                             0x7D, 0x0E, 0x34, 0x95, 0x71, 0x14, 0xCB, 0xD6 },
446         }, {
447                 .plaintext = "message digest",
448                 .psize  = 14,
449                 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
450                             0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
451                             0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
452                             0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
453                             0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
454                             0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6 },
455         }, {
456                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
457                 .psize  = 26,
458                 .digest = { 0xF1, 0xD7, 0x54, 0x66, 0x26, 0x36, 0xFF, 0xE9,
459                             0x2C, 0x82, 0xEB, 0xB9, 0x21, 0x2A, 0x48, 0x4A,
460                             0x8D, 0x38, 0x63, 0x1E, 0xAD, 0x42, 0x38, 0xF5,
461                             0x44, 0x2E, 0xE1, 0x3B, 0x80, 0x54, 0xE4, 0x1B,
462                             0x08, 0xBF, 0x2A, 0x92, 0x51, 0xC3, 0x0B, 0x6A,
463                             0x0B, 0x8A, 0xAE, 0x86, 0x17, 0x7A, 0xB4, 0xA6 },
464         }, {
465                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
466                              "abcdefghijklmnopqrstuvwxyz0123456789",
467                 .psize  = 62,
468                 .digest = { 0xDC, 0x37, 0xE0, 0x08, 0xCF, 0x9E, 0xE6, 0x9B,
469                             0xF1, 0x1F, 0x00, 0xED, 0x9A, 0xBA, 0x26, 0x90,
470                             0x1D, 0xD7, 0xC2, 0x8C, 0xDE, 0xC0, 0x66, 0xCC,
471                             0x6A, 0xF4, 0x2E, 0x40, 0xF8, 0x2F, 0x3A, 0x1E,
472                             0x08, 0xEB, 0xA2, 0x66, 0x29, 0x12, 0x9D, 0x8F,
473                             0xB7, 0xCB, 0x57, 0x21, 0x1B, 0x92, 0x81, 0xA6 },
474         }, {
475                 .plaintext = "1234567890123456789012345678901234567890"
476                              "1234567890123456789012345678901234567890",
477                 .psize  = 80,
478                 .digest = { 0x46, 0x6E, 0xF1, 0x8B, 0xAB, 0xB0, 0x15, 0x4D,
479                             0x25, 0xB9, 0xD3, 0x8A, 0x64, 0x14, 0xF5, 0xC0,
480                             0x87, 0x84, 0x37, 0x2B, 0xCC, 0xB2, 0x04, 0xD6,
481                             0x54, 0x9C, 0x4A, 0xFA, 0xDB, 0x60, 0x14, 0x29,
482                             0x4D, 0x5B, 0xD8, 0xDF, 0x2A, 0x6C, 0x44, 0xE5,
483                             0x38, 0xCD, 0x04, 0x7B, 0x26, 0x81, 0xA5, 0x1A },
484         }, {
485                 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
486                 .psize  = 32,
487                 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
488                             0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
489                             0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
490                             0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
491                             0x16, 0xBD, 0xC8, 0x03, 0x1B, 0xC5, 0xBE, 0x1B,
492                             0x7B, 0x94, 0x76, 0x39, 0xFE, 0x05, 0x0B, 0x56 },
493         },
494 };
495
496 #define WP256_TEST_VECTORS      8
497
498 static struct hash_testvec wp256_tv_template[] = {
499         {
500                 .plaintext = "",
501                 .psize  = 0,
502                 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
503                             0x9B, 0x44, 0xE3, 0x9C, 0x1D, 0x2E, 0x17, 0x26,
504                             0xC5, 0x30, 0x23, 0x21, 0x30, 0xD4, 0x07, 0xF8,
505                             0x9A, 0xFE, 0xE0, 0x96, 0x49, 0x97, 0xF7, 0xA7 },
506
507
508         }, {
509                 .plaintext = "a",
510                 .psize  = 1,
511                 .digest = { 0x8A, 0xCA, 0x26, 0x02, 0x79, 0x2A, 0xEC, 0x6F,
512                             0x11, 0xA6, 0x72, 0x06, 0x53, 0x1F, 0xB7, 0xD7,
513                             0xF0, 0xDF, 0xF5, 0x94, 0x13, 0x14, 0x5E, 0x69,
514                             0x73, 0xC4, 0x50, 0x01, 0xD0, 0x08, 0x7B, 0x42 },
515         }, {
516                 .plaintext = "abc",
517                 .psize  = 3,
518                 .digest = { 0x4E, 0x24, 0x48, 0xA4, 0xC6, 0xF4, 0x86, 0xBB,
519                             0x16, 0xB6, 0x56, 0x2C, 0x73, 0xB4, 0x02, 0x0B,
520                             0xF3, 0x04, 0x3E, 0x3A, 0x73, 0x1B, 0xCE, 0x72,
521                             0x1A, 0xE1, 0xB3, 0x03, 0xD9, 0x7E, 0x6D, 0x4C },
522         }, {
523                 .plaintext = "message digest",
524                 .psize  = 14,
525                 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
526                             0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
527                             0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
528                             0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B },
529         }, {
530                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
531                 .psize  = 26,
532                 .digest = { 0xF1, 0xD7, 0x54, 0x66, 0x26, 0x36, 0xFF, 0xE9,
533                             0x2C, 0x82, 0xEB, 0xB9, 0x21, 0x2A, 0x48, 0x4A,
534                             0x8D, 0x38, 0x63, 0x1E, 0xAD, 0x42, 0x38, 0xF5,
535                             0x44, 0x2E, 0xE1, 0x3B, 0x80, 0x54, 0xE4, 0x1B },
536         }, {
537                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
538                              "abcdefghijklmnopqrstuvwxyz0123456789",
539                 .psize  = 62,
540                 .digest = { 0xDC, 0x37, 0xE0, 0x08, 0xCF, 0x9E, 0xE6, 0x9B,
541                             0xF1, 0x1F, 0x00, 0xED, 0x9A, 0xBA, 0x26, 0x90,
542                             0x1D, 0xD7, 0xC2, 0x8C, 0xDE, 0xC0, 0x66, 0xCC,
543                             0x6A, 0xF4, 0x2E, 0x40, 0xF8, 0x2F, 0x3A, 0x1E },
544         }, {
545                 .plaintext = "1234567890123456789012345678901234567890"
546                              "1234567890123456789012345678901234567890",
547                 .psize  = 80,
548                 .digest = { 0x46, 0x6E, 0xF1, 0x8B, 0xAB, 0xB0, 0x15, 0x4D,
549                             0x25, 0xB9, 0xD3, 0x8A, 0x64, 0x14, 0xF5, 0xC0,
550                             0x87, 0x84, 0x37, 0x2B, 0xCC, 0xB2, 0x04, 0xD6,
551                             0x54, 0x9C, 0x4A, 0xFA, 0xDB, 0x60, 0x14, 0x29 },
552         }, {
553                 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
554                 .psize  = 32,
555                 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
556                             0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
557                             0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
558                             0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69 },
559         },
560 };
561
562 /*
563  * TIGER test vectors from Tiger website
564  */
565 #define TGR192_TEST_VECTORS     6
566
567 static struct hash_testvec tgr192_tv_template[] = {
568         {
569                 .plaintext = "",
570                 .psize  = 0,
571                 .digest = { 0x24, 0xf0, 0x13, 0x0c, 0x63, 0xac, 0x93, 0x32,
572                             0x16, 0x16, 0x6e, 0x76, 0xb1, 0xbb, 0x92, 0x5f,
573                             0xf3, 0x73, 0xde, 0x2d, 0x49, 0x58, 0x4e, 0x7a },
574         }, {
575                 .plaintext = "abc",
576                 .psize  = 3,
577                 .digest = { 0xf2, 0x58, 0xc1, 0xe8, 0x84, 0x14, 0xab, 0x2a,
578                             0x52, 0x7a, 0xb5, 0x41, 0xff, 0xc5, 0xb8, 0xbf,
579                             0x93, 0x5f, 0x7b, 0x95, 0x1c, 0x13, 0x29, 0x51 },
580         }, {
581                 .plaintext = "Tiger",
582                 .psize  = 5,
583                 .digest = { 0x9f, 0x00, 0xf5, 0x99, 0x07, 0x23, 0x00, 0xdd,
584                             0x27, 0x6a, 0xbb, 0x38, 0xc8, 0xeb, 0x6d, 0xec,
585                             0x37, 0x79, 0x0c, 0x11, 0x6f, 0x9d, 0x2b, 0xdf },
586         }, {
587                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
588                 .psize  = 64,
589                 .digest = { 0x87, 0xfb, 0x2a, 0x90, 0x83, 0x85, 0x1c, 0xf7,
590                             0x47, 0x0d, 0x2c, 0xf8, 0x10, 0xe6, 0xdf, 0x9e,
591                             0xb5, 0x86, 0x44, 0x50, 0x34, 0xa5, 0xa3, 0x86 },
592         }, {
593                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789",
594                 .psize  = 64,
595                 .digest = { 0x46, 0x7d, 0xb8, 0x08, 0x63, 0xeb, 0xce, 0x48,
596                             0x8d, 0xf1, 0xcd, 0x12, 0x61, 0x65, 0x5d, 0xe9,
597                             0x57, 0x89, 0x65, 0x65, 0x97, 0x5f, 0x91, 0x97 },
598         }, {
599                 .plaintext = "Tiger - A Fast New Hash Function, "
600                              "by Ross Anderson and Eli Biham, "
601                              "proceedings of Fast Software Encryption 3, "
602                              "Cambridge, 1996.",
603                 .psize  = 125,
604                 .digest = { 0x3d, 0x9a, 0xeb, 0x03, 0xd1, 0xbd, 0x1a, 0x63,
605                             0x57, 0xb2, 0x77, 0x4d, 0xfd, 0x6d, 0x5b, 0x24,
606                             0xdd, 0x68, 0x15, 0x1d, 0x50, 0x39, 0x74, 0xfc },
607         },
608 };
609
610 #define TGR160_TEST_VECTORS     6
611
612 static struct hash_testvec tgr160_tv_template[] = {
613         {
614                 .plaintext = "",
615                 .psize  = 0,
616                 .digest = { 0x24, 0xf0, 0x13, 0x0c, 0x63, 0xac, 0x93, 0x32,
617                             0x16, 0x16, 0x6e, 0x76, 0xb1, 0xbb, 0x92, 0x5f,
618                             0xf3, 0x73, 0xde, 0x2d },
619         }, {
620                 .plaintext = "abc",
621                 .psize  = 3,
622                 .digest = { 0xf2, 0x58, 0xc1, 0xe8, 0x84, 0x14, 0xab, 0x2a,
623                             0x52, 0x7a, 0xb5, 0x41, 0xff, 0xc5, 0xb8, 0xbf,
624                             0x93, 0x5f, 0x7b, 0x95 },
625         }, {
626                 .plaintext = "Tiger",
627                 .psize  = 5,
628                 .digest = { 0x9f, 0x00, 0xf5, 0x99, 0x07, 0x23, 0x00, 0xdd,
629                             0x27, 0x6a, 0xbb, 0x38, 0xc8, 0xeb, 0x6d, 0xec,
630                             0x37, 0x79, 0x0c, 0x11 },
631         }, {
632                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
633                 .psize  = 64,
634                 .digest = { 0x87, 0xfb, 0x2a, 0x90, 0x83, 0x85, 0x1c, 0xf7,
635                             0x47, 0x0d, 0x2c, 0xf8, 0x10, 0xe6, 0xdf, 0x9e,
636                             0xb5, 0x86, 0x44, 0x50 },
637         }, {
638                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789",
639                 .psize  = 64,
640                 .digest = { 0x46, 0x7d, 0xb8, 0x08, 0x63, 0xeb, 0xce, 0x48,
641                             0x8d, 0xf1, 0xcd, 0x12, 0x61, 0x65, 0x5d, 0xe9,
642                             0x57, 0x89, 0x65, 0x65 },
643         }, {
644                 .plaintext = "Tiger - A Fast New Hash Function, "
645                              "by Ross Anderson and Eli Biham, "
646                              "proceedings of Fast Software Encryption 3, "
647                              "Cambridge, 1996.",
648                 .psize  = 125,
649                 .digest = { 0x3d, 0x9a, 0xeb, 0x03, 0xd1, 0xbd, 0x1a, 0x63,
650                             0x57, 0xb2, 0x77, 0x4d, 0xfd, 0x6d, 0x5b, 0x24,
651                             0xdd, 0x68, 0x15, 0x1d },
652         },
653 };
654
655 #define TGR128_TEST_VECTORS     6
656
657 static struct hash_testvec tgr128_tv_template[] = {
658         {
659                 .plaintext = "",
660                 .psize  = 0,
661                 .digest = { 0x24, 0xf0, 0x13, 0x0c, 0x63, 0xac, 0x93, 0x32,
662                             0x16, 0x16, 0x6e, 0x76, 0xb1, 0xbb, 0x92, 0x5f },
663         }, {
664                 .plaintext = "abc",
665                 .psize  = 3,
666                 .digest = { 0xf2, 0x58, 0xc1, 0xe8, 0x84, 0x14, 0xab, 0x2a,
667                             0x52, 0x7a, 0xb5, 0x41, 0xff, 0xc5, 0xb8, 0xbf },
668         }, {
669                 .plaintext = "Tiger",
670                 .psize  = 5,
671                 .digest = { 0x9f, 0x00, 0xf5, 0x99, 0x07, 0x23, 0x00, 0xdd,
672                             0x27, 0x6a, 0xbb, 0x38, 0xc8, 0xeb, 0x6d, 0xec },
673         }, {
674                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
675                 .psize  = 64,
676                 .digest = { 0x87, 0xfb, 0x2a, 0x90, 0x83, 0x85, 0x1c, 0xf7,
677                             0x47, 0x0d, 0x2c, 0xf8, 0x10, 0xe6, 0xdf, 0x9e },
678         }, {
679                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789",
680                 .psize  = 64,
681                 .digest = { 0x46, 0x7d, 0xb8, 0x08, 0x63, 0xeb, 0xce, 0x48,
682                             0x8d, 0xf1, 0xcd, 0x12, 0x61, 0x65, 0x5d, 0xe9 },
683         }, {
684                 .plaintext = "Tiger - A Fast New Hash Function, "
685                              "by Ross Anderson and Eli Biham, "
686                              "proceedings of Fast Software Encryption 3, "
687                              "Cambridge, 1996.",
688                 .psize  = 125,
689                 .digest = { 0x3d, 0x9a, 0xeb, 0x03, 0xd1, 0xbd, 0x1a, 0x63,
690                             0x57, 0xb2, 0x77, 0x4d, 0xfd, 0x6d, 0x5b, 0x24 },
691         },
692 };
693
694 #ifdef CONFIG_CRYPTO_HMAC
695 /*
696  * HMAC-MD5 test vectors from RFC2202
697  * (These need to be fixed to not use strlen).
698  */
699 #define HMAC_MD5_TEST_VECTORS   7
700
701 static struct hmac_testvec hmac_md5_tv_template[] =
702 {
703         {
704                 .key    = { [0 ... 15] =  0x0b },
705                 .ksize  = 16,
706                 .plaintext = "Hi There",
707                 .psize  = 8,
708                 .digest = { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
709                             0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d },
710         }, {
711                 .key    = { 'J', 'e', 'f', 'e' },
712                 .ksize  = 4,
713                 .plaintext = "what do ya want for nothing?",
714                 .psize  = 28,
715                 .digest = { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
716                             0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 },
717                 .np     = 2,
718                 .tap    = {14, 14}
719         }, {
720                 .key    = { [0 ... 15] = 0xaa },
721                 .ksize  = 16,
722                 .plaintext = { [0 ... 49] =  0xdd },
723                 .psize  = 50,
724                 .digest = { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
725                             0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 },
726         }, {
727                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
728                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
729                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, },
730                 .ksize  = 25,
731                 .plaintext = { [0 ... 49] =  0xcd },
732                 .psize  = 50,
733                 .digest = { 0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea,
734                             0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79 },
735         }, {
736                 .key    = { [0 ... 15] = 0x0c },
737                 .ksize  = 16,
738                 .plaintext = "Test With Truncation",
739                 .psize  = 20,
740                 .digest = { 0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00,
741                             0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c },
742         }, {
743                 .key    = { [0 ... 79] =  0xaa },
744                 .ksize  = 80,
745                 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
746                 .psize  = 54,
747                 .digest = { 0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f,
748                             0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd },
749         }, {
750                 .key    = { [0 ... 79] =  0xaa },
751                 .ksize  = 80,
752                 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One "
753                              "Block-Size Data",
754                 .psize  = 73,
755                 .digest = { 0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee,
756                             0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e },
757         },
758 };
759
760 /*
761  * HMAC-SHA1 test vectors from RFC2202
762  */
763 #define HMAC_SHA1_TEST_VECTORS  7
764
765 static struct hmac_testvec hmac_sha1_tv_template[] = {
766         {
767                 .key    = { [0 ... 19] = 0x0b },
768                 .ksize  = 20,
769                 .plaintext = "Hi There",
770                 .psize  = 8,
771                 .digest = { 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
772                             0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1,
773                             0x46, 0xbe },
774         }, {
775                 .key    = { 'J', 'e', 'f', 'e' },
776                 .ksize  = 4,
777                 .plaintext = "what do ya want for nothing?",
778                 .psize  = 28,
779                 .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74,
780                             0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 },
781                 .np     = 2,
782                 .tap    = { 14, 14 }
783         }, {
784                 .key    = { [0 ... 19] = 0xaa },
785                 .ksize  = 20,
786                 .plaintext = { [0 ... 49] = 0xdd },
787                 .psize  = 50,
788                 .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3,
789                             0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3 },
790         }, {
791                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
792                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
793                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 },
794                 .ksize  = 25,
795                 .plaintext = { [0 ... 49] = 0xcd },
796                 .psize  = 50,
797                 .digest = { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84,
798                             0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda },
799         }, {
800                 .key    = { [0 ... 19] = 0x0c },
801                 .ksize  = 20,
802                 .plaintext = "Test With Truncation",
803                 .psize  = 20,
804                 .digest = { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2,
805                             0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04 },
806         }, {
807                 .key    = { [0 ... 79] = 0xaa },
808                 .ksize  = 80,
809                 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
810                 .psize  = 54,
811                 .digest = { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70,
812                             0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12 },
813         }, {
814                 .key    = { [0 ... 79] = 0xaa },
815                 .ksize  = 80,
816                 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One "
817                              "Block-Size Data",
818                 .psize  = 73,
819                 .digest = { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b,
820                             0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91 },
821         },
822 };
823
824 /*
825  * HMAC-SHA256 test vectors from
826  * draft-ietf-ipsec-ciph-sha-256-01.txt
827  */
828 #define HMAC_SHA256_TEST_VECTORS        10
829
830 static struct hmac_testvec hmac_sha256_tv_template[] = {
831         {
832                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
833                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
834                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
835                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20},
836                 .ksize  = 32,
837                 .plaintext = "abc",
838                 .psize  = 3,
839                 .digest = { 0xa2, 0x1b, 0x1f, 0x5d, 0x4c, 0xf4, 0xf7, 0x3a,
840                             0x4d, 0xd9, 0x39, 0x75, 0x0f, 0x7a, 0x06, 0x6a,
841                             0x7f, 0x98, 0xcc, 0x13, 0x1c, 0xb1, 0x6a, 0x66,
842                             0x92, 0x75, 0x90, 0x21, 0xcf, 0xab, 0x81, 0x81 },
843         }, {
844                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
845                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
846                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
847                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 },
848                 .ksize  = 32,
849                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
850                 .psize  = 56,
851                 .digest = { 0x10, 0x4f, 0xdc, 0x12, 0x57, 0x32, 0x8f, 0x08,
852                             0x18, 0x4b, 0xa7, 0x31, 0x31, 0xc5, 0x3c, 0xae,
853                             0xe6, 0x98, 0xe3, 0x61, 0x19, 0x42, 0x11, 0x49,
854                             0xea, 0x8c, 0x71, 0x24, 0x56, 0x69, 0x7d, 0x30 },
855         }, {
856                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
857                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
858                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
859                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 },
860                 .ksize  = 32,
861                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
862                              "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
863                 .psize  = 112,
864                 .digest = { 0x47, 0x03, 0x05, 0xfc, 0x7e, 0x40, 0xfe, 0x34,
865                             0xd3, 0xee, 0xb3, 0xe7, 0x73, 0xd9, 0x5a, 0xab,
866                             0x73, 0xac, 0xf0, 0xfd, 0x06, 0x04, 0x47, 0xa5,
867                             0xeb, 0x45, 0x95, 0xbf, 0x33, 0xa9, 0xd1, 0xa3 },
868         }, {
869                 .key    = { [0 ... 31] = 0x0b },
870                 .ksize  = 32,
871                 .plaintext = "Hi There",
872                 .psize  = 8,
873                 .digest = { 0x19, 0x8a, 0x60, 0x7e, 0xb4, 0x4b, 0xfb, 0xc6,
874                             0x99, 0x03, 0xa0, 0xf1, 0xcf, 0x2b, 0xbd, 0xc5,
875                             0xba, 0x0a, 0xa3, 0xf3, 0xd9, 0xae, 0x3c, 0x1c,
876                             0x7a, 0x3b, 0x16, 0x96, 0xa0, 0xb6, 0x8c, 0xf7 },
877         }, {
878                 .key    = "Jefe",
879                 .ksize  = 4,
880                 .plaintext = "what do ya want for nothing?",
881                 .psize  = 28,
882                 .digest = { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
883                             0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
884                             0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
885                             0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 },
886                 .np     = 2,
887                 .tap    = { 14, 14 }
888         }, {
889                 .key    = { [0 ... 31] = 0xaa },
890                 .ksize  = 32,
891                 .plaintext = { [0 ... 49] = 0xdd },
892                 .psize  = 50,
893                 .digest = { 0xcd, 0xcb, 0x12, 0x20, 0xd1, 0xec, 0xcc, 0xea,
894                             0x91, 0xe5, 0x3a, 0xba, 0x30, 0x92, 0xf9, 0x62,
895                             0xe5, 0x49, 0xfe, 0x6c, 0xe9, 0xed, 0x7f, 0xdc,
896                             0x43, 0x19, 0x1f, 0xbd, 0xe4, 0x5c, 0x30, 0xb0 },
897         }, {
898                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
899                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
900                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
901                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
902                             0x21, 0x22, 0x23, 0x24, 0x25 },
903                 .ksize  = 37,
904                 .plaintext = { [0 ... 49] = 0xcd },
905                 .psize  = 50,
906                 .digest = { 0xd4, 0x63, 0x3c, 0x17, 0xf6, 0xfb, 0x8d, 0x74,
907                             0x4c, 0x66, 0xde, 0xe0, 0xf8, 0xf0, 0x74, 0x55,
908                             0x6e, 0xc4, 0xaf, 0x55, 0xef, 0x07, 0x99, 0x85,
909                             0x41, 0x46, 0x8e, 0xb4, 0x9b, 0xd2, 0xe9, 0x17 },
910         }, {
911                 .key    = { [0 ... 31] = 0x0c },
912                 .ksize  = 32,
913                 .plaintext = "Test With Truncation",
914                 .psize  = 20,
915                 .digest = { 0x75, 0x46, 0xaf, 0x01, 0x84, 0x1f, 0xc0, 0x9b,
916                             0x1a, 0xb9, 0xc3, 0x74, 0x9a, 0x5f, 0x1c, 0x17,
917                             0xd4, 0xf5, 0x89, 0x66, 0x8a, 0x58, 0x7b, 0x27,
918                             0x00, 0xa9, 0xc9, 0x7c, 0x11, 0x93, 0xcf, 0x42 },
919         }, {
920                 .key    = { [0 ... 79] = 0xaa },
921                 .ksize  = 80,
922                 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
923                 .psize  = 54,
924                 .digest = { 0x69, 0x53, 0x02, 0x5e, 0xd9, 0x6f, 0x0c, 0x09,
925                             0xf8, 0x0a, 0x96, 0xf7, 0x8e, 0x65, 0x38, 0xdb,
926                             0xe2, 0xe7, 0xb8, 0x20, 0xe3, 0xdd, 0x97, 0x0e,
927                             0x7d, 0xdd, 0x39, 0x09, 0x1b, 0x32, 0x35, 0x2f },
928         }, {
929                 .key    = { [0 ... 79] = 0xaa },
930                 .ksize  = 80,
931                 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than "
932                              "One Block-Size Data",
933                 .psize  = 73,
934                 .digest = { 0x63, 0x55, 0xac, 0x22, 0xe8, 0x90, 0xd0, 0xa3,
935                             0xc8, 0x48, 0x1a, 0x5c, 0xa4, 0x82, 0x5b, 0xc8,
936                             0x84, 0xd3, 0xe7, 0xa1, 0xff, 0x98, 0xa2, 0xfc,
937                             0x2a, 0xc7, 0xd8, 0xe0, 0x64, 0xc3, 0xb2, 0xe6 },
938         },
939 };
940
941 #endif  /* CONFIG_CRYPTO_HMAC */
942
943 /*
944  * DES test vectors.
945  */
946 #define DES_ENC_TEST_VECTORS            10
947 #define DES_DEC_TEST_VECTORS            4
948 #define DES_CBC_ENC_TEST_VECTORS        5
949 #define DES_CBC_DEC_TEST_VECTORS        4
950 #define DES3_EDE_ENC_TEST_VECTORS       3
951 #define DES3_EDE_DEC_TEST_VECTORS       3
952
953 static struct cipher_testvec des_enc_tv_template[] = {
954         { /* From Applied Cryptography */
955                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
956                 .klen   = 8,
957                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
958                 .ilen   = 8,
959                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
960                 .rlen   = 8,
961         }, { /* Same key, different plaintext block */
962                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
963                 .klen   = 8,
964                 .input  = { 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
965                 .ilen   = 8,
966                 .result = { 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
967                 .rlen   = 8,
968         }, { /* Sbox test from NBS */
969                 .key    = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },
970                 .klen   = 8,
971                 .input  = { 0x01, 0xa1, 0xd6, 0xd0, 0x39, 0x77, 0x67, 0x42 },
972                 .ilen   = 8,
973                 .result = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
974                 .rlen   = 8,
975         }, { /* Three blocks */
976                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
977                 .klen   = 8,
978                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
979                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
980                             0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef },
981                 .ilen   = 24,
982                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
983                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
984                             0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },
985                 .rlen   = 24,
986         }, { /* Weak key */
987                 .fail   = 1,
988                 .wk     = 1,
989                 .key    = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
990                 .klen   = 8,
991                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
992                 .ilen   = 8,
993                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
994                 .rlen   = 8,
995         }, { /* Two blocks -- for testing encryption across pages */
996                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
997                 .klen   = 8,
998                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
999                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
1000                 .ilen   = 16,
1001                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
1002                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
1003                 .rlen   = 16,
1004                 .np     = 2,
1005                 .tap    = { 8, 8 }
1006         }, { /* Four blocks -- for testing encryption with chunking */
1007                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1008                 .klen   = 8,
1009                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
1010                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
1011                             0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef,
1012                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
1013                 .ilen   = 32,
1014                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
1015                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
1016                             0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90,
1017                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
1018                 .rlen   = 32,
1019                 .np     = 3,
1020                 .tap    = { 14, 10, 8 }
1021         }, {
1022                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1023                 .klen   = 8,
1024                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
1025                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
1026                             0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef },
1027                 .ilen   = 24,
1028                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
1029                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
1030                             0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },
1031                 .rlen   = 24,
1032                 .np     = 4,
1033                 .tap    = { 2, 1, 3, 18 }
1034         }, {
1035                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1036                 .klen   = 8,
1037                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
1038                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
1039                 .ilen   = 16,
1040                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
1041                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
1042                 .rlen   = 16,
1043                 .np     = 5,
1044                 .tap    = { 2, 2, 2, 2, 8 }
1045         }, {
1046                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1047                 .klen   = 8,
1048                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
1049                 .ilen   = 8,
1050                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
1051                 .rlen   = 8,
1052                 .np     = 8,
1053                 .tap    = { 1, 1, 1, 1, 1, 1, 1, 1 }
1054         },
1055 };
1056
1057 static struct cipher_testvec des_dec_tv_template[] = {
1058         { /* From Applied Cryptography */
1059                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1060                 .klen   = 8,
1061                 .input  = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
1062                 .ilen   = 8,
1063                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
1064                 .rlen   = 8,
1065         }, { /* Sbox test from NBS */
1066                 .key    = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },
1067                 .klen   = 8,
1068                 .input  = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
1069                 .ilen   = 8,
1070                 .result = { 0x01, 0xa1, 0xd6, 0xd0, 0x39, 0x77, 0x67, 0x42 },
1071                 .rlen   = 8,
1072         }, { /* Two blocks, for chunking test */
1073                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1074                 .klen   = 8,
1075                 .input  = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
1076                             0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
1077                 .ilen   = 16,
1078                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
1079                             0xa3, 0x99, 0x7b, 0xca, 0xaf, 0x69, 0xa0, 0xf5 },
1080                 .rlen   = 16,
1081                 .np     = 2,
1082                 .tap    = { 8, 8 }
1083         }, {
1084                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1085                 .klen   = 8,
1086                 .input  = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
1087                             0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
1088                 .ilen   = 16,
1089                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
1090                             0xa3, 0x99, 0x7b, 0xca, 0xaf, 0x69, 0xa0, 0xf5 },
1091                 .rlen   = 16,
1092                 .np     = 3,
1093                 .tap    = { 3, 12, 1 }
1094         },
1095 };
1096
1097 static struct cipher_testvec des_cbc_enc_tv_template[] = {
1098         { /* From OpenSSL */
1099                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
1100                 .klen   = 8,
1101                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1102                 .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1103                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1104                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1105                 .ilen   = 24,
1106                 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
1107                             0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
1108                             0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
1109                 .rlen   = 24,
1110         }, { /* FIPS Pub 81 */
1111                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1112                 .klen   = 8,
1113                 .iv     = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
1114                 .input  = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
1115                 .ilen   = 8,
1116                 .result = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1117                 .rlen   = 8,
1118         }, {
1119                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1120                 .klen   = 8,
1121                 .iv     = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1122                 .input  = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1123                 .ilen   = 8,
1124                 .result = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1125                 .rlen   = 8,
1126         }, {
1127                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1128                 .klen   = 8,
1129                 .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1130                 .input  = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1131                 .ilen   = 8,
1132                 .result = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1133                 .rlen   = 8,
1134         }, { /* Copy of openssl vector for chunk testing */
1135              /* From OpenSSL */
1136                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
1137                 .klen   = 8,
1138                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1139                 .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1140                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1141                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1142                 .ilen   = 24,
1143                 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
1144                             0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
1145                             0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
1146                 .rlen   = 24,
1147                 .np     = 2,
1148                 .tap    = { 13, 11 }
1149         },
1150 };
1151
1152 static struct cipher_testvec des_cbc_dec_tv_template[] = {
1153         { /* FIPS Pub 81 */
1154                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1155                 .klen   = 8,
1156                 .iv     = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
1157                 .input  = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1158                 .ilen   = 8,
1159                 .result = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
1160                 .rlen   = 8,
1161         }, {
1162                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1163                 .klen   = 8,
1164                 .iv     = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1165                 .input  = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1166                 .ilen   = 8,
1167                 .result = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1168                 .rlen   = 8,
1169         }, {
1170                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1171                 .klen   = 8,
1172                 .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1173                 .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1174                 .ilen   = 8,
1175                 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1176                 .rlen   = 8,
1177         }, { /* Copy of above, for chunk testing */
1178                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1179                 .klen   = 8,
1180                 .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1181                 .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1182                 .ilen   = 8,
1183                 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1184                 .rlen   = 8,
1185                 .np     = 2,
1186                 .tap    = { 4, 4 }
1187         },
1188 };
1189
1190 /*
1191  * We really need some more test vectors, especially for DES3 CBC.
1192  */
1193 static struct cipher_testvec des3_ede_enc_tv_template[] = {
1194         { /* These are from openssl */
1195                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1196                             0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
1197                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1198                 .klen   = 24,
1199                 .input  = { 0x73, 0x6f, 0x6d, 0x65, 0x64, 0x61, 0x74, 0x61 },
1200                 .ilen   = 8,
1201                 .result = { 0x18, 0xd7, 0x48, 0xe5, 0x63, 0x62, 0x05, 0x72 },
1202                 .rlen   = 8,
1203         }, {
1204                 .key    = { 0x03, 0x52, 0x02, 0x07, 0x67, 0x20, 0x82, 0x17,
1205                             0x86, 0x02, 0x87, 0x66, 0x59, 0x08, 0x21, 0x98,
1206                             0x64, 0x05, 0x6a, 0xbd, 0xfe, 0xa9, 0x34, 0x57 },
1207                 .klen   = 24,
1208                 .input  = { 0x73, 0x71, 0x75, 0x69, 0x67, 0x67, 0x6c, 0x65 },
1209                 .ilen   = 8,
1210                 .result = { 0xc0, 0x7d, 0x2a, 0x0f, 0xa5, 0x66, 0xfa, 0x30 },
1211                 .rlen   = 8,
1212         }, {
1213                 .key    = { 0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
1214                             0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
1215                             0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01 },
1216                 .klen   = 24,
1217                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1218                 .ilen   = 8,
1219                 .result = { 0xe1, 0xef, 0x62, 0xc3, 0x32, 0xfe, 0x82, 0x5b },
1220                 .rlen   = 8,
1221         },
1222 };
1223
1224 static struct cipher_testvec des3_ede_dec_tv_template[] = {
1225         { /* These are from openssl */
1226                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1227                             0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
1228                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1229                 .klen   = 24,
1230                 .input  = { 0x18, 0xd7, 0x48, 0xe5, 0x63, 0x62, 0x05, 0x72 },
1231                 .ilen   = 8,
1232                 .result = { 0x73, 0x6f, 0x6d, 0x65, 0x64, 0x61, 0x74, 0x61 },
1233                 .rlen   = 8,
1234         }, {
1235                 .key    = { 0x03, 0x52, 0x02, 0x07, 0x67, 0x20, 0x82, 0x17,
1236                             0x86, 0x02, 0x87, 0x66, 0x59, 0x08, 0x21, 0x98,
1237                             0x64, 0x05, 0x6a, 0xbd, 0xfe, 0xa9, 0x34, 0x57 },
1238                 .klen   = 24,
1239                 .input  = { 0xc0, 0x7d, 0x2a, 0x0f, 0xa5, 0x66, 0xfa, 0x30 },
1240                 .ilen   = 8,
1241                 .result = { 0x73, 0x71, 0x75, 0x69, 0x67, 0x67, 0x6c, 0x65 },
1242                 .rlen   = 8,
1243         }, {
1244                 .key    = { 0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
1245                             0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
1246                             0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01 },
1247                 .klen   = 24,
1248                 .input  = { 0xe1, 0xef, 0x62, 0xc3, 0x32, 0xfe, 0x82, 0x5b },
1249                 .ilen   = 8,
1250                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1251                 .rlen   = 8,
1252         },
1253 };
1254
1255 /*
1256  * Blowfish test vectors.
1257  */
1258 #define BF_ENC_TEST_VECTORS     6
1259 #define BF_DEC_TEST_VECTORS     6
1260 #define BF_CBC_ENC_TEST_VECTORS 1
1261 #define BF_CBC_DEC_TEST_VECTORS 1
1262
1263 static struct cipher_testvec bf_enc_tv_template[] = {
1264         { /* DES test vectors from OpenSSL */
1265                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
1266                 .klen   = 8,
1267                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1268                 .ilen   = 8,
1269                 .result = { 0x4e, 0xf9, 0x97, 0x45, 0x61, 0x98, 0xdd, 0x78 },
1270                 .rlen   = 8,
1271         }, {
1272                 .key    = { 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e },
1273                 .klen   = 8,
1274                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1275                 .ilen   = 8,
1276                 .result = { 0xa7, 0x90, 0x79, 0x51, 0x08, 0xea, 0x3c, 0xae },
1277                 .rlen   = 8,
1278         }, {
1279                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1280                 .klen   = 8,
1281                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1282                 .ilen   = 8,
1283                 .result = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 },
1284                 .rlen   = 8,
1285         }, { /* Vary the keylength... */
1286                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1287                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
1288                 .klen   = 16,
1289                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1290                 .ilen   = 8,
1291                 .result = { 0x93, 0x14, 0x28, 0x87, 0xee, 0x3b, 0xe1, 0x5c },
1292                 .rlen   = 8,
1293         }, {
1294                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1295                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1296                             0x00, 0x11, 0x22, 0x33, 0x44 },
1297                 .klen   = 21,
1298                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1299                 .ilen   = 8,
1300                 .result = { 0xe6, 0xf5, 0x1e, 0xd7, 0x9b, 0x9d, 0xb2, 0x1f },
1301                 .rlen   = 8,
1302         }, { /* Generated with bf488 */
1303                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1304                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1305                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1306                             0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1307                             0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1308                             0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
1309                             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
1310                 .klen   = 56,
1311                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1312                 .ilen   = 8,
1313                 .result = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
1314                 .rlen   = 8,
1315         },
1316 };
1317
1318 static struct cipher_testvec bf_dec_tv_template[] = {
1319         { /* DES test vectors from OpenSSL */
1320                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1321                 .klen   = 8,
1322                 .input  = { 0x4e, 0xf9, 0x97, 0x45, 0x61, 0x98, 0xdd, 0x78 },
1323                 .ilen   = 8,
1324                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1325                 .rlen   = 8,
1326         }, {
1327                 .key    = { 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e },
1328                 .klen   = 8,
1329                 .input  = { 0xa7, 0x90, 0x79, 0x51, 0x08, 0xea, 0x3c, 0xae },
1330                 .ilen   = 8,
1331                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1332                 .rlen   = 8,
1333         }, {
1334                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1335                 .klen   = 8,
1336                 .input  = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 },
1337                 .ilen   = 8,
1338                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1339                 .rlen   = 8,
1340         }, { /* Vary the keylength... */
1341                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1342                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
1343                 .klen   = 16,
1344                 .input  = { 0x93, 0x14, 0x28, 0x87, 0xee, 0x3b, 0xe1, 0x5c },
1345                 .ilen   = 8,
1346                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1347                 .rlen   = 8,
1348         }, {
1349                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1350                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1351                             0x00, 0x11, 0x22, 0x33, 0x44 },
1352                 .klen   = 21,
1353                 .input  = { 0xe6, 0xf5, 0x1e, 0xd7, 0x9b, 0x9d, 0xb2, 0x1f },
1354                 .ilen   = 8,
1355                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1356                 .rlen   = 8,
1357         }, { /* Generated with bf488, using OpenSSL, Libgcrypt and Nettle */
1358                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1359                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1360                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1361                             0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1362                             0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1363                             0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
1364                             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
1365                 .klen   = 56,
1366                 .input  = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
1367                 .ilen   = 8,
1368                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1369                 .rlen   = 8,
1370         },
1371 };
1372
1373 static struct cipher_testvec bf_cbc_enc_tv_template[] = {
1374         { /* From OpenSSL */
1375                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1376                             0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1377                 .klen   = 16,
1378                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1379                 .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1380                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1381                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1382                             0x66, 0x6f, 0x72, 0x20, 0x00, 0x00, 0x00, 0x00 },
1383                 .ilen   = 32,
1384                 .result = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6,
1385                             0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93,
1386                             0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9,
1387                             0x59, 0xf1, 0x65, 0x2b, 0xd5, 0xff, 0x92, 0xcc },
1388                 .rlen   = 32,
1389         },
1390 };
1391
1392 static struct cipher_testvec bf_cbc_dec_tv_template[] = {
1393         { /* From OpenSSL */
1394                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1395                             0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1396                 .klen   = 16,
1397                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1398                 .input  = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6,
1399                             0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93,
1400                             0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9,
1401                             0x59, 0xf1, 0x65, 0x2b, 0xd5, 0xff, 0x92, 0xcc },
1402                 .ilen   = 32,
1403                 .result = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1404                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1405                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1406                             0x66, 0x6f, 0x72, 0x20, 0x00, 0x00, 0x00, 0x00 },
1407                 .rlen   = 32,
1408         },
1409 };
1410
1411 /*
1412  * Twofish test vectors.
1413  */
1414 #define TF_ENC_TEST_VECTORS             3
1415 #define TF_DEC_TEST_VECTORS             3
1416 #define TF_CBC_ENC_TEST_VECTORS         4
1417 #define TF_CBC_DEC_TEST_VECTORS         4
1418
1419 static struct cipher_testvec tf_enc_tv_template[] = {
1420         {
1421                 .key    = { [0 ... 15] = 0x00 },
1422                 .klen   = 16,
1423                 .input  = { [0 ... 15] = 0x00 },
1424                 .ilen   = 16,
1425                 .result = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1426                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1427                 .rlen   = 16,
1428         }, {
1429                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1430                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1431                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
1432                 .klen   = 24,
1433                 .input  = { [0 ... 15] = 0x00 },
1434                 .ilen   = 16,
1435                 .result = { 0xcf, 0xd1, 0xd2, 0xe5, 0xa9, 0xbe, 0x9c, 0xdf,
1436                             0x50, 0x1f, 0x13, 0xb8, 0x92, 0xbd, 0x22, 0x48 },
1437                 .rlen   = 16,
1438         }, {
1439                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1440                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1441                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1442                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1443                 .klen   = 32,
1444                 .input  = { [0 ... 15] = 0x00 },
1445                 .ilen   = 16,
1446                 .result = { 0x37, 0x52, 0x7b, 0xe0, 0x05, 0x23, 0x34, 0xb8,
1447                             0x9f, 0x0c, 0xfc, 0xca, 0xe8, 0x7c, 0xfa, 0x20 },
1448                 .rlen   = 16,
1449         },
1450 };
1451
1452 static struct cipher_testvec tf_dec_tv_template[] = {
1453         {
1454                 .key    = { [0 ... 15] = 0x00 },
1455                 .klen   = 16,
1456                 .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1457                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1458                 .ilen   = 16,
1459                 .result = { [0 ... 15] = 0x00 },
1460                 .rlen   = 16,
1461         }, {
1462                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1463                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1464                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
1465                 .klen   = 24,
1466                 .input  = { 0xcf, 0xd1, 0xd2, 0xe5, 0xa9, 0xbe, 0x9c, 0xdf,
1467                             0x50, 0x1f, 0x13, 0xb8, 0x92, 0xbd, 0x22, 0x48 },
1468                 .ilen   = 16,
1469                 .result = { [0 ... 15] = 0x00 },
1470                 .rlen   = 16,
1471         }, {
1472                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1473                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1474                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1475                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1476                 .klen   = 32,
1477                 .input  = { 0x37, 0x52, 0x7b, 0xe0, 0x05, 0x23, 0x34, 0xb8,
1478                             0x9f, 0x0c, 0xfc, 0xca, 0xe8, 0x7c, 0xfa, 0x20 },
1479                 .ilen   = 16,
1480                 .result = { [0 ... 15] = 0x00 },
1481                 .rlen   = 16,
1482         },
1483 };
1484
1485 static struct cipher_testvec tf_cbc_enc_tv_template[] = {
1486         { /* Generated with Nettle */
1487                 .key    = { [0 ... 15] = 0x00 },
1488                 .klen   = 16,
1489                 .iv     = { [0 ... 15] = 0x00 },
1490                 .input  = { [0 ... 15] = 0x00 },
1491                 .ilen   = 16,
1492                 .result = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1493                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1494                 .rlen   = 16,
1495         }, {
1496                 .key    = { [0 ... 15] = 0x00 },
1497                 .klen   = 16,
1498                 .iv     = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1499                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1500                 .input  = { [0 ... 15] = 0x00 },
1501                 .ilen   = 16,
1502                 .result = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1503                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1504                 .rlen   = 16,
1505         }, {
1506                 .key    = { [0 ... 15] = 0x00 },
1507                 .klen   = 16,
1508                 .iv     = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1509                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1510                 .input  = { [0 ... 15] = 0x00 },
1511                 .ilen   = 16,
1512                 .result = { 0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1513                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1514                 .rlen   = 16,
1515         }, {
1516                 .key    = { [0 ... 15] = 0x00 },
1517                 .klen   = 16,
1518                 .iv     = { [0 ... 15] = 0x00 },
1519                 .input  = { [0 ... 47] = 0x00 },
1520                 .ilen   = 48,
1521                 .result = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1522                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a,
1523                             0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1524                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19,
1525                             0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1526                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1527                 .rlen   = 48,
1528         },
1529 };
1530
1531 static struct cipher_testvec tf_cbc_dec_tv_template[] = {
1532         { /* Reverse of the first four above */
1533                 .key    = { [0 ... 15] = 0x00 },
1534                 .klen   = 16,
1535                 .iv     = { [0 ... 15] = 0x00 },
1536                 .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1537                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1538                 .ilen   = 16,
1539                 .result = { [0 ... 15] = 0x00 },
1540                 .rlen   = 16,
1541         }, {
1542                 .key    = { [0 ... 15] = 0x00 },
1543                 .klen   = 16,
1544                 .iv     = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1545                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1546                 .input  = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1547                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1548                 .ilen   = 16,
1549                 .result = { [0 ... 15] = 0x00 },
1550                 .rlen   = 16,
1551         }, {
1552                 .key    = { [0 ... 15] = 0x00 },
1553                 .klen   = 16,
1554                 .iv     = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1555                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1556                 .input  = { 0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1557                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1558                 .ilen   = 16,
1559                 .result = { [0 ... 15] = 0x00 },
1560                 .rlen   = 16,
1561         }, {
1562                 .key    = { [0 ... 15] = 0x00 },
1563                 .klen   = 16,
1564                 .iv     = { [0 ... 15] = 0x00 },
1565                 .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1566                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a,
1567                             0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1568                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19,
1569                             0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1570                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1571                 .ilen   = 48,
1572                 .result = { [0 ... 47] = 0x00 },
1573                 .rlen   = 48,
1574         },
1575 };
1576
1577 /*
1578  * Serpent test vectors.  These are backwards because Serpent writes
1579  * octet sequences in right-to-left mode.
1580  */
1581 #define SERPENT_ENC_TEST_VECTORS        4
1582 #define SERPENT_DEC_TEST_VECTORS        4
1583
1584 #define TNEPRES_ENC_TEST_VECTORS        4
1585 #define TNEPRES_DEC_TEST_VECTORS        4
1586
1587 static struct cipher_testvec serpent_enc_tv_template[] = {
1588         {
1589                 .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1590                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1591                 .ilen   = 16,
1592                 .result = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
1593                             0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
1594                 .rlen   = 16,
1595         }, {
1596                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1597                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1598                 .klen   = 16,
1599                 .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1600                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1601                 .ilen   = 16,
1602                 .result = { 0x4c, 0x7d, 0x8a, 0x32, 0x80, 0x72, 0xa2, 0x2c,
1603                             0x82, 0x3e, 0x4a, 0x1f, 0x3a, 0xcd, 0xa1, 0x6d },
1604                 .rlen   = 16,
1605         }, {
1606                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1607                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1608                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1609                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1610                 .klen   = 32,
1611                 .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1612                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1613                 .ilen   = 16,
1614                 .result = { 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8,
1615                             0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c },
1616                 .rlen   = 16,
1617         }, {
1618                 .key    = { [15] = 0x80 },
1619                 .klen   = 16,
1620                 .input  = { [0 ... 15] = 0x00 },
1621                 .ilen   = 16,
1622                 .result = { 0xdd, 0xd2, 0x6b, 0x98, 0xa5, 0xff, 0xd8, 0x2c,
1623                             0x05, 0x34, 0x5a, 0x9d, 0xad, 0xbf, 0xaf, 0x49},
1624                 .rlen   = 16,
1625         },
1626 };
1627
1628 static struct cipher_testvec tnepres_enc_tv_template[] = {
1629         { /* KeySize=128, PT=0, I=1 */
1630                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1631                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1632                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1633                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1634                 .klen   = 16,
1635                 .ilen   = 16,
1636                 .result = { 0x49, 0xaf, 0xbf, 0xad, 0x9d, 0x5a, 0x34, 0x05,
1637                             0x2c, 0xd8, 0xff, 0xa5, 0x98, 0x6b, 0xd2, 0xdd },
1638                 .rlen   = 16,
1639         }, { /* KeySize=192, PT=0, I=1 */
1640                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1641                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1642                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1643                 .klen   = 24,
1644                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1645                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1646                 .ilen   = 16,
1647                 .result = { 0xe7, 0x8e, 0x54, 0x02, 0xc7, 0x19, 0x55, 0x68,
1648                             0xac, 0x36, 0x78, 0xf7, 0xa3, 0xf6, 0x0c, 0x66 },
1649                 .rlen   = 16,
1650         }, { /* KeySize=256, PT=0, I=1 */
1651                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1652                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1653                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1654                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1655                 .klen   = 32,
1656                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1657                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1658                 .ilen   = 16,
1659                 .result = { 0xab, 0xed, 0x96, 0xe7, 0x66, 0xbf, 0x28, 0xcb,
1660                             0xc0, 0xeb, 0xd2, 0x1a, 0x82, 0xef, 0x08, 0x19 },
1661                 .rlen   = 16,
1662         }, { /* KeySize=256, I=257 */
1663                 .key    = { 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
1664                             0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
1665                             0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
1666                             0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
1667                 .klen   = 32,
1668                 .input  = { 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
1669                             0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
1670                 .ilen   = 16,
1671                 .result = { 0x5c, 0xe7, 0x1c, 0x70, 0xd2, 0x88, 0x2e, 0x5b,
1672                             0xb8, 0x32, 0xe4, 0x33, 0xf8, 0x9f, 0x26, 0xde },
1673                 .rlen   = 16,
1674         },
1675 };
1676
1677
1678 static struct cipher_testvec serpent_dec_tv_template[] = {
1679         {
1680                 .input  = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
1681                             0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
1682                 .ilen   = 16,
1683                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1684                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1685                 .rlen   = 16,
1686         }, {
1687                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1688                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1689                 .klen   = 16,
1690                 .input  = { 0x4c, 0x7d, 0x8a, 0x32, 0x80, 0x72, 0xa2, 0x2c,
1691                             0x82, 0x3e, 0x4a, 0x1f, 0x3a, 0xcd, 0xa1, 0x6d },
1692                 .ilen   = 16,
1693                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1694                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1695                 .rlen   = 16,
1696         }, {
1697                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1698                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1699                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1700                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1701                 .klen   = 32,
1702                 .input  = { 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8,
1703                             0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c },
1704                 .ilen   = 16,
1705                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1706                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1707                 .rlen   = 16,
1708         }, {
1709                 .key    = { [15] = 0x80 },
1710                 .klen   = 16,
1711                 .input  = { 0xdd, 0xd2, 0x6b, 0x98, 0xa5, 0xff, 0xd8, 0x2c,
1712                             0x05, 0x34, 0x5a, 0x9d, 0xad, 0xbf, 0xaf, 0x49},
1713                 .ilen   = 16,
1714                 .result = { [0 ... 15] = 0x00 },
1715                 .rlen   = 16,
1716         },
1717 };
1718
1719 static struct cipher_testvec tnepres_dec_tv_template[] = {
1720         {
1721                 .input  = { 0x41, 0xcc, 0x6b, 0x31, 0x59, 0x31, 0x45, 0x97,
1722                             0x6d, 0x6f, 0xbb, 0x38, 0x4b, 0x37, 0x21, 0x28 },
1723                 .ilen   = 16,
1724                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1725                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1726                 .rlen   = 16,
1727         }, {
1728                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1729                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1730                 .klen   = 16,
1731                 .input  = { 0xea, 0xf4, 0xd7, 0xfc, 0xd8, 0x01, 0x34, 0x47,
1732                             0x81, 0x45, 0x0b, 0xfa, 0x0c, 0xd6, 0xad, 0x6e },
1733                 .ilen   = 16,
1734                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1735                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1736                 .rlen   = 16,
1737         }, {
1738                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1739                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1740                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1741                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1742                 .klen   = 32,
1743                 .input  = { 0x64, 0xa9, 0x1a, 0x37, 0xed, 0x9f, 0xe7, 0x49,
1744                             0xa8, 0x4e, 0x76, 0xd6, 0xf5, 0x0d, 0x78, 0xee },
1745                 .ilen   = 16,
1746                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1747                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1748                 .rlen   = 16,
1749         }, { /* KeySize=128, I=121 */
1750                 .key    = { [15] = 0x80 },
1751                 .klen   = 16,
1752                 .input  = { 0x3d, 0xda, 0xbf, 0xc0, 0x06, 0xda, 0xab, 0x06,
1753                             0x46, 0x2a, 0xf4, 0xef, 0x81, 0x54, 0x4e, 0x26 },
1754                 .ilen   = 16,
1755                 .result = { [0 ... 15] = 0x00 },
1756                 .rlen   = 16,
1757         },
1758 };
1759
1760
1761 /* Cast6 test vectors from RFC 2612 */
1762 #define CAST6_ENC_TEST_VECTORS  3
1763 #define CAST6_DEC_TEST_VECTORS  3
1764
1765 static struct cipher_testvec cast6_enc_tv_template[] = {
1766         {
1767                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1768                             0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
1769                 .klen   = 16,
1770                 .input  = { [0 ... 15] = 0x00 },
1771                 .ilen   = 16,
1772                 .result = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
1773                             0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
1774                 .rlen   = 16,
1775         }, {
1776                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1777                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1778                             0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
1779                 .klen   = 24,
1780                 .input  = { [0 ... 15] = 0x00 },
1781                 .ilen   = 16,
1782                 .result = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
1783                             0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
1784                 .rlen   = 16,
1785         }, {
1786                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1787                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1788                             0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
1789                             0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
1790                 .klen   = 32,
1791                 .input  = { [0 ... 15] = 0x00 },
1792                 .ilen   = 16,
1793                 .result = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
1794                             0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
1795                 .rlen   = 16,
1796         },
1797 };
1798
1799 static struct cipher_testvec cast6_dec_tv_template[] = {
1800         {
1801                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1802                             0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
1803                 .klen   = 16,
1804                 .input  = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
1805                             0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
1806                 .ilen   = 16,
1807                 .result = { [0 ... 15] = 0x00 },
1808                 .rlen   = 16,
1809         }, {
1810                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1811                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1812                             0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
1813                 .klen   = 24,
1814                 .input  = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
1815                             0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
1816                 .ilen   = 16,
1817                 .result = { [0 ... 15] = 0x00 },
1818                 .rlen   = 16,
1819         }, {
1820                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1821                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1822                             0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
1823                             0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
1824                 .klen   = 32,
1825                 .input  = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
1826                             0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
1827                 .ilen   = 16,
1828                 .result = { [0 ... 15] = 0x00 },
1829                 .rlen   = 16,
1830         },
1831 };
1832
1833
1834 /*
1835  * AES test vectors.
1836  */
1837 #define AES_ENC_TEST_VECTORS 3
1838 #define AES_DEC_TEST_VECTORS 3
1839
1840 static struct cipher_testvec aes_enc_tv_template[] = {
1841         { /* From FIPS-197 */
1842                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1843                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1844                 .klen   = 16,
1845                 .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1846                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1847                 .ilen   = 16,
1848                 .result = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
1849                             0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a },
1850                 .rlen   = 16,
1851         }, {
1852                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1853                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1854                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
1855                 .klen   = 24,
1856                 .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1857                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1858                 .ilen   = 16,
1859                 .result = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
1860                             0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
1861                 .rlen   = 16,
1862         }, {
1863                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1864                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1865                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1866                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1867                 .klen   = 32,
1868                 .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1869                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1870                 .ilen   = 16,
1871                 .result = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
1872                             0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
1873                 .rlen   = 16,
1874         },
1875 };
1876
1877 static struct cipher_testvec aes_dec_tv_template[] = {
1878         { /* From FIPS-197 */
1879                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1880                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1881                 .klen   = 16,
1882                 .input  = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
1883                             0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a },
1884                 .ilen   = 16,
1885                 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1886                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1887                 .rlen   = 16,
1888         }, {
1889                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1890                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1891                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
1892                 .klen   = 24,
1893                 .input  = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
1894                             0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
1895                 .ilen   = 16,
1896                 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1897                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1898                 .rlen   = 16,
1899         }, {
1900                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1901                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1902                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1903                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1904                 .klen   = 32,
1905                 .input  = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
1906                             0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
1907                 .ilen   = 16,
1908                 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1909                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1910                 .rlen   = 16,
1911         },
1912 };
1913
1914 /* Cast5 test vectors from RFC 2144 */
1915 #define CAST5_ENC_TEST_VECTORS  3
1916 #define CAST5_DEC_TEST_VECTORS  3
1917
1918 static struct cipher_testvec cast5_enc_tv_template[] = {
1919         {
1920                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1921                             0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
1922                 .klen   = 16,
1923                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1924                 .ilen   = 8,
1925                 .result = { 0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2 },
1926                 .rlen   = 8,
1927         }, {
1928                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1929                             0x23, 0x45 },
1930                 .klen   = 10,
1931                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1932                 .ilen   = 8,
1933                 .result = { 0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b },
1934                 .rlen   = 8,
1935         }, {
1936                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12 },
1937                 .klen   = 5,
1938                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1939                 .ilen   = 8,
1940                 .result = { 0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e },
1941                 .rlen   = 8,
1942         },
1943 };
1944
1945 static struct cipher_testvec cast5_dec_tv_template[] = {
1946         {
1947                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1948                             0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
1949                 .klen   = 16,
1950                 .input  = { 0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2 },
1951                 .ilen   = 8,
1952                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1953                 .rlen   = 8,
1954         }, {
1955                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1956                             0x23, 0x45 },
1957                 .klen   = 10,
1958                 .input  = { 0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b },
1959                 .ilen   = 8,
1960                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1961                 .rlen   = 8,
1962         }, {
1963                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12 },
1964                 .klen   = 5,
1965                 .input  = { 0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e },
1966                 .ilen   = 8,
1967                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1968                 .rlen   = 8,
1969         },
1970 };
1971
1972 /*
1973  * ARC4 test vectors from OpenSSL
1974  */
1975 #define ARC4_ENC_TEST_VECTORS   7
1976 #define ARC4_DEC_TEST_VECTORS   7
1977
1978 static struct cipher_testvec arc4_enc_tv_template[] = {
1979         {
1980                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1981                 .klen   = 8,
1982                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1983                 .ilen   = 8,
1984                 .result = { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96 },
1985                 .rlen   = 8,
1986         }, {
1987                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1988                 .klen   = 8,
1989                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1990                 .ilen   = 8,
1991                 .result = { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79 },
1992                 .rlen   = 8,
1993         }, {
1994                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1995                 .klen   = 8,
1996                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1997                 .ilen   = 8,
1998                 .result = { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a },
1999                 .rlen   = 8,
2000         }, {
2001                 .key    = { 0xef, 0x01, 0x23, 0x45},
2002                 .klen   = 4,
2003                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2004                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2005                             0x00, 0x00, 0x00, 0x00 },
2006                 .ilen   = 20,
2007                 .result = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
2008                             0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
2009                             0x36, 0xb6, 0x78, 0x58 },
2010                 .rlen   = 20,
2011         }, {
2012                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
2013                 .klen   = 8,
2014                 .input  = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
2015                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
2016                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
2017                             0x12, 0x34, 0x56, 0x78 },
2018                 .ilen   = 28,
2019                 .result = { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
2020                             0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
2021                             0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
2022                             0x40, 0x01, 0x1e, 0xcf },
2023                 .rlen   = 28,
2024         }, {
2025                 .key    = { 0xef, 0x01, 0x23, 0x45 },
2026                 .klen   = 4,
2027                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2028                             0x00, 0x00 },
2029                 .ilen   = 10,
2030                 .result = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
2031                             0xbd, 0x61 },
2032                 .rlen   = 10,
2033         }, {
2034                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
2035                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2036                 .klen   = 16,
2037                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
2038                 .ilen   = 8,
2039                 .result = { 0x69, 0x72, 0x36, 0x59, 0x1B, 0x52, 0x42, 0xB1 },
2040                 .rlen   = 8,
2041         },
2042 };
2043
2044 static struct cipher_testvec arc4_dec_tv_template[] = {
2045         {
2046                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
2047                 .klen   = 8,
2048                 .input  = { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96 },
2049                 .ilen   = 8,
2050                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
2051                 .rlen   = 8,
2052         }, {
2053                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
2054                 .klen   = 8,
2055                 .input  = { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79 },
2056                 .ilen   = 8,
2057                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2058                 .rlen   = 8,
2059         }, {
2060                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2061                 .klen   = 8,
2062                 .input  = { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a },
2063                 .ilen   = 8,
2064                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2065                 .rlen   = 8,
2066         }, {
2067                 .key    = { 0xef, 0x01, 0x23, 0x45},
2068                 .klen   = 4,
2069                 .input  = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
2070                             0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
2071                             0x36, 0xb6, 0x78, 0x58 },
2072                 .ilen   = 20,
2073                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2074                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2075                             0x00, 0x00, 0x00, 0x00 },
2076                 .rlen   = 20,
2077         }, {
2078                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
2079                 .klen   = 8,
2080                 .input  = { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
2081                             0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
2082                             0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
2083                             0x40, 0x01, 0x1e, 0xcf },
2084                 .ilen   = 28,
2085                 .result = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
2086                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
2087                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
2088                             0x12, 0x34, 0x56, 0x78 },
2089                 .rlen   = 28,
2090         }, {
2091                 .key    = { 0xef, 0x01, 0x23, 0x45 },
2092                 .klen   = 4,
2093                 .input  = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
2094                             0xbd, 0x61 },
2095                 .ilen   = 10,
2096                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2097                             0x00, 0x00 },
2098                 .rlen   = 10,
2099         }, {
2100                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
2101                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2102                 .klen   = 16,
2103                 .input  = { 0x69, 0x72, 0x36, 0x59, 0x1B, 0x52, 0x42, 0xB1 },
2104                 .ilen   = 8,
2105                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
2106                 .rlen   = 8,
2107         },
2108 };
2109
2110 /*
2111  * TEA test vectors
2112  */
2113 #define TEA_ENC_TEST_VECTORS    4
2114 #define TEA_DEC_TEST_VECTORS    4
2115
2116 static struct cipher_testvec tea_enc_tv_template[] = {
2117         {
2118                 .key    = { [0 ... 15] = 0x00 },
2119                 .klen   = 16,
2120                 .input  = { [0 ... 8] = 0x00 },
2121                 .ilen   = 8,
2122                 .result = { 0x0a, 0x3a, 0xea, 0x41, 0x40, 0xa9, 0xba, 0x94 },
2123                 .rlen   = 8,
2124         }, {
2125                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2126                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2127                 .klen   = 16,
2128                 .input  = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2129                 .ilen   = 8,
2130                 .result = { 0x77, 0x5d, 0x2a, 0x6a, 0xf6, 0xce, 0x92, 0x09 },
2131                 .rlen   = 8,
2132         }, {
2133                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2134                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2135                 .klen   = 16,
2136                 .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2137                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2138                 .ilen   = 16,
2139                 .result = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
2140                             0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
2141                 .rlen   = 16,
2142         }, {
2143                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2144                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2145                 .klen   = 16,
2146                 .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2147                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2148                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2149                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2150                 .ilen   = 32,
2151                 .result = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
2152                             0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
2153                             0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
2154                             0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
2155                 .rlen   = 32,
2156         }
2157 };
2158
2159 static struct cipher_testvec tea_dec_tv_template[] = {
2160         {
2161                 .key    = { [0 ... 15] = 0x00 },
2162                 .klen   = 16,
2163                 .input  = { 0x0a, 0x3a, 0xea, 0x41, 0x40, 0xa9, 0xba, 0x94 },
2164                 .ilen   = 8,
2165                 .result = { [0 ... 8] = 0x00 },
2166                 .rlen   = 8,
2167         }, {
2168                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2169                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2170                 .klen   = 16,
2171                 .input  = { 0x77, 0x5d, 0x2a, 0x6a, 0xf6, 0xce, 0x92, 0x09 },
2172                 .ilen   = 8,
2173                 .result = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2174                 .rlen   = 8,
2175         }, {
2176                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2177                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2178                 .klen   = 16,
2179                 .input  = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
2180                             0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
2181                 .ilen   = 16,
2182                 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2183                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2184                 .rlen   = 16,
2185         }, {
2186                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2187                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2188                 .klen   = 16,
2189                 .input  = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
2190                             0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
2191                             0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
2192                             0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
2193                 .ilen   = 32,
2194                 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2195                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2196                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2197                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2198                 .rlen   = 32,
2199         }
2200 };
2201
2202 /*
2203  * XTEA test vectors
2204  */
2205 #define XTEA_ENC_TEST_VECTORS   4
2206 #define XTEA_DEC_TEST_VECTORS   4
2207
2208 static struct cipher_testvec xtea_enc_tv_template[] = {
2209         {
2210                 .key    = { [0 ... 15] = 0x00 },
2211                 .klen   = 16,
2212                 .input  = { [0 ... 8] = 0x00 },
2213                 .ilen   = 8,
2214                 .result = { 0xaa, 0x22, 0x96, 0xe5, 0x6c, 0x61, 0xf3, 0x45 },
2215                 .rlen   = 8,
2216         }, {
2217                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2218                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2219                 .klen   = 16,
2220                 .input  = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2221                 .ilen   = 8,
2222                 .result = { 0x82, 0x3e, 0xeb, 0x35, 0xdc, 0xdd, 0xd9, 0xc3 },
2223                 .rlen   = 8,
2224         }, {
2225                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2226                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2227                 .klen   = 16,
2228                 .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2229                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2230                 .ilen   = 16,
2231                 .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2232                             0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2233                 .rlen   = 16,
2234         }, {
2235                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2236                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2237                 .klen   = 16,
2238                 .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2239                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2240                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2241                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2242                 .ilen   = 32,
2243                 .result = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
2244                             0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
2245                             0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
2246                             0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
2247                 .rlen   = 32,
2248         }
2249 };
2250
2251 static struct cipher_testvec xtea_dec_tv_template[] = {
2252         {
2253                 .key    = { [0 ... 15] = 0x00 },
2254                 .klen   = 16,
2255                 .input  = { 0xaa, 0x22, 0x96, 0xe5, 0x6c, 0x61, 0xf3, 0x45 },
2256                 .ilen   = 8,
2257                 .result = { [0 ... 8] = 0x00 },
2258                 .rlen   = 8,
2259         }, {
2260                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2261                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2262                 .klen   = 16,
2263                 .input  = { 0x82, 0x3e, 0xeb, 0x35, 0xdc, 0xdd, 0xd9, 0xc3 },
2264                 .ilen   = 8,
2265                 .result = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2266                 .rlen   = 8,
2267         }, {
2268                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2269                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2270                 .klen   = 16,
2271                 .input  = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2272                             0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2273                 .ilen   = 16,
2274                 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2275                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2276                 .rlen   = 16,
2277         }, {
2278                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2279                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2280                 .klen   = 16,
2281                 .input  = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
2282                             0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
2283                             0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
2284                             0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
2285                 .ilen   = 32,
2286                 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2287                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2288                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2289                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2290                 .rlen   = 32,
2291         }
2292 };
2293
2294 /*
2295  * KHAZAD test vectors.
2296  */
2297 #define KHAZAD_ENC_TEST_VECTORS 5
2298 #define KHAZAD_DEC_TEST_VECTORS 5
2299
2300 static struct cipher_testvec khazad_enc_tv_template[] = {
2301         {
2302                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2303                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2304                 .klen   = 16,
2305                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2306                 .ilen   = 8,
2307                 .result = { 0x49, 0xa4, 0xce, 0x32, 0xac, 0x19, 0x0e, 0x3f },
2308                 .rlen   = 8,
2309         }, {
2310                 .key    = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
2311                             0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2312                 .klen   = 16,
2313                 .input  = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2314                 .ilen   = 8,
2315                 .result = { 0x7e, 0x82, 0x12, 0xa1, 0Xd9, 0X5b, 0Xe4, 0Xf9 },
2316                 .rlen   = 8,
2317         }, {
2318                 .key    = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2,
2319                             0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2320                 .klen   = 16,
2321                 .input  = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2322                 .ilen   = 8,
2323                 .result = { 0Xaa, 0Xbe, 0Xc1, 0X95, 0Xc5, 0X94, 0X1a, 0X9c },
2324                 .rlen   = 8,
2325         }, {
2326                 .key    = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2327                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2328                 .klen   = 16,
2329                 .input  = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2330                 .ilen   = 8,
2331                 .result = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2332                 .rlen   = 8,
2333         }, {
2334                 .key    = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2335                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2336                 .klen   = 16,
2337                 .input  = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f ,
2338                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2339                 .ilen   = 16,
2340                 .result = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 ,
2341                             0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2342                 .rlen   = 16,
2343         },
2344 };
2345
2346 static struct cipher_testvec khazad_dec_tv_template[] = {
2347         {
2348                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2349                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2350                 .klen   = 16,
2351                 .input  = { 0X49, 0Xa4, 0Xce, 0X32, 0Xac, 0X19, 0X0e, 0X3f },
2352                 .ilen   = 8,
2353                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2354                 .rlen   = 8,
2355         }, {
2356                 .key    = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
2357                             0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2358                 .klen   = 16,
2359                 .input  = { 0X7e, 0X82, 0X12, 0Xa1, 0Xd9, 0X5b, 0Xe4, 0Xf9 },
2360                 .ilen   = 8,
2361                 .result = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2362                 .rlen   = 8,
2363         }, {
2364                 .key    = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2,
2365                             0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2366                 .klen   = 16,
2367                 .input  = { 0Xaa, 0Xbe, 0Xc1, 0X95, 0Xc5, 0X94, 0X1a, 0X9c },
2368                 .ilen   = 8,
2369                 .result = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2370                 .rlen   = 8,
2371         }, {
2372                 .key    = { 0x2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2373                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2374                 .klen   = 16,
2375                 .input = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2376                 .ilen   = 8,
2377                 .result = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2378                 .rlen   = 8,
2379         }, {
2380                 .key    = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2381                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2382                 .klen   = 16,
2383                 .input = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 ,
2384                             0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2385                 .ilen   = 16,
2386                 .result = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f ,
2387                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2388                 .rlen   = 16,
2389         },
2390 };
2391
2392 /*
2393  * Anubis test vectors.
2394  */
2395
2396 #define ANUBIS_ENC_TEST_VECTORS                 5
2397 #define ANUBIS_DEC_TEST_VECTORS                 5
2398 #define ANUBIS_CBC_ENC_TEST_VECTORS             2
2399 #define ANUBIS_CBC_DEC_TEST_VECTORS             2
2400
2401 static struct cipher_testvec anubis_enc_tv_template[] = {
2402         {
2403                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2404                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2405                 .klen   = 16,
2406                 .input  = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2407                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2408                 .ilen   = 16,
2409                 .result = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2410                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90 },
2411                 .rlen   = 16,
2412         }, {
2413
2414                 .key    = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2415                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2416                             0x03, 0x03, 0x03, 0x03 },
2417                 .klen   = 20,
2418                 .input  = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2419                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 },
2420                 .ilen   = 16,
2421                 .result = { 0xdb, 0xf1, 0x42, 0xf4, 0xd1, 0x8a, 0xc7, 0x49,
2422                             0x87, 0x41, 0x6f, 0x82, 0x0a, 0x98, 0x64, 0xae },
2423                 .rlen   = 16,
2424         }, {
2425                 .key    = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2426                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2427                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2428                             0x24, 0x24, 0x24, 0x24 },
2429                 .klen   = 28,
2430                 .input  = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2431                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24 },
2432                 .ilen   = 16,
2433                 .result = { 0xfd, 0x1b, 0x4a, 0xe3, 0xbf, 0xf0, 0xad, 0x3d,
2434                             0x06, 0xd3, 0x61, 0x27, 0xfd, 0x13, 0x9e, 0xde },
2435                 .rlen   = 16,
2436         }, {
2437                 .key    = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2438                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2439                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2440                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2441                 .klen   = 32,
2442                 .input  = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2443                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2444                 .ilen   = 16,
2445                 .result = { 0x1a, 0x91, 0xfb, 0x2b, 0xb7, 0x78, 0x6b, 0xc4,
2446                             0x17, 0xd9, 0xff, 0x40, 0x3b, 0x0e, 0xe5, 0xfe },
2447                 .rlen   = 16,
2448         }, {
2449                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2450                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2451                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2452                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2453                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2454                 .klen   = 40,
2455                 .input  = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2456                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2457                 .ilen   = 16,
2458                 .result = { 0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2459                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee },
2460                 .rlen   = 16,
2461         },
2462 };
2463
2464 static struct cipher_testvec anubis_dec_tv_template[] = {
2465         {
2466                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2467                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2468                 .klen   = 16,
2469                 .input  = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2470                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90 },
2471                 .ilen   = 16,
2472                 .result = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2473                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2474                 .rlen   = 16,
2475         }, {
2476
2477                 .key    = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2478                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2479                             0x03, 0x03, 0x03, 0x03 },
2480                 .klen   = 20,
2481                 .input  = { 0xdb, 0xf1, 0x42, 0xf4, 0xd1, 0x8a, 0xc7, 0x49,
2482                             0x87, 0x41, 0x6f, 0x82, 0x0a, 0x98, 0x64, 0xae },
2483                 .ilen   = 16,
2484                 .result = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2485                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 },
2486                 .rlen   = 16,
2487         }, {
2488                 .key    = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2489                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2490                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2491                             0x24, 0x24, 0x24, 0x24 },
2492                 .klen   = 28,
2493                 .input  = { 0xfd, 0x1b, 0x4a, 0xe3, 0xbf, 0xf0, 0xad, 0x3d,
2494                             0x06, 0xd3, 0x61, 0x27, 0xfd, 0x13, 0x9e, 0xde },
2495                 .ilen   = 16,
2496                 .result = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2497                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24 },
2498                 .rlen   = 16,
2499         }, {
2500                 .key    = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2501                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2502                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2503                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2504                 .klen   = 32,
2505                 .input  = { 0x1a, 0x91, 0xfb, 0x2b, 0xb7, 0x78, 0x6b, 0xc4,
2506                             0x17, 0xd9, 0xff, 0x40, 0x3b, 0x0e, 0xe5, 0xfe },
2507                 .ilen   = 16,
2508                 .result = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2509                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2510                 .rlen   = 16,
2511         }, {
2512                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2513                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2514                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2515                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2516                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2517                 .input = {  0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2518                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee },
2519                 .klen   = 40,
2520                 .ilen   = 16,
2521                 .result = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2522                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2523                 .rlen   = 16,
2524         },
2525 };
2526
2527 static struct cipher_testvec anubis_cbc_enc_tv_template[] = {
2528         {
2529                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2530                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2531                 .klen   = 16,
2532                 .input  = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2533                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2534                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2535                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2536                 .ilen   = 32,
2537                 .result = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2538                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90,
2539                             0x86, 0xd8, 0xb5, 0x6f, 0x98, 0x5e, 0x8a, 0x66,
2540                             0x4f, 0x1f, 0x78, 0xa1, 0xbb, 0x37, 0xf1, 0xbe },
2541                 .rlen   = 32,
2542         }, {
2543                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2544                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2545                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2546                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2547                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2548                 .klen   = 40,
2549                 .input  = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2550                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2551                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2552                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2553                 .ilen   = 32,
2554                 .result = { 0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2555                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee,
2556                             0xa2, 0xbc, 0x06, 0x98, 0xc6, 0x4b, 0xda, 0x75,
2557                             0x2e, 0xaa, 0xbe, 0x58, 0xce, 0x01, 0x5b, 0xc7 },
2558                 .rlen   = 32,
2559         },
2560 };
2561
2562 static struct cipher_testvec anubis_cbc_dec_tv_template[] = {
2563         {
2564                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2565                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2566                 .klen   = 16,
2567                 .input  = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2568                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90,
2569                             0x86, 0xd8, 0xb5, 0x6f, 0x98, 0x5e, 0x8a, 0x66,
2570                             0x4f, 0x1f, 0x78, 0xa1, 0xbb, 0x37, 0xf1, 0xbe },
2571                 .ilen   = 32,
2572                 .result = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2573                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2574                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2575                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2576                 .rlen   = 32,
2577         }, {
2578                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2579                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2580                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2581                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2582                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2583                 .klen   = 40,
2584                 .input = { 0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2585                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee,
2586                             0xa2, 0xbc, 0x06, 0x98, 0xc6, 0x4b, 0xda, 0x75,
2587                             0x2e, 0xaa, 0xbe, 0x58, 0xce, 0x01, 0x5b, 0xc7 },
2588                 .ilen   = 32,
2589                 .result = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2590                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2591                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2592                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2593                 .rlen   = 32,
2594         },
2595 };
2596
2597 /*
2598  * Compression stuff.
2599  */
2600 #define COMP_BUF_SIZE           512
2601
2602 struct comp_testvec {
2603         int inlen, outlen;
2604         char input[COMP_BUF_SIZE];
2605         char output[COMP_BUF_SIZE];
2606 };
2607
2608 /*
2609  * Deflate test vectors (null-terminated strings).
2610  * Params: winbits=11, Z_DEFAULT_COMPRESSION, MAX_MEM_LEVEL.
2611  */
2612 #define DEFLATE_COMP_TEST_VECTORS 2
2613 #define DEFLATE_DECOMP_TEST_VECTORS 2
2614
2615 static struct comp_testvec deflate_comp_tv_template[] = {
2616         {
2617                 .inlen  = 70,
2618                 .outlen = 38,
2619                 .input  = "Join us now and share the software "
2620                           "Join us now and share the software ",
2621                 .output = { 0xf3, 0xca, 0xcf, 0xcc, 0x53, 0x28, 0x2d, 0x56,
2622                             0xc8, 0xcb, 0x2f, 0x57, 0x48, 0xcc, 0x4b, 0x51,
2623                             0x28, 0xce, 0x48, 0x2c, 0x4a, 0x55, 0x28, 0xc9,
2624                             0x48, 0x55, 0x28, 0xce, 0x4f, 0x2b, 0x29, 0x07,
2625                             0x71, 0xbc, 0x08, 0x2b, 0x01, 0x00 },
2626         }, {
2627                 .inlen  = 191,
2628                 .outlen = 122,
2629                 .input  = "This document describes a compression method based on the DEFLATE"
2630                           "compression algorithm.  This document defines the application of "
2631                           "the DEFLATE algorithm to the IP Payload Compression Protocol.",
2632                 .output = { 0x5d, 0x8d, 0x31, 0x0e, 0xc2, 0x30, 0x10, 0x04,
2633                             0xbf, 0xb2, 0x2f, 0xc8, 0x1f, 0x10, 0x04, 0x09,
2634                             0x89, 0xc2, 0x85, 0x3f, 0x70, 0xb1, 0x2f, 0xf8,
2635                             0x24, 0xdb, 0x67, 0xd9, 0x47, 0xc1, 0xef, 0x49,
2636                             0x68, 0x12, 0x51, 0xae, 0x76, 0x67, 0xd6, 0x27,
2637                             0x19, 0x88, 0x1a, 0xde, 0x85, 0xab, 0x21, 0xf2,
2638                             0x08, 0x5d, 0x16, 0x1e, 0x20, 0x04, 0x2d, 0xad,
2639                             0xf3, 0x18, 0xa2, 0x15, 0x85, 0x2d, 0x69, 0xc4,
2640                             0x42, 0x83, 0x23, 0xb6, 0x6c, 0x89, 0x71, 0x9b,
2641                             0xef, 0xcf, 0x8b, 0x9f, 0xcf, 0x33, 0xca, 0x2f,
2642                             0xed, 0x62, 0xa9, 0x4c, 0x80, 0xff, 0x13, 0xaf,
2643                             0x52, 0x37, 0xed, 0x0e, 0x52, 0x6b, 0x59, 0x02,
2644                             0xd9, 0x4e, 0xe8, 0x7a, 0x76, 0x1d, 0x02, 0x98,
2645                             0xfe, 0x8a, 0x87, 0x83, 0xa3, 0x4f, 0x56, 0x8a,
2646                             0xb8, 0x9e, 0x8e, 0x5c, 0x57, 0xd3, 0xa0, 0x79,
2647                             0xfa, 0x02 },
2648         },
2649 };
2650
2651 static struct comp_testvec deflate_decomp_tv_template[] = {
2652         {
2653                 .inlen  = 122,
2654                 .outlen = 191,
2655                 .input  = { 0x5d, 0x8d, 0x31, 0x0e, 0xc2, 0x30, 0x10, 0x04,
2656                             0xbf, 0xb2, 0x2f, 0xc8, 0x1f, 0x10, 0x04, 0x09,
2657                             0x89, 0xc2, 0x85, 0x3f, 0x70, 0xb1, 0x2f, 0xf8,
2658                             0x24, 0xdb, 0x67, 0xd9, 0x47, 0xc1, 0xef, 0x49,
2659                             0x68, 0x12, 0x51, 0xae, 0x76, 0x67, 0xd6, 0x27,
2660                             0x19, 0x88, 0x1a, 0xde, 0x85, 0xab, 0x21, 0xf2,
2661                             0x08, 0x5d, 0x16, 0x1e, 0x20, 0x04, 0x2d, 0xad,
2662                             0xf3, 0x18, 0xa2, 0x15, 0x85, 0x2d, 0x69, 0xc4,
2663                             0x42, 0x83, 0x23, 0xb6, 0x6c, 0x89, 0x71, 0x9b,
2664                             0xef, 0xcf, 0x8b, 0x9f, 0xcf, 0x33, 0xca, 0x2f,
2665                             0xed, 0x62, 0xa9, 0x4c, 0x80, 0xff, 0x13, 0xaf,
2666                             0x52, 0x37, 0xed, 0x0e, 0x52, 0x6b, 0x59, 0x02,
2667                             0xd9, 0x4e, 0xe8, 0x7a, 0x76, 0x1d, 0x02, 0x98,
2668                             0xfe, 0x8a, 0x87, 0x83, 0xa3, 0x4f, 0x56, 0x8a,
2669                             0xb8, 0x9e, 0x8e, 0x5c, 0x57, 0xd3, 0xa0, 0x79,
2670                             0xfa, 0x02 },
2671                 .output = "This document describes a compression method based on the DEFLATE"
2672                           "compression algorithm.  This document defines the application of "
2673                           "the DEFLATE algorithm to the IP Payload Compression Protocol.",
2674         }, {
2675                 .inlen  = 38,
2676                 .outlen = 70,
2677                 .input  = { 0xf3, 0xca, 0xcf, 0xcc, 0x53, 0x28, 0x2d, 0x56,
2678                             0xc8, 0xcb, 0x2f, 0x57, 0x48, 0xcc, 0x4b, 0x51,
2679                             0x28, 0xce, 0x48, 0x2c, 0x4a, 0x55, 0x28, 0xc9,
2680                             0x48, 0x55, 0x28, 0xce, 0x4f, 0x2b, 0x29, 0x07,
2681                             0x71, 0xbc, 0x08, 0x2b, 0x01, 0x00 },
2682                 .output = "Join us now and share the software "
2683                           "Join us now and share the software ",
2684         },
2685 };
2686
2687 /*
2688  * Michael MIC test vectors from IEEE 802.11i
2689  */
2690 #define MICHAEL_MIC_TEST_VECTORS 6
2691
2692 static struct hash_testvec michael_mic_tv_template[] = {
2693         {
2694                 .key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2695                 .ksize = 8,
2696                 .plaintext = { },
2697                 .psize = 0,
2698                 .digest = { 0x82, 0x92, 0x5c, 0x1c, 0xa1, 0xd1, 0x30, 0xb8 }
2699         },
2700         {
2701                 .key = { 0x82, 0x92, 0x5c, 0x1c, 0xa1, 0xd1, 0x30, 0xb8 },
2702                 .ksize = 8,
2703                 .plaintext = { 'M' },
2704                 .psize = 1,
2705                 .digest = { 0x43, 0x47, 0x21, 0xca, 0x40, 0x63, 0x9b, 0x3f }
2706         },
2707         {
2708                 .key = { 0x43, 0x47, 0x21, 0xca, 0x40, 0x63, 0x9b, 0x3f },
2709                 .ksize = 8,
2710                 .plaintext = { 'M', 'i' },
2711                 .psize = 2,
2712                 .digest = { 0xe8, 0xf9, 0xbe, 0xca, 0xe9, 0x7e, 0x5d, 0x29 }
2713         },
2714         {
2715                 .key = { 0xe8, 0xf9, 0xbe, 0xca, 0xe9, 0x7e, 0x5d, 0x29 },
2716                 .ksize = 8,
2717                 .plaintext = { 'M', 'i', 'c' },
2718                 .psize = 3,
2719                 .digest = { 0x90, 0x03, 0x8f, 0xc6, 0xcf, 0x13, 0xc1, 0xdb }
2720         },
2721         {
2722                 .key = { 0x90, 0x03, 0x8f, 0xc6, 0xcf, 0x13, 0xc1, 0xdb },
2723                 .ksize = 8,
2724                 .plaintext = { 'M', 'i', 'c', 'h' },
2725                 .psize = 4,
2726                 .digest = { 0xd5, 0x5e, 0x10, 0x05, 0x10, 0x12, 0x89, 0x86 }
2727         },
2728         {
2729                 .key = { 0xd5, 0x5e, 0x10, 0x05, 0x10, 0x12, 0x89, 0x86 },
2730                 .ksize = 8,
2731                 .plaintext = { 'M', 'i', 'c', 'h', 'a', 'e', 'l' },
2732                 .psize = 7,
2733                 .digest = { 0x0a, 0x94, 0x2b, 0x12, 0x4e, 0xca, 0xa5, 0x46 },
2734         }
2735 };
2736
2737 /*
2738  * Cipher speed tests
2739  */
2740 static struct cipher_speed aes_speed_template[] = {
2741         { .klen = 16, .blen = 16, },
2742         { .klen = 16, .blen = 64, },
2743         { .klen = 16, .blen = 256, },
2744         { .klen = 16, .blen = 1024, },
2745         { .klen = 16, .blen = 8192, },
2746         { .klen = 24, .blen = 16, },
2747         { .klen = 24, .blen = 64, },
2748         { .klen = 24, .blen = 256, },
2749         { .klen = 24, .blen = 1024, },
2750         { .klen = 24, .blen = 8192, },
2751         { .klen = 32, .blen = 16, },
2752         { .klen = 32, .blen = 64, },
2753         { .klen = 32, .blen = 256, },
2754         { .klen = 32, .blen = 1024, },
2755         { .klen = 32, .blen = 8192, },
2756
2757         /* End marker */
2758         {  .klen = 0, .blen = 0, }
2759 };
2760
2761 static struct cipher_speed des3_ede_speed_template[] = {
2762         { .klen = 24, .blen = 16, },
2763         { .klen = 24, .blen = 64, },
2764         { .klen = 24, .blen = 256, },
2765         { .klen = 24, .blen = 1024, },
2766         { .klen = 24, .blen = 8192, },
2767
2768         /* End marker */
2769         {  .klen = 0, .blen = 0, }
2770 };
2771
2772 static struct cipher_speed twofish_speed_template[] = {
2773         { .klen = 16, .blen = 16, },
2774         { .klen = 16, .blen = 64, },
2775         { .klen = 16, .blen = 256, },
2776         { .klen = 16, .blen = 1024, },
2777         { .klen = 16, .blen = 8192, },
2778         { .klen = 24, .blen = 16, },
2779         { .klen = 24, .blen = 64, },
2780         { .klen = 24, .blen = 256, },
2781         { .klen = 24, .blen = 1024, },
2782         { .klen = 24, .blen = 8192, },
2783         { .klen = 32, .blen = 16, },
2784         { .klen = 32, .blen = 64, },
2785         { .klen = 32, .blen = 256, },
2786         { .klen = 32, .blen = 1024, },
2787         { .klen = 32, .blen = 8192, },
2788
2789         /* End marker */
2790         {  .klen = 0, .blen = 0, }
2791 };
2792
2793 static struct cipher_speed blowfish_speed_template[] = {
2794         /* Don't support blowfish keys > 256 bit in this test */
2795         { .klen = 8, .blen = 16, },
2796         { .klen = 8, .blen = 64, },
2797         { .klen = 8, .blen = 256, },
2798         { .klen = 8, .blen = 1024, },
2799         { .klen = 8, .blen = 8192, },
2800         { .klen = 32, .blen = 16, },
2801         { .klen = 32, .blen = 64, },
2802         { .klen = 32, .blen = 256, },
2803         { .klen = 32, .blen = 1024, },
2804         { .klen = 32, .blen = 8192, },
2805
2806         /* End marker */
2807         {  .klen = 0, .blen = 0, }
2808 };
2809
2810 static struct cipher_speed des_speed_template[] = {
2811         { .klen = 8, .blen = 16, },
2812         { .klen = 8, .blen = 64, },
2813         { .klen = 8, .blen = 256, },
2814         { .klen = 8, .blen = 1024, },
2815         { .klen = 8, .blen = 8192, },
2816
2817         /* End marker */
2818         {  .klen = 0, .blen = 0, }
2819 };
2820
2821 #endif  /* _CRYPTO_TCRYPT_H */