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