]>
Commit | Line | Data |
---|---|---|
ef2736fc | 1 | /* |
1da177e4 LT |
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> | |
e3a4ea4f | 9 | * Copyright (c) 2007 Nokia Siemens Networks |
1da177e4 LT |
10 | * |
11 | * This program is free software; you can redistribute it and/or modify it | |
12 | * under the terms of the GNU General Public License as published by the Free | |
ef2736fc | 13 | * Software Foundation; either version 2 of the License, or (at your option) |
1da177e4 LT |
14 | * any later version. |
15 | * | |
28db8e3e | 16 | * 2007-11-13 Added GCM tests |
e3a4ea4f | 17 | * 2007-11-13 Added AEAD support |
cd12fb90 | 18 | * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests |
a28091ae | 19 | * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests |
ebfd9bcf HW |
20 | * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>) |
21 | * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt | |
22 | * | |
1da177e4 LT |
23 | */ |
24 | ||
cba83564 | 25 | #include <linux/err.h> |
1da177e4 LT |
26 | #include <linux/init.h> |
27 | #include <linux/module.h> | |
28 | #include <linux/mm.h> | |
29 | #include <linux/slab.h> | |
378f058c | 30 | #include <linux/scatterlist.h> |
1da177e4 LT |
31 | #include <linux/string.h> |
32 | #include <linux/crypto.h> | |
33 | #include <linux/highmem.h> | |
34 | #include <linux/moduleparam.h> | |
ebfd9bcf | 35 | #include <linux/jiffies.h> |
6a17944c HX |
36 | #include <linux/timex.h> |
37 | #include <linux/interrupt.h> | |
1da177e4 LT |
38 | #include "tcrypt.h" |
39 | ||
40 | /* | |
41 | * Need to kmalloc() memory for testing kmap(). | |
42 | */ | |
ebfd9bcf | 43 | #define TVMEMSIZE 16384 |
1da177e4 LT |
44 | #define XBUFSIZE 32768 |
45 | ||
46 | /* | |
47 | * Indexes into the xbuf to simulate cross-page access. | |
48 | */ | |
49 | #define IDX1 37 | |
50 | #define IDX2 32400 | |
51 | #define IDX3 1 | |
52 | #define IDX4 8193 | |
53 | #define IDX5 22222 | |
54 | #define IDX6 17101 | |
55 | #define IDX7 27333 | |
56 | #define IDX8 3000 | |
57 | ||
58 | /* | |
59 | * Used by test_cipher() | |
60 | */ | |
61 | #define ENCRYPT 1 | |
62 | #define DECRYPT 0 | |
1da177e4 | 63 | |
6158efc0 HX |
64 | struct tcrypt_result { |
65 | struct completion completion; | |
66 | int err; | |
67 | }; | |
68 | ||
1da177e4 LT |
69 | static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; |
70 | ||
ebfd9bcf HW |
71 | /* |
72 | * Used by test_cipher_speed() | |
73 | */ | |
6a17944c | 74 | static unsigned int sec; |
ebfd9bcf | 75 | |
1da177e4 LT |
76 | static int mode; |
77 | static char *xbuf; | |
e3a4ea4f | 78 | static char *axbuf; |
1da177e4 LT |
79 | static char *tvmem; |
80 | ||
81 | static char *check[] = { | |
cd12fb90 JL |
82 | "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", |
83 | "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", | |
84 | "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", | |
ef2736fc | 85 | "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", |
90831639 | 86 | "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", |
0b77abb3 | 87 | "camellia", "seed", "salsa20", "lzo", NULL |
1da177e4 LT |
88 | }; |
89 | ||
ef2736fc | 90 | static void hexdump(unsigned char *buf, unsigned int len) |
1da177e4 | 91 | { |
a10e1194 DC |
92 | print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, |
93 | 16, 1, | |
94 | buf, len, false); | |
1da177e4 LT |
95 | } |
96 | ||
6158efc0 HX |
97 | static void tcrypt_complete(struct crypto_async_request *req, int err) |
98 | { | |
99 | struct tcrypt_result *res = req->data; | |
100 | ||
101 | if (err == -EINPROGRESS) | |
102 | return; | |
103 | ||
104 | res->err = err; | |
105 | complete(&res->completion); | |
106 | } | |
107 | ||
ef2736fc HX |
108 | static void test_hash(char *algo, struct hash_testvec *template, |
109 | unsigned int tcount) | |
1da177e4 | 110 | { |
ef2736fc HX |
111 | unsigned int i, j, k, temp; |
112 | struct scatterlist sg[8]; | |
113 | char result[64]; | |
e9d41164 HX |
114 | struct crypto_hash *tfm; |
115 | struct hash_desc desc; | |
ef2736fc HX |
116 | struct hash_testvec *hash_tv; |
117 | unsigned int tsize; | |
e9d41164 | 118 | int ret; |
ef2736fc HX |
119 | |
120 | printk("\ntesting %s\n", algo); | |
121 | ||
122 | tsize = sizeof(struct hash_testvec); | |
1da177e4 | 123 | tsize *= tcount; |
ef2736fc | 124 | |
1da177e4 LT |
125 | if (tsize > TVMEMSIZE) { |
126 | printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE); | |
127 | return; | |
128 | } | |
129 | ||
130 | memcpy(tvmem, template, tsize); | |
ef2736fc | 131 | hash_tv = (void *)tvmem; |
e9d41164 HX |
132 | |
133 | tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); | |
134 | if (IS_ERR(tfm)) { | |
135 | printk("failed to load transform for %s: %ld\n", algo, | |
136 | PTR_ERR(tfm)); | |
1da177e4 LT |
137 | return; |
138 | } | |
139 | ||
e9d41164 HX |
140 | desc.tfm = tfm; |
141 | desc.flags = 0; | |
142 | ||
1da177e4 | 143 | for (i = 0; i < tcount; i++) { |
ef2736fc HX |
144 | printk("test %u:\n", i + 1); |
145 | memset(result, 0, 64); | |
1da177e4 | 146 | |
b7335885 | 147 | sg_init_one(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize); |
1da177e4 | 148 | |
e9d41164 HX |
149 | if (hash_tv[i].ksize) { |
150 | ret = crypto_hash_setkey(tfm, hash_tv[i].key, | |
151 | hash_tv[i].ksize); | |
152 | if (ret) { | |
153 | printk("setkey() failed ret=%d\n", ret); | |
154 | goto out; | |
155 | } | |
156 | } | |
157 | ||
158 | ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result); | |
159 | if (ret) { | |
160 | printk("digest () failed ret=%d\n", ret); | |
161 | goto out; | |
162 | } | |
1da177e4 | 163 | |
e9d41164 | 164 | hexdump(result, crypto_hash_digestsize(tfm)); |
1da177e4 | 165 | printk("%s\n", |
ef2736fc | 166 | memcmp(result, hash_tv[i].digest, |
e9d41164 | 167 | crypto_hash_digestsize(tfm)) ? |
ef2736fc | 168 | "fail" : "pass"); |
1da177e4 LT |
169 | } |
170 | ||
ef2736fc | 171 | printk("testing %s across pages\n", algo); |
1da177e4 LT |
172 | |
173 | /* setup the dummy buffer first */ | |
ef2736fc | 174 | memset(xbuf, 0, XBUFSIZE); |
e3a4ea4f | 175 | memset(axbuf, 0, XBUFSIZE); |
1da177e4 LT |
176 | |
177 | j = 0; | |
178 | for (i = 0; i < tcount; i++) { | |
179 | if (hash_tv[i].np) { | |
180 | j++; | |
ef2736fc HX |
181 | printk("test %u:\n", j); |
182 | memset(result, 0, 64); | |
1da177e4 LT |
183 | |
184 | temp = 0; | |
b7335885 | 185 | sg_init_table(sg, hash_tv[i].np); |
1da177e4 | 186 | for (k = 0; k < hash_tv[i].np; k++) { |
ef2736fc HX |
187 | memcpy(&xbuf[IDX[k]], |
188 | hash_tv[i].plaintext + temp, | |
189 | hash_tv[i].tap[k]); | |
1da177e4 | 190 | temp += hash_tv[i].tap[k]; |
378f058c DH |
191 | sg_set_buf(&sg[k], &xbuf[IDX[k]], |
192 | hash_tv[i].tap[k]); | |
1da177e4 LT |
193 | } |
194 | ||
e9d41164 HX |
195 | if (hash_tv[i].ksize) { |
196 | ret = crypto_hash_setkey(tfm, hash_tv[i].key, | |
197 | hash_tv[i].ksize); | |
ef2736fc | 198 | |
e9d41164 HX |
199 | if (ret) { |
200 | printk("setkey() failed ret=%d\n", ret); | |
201 | goto out; | |
202 | } | |
1da177e4 LT |
203 | } |
204 | ||
e9d41164 HX |
205 | ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, |
206 | result); | |
207 | if (ret) { | |
208 | printk("digest () failed ret=%d\n", ret); | |
209 | goto out; | |
210 | } | |
ef2736fc | 211 | |
e9d41164 | 212 | hexdump(result, crypto_hash_digestsize(tfm)); |
1da177e4 | 213 | printk("%s\n", |
e9d41164 HX |
214 | memcmp(result, hash_tv[i].digest, |
215 | crypto_hash_digestsize(tfm)) ? | |
ef2736fc | 216 | "fail" : "pass"); |
1da177e4 LT |
217 | } |
218 | } | |
e9d41164 | 219 | |
1da177e4 | 220 | out: |
e9d41164 | 221 | crypto_free_hash(tfm); |
1da177e4 LT |
222 | } |
223 | ||
e3a4ea4f MH |
224 | static void test_aead(char *algo, int enc, struct aead_testvec *template, |
225 | unsigned int tcount) | |
226 | { | |
227 | unsigned int ret, i, j, k, temp; | |
228 | unsigned int tsize; | |
229 | char *q; | |
230 | struct crypto_aead *tfm; | |
231 | char *key; | |
232 | struct aead_testvec *aead_tv; | |
233 | struct aead_request *req; | |
234 | struct scatterlist sg[8]; | |
235 | struct scatterlist asg[8]; | |
236 | const char *e; | |
237 | struct tcrypt_result result; | |
6160b289 | 238 | unsigned int authsize; |
e3a4ea4f MH |
239 | |
240 | if (enc == ENCRYPT) | |
241 | e = "encryption"; | |
242 | else | |
243 | e = "decryption"; | |
244 | ||
245 | printk(KERN_INFO "\ntesting %s %s\n", algo, e); | |
246 | ||
247 | tsize = sizeof(struct aead_testvec); | |
248 | tsize *= tcount; | |
249 | ||
250 | if (tsize > TVMEMSIZE) { | |
251 | printk(KERN_INFO "template (%u) too big for tvmem (%u)\n", | |
252 | tsize, TVMEMSIZE); | |
253 | return; | |
254 | } | |
255 | ||
256 | memcpy(tvmem, template, tsize); | |
257 | aead_tv = (void *)tvmem; | |
258 | ||
259 | init_completion(&result.completion); | |
260 | ||
261 | tfm = crypto_alloc_aead(algo, 0, 0); | |
262 | ||
263 | if (IS_ERR(tfm)) { | |
264 | printk(KERN_INFO "failed to load transform for %s: %ld\n", | |
265 | algo, PTR_ERR(tfm)); | |
266 | return; | |
267 | } | |
268 | ||
6160b289 HX |
269 | authsize = crypto_aead_authsize(tfm); |
270 | ||
e3a4ea4f MH |
271 | req = aead_request_alloc(tfm, GFP_KERNEL); |
272 | if (!req) { | |
273 | printk(KERN_INFO "failed to allocate request for %s\n", algo); | |
274 | goto out; | |
275 | } | |
276 | ||
277 | aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, | |
278 | tcrypt_complete, &result); | |
279 | ||
280 | for (i = 0, j = 0; i < tcount; i++) { | |
281 | if (!aead_tv[i].np) { | |
282 | printk(KERN_INFO "test %u (%d bit key):\n", | |
283 | ++j, aead_tv[i].klen * 8); | |
284 | ||
285 | crypto_aead_clear_flags(tfm, ~0); | |
286 | if (aead_tv[i].wk) | |
287 | crypto_aead_set_flags( | |
288 | tfm, CRYPTO_TFM_REQ_WEAK_KEY); | |
289 | key = aead_tv[i].key; | |
290 | ||
291 | ret = crypto_aead_setkey(tfm, key, | |
292 | aead_tv[i].klen); | |
293 | if (ret) { | |
294 | printk(KERN_INFO "setkey() failed flags=%x\n", | |
295 | crypto_aead_get_flags(tfm)); | |
296 | ||
297 | if (!aead_tv[i].fail) | |
298 | goto out; | |
299 | } | |
300 | ||
301 | sg_init_one(&sg[0], aead_tv[i].input, | |
6160b289 | 302 | aead_tv[i].ilen + (enc ? authsize : 0)); |
e3a4ea4f MH |
303 | |
304 | sg_init_one(&asg[0], aead_tv[i].assoc, | |
305 | aead_tv[i].alen); | |
306 | ||
307 | aead_request_set_crypt(req, sg, sg, | |
308 | aead_tv[i].ilen, | |
309 | aead_tv[i].iv); | |
310 | ||
311 | aead_request_set_assoc(req, asg, aead_tv[i].alen); | |
312 | ||
6160b289 HX |
313 | ret = enc ? |
314 | crypto_aead_encrypt(req) : | |
315 | crypto_aead_decrypt(req); | |
e3a4ea4f MH |
316 | |
317 | switch (ret) { | |
318 | case 0: | |
319 | break; | |
320 | case -EINPROGRESS: | |
321 | case -EBUSY: | |
322 | ret = wait_for_completion_interruptible( | |
323 | &result.completion); | |
324 | if (!ret && !(ret = result.err)) { | |
325 | INIT_COMPLETION(result.completion); | |
326 | break; | |
327 | } | |
328 | /* fall through */ | |
329 | default: | |
330 | printk(KERN_INFO "%s () failed err=%d\n", | |
331 | e, -ret); | |
332 | goto out; | |
333 | } | |
334 | ||
335 | q = kmap(sg_page(&sg[0])) + sg[0].offset; | |
336 | hexdump(q, aead_tv[i].rlen); | |
e3a4ea4f MH |
337 | |
338 | printk(KERN_INFO "enc/dec: %s\n", | |
339 | memcmp(q, aead_tv[i].result, | |
340 | aead_tv[i].rlen) ? "fail" : "pass"); | |
e3a4ea4f MH |
341 | } |
342 | } | |
343 | ||
344 | printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e); | |
345 | memset(xbuf, 0, XBUFSIZE); | |
346 | ||
347 | for (i = 0, j = 0; i < tcount; i++) { | |
348 | if (aead_tv[i].np) { | |
349 | printk(KERN_INFO "test %u (%d bit key):\n", | |
350 | ++j, aead_tv[i].klen * 8); | |
351 | ||
352 | crypto_aead_clear_flags(tfm, ~0); | |
353 | if (aead_tv[i].wk) | |
354 | crypto_aead_set_flags( | |
355 | tfm, CRYPTO_TFM_REQ_WEAK_KEY); | |
356 | key = aead_tv[i].key; | |
357 | ||
358 | ret = crypto_aead_setkey(tfm, key, aead_tv[i].klen); | |
359 | if (ret) { | |
360 | printk(KERN_INFO "setkey() failed flags=%x\n", | |
361 | crypto_aead_get_flags(tfm)); | |
362 | ||
363 | if (!aead_tv[i].fail) | |
364 | goto out; | |
365 | } | |
366 | ||
367 | sg_init_table(sg, aead_tv[i].np); | |
368 | for (k = 0, temp = 0; k < aead_tv[i].np; k++) { | |
369 | memcpy(&xbuf[IDX[k]], | |
370 | aead_tv[i].input + temp, | |
371 | aead_tv[i].tap[k]); | |
372 | temp += aead_tv[i].tap[k]; | |
373 | sg_set_buf(&sg[k], &xbuf[IDX[k]], | |
374 | aead_tv[i].tap[k]); | |
375 | } | |
376 | ||
6160b289 HX |
377 | if (enc) |
378 | sg[k - 1].length += authsize; | |
379 | ||
e3a4ea4f MH |
380 | sg_init_table(asg, aead_tv[i].anp); |
381 | for (k = 0, temp = 0; k < aead_tv[i].anp; k++) { | |
382 | memcpy(&axbuf[IDX[k]], | |
383 | aead_tv[i].assoc + temp, | |
384 | aead_tv[i].atap[k]); | |
385 | temp += aead_tv[i].atap[k]; | |
386 | sg_set_buf(&asg[k], &axbuf[IDX[k]], | |
387 | aead_tv[i].atap[k]); | |
388 | } | |
389 | ||
390 | aead_request_set_crypt(req, sg, sg, | |
391 | aead_tv[i].ilen, | |
392 | aead_tv[i].iv); | |
393 | ||
394 | aead_request_set_assoc(req, asg, aead_tv[i].alen); | |
395 | ||
6160b289 HX |
396 | ret = enc ? |
397 | crypto_aead_encrypt(req) : | |
398 | crypto_aead_decrypt(req); | |
e3a4ea4f MH |
399 | |
400 | switch (ret) { | |
401 | case 0: | |
402 | break; | |
403 | case -EINPROGRESS: | |
404 | case -EBUSY: | |
405 | ret = wait_for_completion_interruptible( | |
406 | &result.completion); | |
407 | if (!ret && !(ret = result.err)) { | |
408 | INIT_COMPLETION(result.completion); | |
409 | break; | |
410 | } | |
411 | /* fall through */ | |
412 | default: | |
413 | printk(KERN_INFO "%s () failed err=%d\n", | |
414 | e, -ret); | |
415 | goto out; | |
416 | } | |
417 | ||
418 | for (k = 0, temp = 0; k < aead_tv[i].np; k++) { | |
419 | printk(KERN_INFO "page %u\n", k); | |
420 | q = kmap(sg_page(&sg[k])) + sg[k].offset; | |
421 | hexdump(q, aead_tv[i].tap[k]); | |
422 | printk(KERN_INFO "%s\n", | |
423 | memcmp(q, aead_tv[i].result + temp, | |
6160b289 HX |
424 | aead_tv[i].tap[k] - |
425 | (k < aead_tv[i].np - 1 || enc ? | |
426 | 0 : authsize)) ? | |
e3a4ea4f MH |
427 | "fail" : "pass"); |
428 | ||
429 | temp += aead_tv[i].tap[k]; | |
430 | } | |
e3a4ea4f MH |
431 | } |
432 | } | |
433 | ||
434 | out: | |
435 | crypto_free_aead(tfm); | |
436 | aead_request_free(req); | |
437 | } | |
438 | ||
cba83564 | 439 | static void test_cipher(char *algo, int enc, |
ef2736fc | 440 | struct cipher_testvec *template, unsigned int tcount) |
1da177e4 LT |
441 | { |
442 | unsigned int ret, i, j, k, temp; | |
443 | unsigned int tsize; | |
378f058c | 444 | char *q; |
6158efc0 | 445 | struct crypto_ablkcipher *tfm; |
1da177e4 LT |
446 | char *key; |
447 | struct cipher_testvec *cipher_tv; | |
6158efc0 | 448 | struct ablkcipher_request *req; |
1da177e4 | 449 | struct scatterlist sg[8]; |
cba83564 | 450 | const char *e; |
6158efc0 | 451 | struct tcrypt_result result; |
1da177e4 LT |
452 | |
453 | if (enc == ENCRYPT) | |
3cc3816f | 454 | e = "encryption"; |
1da177e4 | 455 | else |
3cc3816f | 456 | e = "decryption"; |
1da177e4 | 457 | |
cba83564 | 458 | printk("\ntesting %s %s\n", algo, e); |
1da177e4 | 459 | |
ef2736fc | 460 | tsize = sizeof (struct cipher_testvec); |
1da177e4 LT |
461 | if (tsize > TVMEMSIZE) { |
462 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
463 | TVMEMSIZE); | |
464 | return; | |
465 | } | |
ef2736fc HX |
466 | cipher_tv = (void *)tvmem; |
467 | ||
6158efc0 HX |
468 | init_completion(&result.completion); |
469 | ||
470 | tfm = crypto_alloc_ablkcipher(algo, 0, 0); | |
1da177e4 | 471 | |
cba83564 HX |
472 | if (IS_ERR(tfm)) { |
473 | printk("failed to load transform for %s: %ld\n", algo, | |
474 | PTR_ERR(tfm)); | |
1da177e4 LT |
475 | return; |
476 | } | |
6158efc0 HX |
477 | |
478 | req = ablkcipher_request_alloc(tfm, GFP_KERNEL); | |
479 | if (!req) { | |
480 | printk("failed to allocate request for %s\n", algo); | |
481 | goto out; | |
482 | } | |
483 | ||
484 | ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, | |
485 | tcrypt_complete, &result); | |
ef2736fc | 486 | |
1da177e4 LT |
487 | j = 0; |
488 | for (i = 0; i < tcount; i++) { | |
6d1a69d5 TSH |
489 | memcpy(cipher_tv, &template[i], tsize); |
490 | if (!(cipher_tv->np)) { | |
ef2736fc | 491 | j++; |
1da177e4 | 492 | printk("test %u (%d bit key):\n", |
6d1a69d5 | 493 | j, cipher_tv->klen * 8); |
1da177e4 | 494 | |
6158efc0 | 495 | crypto_ablkcipher_clear_flags(tfm, ~0); |
6d1a69d5 | 496 | if (cipher_tv->wk) |
6158efc0 | 497 | crypto_ablkcipher_set_flags( |
cba83564 | 498 | tfm, CRYPTO_TFM_REQ_WEAK_KEY); |
6d1a69d5 | 499 | key = cipher_tv->key; |
ef2736fc | 500 | |
6158efc0 | 501 | ret = crypto_ablkcipher_setkey(tfm, key, |
6d1a69d5 | 502 | cipher_tv->klen); |
1da177e4 | 503 | if (ret) { |
cba83564 | 504 | printk("setkey() failed flags=%x\n", |
6158efc0 | 505 | crypto_ablkcipher_get_flags(tfm)); |
ef2736fc | 506 | |
6d1a69d5 | 507 | if (!cipher_tv->fail) |
1da177e4 | 508 | goto out; |
ef2736fc | 509 | } |
1da177e4 | 510 | |
6d1a69d5 TSH |
511 | sg_init_one(&sg[0], cipher_tv->input, |
512 | cipher_tv->ilen); | |
ef2736fc | 513 | |
6158efc0 | 514 | ablkcipher_request_set_crypt(req, sg, sg, |
6d1a69d5 TSH |
515 | cipher_tv->ilen, |
516 | cipher_tv->iv); | |
ef2736fc | 517 | |
cba83564 | 518 | ret = enc ? |
6158efc0 HX |
519 | crypto_ablkcipher_encrypt(req) : |
520 | crypto_ablkcipher_decrypt(req); | |
ef2736fc | 521 | |
6158efc0 HX |
522 | switch (ret) { |
523 | case 0: | |
524 | break; | |
525 | case -EINPROGRESS: | |
526 | case -EBUSY: | |
527 | ret = wait_for_completion_interruptible( | |
528 | &result.completion); | |
529 | if (!ret && !((ret = result.err))) { | |
530 | INIT_COMPLETION(result.completion); | |
531 | break; | |
532 | } | |
533 | /* fall through */ | |
534 | default: | |
535 | printk("%s () failed err=%d\n", e, -ret); | |
1da177e4 | 536 | goto out; |
ef2736fc HX |
537 | } |
538 | ||
78c2f0b8 | 539 | q = kmap(sg_page(&sg[0])) + sg[0].offset; |
6d1a69d5 | 540 | hexdump(q, cipher_tv->rlen); |
ef2736fc HX |
541 | |
542 | printk("%s\n", | |
6d1a69d5 TSH |
543 | memcmp(q, cipher_tv->result, |
544 | cipher_tv->rlen) ? "fail" : "pass"); | |
1da177e4 LT |
545 | } |
546 | } | |
ef2736fc | 547 | |
cba83564 | 548 | printk("\ntesting %s %s across pages (chunking)\n", algo, e); |
1da177e4 | 549 | memset(xbuf, 0, XBUFSIZE); |
ef2736fc | 550 | |
1da177e4 LT |
551 | j = 0; |
552 | for (i = 0; i < tcount; i++) { | |
6d1a69d5 TSH |
553 | memcpy(cipher_tv, &template[i], tsize); |
554 | if (cipher_tv->np) { | |
ef2736fc | 555 | j++; |
1da177e4 | 556 | printk("test %u (%d bit key):\n", |
6d1a69d5 | 557 | j, cipher_tv->klen * 8); |
1da177e4 | 558 | |
6158efc0 | 559 | crypto_ablkcipher_clear_flags(tfm, ~0); |
6d1a69d5 | 560 | if (cipher_tv->wk) |
6158efc0 | 561 | crypto_ablkcipher_set_flags( |
cba83564 | 562 | tfm, CRYPTO_TFM_REQ_WEAK_KEY); |
6d1a69d5 | 563 | key = cipher_tv->key; |
ef2736fc | 564 | |
6158efc0 | 565 | ret = crypto_ablkcipher_setkey(tfm, key, |
6d1a69d5 | 566 | cipher_tv->klen); |
1da177e4 | 567 | if (ret) { |
cba83564 | 568 | printk("setkey() failed flags=%x\n", |
6158efc0 | 569 | crypto_ablkcipher_get_flags(tfm)); |
ef2736fc | 570 | |
6d1a69d5 | 571 | if (!cipher_tv->fail) |
1da177e4 LT |
572 | goto out; |
573 | } | |
574 | ||
575 | temp = 0; | |
6d1a69d5 TSH |
576 | sg_init_table(sg, cipher_tv->np); |
577 | for (k = 0; k < cipher_tv->np; k++) { | |
ef2736fc | 578 | memcpy(&xbuf[IDX[k]], |
6d1a69d5 TSH |
579 | cipher_tv->input + temp, |
580 | cipher_tv->tap[k]); | |
581 | temp += cipher_tv->tap[k]; | |
378f058c | 582 | sg_set_buf(&sg[k], &xbuf[IDX[k]], |
6d1a69d5 | 583 | cipher_tv->tap[k]); |
1da177e4 | 584 | } |
ef2736fc | 585 | |
6158efc0 | 586 | ablkcipher_request_set_crypt(req, sg, sg, |
6d1a69d5 TSH |
587 | cipher_tv->ilen, |
588 | cipher_tv->iv); | |
ef2736fc | 589 | |
cba83564 | 590 | ret = enc ? |
6158efc0 HX |
591 | crypto_ablkcipher_encrypt(req) : |
592 | crypto_ablkcipher_decrypt(req); | |
ef2736fc | 593 | |
6158efc0 HX |
594 | switch (ret) { |
595 | case 0: | |
596 | break; | |
597 | case -EINPROGRESS: | |
598 | case -EBUSY: | |
599 | ret = wait_for_completion_interruptible( | |
600 | &result.completion); | |
601 | if (!ret && !((ret = result.err))) { | |
602 | INIT_COMPLETION(result.completion); | |
603 | break; | |
604 | } | |
605 | /* fall through */ | |
606 | default: | |
607 | printk("%s () failed err=%d\n", e, -ret); | |
1da177e4 LT |
608 | goto out; |
609 | } | |
610 | ||
611 | temp = 0; | |
6d1a69d5 | 612 | for (k = 0; k < cipher_tv->np; k++) { |
1da177e4 | 613 | printk("page %u\n", k); |
78c2f0b8 | 614 | q = kmap(sg_page(&sg[k])) + sg[k].offset; |
6d1a69d5 | 615 | hexdump(q, cipher_tv->tap[k]); |
ef2736fc | 616 | printk("%s\n", |
6d1a69d5 TSH |
617 | memcmp(q, cipher_tv->result + temp, |
618 | cipher_tv->tap[k]) ? "fail" : | |
1da177e4 | 619 | "pass"); |
6d1a69d5 | 620 | temp += cipher_tv->tap[k]; |
1da177e4 LT |
621 | } |
622 | } | |
623 | } | |
624 | ||
625 | out: | |
6158efc0 HX |
626 | crypto_free_ablkcipher(tfm); |
627 | ablkcipher_request_free(req); | |
1da177e4 LT |
628 | } |
629 | ||
cba83564 | 630 | static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p, |
6a17944c HX |
631 | int blen, int sec) |
632 | { | |
6df5b9f4 | 633 | struct scatterlist sg[1]; |
6a17944c HX |
634 | unsigned long start, end; |
635 | int bcount; | |
636 | int ret; | |
637 | ||
b7335885 | 638 | sg_init_one(sg, p, blen); |
6a17944c HX |
639 | |
640 | for (start = jiffies, end = start + sec * HZ, bcount = 0; | |
641 | time_before(jiffies, end); bcount++) { | |
642 | if (enc) | |
cba83564 | 643 | ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); |
6a17944c | 644 | else |
cba83564 | 645 | ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); |
6a17944c HX |
646 | |
647 | if (ret) | |
648 | return ret; | |
649 | } | |
650 | ||
651 | printk("%d operations in %d seconds (%ld bytes)\n", | |
652 | bcount, sec, (long)bcount * blen); | |
653 | return 0; | |
654 | } | |
655 | ||
cba83564 | 656 | static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p, |
6a17944c HX |
657 | int blen) |
658 | { | |
6df5b9f4 | 659 | struct scatterlist sg[1]; |
6a17944c HX |
660 | unsigned long cycles = 0; |
661 | int ret = 0; | |
662 | int i; | |
663 | ||
b7335885 | 664 | sg_init_one(sg, p, blen); |
6a17944c HX |
665 | |
666 | local_bh_disable(); | |
667 | local_irq_disable(); | |
668 | ||
669 | /* Warm-up run. */ | |
670 | for (i = 0; i < 4; i++) { | |
671 | if (enc) | |
cba83564 | 672 | ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); |
6a17944c | 673 | else |
cba83564 | 674 | ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); |
6a17944c HX |
675 | |
676 | if (ret) | |
677 | goto out; | |
678 | } | |
679 | ||
680 | /* The real thing. */ | |
681 | for (i = 0; i < 8; i++) { | |
682 | cycles_t start, end; | |
683 | ||
684 | start = get_cycles(); | |
685 | if (enc) | |
cba83564 | 686 | ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); |
6a17944c | 687 | else |
cba83564 | 688 | ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); |
6a17944c HX |
689 | end = get_cycles(); |
690 | ||
691 | if (ret) | |
692 | goto out; | |
693 | ||
694 | cycles += end - start; | |
695 | } | |
696 | ||
697 | out: | |
698 | local_irq_enable(); | |
699 | local_bh_enable(); | |
700 | ||
701 | if (ret == 0) | |
702 | printk("1 operation in %lu cycles (%d bytes)\n", | |
703 | (cycles + 4) / 8, blen); | |
704 | ||
705 | return ret; | |
706 | } | |
707 | ||
cba83564 | 708 | static void test_cipher_speed(char *algo, int enc, unsigned int sec, |
dce907c0 HX |
709 | struct cipher_testvec *template, |
710 | unsigned int tcount, struct cipher_speed *speed) | |
ebfd9bcf | 711 | { |
dce907c0 | 712 | unsigned int ret, i, j, iv_len; |
ebfd9bcf | 713 | unsigned char *key, *p, iv[128]; |
cba83564 HX |
714 | struct crypto_blkcipher *tfm; |
715 | struct blkcipher_desc desc; | |
716 | const char *e; | |
ebfd9bcf HW |
717 | |
718 | if (enc == ENCRYPT) | |
719 | e = "encryption"; | |
720 | else | |
721 | e = "decryption"; | |
ebfd9bcf | 722 | |
cba83564 | 723 | printk("\ntesting speed of %s %s\n", algo, e); |
ebfd9bcf | 724 | |
cba83564 | 725 | tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); |
ebfd9bcf | 726 | |
cba83564 HX |
727 | if (IS_ERR(tfm)) { |
728 | printk("failed to load transform for %s: %ld\n", algo, | |
729 | PTR_ERR(tfm)); | |
ebfd9bcf HW |
730 | return; |
731 | } | |
cba83564 HX |
732 | desc.tfm = tfm; |
733 | desc.flags = 0; | |
ebfd9bcf HW |
734 | |
735 | for (i = 0; speed[i].klen != 0; i++) { | |
736 | if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) { | |
737 | printk("template (%u) too big for tvmem (%u)\n", | |
738 | speed[i].blen + speed[i].klen, TVMEMSIZE); | |
739 | goto out; | |
740 | } | |
741 | ||
742 | printk("test %u (%d bit key, %d byte blocks): ", i, | |
743 | speed[i].klen * 8, speed[i].blen); | |
744 | ||
745 | memset(tvmem, 0xff, speed[i].klen + speed[i].blen); | |
746 | ||
747 | /* set key, plain text and IV */ | |
748 | key = (unsigned char *)tvmem; | |
dce907c0 HX |
749 | for (j = 0; j < tcount; j++) { |
750 | if (template[j].klen == speed[i].klen) { | |
751 | key = template[j].key; | |
752 | break; | |
753 | } | |
754 | } | |
ebfd9bcf HW |
755 | p = (unsigned char *)tvmem + speed[i].klen; |
756 | ||
cba83564 | 757 | ret = crypto_blkcipher_setkey(tfm, key, speed[i].klen); |
ebfd9bcf | 758 | if (ret) { |
cba83564 HX |
759 | printk("setkey() failed flags=%x\n", |
760 | crypto_blkcipher_get_flags(tfm)); | |
ebfd9bcf HW |
761 | goto out; |
762 | } | |
763 | ||
cba83564 HX |
764 | iv_len = crypto_blkcipher_ivsize(tfm); |
765 | if (iv_len) { | |
ebfd9bcf | 766 | memset(&iv, 0xff, iv_len); |
cba83564 | 767 | crypto_blkcipher_set_iv(tfm, iv, iv_len); |
ebfd9bcf HW |
768 | } |
769 | ||
6a17944c | 770 | if (sec) |
cba83564 | 771 | ret = test_cipher_jiffies(&desc, enc, p, speed[i].blen, |
6a17944c HX |
772 | sec); |
773 | else | |
cba83564 | 774 | ret = test_cipher_cycles(&desc, enc, p, speed[i].blen); |
ebfd9bcf | 775 | |
6a17944c | 776 | if (ret) { |
cba83564 | 777 | printk("%s() failed flags=%x\n", e, desc.flags); |
6a17944c | 778 | break; |
ebfd9bcf | 779 | } |
ebfd9bcf HW |
780 | } |
781 | ||
782 | out: | |
cba83564 | 783 | crypto_free_blkcipher(tfm); |
ebfd9bcf HW |
784 | } |
785 | ||
e9d41164 HX |
786 | static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen, |
787 | char *out, int sec) | |
788 | { | |
789 | struct scatterlist sg[1]; | |
790 | unsigned long start, end; | |
791 | int bcount; | |
792 | int ret; | |
793 | ||
a5a613a4 HX |
794 | sg_init_table(sg, 1); |
795 | ||
e9d41164 HX |
796 | for (start = jiffies, end = start + sec * HZ, bcount = 0; |
797 | time_before(jiffies, end); bcount++) { | |
a5a613a4 | 798 | sg_set_buf(sg, p, blen); |
e9d41164 HX |
799 | ret = crypto_hash_digest(desc, sg, blen, out); |
800 | if (ret) | |
801 | return ret; | |
802 | } | |
803 | ||
804 | printk("%6u opers/sec, %9lu bytes/sec\n", | |
805 | bcount / sec, ((long)bcount * blen) / sec); | |
806 | ||
807 | return 0; | |
808 | } | |
809 | ||
810 | static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen, | |
811 | int plen, char *out, int sec) | |
e8057928 ML |
812 | { |
813 | struct scatterlist sg[1]; | |
814 | unsigned long start, end; | |
815 | int bcount, pcount; | |
e9d41164 HX |
816 | int ret; |
817 | ||
818 | if (plen == blen) | |
819 | return test_hash_jiffies_digest(desc, p, blen, out, sec); | |
e8057928 | 820 | |
a5a613a4 HX |
821 | sg_init_table(sg, 1); |
822 | ||
e8057928 ML |
823 | for (start = jiffies, end = start + sec * HZ, bcount = 0; |
824 | time_before(jiffies, end); bcount++) { | |
e9d41164 HX |
825 | ret = crypto_hash_init(desc); |
826 | if (ret) | |
827 | return ret; | |
e8057928 | 828 | for (pcount = 0; pcount < blen; pcount += plen) { |
a5a613a4 | 829 | sg_set_buf(sg, p + pcount, plen); |
e9d41164 HX |
830 | ret = crypto_hash_update(desc, sg, plen); |
831 | if (ret) | |
832 | return ret; | |
e8057928 ML |
833 | } |
834 | /* we assume there is enough space in 'out' for the result */ | |
e9d41164 HX |
835 | ret = crypto_hash_final(desc, out); |
836 | if (ret) | |
837 | return ret; | |
e8057928 ML |
838 | } |
839 | ||
840 | printk("%6u opers/sec, %9lu bytes/sec\n", | |
841 | bcount / sec, ((long)bcount * blen) / sec); | |
842 | ||
e9d41164 HX |
843 | return 0; |
844 | } | |
845 | ||
846 | static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen, | |
847 | char *out) | |
848 | { | |
849 | struct scatterlist sg[1]; | |
850 | unsigned long cycles = 0; | |
851 | int i; | |
852 | int ret; | |
853 | ||
a5a613a4 HX |
854 | sg_init_table(sg, 1); |
855 | ||
e9d41164 HX |
856 | local_bh_disable(); |
857 | local_irq_disable(); | |
858 | ||
859 | /* Warm-up run. */ | |
860 | for (i = 0; i < 4; i++) { | |
a5a613a4 | 861 | sg_set_buf(sg, p, blen); |
e9d41164 HX |
862 | ret = crypto_hash_digest(desc, sg, blen, out); |
863 | if (ret) | |
864 | goto out; | |
865 | } | |
866 | ||
867 | /* The real thing. */ | |
868 | for (i = 0; i < 8; i++) { | |
869 | cycles_t start, end; | |
870 | ||
871 | start = get_cycles(); | |
872 | ||
a5a613a4 | 873 | sg_set_buf(sg, p, blen); |
e9d41164 HX |
874 | ret = crypto_hash_digest(desc, sg, blen, out); |
875 | if (ret) | |
876 | goto out; | |
877 | ||
878 | end = get_cycles(); | |
879 | ||
880 | cycles += end - start; | |
881 | } | |
882 | ||
883 | out: | |
884 | local_irq_enable(); | |
885 | local_bh_enable(); | |
886 | ||
887 | if (ret) | |
888 | return ret; | |
889 | ||
890 | printk("%6lu cycles/operation, %4lu cycles/byte\n", | |
891 | cycles / 8, cycles / (8 * blen)); | |
892 | ||
893 | return 0; | |
e8057928 ML |
894 | } |
895 | ||
e9d41164 HX |
896 | static int test_hash_cycles(struct hash_desc *desc, char *p, int blen, |
897 | int plen, char *out) | |
e8057928 ML |
898 | { |
899 | struct scatterlist sg[1]; | |
900 | unsigned long cycles = 0; | |
901 | int i, pcount; | |
e9d41164 HX |
902 | int ret; |
903 | ||
904 | if (plen == blen) | |
905 | return test_hash_cycles_digest(desc, p, blen, out); | |
e8057928 | 906 | |
a5a613a4 HX |
907 | sg_init_table(sg, 1); |
908 | ||
e8057928 ML |
909 | local_bh_disable(); |
910 | local_irq_disable(); | |
911 | ||
912 | /* Warm-up run. */ | |
913 | for (i = 0; i < 4; i++) { | |
e9d41164 HX |
914 | ret = crypto_hash_init(desc); |
915 | if (ret) | |
916 | goto out; | |
e8057928 | 917 | for (pcount = 0; pcount < blen; pcount += plen) { |
a5a613a4 | 918 | sg_set_buf(sg, p + pcount, plen); |
e9d41164 HX |
919 | ret = crypto_hash_update(desc, sg, plen); |
920 | if (ret) | |
921 | goto out; | |
e8057928 | 922 | } |
29059d12 | 923 | ret = crypto_hash_final(desc, out); |
e9d41164 HX |
924 | if (ret) |
925 | goto out; | |
e8057928 ML |
926 | } |
927 | ||
928 | /* The real thing. */ | |
929 | for (i = 0; i < 8; i++) { | |
930 | cycles_t start, end; | |
931 | ||
e8057928 ML |
932 | start = get_cycles(); |
933 | ||
e9d41164 HX |
934 | ret = crypto_hash_init(desc); |
935 | if (ret) | |
936 | goto out; | |
e8057928 | 937 | for (pcount = 0; pcount < blen; pcount += plen) { |
a5a613a4 | 938 | sg_set_buf(sg, p + pcount, plen); |
e9d41164 HX |
939 | ret = crypto_hash_update(desc, sg, plen); |
940 | if (ret) | |
941 | goto out; | |
e8057928 | 942 | } |
e9d41164 HX |
943 | ret = crypto_hash_final(desc, out); |
944 | if (ret) | |
945 | goto out; | |
e8057928 ML |
946 | |
947 | end = get_cycles(); | |
948 | ||
949 | cycles += end - start; | |
950 | } | |
951 | ||
e9d41164 | 952 | out: |
e8057928 ML |
953 | local_irq_enable(); |
954 | local_bh_enable(); | |
955 | ||
e9d41164 HX |
956 | if (ret) |
957 | return ret; | |
958 | ||
e8057928 ML |
959 | printk("%6lu cycles/operation, %4lu cycles/byte\n", |
960 | cycles / 8, cycles / (8 * blen)); | |
961 | ||
e9d41164 | 962 | return 0; |
e8057928 ML |
963 | } |
964 | ||
e9d41164 HX |
965 | static void test_hash_speed(char *algo, unsigned int sec, |
966 | struct hash_speed *speed) | |
e8057928 | 967 | { |
e9d41164 HX |
968 | struct crypto_hash *tfm; |
969 | struct hash_desc desc; | |
e8057928 ML |
970 | char output[1024]; |
971 | int i; | |
e9d41164 | 972 | int ret; |
e8057928 ML |
973 | |
974 | printk("\ntesting speed of %s\n", algo); | |
975 | ||
e9d41164 | 976 | tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); |
e8057928 | 977 | |
e9d41164 HX |
978 | if (IS_ERR(tfm)) { |
979 | printk("failed to load transform for %s: %ld\n", algo, | |
980 | PTR_ERR(tfm)); | |
e8057928 ML |
981 | return; |
982 | } | |
983 | ||
e9d41164 HX |
984 | desc.tfm = tfm; |
985 | desc.flags = 0; | |
986 | ||
987 | if (crypto_hash_digestsize(tfm) > sizeof(output)) { | |
e8057928 | 988 | printk("digestsize(%u) > outputbuffer(%zu)\n", |
e9d41164 | 989 | crypto_hash_digestsize(tfm), sizeof(output)); |
e8057928 ML |
990 | goto out; |
991 | } | |
992 | ||
993 | for (i = 0; speed[i].blen != 0; i++) { | |
994 | if (speed[i].blen > TVMEMSIZE) { | |
995 | printk("template (%u) too big for tvmem (%u)\n", | |
996 | speed[i].blen, TVMEMSIZE); | |
997 | goto out; | |
998 | } | |
999 | ||
1000 | printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ", | |
1001 | i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); | |
1002 | ||
1003 | memset(tvmem, 0xff, speed[i].blen); | |
1004 | ||
1005 | if (sec) | |
e9d41164 HX |
1006 | ret = test_hash_jiffies(&desc, tvmem, speed[i].blen, |
1007 | speed[i].plen, output, sec); | |
e8057928 | 1008 | else |
e9d41164 HX |
1009 | ret = test_hash_cycles(&desc, tvmem, speed[i].blen, |
1010 | speed[i].plen, output); | |
1011 | ||
1012 | if (ret) { | |
1013 | printk("hashing failed ret=%d\n", ret); | |
1014 | break; | |
1015 | } | |
e8057928 ML |
1016 | } |
1017 | ||
1018 | out: | |
e9d41164 | 1019 | crypto_free_hash(tfm); |
e8057928 ML |
1020 | } |
1021 | ||
91755a92 ZS |
1022 | static void test_comp(char *algo, struct comp_testvec *ctemplate, |
1023 | struct comp_testvec *dtemplate, int ctcount, int dtcount) | |
1da177e4 LT |
1024 | { |
1025 | unsigned int i; | |
1026 | char result[COMP_BUF_SIZE]; | |
e4d5b79c | 1027 | struct crypto_comp *tfm; |
1da177e4 LT |
1028 | struct comp_testvec *tv; |
1029 | unsigned int tsize; | |
1030 | ||
91755a92 | 1031 | printk("\ntesting %s compression\n", algo); |
1da177e4 | 1032 | |
91755a92 ZS |
1033 | tsize = sizeof(struct comp_testvec); |
1034 | tsize *= ctcount; | |
1da177e4 LT |
1035 | if (tsize > TVMEMSIZE) { |
1036 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
1037 | TVMEMSIZE); | |
1038 | return; | |
1039 | } | |
1040 | ||
91755a92 | 1041 | memcpy(tvmem, ctemplate, tsize); |
ef2736fc | 1042 | tv = (void *)tvmem; |
1da177e4 | 1043 | |
91755a92 | 1044 | tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC); |
7bc301e9 | 1045 | if (IS_ERR(tfm)) { |
91755a92 | 1046 | printk("failed to load transform for %s\n", algo); |
1da177e4 LT |
1047 | return; |
1048 | } | |
1049 | ||
91755a92 | 1050 | for (i = 0; i < ctcount; i++) { |
1da177e4 | 1051 | int ilen, ret, dlen = COMP_BUF_SIZE; |
ef2736fc | 1052 | |
1da177e4 LT |
1053 | printk("test %u:\n", i + 1); |
1054 | memset(result, 0, sizeof (result)); | |
1055 | ||
1056 | ilen = tv[i].inlen; | |
1057 | ret = crypto_comp_compress(tfm, tv[i].input, | |
1058 | ilen, result, &dlen); | |
1059 | if (ret) { | |
1060 | printk("fail: ret=%d\n", ret); | |
1061 | continue; | |
1062 | } | |
1063 | hexdump(result, dlen); | |
1064 | printk("%s (ratio %d:%d)\n", | |
1065 | memcmp(result, tv[i].output, dlen) ? "fail" : "pass", | |
1066 | ilen, dlen); | |
1067 | } | |
1068 | ||
91755a92 | 1069 | printk("\ntesting %s decompression\n", algo); |
1da177e4 | 1070 | |
91755a92 ZS |
1071 | tsize = sizeof(struct comp_testvec); |
1072 | tsize *= dtcount; | |
1da177e4 LT |
1073 | if (tsize > TVMEMSIZE) { |
1074 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
1075 | TVMEMSIZE); | |
1076 | goto out; | |
1077 | } | |
1078 | ||
91755a92 | 1079 | memcpy(tvmem, dtemplate, tsize); |
ef2736fc | 1080 | tv = (void *)tvmem; |
1da177e4 | 1081 | |
91755a92 | 1082 | for (i = 0; i < dtcount; i++) { |
1da177e4 | 1083 | int ilen, ret, dlen = COMP_BUF_SIZE; |
ef2736fc | 1084 | |
1da177e4 LT |
1085 | printk("test %u:\n", i + 1); |
1086 | memset(result, 0, sizeof (result)); | |
1087 | ||
1088 | ilen = tv[i].inlen; | |
1089 | ret = crypto_comp_decompress(tfm, tv[i].input, | |
1090 | ilen, result, &dlen); | |
1091 | if (ret) { | |
1092 | printk("fail: ret=%d\n", ret); | |
1093 | continue; | |
1094 | } | |
1095 | hexdump(result, dlen); | |
1096 | printk("%s (ratio %d:%d)\n", | |
1097 | memcmp(result, tv[i].output, dlen) ? "fail" : "pass", | |
1098 | ilen, dlen); | |
1099 | } | |
1100 | out: | |
e4d5b79c | 1101 | crypto_free_comp(tfm); |
1da177e4 LT |
1102 | } |
1103 | ||
ef2736fc | 1104 | static void test_available(void) |
1da177e4 LT |
1105 | { |
1106 | char **name = check; | |
ef2736fc | 1107 | |
1da177e4 LT |
1108 | while (*name) { |
1109 | printk("alg %s ", *name); | |
6158efc0 | 1110 | printk(crypto_has_alg(*name, 0, 0) ? |
e4d5b79c | 1111 | "found\n" : "not found\n"); |
1da177e4 | 1112 | name++; |
ef2736fc | 1113 | } |
1da177e4 LT |
1114 | } |
1115 | ||
ef2736fc | 1116 | static void do_test(void) |
1da177e4 LT |
1117 | { |
1118 | switch (mode) { | |
1119 | ||
1120 | case 0: | |
1121 | test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); | |
ef2736fc | 1122 | |
1da177e4 | 1123 | test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); |
ef2736fc | 1124 | |
1da177e4 | 1125 | //DES |
cba83564 HX |
1126 | test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template, |
1127 | DES_ENC_TEST_VECTORS); | |
1128 | test_cipher("ecb(des)", DECRYPT, des_dec_tv_template, | |
1129 | DES_DEC_TEST_VECTORS); | |
1130 | test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template, | |
1131 | DES_CBC_ENC_TEST_VECTORS); | |
1132 | test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template, | |
1133 | DES_CBC_DEC_TEST_VECTORS); | |
ef2736fc | 1134 | |
1da177e4 | 1135 | //DES3_EDE |
cba83564 HX |
1136 | test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template, |
1137 | DES3_EDE_ENC_TEST_VECTORS); | |
1138 | test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template, | |
1139 | DES3_EDE_DEC_TEST_VECTORS); | |
ef2736fc | 1140 | |
1da177e4 | 1141 | test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); |
ef2736fc | 1142 | |
cd12fb90 JL |
1143 | test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS); |
1144 | ||
1da177e4 | 1145 | test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); |
ef2736fc | 1146 | |
1da177e4 | 1147 | //BLOWFISH |
cba83564 HX |
1148 | test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template, |
1149 | BF_ENC_TEST_VECTORS); | |
1150 | test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template, | |
1151 | BF_DEC_TEST_VECTORS); | |
1152 | test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template, | |
1153 | BF_CBC_ENC_TEST_VECTORS); | |
1154 | test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template, | |
1155 | BF_CBC_DEC_TEST_VECTORS); | |
ef2736fc | 1156 | |
1da177e4 | 1157 | //TWOFISH |
cba83564 HX |
1158 | test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template, |
1159 | TF_ENC_TEST_VECTORS); | |
1160 | test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template, | |
1161 | TF_DEC_TEST_VECTORS); | |
1162 | test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template, | |
1163 | TF_CBC_ENC_TEST_VECTORS); | |
1164 | test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template, | |
1165 | TF_CBC_DEC_TEST_VECTORS); | |
ef2736fc | 1166 | |
1da177e4 | 1167 | //SERPENT |
cba83564 HX |
1168 | test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template, |
1169 | SERPENT_ENC_TEST_VECTORS); | |
1170 | test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template, | |
1171 | SERPENT_DEC_TEST_VECTORS); | |
ef2736fc | 1172 | |
1da177e4 | 1173 | //TNEPRES |
cba83564 HX |
1174 | test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template, |
1175 | TNEPRES_ENC_TEST_VECTORS); | |
1176 | test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template, | |
1177 | TNEPRES_DEC_TEST_VECTORS); | |
1da177e4 LT |
1178 | |
1179 | //AES | |
cba83564 HX |
1180 | test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template, |
1181 | AES_ENC_TEST_VECTORS); | |
1182 | test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template, | |
1183 | AES_DEC_TEST_VECTORS); | |
1184 | test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template, | |
1185 | AES_CBC_ENC_TEST_VECTORS); | |
1186 | test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template, | |
1187 | AES_CBC_DEC_TEST_VECTORS); | |
f3d1044c RS |
1188 | test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template, |
1189 | AES_LRW_ENC_TEST_VECTORS); | |
1190 | test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template, | |
1191 | AES_LRW_DEC_TEST_VECTORS); | |
f19f5111 RS |
1192 | test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template, |
1193 | AES_XTS_ENC_TEST_VECTORS); | |
1194 | test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template, | |
1195 | AES_XTS_DEC_TEST_VECTORS); | |
41fdab3d | 1196 | test_cipher("ctr(aes,4,8,4)", ENCRYPT, aes_ctr_enc_tv_template, |
23e353c8 | 1197 | AES_CTR_ENC_TEST_VECTORS); |
41fdab3d | 1198 | test_cipher("ctr(aes,4,8,4)", DECRYPT, aes_ctr_dec_tv_template, |
23e353c8 | 1199 | AES_CTR_DEC_TEST_VECTORS); |
28db8e3e MH |
1200 | test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template, |
1201 | AES_GCM_ENC_TEST_VECTORS); | |
1202 | test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template, | |
1203 | AES_GCM_DEC_TEST_VECTORS); | |
1da177e4 LT |
1204 | |
1205 | //CAST5 | |
cba83564 HX |
1206 | test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template, |
1207 | CAST5_ENC_TEST_VECTORS); | |
1208 | test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template, | |
1209 | CAST5_DEC_TEST_VECTORS); | |
ef2736fc | 1210 | |
1da177e4 | 1211 | //CAST6 |
cba83564 HX |
1212 | test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template, |
1213 | CAST6_ENC_TEST_VECTORS); | |
1214 | test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template, | |
1215 | CAST6_DEC_TEST_VECTORS); | |
1da177e4 LT |
1216 | |
1217 | //ARC4 | |
cba83564 HX |
1218 | test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template, |
1219 | ARC4_ENC_TEST_VECTORS); | |
1220 | test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template, | |
1221 | ARC4_DEC_TEST_VECTORS); | |
1da177e4 LT |
1222 | |
1223 | //TEA | |
cba83564 HX |
1224 | test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template, |
1225 | TEA_ENC_TEST_VECTORS); | |
1226 | test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template, | |
1227 | TEA_DEC_TEST_VECTORS); | |
1da177e4 LT |
1228 | |
1229 | ||
1230 | //XTEA | |
cba83564 HX |
1231 | test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template, |
1232 | XTEA_ENC_TEST_VECTORS); | |
1233 | test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template, | |
1234 | XTEA_DEC_TEST_VECTORS); | |
1da177e4 LT |
1235 | |
1236 | //KHAZAD | |
cba83564 HX |
1237 | test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template, |
1238 | KHAZAD_ENC_TEST_VECTORS); | |
1239 | test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template, | |
1240 | KHAZAD_DEC_TEST_VECTORS); | |
1da177e4 LT |
1241 | |
1242 | //ANUBIS | |
cba83564 HX |
1243 | test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template, |
1244 | ANUBIS_ENC_TEST_VECTORS); | |
1245 | test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template, | |
1246 | ANUBIS_DEC_TEST_VECTORS); | |
1247 | test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template, | |
1248 | ANUBIS_CBC_ENC_TEST_VECTORS); | |
1249 | test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template, | |
1250 | ANUBIS_CBC_ENC_TEST_VECTORS); | |
1da177e4 | 1251 | |
fb4f10ed | 1252 | //XETA |
cba83564 HX |
1253 | test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template, |
1254 | XETA_ENC_TEST_VECTORS); | |
1255 | test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template, | |
1256 | XETA_DEC_TEST_VECTORS); | |
fb4f10ed | 1257 | |
90831639 DH |
1258 | //FCrypt |
1259 | test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template, | |
1260 | FCRYPT_ENC_TEST_VECTORS); | |
1261 | test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template, | |
1262 | FCRYPT_DEC_TEST_VECTORS); | |
1263 | ||
02ab5a70 NT |
1264 | //CAMELLIA |
1265 | test_cipher("ecb(camellia)", ENCRYPT, | |
1266 | camellia_enc_tv_template, | |
1267 | CAMELLIA_ENC_TEST_VECTORS); | |
1268 | test_cipher("ecb(camellia)", DECRYPT, | |
1269 | camellia_dec_tv_template, | |
1270 | CAMELLIA_DEC_TEST_VECTORS); | |
1271 | test_cipher("cbc(camellia)", ENCRYPT, | |
1272 | camellia_cbc_enc_tv_template, | |
1273 | CAMELLIA_CBC_ENC_TEST_VECTORS); | |
1274 | test_cipher("cbc(camellia)", DECRYPT, | |
1275 | camellia_cbc_dec_tv_template, | |
1276 | CAMELLIA_CBC_DEC_TEST_VECTORS); | |
1277 | ||
e2ee95b8 HSC |
1278 | //SEED |
1279 | test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template, | |
1280 | SEED_ENC_TEST_VECTORS); | |
1281 | test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template, | |
1282 | SEED_DEC_TEST_VECTORS); | |
1283 | ||
1da177e4 LT |
1284 | test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); |
1285 | test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); | |
1286 | test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); | |
1287 | test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); | |
1288 | test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); | |
1289 | test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); | |
1290 | test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); | |
1291 | test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); | |
91755a92 ZS |
1292 | test_comp("deflate", deflate_comp_tv_template, |
1293 | deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS, | |
1294 | DEFLATE_DECOMP_TEST_VECTORS); | |
0b77abb3 ZS |
1295 | test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template, |
1296 | LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS); | |
c907ee76 | 1297 | test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS); |
e9d41164 HX |
1298 | test_hash("hmac(md5)", hmac_md5_tv_template, |
1299 | HMAC_MD5_TEST_VECTORS); | |
1300 | test_hash("hmac(sha1)", hmac_sha1_tv_template, | |
1301 | HMAC_SHA1_TEST_VECTORS); | |
cd12fb90 JL |
1302 | test_hash("hmac(sha224)", hmac_sha224_tv_template, |
1303 | HMAC_SHA224_TEST_VECTORS); | |
e9d41164 HX |
1304 | test_hash("hmac(sha256)", hmac_sha256_tv_template, |
1305 | HMAC_SHA256_TEST_VECTORS); | |
a28091ae AD |
1306 | test_hash("hmac(sha384)", hmac_sha384_tv_template, |
1307 | HMAC_SHA384_TEST_VECTORS); | |
1308 | test_hash("hmac(sha512)", hmac_sha512_tv_template, | |
1309 | HMAC_SHA512_TEST_VECTORS); | |
1da177e4 | 1310 | |
5b2becf5 KM |
1311 | test_hash("xcbc(aes)", aes_xcbc128_tv_template, |
1312 | XCBC_AES_TEST_VECTORS); | |
1313 | ||
1da177e4 LT |
1314 | test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); |
1315 | break; | |
1316 | ||
1317 | case 1: | |
1318 | test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); | |
1319 | break; | |
1320 | ||
1321 | case 2: | |
1322 | test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); | |
1323 | break; | |
1324 | ||
1325 | case 3: | |
cba83564 HX |
1326 | test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template, |
1327 | DES_ENC_TEST_VECTORS); | |
1328 | test_cipher("ecb(des)", DECRYPT, des_dec_tv_template, | |
1329 | DES_DEC_TEST_VECTORS); | |
1330 | test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template, | |
1331 | DES_CBC_ENC_TEST_VECTORS); | |
1332 | test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template, | |
1333 | DES_CBC_DEC_TEST_VECTORS); | |
1da177e4 LT |
1334 | break; |
1335 | ||
1336 | case 4: | |
cba83564 HX |
1337 | test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template, |
1338 | DES3_EDE_ENC_TEST_VECTORS); | |
1339 | test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template, | |
1340 | DES3_EDE_DEC_TEST_VECTORS); | |
1da177e4 LT |
1341 | break; |
1342 | ||
1343 | case 5: | |
1344 | test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); | |
1345 | break; | |
ef2736fc | 1346 | |
1da177e4 LT |
1347 | case 6: |
1348 | test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); | |
1349 | break; | |
ef2736fc | 1350 | |
1da177e4 | 1351 | case 7: |
cba83564 HX |
1352 | test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template, |
1353 | BF_ENC_TEST_VECTORS); | |
1354 | test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template, | |
1355 | BF_DEC_TEST_VECTORS); | |
1356 | test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template, | |
1357 | BF_CBC_ENC_TEST_VECTORS); | |
1358 | test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template, | |
1359 | BF_CBC_DEC_TEST_VECTORS); | |
1da177e4 LT |
1360 | break; |
1361 | ||
1362 | case 8: | |
cba83564 HX |
1363 | test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template, |
1364 | TF_ENC_TEST_VECTORS); | |
1365 | test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template, | |
1366 | TF_DEC_TEST_VECTORS); | |
1367 | test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template, | |
1368 | TF_CBC_ENC_TEST_VECTORS); | |
1369 | test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template, | |
1370 | TF_CBC_DEC_TEST_VECTORS); | |
1da177e4 | 1371 | break; |
ef2736fc | 1372 | |
1da177e4 | 1373 | case 9: |
cba83564 HX |
1374 | test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template, |
1375 | SERPENT_ENC_TEST_VECTORS); | |
1376 | test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template, | |
1377 | SERPENT_DEC_TEST_VECTORS); | |
1da177e4 LT |
1378 | break; |
1379 | ||
1380 | case 10: | |
cba83564 HX |
1381 | test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template, |
1382 | AES_ENC_TEST_VECTORS); | |
1383 | test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template, | |
1384 | AES_DEC_TEST_VECTORS); | |
1385 | test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template, | |
1386 | AES_CBC_ENC_TEST_VECTORS); | |
1387 | test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template, | |
1388 | AES_CBC_DEC_TEST_VECTORS); | |
f3d1044c RS |
1389 | test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template, |
1390 | AES_LRW_ENC_TEST_VECTORS); | |
1391 | test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template, | |
1392 | AES_LRW_DEC_TEST_VECTORS); | |
f19f5111 RS |
1393 | test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template, |
1394 | AES_XTS_ENC_TEST_VECTORS); | |
1395 | test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template, | |
1396 | AES_XTS_DEC_TEST_VECTORS); | |
41fdab3d | 1397 | test_cipher("ctr(aes,4,8,4)", ENCRYPT, aes_ctr_enc_tv_template, |
23e353c8 | 1398 | AES_CTR_ENC_TEST_VECTORS); |
41fdab3d | 1399 | test_cipher("ctr(aes,4,8,4)", DECRYPT, aes_ctr_dec_tv_template, |
23e353c8 | 1400 | AES_CTR_DEC_TEST_VECTORS); |
1da177e4 LT |
1401 | break; |
1402 | ||
1403 | case 11: | |
1404 | test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); | |
1405 | break; | |
ef2736fc | 1406 | |
1da177e4 LT |
1407 | case 12: |
1408 | test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); | |
1409 | break; | |
1410 | ||
1411 | case 13: | |
91755a92 ZS |
1412 | test_comp("deflate", deflate_comp_tv_template, |
1413 | deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS, | |
1414 | DEFLATE_DECOMP_TEST_VECTORS); | |
1da177e4 LT |
1415 | break; |
1416 | ||
1417 | case 14: | |
cba83564 HX |
1418 | test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template, |
1419 | CAST5_ENC_TEST_VECTORS); | |
1420 | test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template, | |
1421 | CAST5_DEC_TEST_VECTORS); | |
1da177e4 LT |
1422 | break; |
1423 | ||
1424 | case 15: | |
cba83564 HX |
1425 | test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template, |
1426 | CAST6_ENC_TEST_VECTORS); | |
1427 | test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template, | |
1428 | CAST6_DEC_TEST_VECTORS); | |
1da177e4 LT |
1429 | break; |
1430 | ||
1431 | case 16: | |
cba83564 HX |
1432 | test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template, |
1433 | ARC4_ENC_TEST_VECTORS); | |
1434 | test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template, | |
1435 | ARC4_DEC_TEST_VECTORS); | |
1da177e4 LT |
1436 | break; |
1437 | ||
1438 | case 17: | |
1439 | test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); | |
1440 | break; | |
1441 | ||
1442 | case 18: | |
c907ee76 | 1443 | test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS); |
1da177e4 LT |
1444 | break; |
1445 | ||
1446 | case 19: | |
cba83564 HX |
1447 | test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template, |
1448 | TEA_ENC_TEST_VECTORS); | |
1449 | test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template, | |
1450 | TEA_DEC_TEST_VECTORS); | |
1da177e4 LT |
1451 | break; |
1452 | ||
1453 | case 20: | |
cba83564 HX |
1454 | test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template, |
1455 | XTEA_ENC_TEST_VECTORS); | |
1456 | test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template, | |
1457 | XTEA_DEC_TEST_VECTORS); | |
1da177e4 LT |
1458 | break; |
1459 | ||
1460 | case 21: | |
cba83564 HX |
1461 | test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template, |
1462 | KHAZAD_ENC_TEST_VECTORS); | |
1463 | test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template, | |
1464 | KHAZAD_DEC_TEST_VECTORS); | |
1da177e4 LT |
1465 | break; |
1466 | ||
1467 | case 22: | |
1468 | test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); | |
1469 | break; | |
1470 | ||
1471 | case 23: | |
1472 | test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); | |
1473 | break; | |
1474 | ||
1475 | case 24: | |
1476 | test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); | |
1477 | break; | |
1478 | ||
1479 | case 25: | |
cba83564 HX |
1480 | test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template, |
1481 | TNEPRES_ENC_TEST_VECTORS); | |
1482 | test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template, | |
1483 | TNEPRES_DEC_TEST_VECTORS); | |
1da177e4 LT |
1484 | break; |
1485 | ||
1486 | case 26: | |
cba83564 HX |
1487 | test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template, |
1488 | ANUBIS_ENC_TEST_VECTORS); | |
1489 | test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template, | |
1490 | ANUBIS_DEC_TEST_VECTORS); | |
1491 | test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template, | |
1492 | ANUBIS_CBC_ENC_TEST_VECTORS); | |
1493 | test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template, | |
1494 | ANUBIS_CBC_ENC_TEST_VECTORS); | |
1da177e4 LT |
1495 | break; |
1496 | ||
1497 | case 27: | |
1498 | test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); | |
1499 | break; | |
1500 | ||
1501 | case 28: | |
1502 | ||
1503 | test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); | |
1504 | break; | |
1505 | ||
1506 | case 29: | |
1507 | test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); | |
1508 | break; | |
fb4f10ed AG |
1509 | |
1510 | case 30: | |
cba83564 HX |
1511 | test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template, |
1512 | XETA_ENC_TEST_VECTORS); | |
1513 | test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template, | |
1514 | XETA_DEC_TEST_VECTORS); | |
fb4f10ed | 1515 | break; |
1da177e4 | 1516 | |
90831639 DH |
1517 | case 31: |
1518 | test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template, | |
1519 | FCRYPT_ENC_TEST_VECTORS); | |
1520 | test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template, | |
1521 | FCRYPT_DEC_TEST_VECTORS); | |
1522 | break; | |
1523 | ||
02ab5a70 NT |
1524 | case 32: |
1525 | test_cipher("ecb(camellia)", ENCRYPT, | |
1526 | camellia_enc_tv_template, | |
1527 | CAMELLIA_ENC_TEST_VECTORS); | |
1528 | test_cipher("ecb(camellia)", DECRYPT, | |
1529 | camellia_dec_tv_template, | |
1530 | CAMELLIA_DEC_TEST_VECTORS); | |
1531 | test_cipher("cbc(camellia)", ENCRYPT, | |
1532 | camellia_cbc_enc_tv_template, | |
1533 | CAMELLIA_CBC_ENC_TEST_VECTORS); | |
1534 | test_cipher("cbc(camellia)", DECRYPT, | |
1535 | camellia_cbc_dec_tv_template, | |
1536 | CAMELLIA_CBC_DEC_TEST_VECTORS); | |
1537 | break; | |
cd12fb90 JL |
1538 | case 33: |
1539 | test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS); | |
1540 | break; | |
02ab5a70 | 1541 | |
2407d608 TSH |
1542 | case 34: |
1543 | test_cipher("salsa20", ENCRYPT, | |
1544 | salsa20_stream_enc_tv_template, | |
1545 | SALSA20_STREAM_ENC_TEST_VECTORS); | |
1546 | break; | |
1547 | ||
8df213d9 HX |
1548 | case 35: |
1549 | test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template, | |
1550 | AES_GCM_ENC_TEST_VECTORS); | |
1551 | test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template, | |
1552 | AES_GCM_DEC_TEST_VECTORS); | |
1553 | break; | |
1554 | ||
0b77abb3 ZS |
1555 | case 36: |
1556 | test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template, | |
1557 | LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS); | |
1558 | break; | |
1559 | ||
1da177e4 | 1560 | case 100: |
e9d41164 HX |
1561 | test_hash("hmac(md5)", hmac_md5_tv_template, |
1562 | HMAC_MD5_TEST_VECTORS); | |
1da177e4 | 1563 | break; |
ef2736fc | 1564 | |
1da177e4 | 1565 | case 101: |
e9d41164 HX |
1566 | test_hash("hmac(sha1)", hmac_sha1_tv_template, |
1567 | HMAC_SHA1_TEST_VECTORS); | |
1da177e4 | 1568 | break; |
ef2736fc | 1569 | |
1da177e4 | 1570 | case 102: |
e9d41164 HX |
1571 | test_hash("hmac(sha256)", hmac_sha256_tv_template, |
1572 | HMAC_SHA256_TEST_VECTORS); | |
1da177e4 LT |
1573 | break; |
1574 | ||
a28091ae AD |
1575 | case 103: |
1576 | test_hash("hmac(sha384)", hmac_sha384_tv_template, | |
1577 | HMAC_SHA384_TEST_VECTORS); | |
1578 | break; | |
1579 | ||
1580 | case 104: | |
1581 | test_hash("hmac(sha512)", hmac_sha512_tv_template, | |
1582 | HMAC_SHA512_TEST_VECTORS); | |
1583 | break; | |
cd12fb90 JL |
1584 | case 105: |
1585 | test_hash("hmac(sha224)", hmac_sha224_tv_template, | |
1586 | HMAC_SHA224_TEST_VECTORS); | |
1587 | break; | |
1da177e4 | 1588 | |
ebfd9bcf | 1589 | case 200: |
cba83564 | 1590 | test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1591 | aes_speed_template); |
cba83564 | 1592 | test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1593 | aes_speed_template); |
cba83564 | 1594 | test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1595 | aes_speed_template); |
cba83564 | 1596 | test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1597 | aes_speed_template); |
f3d1044c RS |
1598 | test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, |
1599 | aes_lrw_speed_template); | |
1600 | test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, | |
1601 | aes_lrw_speed_template); | |
f19f5111 RS |
1602 | test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, |
1603 | aes_xts_speed_template); | |
1604 | test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, | |
1605 | aes_xts_speed_template); | |
ebfd9bcf HW |
1606 | break; |
1607 | ||
1608 | case 201: | |
cba83564 | 1609 | test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, |
dce907c0 HX |
1610 | des3_ede_enc_tv_template, |
1611 | DES3_EDE_ENC_TEST_VECTORS, | |
1612 | des3_ede_speed_template); | |
cba83564 | 1613 | test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, |
dce907c0 HX |
1614 | des3_ede_dec_tv_template, |
1615 | DES3_EDE_DEC_TEST_VECTORS, | |
1616 | des3_ede_speed_template); | |
cba83564 | 1617 | test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, |
dce907c0 HX |
1618 | des3_ede_enc_tv_template, |
1619 | DES3_EDE_ENC_TEST_VECTORS, | |
1620 | des3_ede_speed_template); | |
cba83564 | 1621 | test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, |
dce907c0 HX |
1622 | des3_ede_dec_tv_template, |
1623 | DES3_EDE_DEC_TEST_VECTORS, | |
1624 | des3_ede_speed_template); | |
ebfd9bcf HW |
1625 | break; |
1626 | ||
1627 | case 202: | |
cba83564 | 1628 | test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1629 | twofish_speed_template); |
cba83564 | 1630 | test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1631 | twofish_speed_template); |
cba83564 | 1632 | test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1633 | twofish_speed_template); |
cba83564 | 1634 | test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1635 | twofish_speed_template); |
ebfd9bcf HW |
1636 | break; |
1637 | ||
1638 | case 203: | |
cba83564 | 1639 | test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1640 | blowfish_speed_template); |
cba83564 | 1641 | test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1642 | blowfish_speed_template); |
cba83564 | 1643 | test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1644 | blowfish_speed_template); |
cba83564 | 1645 | test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1646 | blowfish_speed_template); |
ebfd9bcf HW |
1647 | break; |
1648 | ||
1649 | case 204: | |
cba83564 | 1650 | test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1651 | des_speed_template); |
cba83564 | 1652 | test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1653 | des_speed_template); |
cba83564 | 1654 | test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, |
dce907c0 | 1655 | des_speed_template); |
cba83564 | 1656 | test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, |
dce907c0 | 1657 | des_speed_template); |
ebfd9bcf HW |
1658 | break; |
1659 | ||
02ab5a70 NT |
1660 | case 205: |
1661 | test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, | |
1662 | camellia_speed_template); | |
1663 | test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, | |
1664 | camellia_speed_template); | |
1665 | test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, | |
1666 | camellia_speed_template); | |
1667 | test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, | |
1668 | camellia_speed_template); | |
1669 | break; | |
1670 | ||
5de8f1b5 TSH |
1671 | case 206: |
1672 | test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, | |
1673 | salsa20_speed_template); | |
1674 | break; | |
1675 | ||
e8057928 ML |
1676 | case 300: |
1677 | /* fall through */ | |
1678 | ||
1679 | case 301: | |
e9d41164 | 1680 | test_hash_speed("md4", sec, generic_hash_speed_template); |
e8057928 ML |
1681 | if (mode > 300 && mode < 400) break; |
1682 | ||
1683 | case 302: | |
e9d41164 | 1684 | test_hash_speed("md5", sec, generic_hash_speed_template); |
e8057928 ML |
1685 | if (mode > 300 && mode < 400) break; |
1686 | ||
1687 | case 303: | |
e9d41164 | 1688 | test_hash_speed("sha1", sec, generic_hash_speed_template); |
e8057928 ML |
1689 | if (mode > 300 && mode < 400) break; |
1690 | ||
1691 | case 304: | |
e9d41164 | 1692 | test_hash_speed("sha256", sec, generic_hash_speed_template); |
e8057928 ML |
1693 | if (mode > 300 && mode < 400) break; |
1694 | ||
1695 | case 305: | |
e9d41164 | 1696 | test_hash_speed("sha384", sec, generic_hash_speed_template); |
e8057928 ML |
1697 | if (mode > 300 && mode < 400) break; |
1698 | ||
1699 | case 306: | |
e9d41164 | 1700 | test_hash_speed("sha512", sec, generic_hash_speed_template); |
e8057928 ML |
1701 | if (mode > 300 && mode < 400) break; |
1702 | ||
1703 | case 307: | |
e9d41164 | 1704 | test_hash_speed("wp256", sec, generic_hash_speed_template); |
e8057928 ML |
1705 | if (mode > 300 && mode < 400) break; |
1706 | ||
1707 | case 308: | |
e9d41164 | 1708 | test_hash_speed("wp384", sec, generic_hash_speed_template); |
e8057928 ML |
1709 | if (mode > 300 && mode < 400) break; |
1710 | ||
1711 | case 309: | |
e9d41164 | 1712 | test_hash_speed("wp512", sec, generic_hash_speed_template); |
e8057928 ML |
1713 | if (mode > 300 && mode < 400) break; |
1714 | ||
1715 | case 310: | |
e9d41164 | 1716 | test_hash_speed("tgr128", sec, generic_hash_speed_template); |
e8057928 ML |
1717 | if (mode > 300 && mode < 400) break; |
1718 | ||
1719 | case 311: | |
e9d41164 | 1720 | test_hash_speed("tgr160", sec, generic_hash_speed_template); |
e8057928 ML |
1721 | if (mode > 300 && mode < 400) break; |
1722 | ||
1723 | case 312: | |
e9d41164 | 1724 | test_hash_speed("tgr192", sec, generic_hash_speed_template); |
e8057928 ML |
1725 | if (mode > 300 && mode < 400) break; |
1726 | ||
cd12fb90 JL |
1727 | case 313: |
1728 | test_hash_speed("sha224", sec, generic_hash_speed_template); | |
1729 | if (mode > 300 && mode < 400) break; | |
1730 | ||
e8057928 ML |
1731 | case 399: |
1732 | break; | |
1733 | ||
1da177e4 LT |
1734 | case 1000: |
1735 | test_available(); | |
1736 | break; | |
ef2736fc | 1737 | |
1da177e4 LT |
1738 | default: |
1739 | /* useful for debugging */ | |
1740 | printk("not testing anything\n"); | |
1741 | break; | |
1742 | } | |
1743 | } | |
1744 | ||
ef2736fc | 1745 | static int __init init(void) |
1da177e4 | 1746 | { |
e3a4ea4f MH |
1747 | int err = -ENOMEM; |
1748 | ||
1da177e4 LT |
1749 | tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); |
1750 | if (tvmem == NULL) | |
e3a4ea4f | 1751 | return err; |
1da177e4 LT |
1752 | |
1753 | xbuf = kmalloc(XBUFSIZE, GFP_KERNEL); | |
e3a4ea4f MH |
1754 | if (xbuf == NULL) |
1755 | goto err_free_tv; | |
1da177e4 | 1756 | |
e3a4ea4f MH |
1757 | axbuf = kmalloc(XBUFSIZE, GFP_KERNEL); |
1758 | if (axbuf == NULL) | |
1759 | goto err_free_xbuf; | |
1da177e4 | 1760 | |
e3a4ea4f | 1761 | do_test(); |
14fdf477 ML |
1762 | |
1763 | /* We intentionaly return -EAGAIN to prevent keeping | |
1764 | * the module. It does all its work from init() | |
1765 | * and doesn't offer any runtime functionality | |
1766 | * => we don't need it in the memory, do we? | |
1767 | * -- mludvig | |
1768 | */ | |
e3a4ea4f MH |
1769 | err = -EAGAIN; |
1770 | ||
1771 | kfree(axbuf); | |
1772 | err_free_xbuf: | |
1773 | kfree(xbuf); | |
1774 | err_free_tv: | |
1775 | kfree(tvmem); | |
1776 | ||
1777 | return err; | |
1da177e4 LT |
1778 | } |
1779 | ||
1780 | /* | |
1781 | * If an init function is provided, an exit function must also be provided | |
1782 | * to allow module unload. | |
1783 | */ | |
1784 | static void __exit fini(void) { } | |
1785 | ||
1786 | module_init(init); | |
1787 | module_exit(fini); | |
1788 | ||
1789 | module_param(mode, int, 0); | |
ebfd9bcf | 1790 | module_param(sec, uint, 0); |
6a17944c HX |
1791 | MODULE_PARM_DESC(sec, "Length in seconds of speed tests " |
1792 | "(defaults to zero which uses CPU cycles instead)"); | |
1da177e4 LT |
1793 | |
1794 | MODULE_LICENSE("GPL"); | |
1795 | MODULE_DESCRIPTION("Quick & dirty crypto testing module"); | |
1796 | MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); |