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