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