Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | * 14 - 09 - 2003 | |
16 | * Rewritten by Kartikey Mahendra Bhatt | |
17 | */ | |
18 | ||
19 | #include <linux/init.h> | |
20 | #include <linux/module.h> | |
21 | #include <linux/mm.h> | |
22 | #include <linux/slab.h> | |
23 | #include <asm/scatterlist.h> | |
24 | #include <linux/string.h> | |
25 | #include <linux/crypto.h> | |
26 | #include <linux/highmem.h> | |
27 | #include <linux/moduleparam.h> | |
28 | #include "tcrypt.h" | |
29 | ||
30 | /* | |
31 | * Need to kmalloc() memory for testing kmap(). | |
32 | */ | |
33 | #define TVMEMSIZE 4096 | |
34 | #define XBUFSIZE 32768 | |
35 | ||
36 | /* | |
37 | * Indexes into the xbuf to simulate cross-page access. | |
38 | */ | |
39 | #define IDX1 37 | |
40 | #define IDX2 32400 | |
41 | #define IDX3 1 | |
42 | #define IDX4 8193 | |
43 | #define IDX5 22222 | |
44 | #define IDX6 17101 | |
45 | #define IDX7 27333 | |
46 | #define IDX8 3000 | |
47 | ||
48 | /* | |
49 | * Used by test_cipher() | |
50 | */ | |
51 | #define ENCRYPT 1 | |
52 | #define DECRYPT 0 | |
53 | #define MODE_ECB 1 | |
54 | #define MODE_CBC 0 | |
55 | ||
56 | static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; | |
57 | ||
58 | static int mode; | |
59 | static char *xbuf; | |
60 | static char *tvmem; | |
61 | ||
62 | static char *check[] = { | |
63 | "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish", | |
64 | "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6", | |
65 | "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", | |
66 | "khazad", "wp512", "wp384", "wp256", "tnepres", NULL | |
67 | }; | |
68 | ||
69 | static void | |
70 | hexdump(unsigned char *buf, unsigned int len) | |
71 | { | |
72 | while (len--) | |
73 | printk("%02x", *buf++); | |
74 | ||
75 | printk("\n"); | |
76 | } | |
77 | ||
78 | static void | |
79 | test_hash (char * algo, struct hash_testvec * template, unsigned int tcount) | |
80 | { | |
81 | char *p; | |
82 | unsigned int i, j, k, temp; | |
83 | struct scatterlist sg[8]; | |
84 | char result[64]; | |
85 | struct crypto_tfm *tfm; | |
86 | struct hash_testvec *hash_tv; | |
87 | unsigned int tsize; | |
88 | ||
89 | printk("\ntesting %s\n", algo); | |
90 | ||
91 | tsize = sizeof (struct hash_testvec); | |
92 | tsize *= tcount; | |
93 | ||
94 | if (tsize > TVMEMSIZE) { | |
95 | printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE); | |
96 | return; | |
97 | } | |
98 | ||
99 | memcpy(tvmem, template, tsize); | |
100 | hash_tv = (void *) tvmem; | |
101 | tfm = crypto_alloc_tfm(algo, 0); | |
102 | if (tfm == NULL) { | |
103 | printk("failed to load transform for %s\n", algo); | |
104 | return; | |
105 | } | |
106 | ||
107 | for (i = 0; i < tcount; i++) { | |
108 | printk ("test %u:\n", i + 1); | |
109 | memset (result, 0, 64); | |
110 | ||
111 | p = hash_tv[i].plaintext; | |
112 | sg[0].page = virt_to_page (p); | |
113 | sg[0].offset = offset_in_page (p); | |
114 | sg[0].length = hash_tv[i].psize; | |
115 | ||
116 | crypto_digest_init (tfm); | |
117 | if (tfm->crt_u.digest.dit_setkey) { | |
118 | crypto_digest_setkey (tfm, hash_tv[i].key, | |
119 | hash_tv[i].ksize); | |
120 | } | |
121 | crypto_digest_update (tfm, sg, 1); | |
122 | crypto_digest_final (tfm, result); | |
123 | ||
124 | hexdump (result, crypto_tfm_alg_digestsize (tfm)); | |
125 | printk("%s\n", | |
126 | memcmp(result, hash_tv[i].digest, | |
127 | crypto_tfm_alg_digestsize(tfm)) ? "fail" : | |
128 | "pass"); | |
129 | } | |
130 | ||
131 | printk ("testing %s across pages\n", algo); | |
132 | ||
133 | /* setup the dummy buffer first */ | |
134 | memset(xbuf, 0, XBUFSIZE); | |
135 | ||
136 | j = 0; | |
137 | for (i = 0; i < tcount; i++) { | |
138 | if (hash_tv[i].np) { | |
139 | j++; | |
140 | printk ("test %u:\n", j); | |
141 | memset (result, 0, 64); | |
142 | ||
143 | temp = 0; | |
144 | for (k = 0; k < hash_tv[i].np; k++) { | |
145 | memcpy (&xbuf[IDX[k]], hash_tv[i].plaintext + temp, | |
146 | hash_tv[i].tap[k]); | |
147 | temp += hash_tv[i].tap[k]; | |
148 | p = &xbuf[IDX[k]]; | |
149 | sg[k].page = virt_to_page (p); | |
150 | sg[k].offset = offset_in_page (p); | |
151 | sg[k].length = hash_tv[i].tap[k]; | |
152 | } | |
153 | ||
154 | crypto_digest_digest (tfm, sg, hash_tv[i].np, result); | |
155 | ||
156 | hexdump (result, crypto_tfm_alg_digestsize (tfm)); | |
157 | printk("%s\n", | |
158 | memcmp(result, hash_tv[i].digest, | |
159 | crypto_tfm_alg_digestsize(tfm)) ? "fail" : | |
160 | "pass"); | |
161 | } | |
162 | } | |
163 | ||
164 | crypto_free_tfm (tfm); | |
165 | } | |
166 | ||
167 | ||
168 | #ifdef CONFIG_CRYPTO_HMAC | |
169 | ||
170 | static void | |
171 | test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount) | |
172 | { | |
173 | char *p; | |
174 | unsigned int i, j, k, temp; | |
175 | struct scatterlist sg[8]; | |
176 | char result[64]; | |
177 | struct crypto_tfm *tfm; | |
178 | struct hmac_testvec *hmac_tv; | |
179 | unsigned int tsize, klen; | |
180 | ||
181 | tfm = crypto_alloc_tfm(algo, 0); | |
182 | if (tfm == NULL) { | |
183 | printk("failed to load transform for %s\n", algo); | |
184 | return; | |
185 | } | |
186 | ||
187 | printk("\ntesting hmac_%s\n", algo); | |
188 | ||
189 | tsize = sizeof (struct hmac_testvec); | |
190 | tsize *= tcount; | |
191 | if (tsize > TVMEMSIZE) { | |
192 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
193 | TVMEMSIZE); | |
194 | goto out; | |
195 | } | |
196 | ||
197 | memcpy(tvmem, template, tsize); | |
198 | hmac_tv = (void *) tvmem; | |
199 | ||
200 | for (i = 0; i < tcount; i++) { | |
201 | printk("test %u:\n", i + 1); | |
202 | memset(result, 0, sizeof (result)); | |
203 | ||
204 | p = hmac_tv[i].plaintext; | |
205 | klen = hmac_tv[i].ksize; | |
206 | sg[0].page = virt_to_page(p); | |
207 | sg[0].offset = offset_in_page(p); | |
208 | sg[0].length = hmac_tv[i].psize; | |
209 | ||
210 | crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result); | |
211 | ||
212 | hexdump(result, crypto_tfm_alg_digestsize(tfm)); | |
213 | printk("%s\n", | |
214 | memcmp(result, hmac_tv[i].digest, | |
215 | crypto_tfm_alg_digestsize(tfm)) ? "fail" : | |
216 | "pass"); | |
217 | } | |
218 | ||
219 | printk("\ntesting hmac_%s across pages\n", algo); | |
220 | ||
221 | memset(xbuf, 0, XBUFSIZE); | |
222 | ||
223 | j = 0; | |
224 | for (i = 0; i < tcount; i++) { | |
225 | if (hmac_tv[i].np) { | |
226 | j++; | |
227 | printk ("test %u:\n",j); | |
228 | memset (result, 0, 64); | |
229 | ||
230 | temp = 0; | |
231 | klen = hmac_tv[i].ksize; | |
232 | for (k = 0; k < hmac_tv[i].np; k++) { | |
233 | memcpy (&xbuf[IDX[k]], hmac_tv[i].plaintext + temp, | |
234 | hmac_tv[i].tap[k]); | |
235 | temp += hmac_tv[i].tap[k]; | |
236 | p = &xbuf[IDX[k]]; | |
237 | sg[k].page = virt_to_page (p); | |
238 | sg[k].offset = offset_in_page (p); | |
239 | sg[k].length = hmac_tv[i].tap[k]; | |
240 | } | |
241 | ||
242 | crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, hmac_tv[i].np, | |
243 | result); | |
244 | hexdump(result, crypto_tfm_alg_digestsize(tfm)); | |
245 | ||
246 | printk("%s\n", | |
247 | memcmp(result, hmac_tv[i].digest, | |
248 | crypto_tfm_alg_digestsize(tfm)) ? "fail" : | |
249 | "pass"); | |
250 | } | |
251 | } | |
252 | out: | |
253 | crypto_free_tfm(tfm); | |
254 | } | |
255 | ||
256 | #endif /* CONFIG_CRYPTO_HMAC */ | |
257 | ||
258 | static void | |
259 | test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, unsigned int tcount) | |
260 | { | |
261 | unsigned int ret, i, j, k, temp; | |
262 | unsigned int tsize; | |
263 | char *p, *q; | |
264 | struct crypto_tfm *tfm; | |
265 | char *key; | |
266 | struct cipher_testvec *cipher_tv; | |
267 | struct scatterlist sg[8]; | |
268 | char e[11], m[4]; | |
269 | ||
270 | if (enc == ENCRYPT) | |
271 | strncpy(e, "encryption", 11); | |
272 | else | |
273 | strncpy(e, "decryption", 11); | |
274 | if (mode == MODE_ECB) | |
275 | strncpy(m, "ECB", 4); | |
276 | else | |
277 | strncpy(m, "CBC", 4); | |
278 | ||
279 | printk("\ntesting %s %s %s \n", algo, m, e); | |
280 | ||
281 | tsize = sizeof (struct cipher_testvec); | |
282 | tsize *= tcount; | |
283 | ||
284 | if (tsize > TVMEMSIZE) { | |
285 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
286 | TVMEMSIZE); | |
287 | return; | |
288 | } | |
289 | ||
290 | memcpy(tvmem, template, tsize); | |
291 | cipher_tv = (void *) tvmem; | |
292 | ||
293 | if (mode) | |
294 | tfm = crypto_alloc_tfm (algo, 0); | |
295 | else | |
296 | tfm = crypto_alloc_tfm (algo, CRYPTO_TFM_MODE_CBC); | |
297 | ||
298 | if (tfm == NULL) { | |
299 | printk("failed to load transform for %s %s\n", algo, m); | |
300 | return; | |
301 | } | |
302 | ||
303 | j = 0; | |
304 | for (i = 0; i < tcount; i++) { | |
305 | if (!(cipher_tv[i].np)) { | |
306 | j++; | |
307 | printk("test %u (%d bit key):\n", | |
308 | j, cipher_tv[i].klen * 8); | |
309 | ||
310 | tfm->crt_flags = 0; | |
311 | if (cipher_tv[i].wk) | |
312 | tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; | |
313 | key = cipher_tv[i].key; | |
314 | ||
315 | ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); | |
316 | if (ret) { | |
317 | printk("setkey() failed flags=%x\n", tfm->crt_flags); | |
318 | ||
319 | if (!cipher_tv[i].fail) | |
320 | goto out; | |
321 | } | |
322 | ||
323 | p = cipher_tv[i].input; | |
324 | sg[0].page = virt_to_page(p); | |
325 | sg[0].offset = offset_in_page(p); | |
326 | sg[0].length = cipher_tv[i].ilen; | |
327 | ||
328 | if (!mode) { | |
329 | crypto_cipher_set_iv(tfm, cipher_tv[i].iv, | |
330 | crypto_tfm_alg_ivsize (tfm)); | |
331 | } | |
332 | ||
333 | if (enc) | |
334 | ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); | |
335 | else | |
336 | ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); | |
337 | ||
338 | ||
339 | if (ret) { | |
340 | printk("%s () failed flags=%x\n", e, tfm->crt_flags); | |
341 | goto out; | |
342 | } | |
343 | ||
344 | q = kmap(sg[0].page) + sg[0].offset; | |
345 | hexdump(q, cipher_tv[i].rlen); | |
346 | ||
347 | printk("%s\n", | |
348 | memcmp(q, cipher_tv[i].result, cipher_tv[i].rlen) ? "fail" : | |
349 | "pass"); | |
350 | } | |
351 | } | |
352 | ||
353 | printk("\ntesting %s %s %s across pages (chunking) \n", algo, m, e); | |
354 | memset(xbuf, 0, XBUFSIZE); | |
355 | ||
356 | j = 0; | |
357 | for (i = 0; i < tcount; i++) { | |
358 | if (cipher_tv[i].np) { | |
359 | j++; | |
360 | printk("test %u (%d bit key):\n", | |
361 | j, cipher_tv[i].klen * 8); | |
362 | ||
363 | tfm->crt_flags = 0; | |
364 | if (cipher_tv[i].wk) | |
365 | tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; | |
366 | key = cipher_tv[i].key; | |
367 | ||
368 | ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); | |
369 | if (ret) { | |
370 | printk("setkey() failed flags=%x\n", tfm->crt_flags); | |
371 | ||
372 | if (!cipher_tv[i].fail) | |
373 | goto out; | |
374 | } | |
375 | ||
376 | temp = 0; | |
377 | for (k = 0; k < cipher_tv[i].np; k++) { | |
378 | memcpy (&xbuf[IDX[k]], cipher_tv[i].input + temp, | |
379 | cipher_tv[i].tap[k]); | |
380 | temp += cipher_tv[i].tap[k]; | |
381 | p = &xbuf[IDX[k]]; | |
382 | sg[k].page = virt_to_page (p); | |
383 | sg[k].offset = offset_in_page (p); | |
384 | sg[k].length = cipher_tv[i].tap[k]; | |
385 | } | |
386 | ||
387 | if (!mode) { | |
388 | crypto_cipher_set_iv(tfm, cipher_tv[i].iv, | |
389 | crypto_tfm_alg_ivsize (tfm)); | |
390 | } | |
391 | ||
392 | if (enc) | |
393 | ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); | |
394 | else | |
395 | ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); | |
396 | ||
397 | if (ret) { | |
398 | printk("%s () failed flags=%x\n", e, tfm->crt_flags); | |
399 | goto out; | |
400 | } | |
401 | ||
402 | temp = 0; | |
403 | for (k = 0; k < cipher_tv[i].np; k++) { | |
404 | printk("page %u\n", k); | |
405 | q = kmap(sg[k].page) + sg[k].offset; | |
406 | hexdump(q, cipher_tv[i].tap[k]); | |
407 | printk("%s\n", | |
408 | memcmp(q, cipher_tv[i].result + temp, | |
409 | cipher_tv[i].tap[k]) ? "fail" : | |
410 | "pass"); | |
411 | temp += cipher_tv[i].tap[k]; | |
412 | } | |
413 | } | |
414 | } | |
415 | ||
416 | out: | |
417 | crypto_free_tfm(tfm); | |
418 | } | |
419 | ||
420 | static void | |
421 | test_deflate(void) | |
422 | { | |
423 | unsigned int i; | |
424 | char result[COMP_BUF_SIZE]; | |
425 | struct crypto_tfm *tfm; | |
426 | struct comp_testvec *tv; | |
427 | unsigned int tsize; | |
428 | ||
429 | printk("\ntesting deflate compression\n"); | |
430 | ||
431 | tsize = sizeof (deflate_comp_tv_template); | |
432 | if (tsize > TVMEMSIZE) { | |
433 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
434 | TVMEMSIZE); | |
435 | return; | |
436 | } | |
437 | ||
438 | memcpy(tvmem, deflate_comp_tv_template, tsize); | |
439 | tv = (void *) tvmem; | |
440 | ||
441 | tfm = crypto_alloc_tfm("deflate", 0); | |
442 | if (tfm == NULL) { | |
443 | printk("failed to load transform for deflate\n"); | |
444 | return; | |
445 | } | |
446 | ||
447 | for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) { | |
448 | int ilen, ret, dlen = COMP_BUF_SIZE; | |
449 | ||
450 | printk("test %u:\n", i + 1); | |
451 | memset(result, 0, sizeof (result)); | |
452 | ||
453 | ilen = tv[i].inlen; | |
454 | ret = crypto_comp_compress(tfm, tv[i].input, | |
455 | ilen, result, &dlen); | |
456 | if (ret) { | |
457 | printk("fail: ret=%d\n", ret); | |
458 | continue; | |
459 | } | |
460 | hexdump(result, dlen); | |
461 | printk("%s (ratio %d:%d)\n", | |
462 | memcmp(result, tv[i].output, dlen) ? "fail" : "pass", | |
463 | ilen, dlen); | |
464 | } | |
465 | ||
466 | printk("\ntesting deflate decompression\n"); | |
467 | ||
468 | tsize = sizeof (deflate_decomp_tv_template); | |
469 | if (tsize > TVMEMSIZE) { | |
470 | printk("template (%u) too big for tvmem (%u)\n", tsize, | |
471 | TVMEMSIZE); | |
472 | goto out; | |
473 | } | |
474 | ||
475 | memcpy(tvmem, deflate_decomp_tv_template, tsize); | |
476 | tv = (void *) tvmem; | |
477 | ||
478 | for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) { | |
479 | int ilen, ret, dlen = COMP_BUF_SIZE; | |
480 | ||
481 | printk("test %u:\n", i + 1); | |
482 | memset(result, 0, sizeof (result)); | |
483 | ||
484 | ilen = tv[i].inlen; | |
485 | ret = crypto_comp_decompress(tfm, tv[i].input, | |
486 | ilen, result, &dlen); | |
487 | if (ret) { | |
488 | printk("fail: ret=%d\n", ret); | |
489 | continue; | |
490 | } | |
491 | hexdump(result, dlen); | |
492 | printk("%s (ratio %d:%d)\n", | |
493 | memcmp(result, tv[i].output, dlen) ? "fail" : "pass", | |
494 | ilen, dlen); | |
495 | } | |
496 | out: | |
497 | crypto_free_tfm(tfm); | |
498 | } | |
499 | ||
500 | static void | |
501 | test_crc32c(void) | |
502 | { | |
503 | #define NUMVEC 6 | |
504 | #define VECSIZE 40 | |
505 | ||
506 | int i, j, pass; | |
507 | u32 crc; | |
508 | u8 b, test_vec[NUMVEC][VECSIZE]; | |
509 | static u32 vec_results[NUMVEC] = { | |
510 | 0x0e2c157f, 0xe980ebf6, 0xde74bded, | |
511 | 0xd579c862, 0xba979ad0, 0x2b29d913 | |
512 | }; | |
513 | static u32 tot_vec_results = 0x24c5d375; | |
514 | ||
515 | struct scatterlist sg[NUMVEC]; | |
516 | struct crypto_tfm *tfm; | |
517 | char *fmtdata = "testing crc32c initialized to %08x: %s\n"; | |
518 | #define SEEDTESTVAL 0xedcba987 | |
519 | u32 seed; | |
520 | ||
521 | printk("\ntesting crc32c\n"); | |
522 | ||
523 | tfm = crypto_alloc_tfm("crc32c", 0); | |
524 | if (tfm == NULL) { | |
525 | printk("failed to load transform for crc32c\n"); | |
526 | return; | |
527 | } | |
528 | ||
529 | crypto_digest_init(tfm); | |
530 | crypto_digest_final(tfm, (u8*)&crc); | |
531 | printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR"); | |
532 | ||
533 | /* | |
534 | * stuff test_vec with known values, simple incrementing | |
535 | * byte values. | |
536 | */ | |
537 | b = 0; | |
538 | for (i = 0; i < NUMVEC; i++) { | |
539 | for (j = 0; j < VECSIZE; j++) | |
540 | test_vec[i][j] = ++b; | |
541 | sg[i].page = virt_to_page(test_vec[i]); | |
542 | sg[i].offset = offset_in_page(test_vec[i]); | |
543 | sg[i].length = VECSIZE; | |
544 | } | |
545 | ||
546 | seed = SEEDTESTVAL; | |
547 | (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); | |
548 | crypto_digest_final(tfm, (u8*)&crc); | |
549 | printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ? | |
550 | "pass" : "ERROR"); | |
551 | ||
552 | printk("testing crc32c using update/final:\n"); | |
553 | ||
554 | pass = 1; /* assume all is well */ | |
555 | ||
556 | for (i = 0; i < NUMVEC; i++) { | |
557 | seed = ~(u32)0; | |
558 | (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); | |
559 | crypto_digest_update(tfm, &sg[i], 1); | |
560 | crypto_digest_final(tfm, (u8*)&crc); | |
561 | if (crc == vec_results[i]) { | |
562 | printk(" %08x:OK", crc); | |
563 | } else { | |
564 | printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]); | |
565 | pass = 0; | |
566 | } | |
567 | } | |
568 | ||
569 | printk("\ntesting crc32c using incremental accumulator:\n"); | |
570 | crc = 0; | |
571 | for (i = 0; i < NUMVEC; i++) { | |
572 | seed = (crc ^ ~(u32)0); | |
573 | (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); | |
574 | crypto_digest_update(tfm, &sg[i], 1); | |
575 | crypto_digest_final(tfm, (u8*)&crc); | |
576 | } | |
577 | if (crc == tot_vec_results) { | |
578 | printk(" %08x:OK", crc); | |
579 | } else { | |
580 | printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results); | |
581 | pass = 0; | |
582 | } | |
583 | ||
584 | printk("\ntesting crc32c using digest:\n"); | |
585 | seed = ~(u32)0; | |
586 | (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); | |
587 | crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc); | |
588 | if (crc == tot_vec_results) { | |
589 | printk(" %08x:OK", crc); | |
590 | } else { | |
591 | printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results); | |
592 | pass = 0; | |
593 | } | |
594 | ||
595 | printk("\n%s\n", pass ? "pass" : "ERROR"); | |
596 | ||
597 | crypto_free_tfm(tfm); | |
598 | printk("crc32c test complete\n"); | |
599 | } | |
600 | ||
601 | static void | |
602 | test_available(void) | |
603 | { | |
604 | char **name = check; | |
605 | ||
606 | while (*name) { | |
607 | printk("alg %s ", *name); | |
608 | printk((crypto_alg_available(*name, 0)) ? | |
609 | "found\n" : "not found\n"); | |
610 | name++; | |
611 | } | |
612 | } | |
613 | ||
614 | static void | |
615 | do_test(void) | |
616 | { | |
617 | switch (mode) { | |
618 | ||
619 | case 0: | |
620 | test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); | |
621 | ||
622 | test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); | |
623 | ||
624 | //DES | |
625 | test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS); | |
626 | test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS); | |
627 | test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS); | |
628 | test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS); | |
629 | ||
630 | //DES3_EDE | |
631 | test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); | |
632 | test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); | |
633 | ||
634 | test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); | |
635 | ||
636 | test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); | |
637 | ||
638 | //BLOWFISH | |
639 | test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); | |
640 | test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); | |
641 | test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS); | |
642 | test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS); | |
643 | ||
644 | //TWOFISH | |
645 | test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS); | |
646 | test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS); | |
647 | test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); | |
648 | test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); | |
649 | ||
650 | //SERPENT | |
651 | test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); | |
652 | test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); | |
653 | ||
654 | //TNEPRES | |
655 | test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS); | |
656 | test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS); | |
657 | ||
658 | //AES | |
659 | test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS); | |
660 | test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS); | |
661 | ||
662 | //CAST5 | |
663 | test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS); | |
664 | test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS); | |
665 | ||
666 | //CAST6 | |
667 | test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS); | |
668 | test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS); | |
669 | ||
670 | //ARC4 | |
671 | test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS); | |
672 | test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS); | |
673 | ||
674 | //TEA | |
675 | test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS); | |
676 | test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS); | |
677 | ||
678 | ||
679 | //XTEA | |
680 | test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS); | |
681 | test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS); | |
682 | ||
683 | //KHAZAD | |
684 | test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS); | |
685 | test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS); | |
686 | ||
687 | //ANUBIS | |
688 | test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS); | |
689 | test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS); | |
690 | test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); | |
691 | test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); | |
692 | ||
693 | test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); | |
694 | test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); | |
695 | test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); | |
696 | test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); | |
697 | test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); | |
698 | test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); | |
699 | test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); | |
700 | test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); | |
701 | test_deflate(); | |
702 | test_crc32c(); | |
703 | #ifdef CONFIG_CRYPTO_HMAC | |
704 | test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); | |
705 | test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); | |
706 | test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); | |
707 | #endif | |
708 | ||
709 | test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); | |
710 | break; | |
711 | ||
712 | case 1: | |
713 | test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); | |
714 | break; | |
715 | ||
716 | case 2: | |
717 | test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); | |
718 | break; | |
719 | ||
720 | case 3: | |
721 | test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS); | |
722 | test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS); | |
723 | test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS); | |
724 | test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS); | |
725 | break; | |
726 | ||
727 | case 4: | |
728 | test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); | |
729 | test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); | |
730 | break; | |
731 | ||
732 | case 5: | |
733 | test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); | |
734 | break; | |
735 | ||
736 | case 6: | |
737 | test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); | |
738 | break; | |
739 | ||
740 | case 7: | |
741 | test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); | |
742 | test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); | |
743 | test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS); | |
744 | test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS); | |
745 | break; | |
746 | ||
747 | case 8: | |
748 | test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS); | |
749 | test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS); | |
750 | test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); | |
751 | test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); | |
752 | break; | |
753 | ||
754 | case 9: | |
755 | test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); | |
756 | test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); | |
757 | break; | |
758 | ||
759 | case 10: | |
760 | test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS); | |
761 | test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS); | |
762 | break; | |
763 | ||
764 | case 11: | |
765 | test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); | |
766 | break; | |
767 | ||
768 | case 12: | |
769 | test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); | |
770 | break; | |
771 | ||
772 | case 13: | |
773 | test_deflate(); | |
774 | break; | |
775 | ||
776 | case 14: | |
777 | test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS); | |
778 | test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS); | |
779 | break; | |
780 | ||
781 | case 15: | |
782 | test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS); | |
783 | test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS); | |
784 | break; | |
785 | ||
786 | case 16: | |
787 | test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS); | |
788 | test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS); | |
789 | break; | |
790 | ||
791 | case 17: | |
792 | test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); | |
793 | break; | |
794 | ||
795 | case 18: | |
796 | test_crc32c(); | |
797 | break; | |
798 | ||
799 | case 19: | |
800 | test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS); | |
801 | test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS); | |
802 | break; | |
803 | ||
804 | case 20: | |
805 | test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS); | |
806 | test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS); | |
807 | break; | |
808 | ||
809 | case 21: | |
810 | test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS); | |
811 | test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS); | |
812 | break; | |
813 | ||
814 | case 22: | |
815 | test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); | |
816 | break; | |
817 | ||
818 | case 23: | |
819 | test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); | |
820 | break; | |
821 | ||
822 | case 24: | |
823 | test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); | |
824 | break; | |
825 | ||
826 | case 25: | |
827 | test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS); | |
828 | test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS); | |
829 | break; | |
830 | ||
831 | case 26: | |
832 | test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS); | |
833 | test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS); | |
834 | test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); | |
835 | test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); | |
836 | break; | |
837 | ||
838 | case 27: | |
839 | test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); | |
840 | break; | |
841 | ||
842 | case 28: | |
843 | ||
844 | test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); | |
845 | break; | |
846 | ||
847 | case 29: | |
848 | test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); | |
849 | break; | |
850 | ||
851 | #ifdef CONFIG_CRYPTO_HMAC | |
852 | case 100: | |
853 | test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); | |
854 | break; | |
855 | ||
856 | case 101: | |
857 | test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); | |
858 | break; | |
859 | ||
860 | case 102: | |
861 | test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); | |
862 | break; | |
863 | ||
864 | #endif | |
865 | ||
866 | case 1000: | |
867 | test_available(); | |
868 | break; | |
869 | ||
870 | default: | |
871 | /* useful for debugging */ | |
872 | printk("not testing anything\n"); | |
873 | break; | |
874 | } | |
875 | } | |
876 | ||
877 | static int __init | |
878 | init(void) | |
879 | { | |
880 | tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); | |
881 | if (tvmem == NULL) | |
882 | return -ENOMEM; | |
883 | ||
884 | xbuf = kmalloc(XBUFSIZE, GFP_KERNEL); | |
885 | if (xbuf == NULL) { | |
886 | kfree(tvmem); | |
887 | return -ENOMEM; | |
888 | } | |
889 | ||
890 | do_test(); | |
891 | ||
892 | kfree(xbuf); | |
893 | kfree(tvmem); | |
894 | return 0; | |
895 | } | |
896 | ||
897 | /* | |
898 | * If an init function is provided, an exit function must also be provided | |
899 | * to allow module unload. | |
900 | */ | |
901 | static void __exit fini(void) { } | |
902 | ||
903 | module_init(init); | |
904 | module_exit(fini); | |
905 | ||
906 | module_param(mode, int, 0); | |
907 | ||
908 | MODULE_LICENSE("GPL"); | |
909 | MODULE_DESCRIPTION("Quick & dirty crypto testing module"); | |
910 | MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); |