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