PageRenderTime 56ms CodeModel.GetById 2ms app.highlight 48ms RepoModel.GetById 1ms app.codeStats 0ms

/crypto/tcrypt.c

https://bitbucket.org/evzijst/gittest
C | 910 lines | 690 code | 170 blank | 50 comment | 74 complexity | 548f180952ada2cdb3dc43cc7d810282 MD5 | raw file
  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
 56static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
 57
 58static int mode;
 59static char *xbuf;
 60static char *tvmem;
 61
 62static 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
 69static void
 70hexdump(unsigned char *buf, unsigned int len)
 71{
 72	while (len--)
 73		printk("%02x", *buf++);
 74
 75	printk("\n");
 76}
 77
 78static void 
 79test_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
170static void
171test_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	}
252out:
253	crypto_free_tfm(tfm);
254}
255
256#endif	/* CONFIG_CRYPTO_HMAC */
257
258static void
259test_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
416out:
417	crypto_free_tfm(tfm);
418}
419
420static void
421test_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	}
496out:
497	crypto_free_tfm(tfm);
498}
499
500static void
501test_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
601static void
602test_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
614static void
615do_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
877static int __init
878init(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 */
901static void __exit fini(void) { }
902
903module_init(init);
904module_exit(fini);
905
906module_param(mode, int, 0);
907
908MODULE_LICENSE("GPL");
909MODULE_DESCRIPTION("Quick & dirty crypto testing module");
910MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");