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