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