2 * Quick & dirty crypto testing module.
4 * This will only exist until we have a better testing mechanism
5 * (e.g. a char device).
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
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)
16 * Rewritten by Kartikey Mahendra Bhatt
19 #include <linux/init.h>
20 #include <linux/module.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>
31 * Need to kmalloc() memory for testing kmap().
33 #define TVMEMSIZE 4096
34 #define XBUFSIZE 32768
37 * Indexes into the xbuf to simulate cross-page access.
49 * Used by test_cipher()
56 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
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
69 static void hexdump(unsigned char *buf
, unsigned int len
)
72 printk("%02x", *buf
++);
77 static void test_hash(char *algo
, struct hash_testvec
*template,
81 unsigned int i
, j
, k
, temp
;
82 struct scatterlist sg
[8];
84 struct crypto_tfm
*tfm
;
85 struct hash_testvec
*hash_tv
;
88 printk("\ntesting %s\n", algo
);
90 tsize
= sizeof(struct hash_testvec
);
93 if (tsize
> TVMEMSIZE
) {
94 printk("template (%u) too big for tvmem (%u)\n", tsize
, TVMEMSIZE
);
98 memcpy(tvmem
, template, tsize
);
99 hash_tv
= (void *)tvmem
;
100 tfm
= crypto_alloc_tfm(algo
, 0);
102 printk("failed to load transform for %s\n", algo
);
106 for (i
= 0; i
< tcount
; i
++) {
107 printk("test %u:\n", i
+ 1);
108 memset(result
, 0, 64);
110 p
= hash_tv
[i
].plaintext
;
111 sg
[0].page
= virt_to_page(p
);
112 sg
[0].offset
= offset_in_page(p
);
113 sg
[0].length
= hash_tv
[i
].psize
;
115 crypto_digest_init(tfm
);
116 if (tfm
->crt_u
.digest
.dit_setkey
) {
117 crypto_digest_setkey(tfm
, hash_tv
[i
].key
,
120 crypto_digest_update(tfm
, sg
, 1);
121 crypto_digest_final(tfm
, result
);
123 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
125 memcmp(result
, hash_tv
[i
].digest
,
126 crypto_tfm_alg_digestsize(tfm
)) ?
130 printk("testing %s across pages\n", algo
);
132 /* setup the dummy buffer first */
133 memset(xbuf
, 0, XBUFSIZE
);
136 for (i
= 0; i
< tcount
; i
++) {
139 printk("test %u:\n", j
);
140 memset(result
, 0, 64);
143 for (k
= 0; k
< hash_tv
[i
].np
; k
++) {
144 memcpy(&xbuf
[IDX
[k
]],
145 hash_tv
[i
].plaintext
+ temp
,
147 temp
+= hash_tv
[i
].tap
[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
];
154 crypto_digest_digest(tfm
, sg
, hash_tv
[i
].np
, result
);
156 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
158 memcmp(result
, hash_tv
[i
].digest
,
159 crypto_tfm_alg_digestsize(tfm
)) ?
164 crypto_free_tfm(tfm
);
168 #ifdef CONFIG_CRYPTO_HMAC
170 static void test_hmac(char *algo
, struct hmac_testvec
*template,
174 unsigned int i
, j
, k
, temp
;
175 struct scatterlist sg
[8];
177 struct crypto_tfm
*tfm
;
178 struct hmac_testvec
*hmac_tv
;
179 unsigned int tsize
, klen
;
181 tfm
= crypto_alloc_tfm(algo
, 0);
183 printk("failed to load transform for %s\n", algo
);
187 printk("\ntesting hmac_%s\n", algo
);
189 tsize
= sizeof(struct hmac_testvec
);
191 if (tsize
> TVMEMSIZE
) {
192 printk("template (%u) too big for tvmem (%u)\n", tsize
,
197 memcpy(tvmem
, template, tsize
);
198 hmac_tv
= (void *)tvmem
;
200 for (i
= 0; i
< tcount
; i
++) {
201 printk("test %u:\n", i
+ 1);
202 memset(result
, 0, sizeof (result
));
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
;
210 crypto_hmac(tfm
, hmac_tv
[i
].key
, &klen
, sg
, 1, result
);
212 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
214 memcmp(result
, hmac_tv
[i
].digest
,
215 crypto_tfm_alg_digestsize(tfm
)) ? "fail" :
219 printk("\ntesting hmac_%s across pages\n", algo
);
221 memset(xbuf
, 0, XBUFSIZE
);
224 for (i
= 0; i
< tcount
; i
++) {
227 printk("test %u:\n",j
);
228 memset(result
, 0, 64);
231 klen
= hmac_tv
[i
].ksize
;
232 for (k
= 0; k
< hmac_tv
[i
].np
; k
++) {
233 memcpy(&xbuf
[IDX
[k
]],
234 hmac_tv
[i
].plaintext
+ temp
,
236 temp
+= hmac_tv
[i
].tap
[k
];
238 sg
[k
].page
= virt_to_page(p
);
239 sg
[k
].offset
= offset_in_page(p
);
240 sg
[k
].length
= hmac_tv
[i
].tap
[k
];
243 crypto_hmac(tfm
, hmac_tv
[i
].key
, &klen
, sg
,
244 hmac_tv
[i
].np
, result
);
245 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
248 memcmp(result
, hmac_tv
[i
].digest
,
249 crypto_tfm_alg_digestsize(tfm
)) ?
254 crypto_free_tfm(tfm
);
257 #endif /* CONFIG_CRYPTO_HMAC */
259 static void test_cipher(char *algo
, int mode
, int enc
,
260 struct cipher_testvec
*template, unsigned int tcount
)
262 unsigned int ret
, i
, j
, k
, temp
;
265 struct crypto_tfm
*tfm
;
267 struct cipher_testvec
*cipher_tv
;
268 struct scatterlist sg
[8];
272 strncpy(e
, "encryption", 11);
274 strncpy(e
, "decryption", 11);
275 if (mode
== MODE_ECB
)
276 strncpy(m
, "ECB", 4);
278 strncpy(m
, "CBC", 4);
280 printk("\ntesting %s %s %s\n", algo
, m
, e
);
282 tsize
= sizeof (struct cipher_testvec
);
285 if (tsize
> TVMEMSIZE
) {
286 printk("template (%u) too big for tvmem (%u)\n", tsize
,
291 memcpy(tvmem
, template, tsize
);
292 cipher_tv
= (void *)tvmem
;
295 tfm
= crypto_alloc_tfm(algo
, 0);
297 tfm
= crypto_alloc_tfm(algo
, CRYPTO_TFM_MODE_CBC
);
300 printk("failed to load transform for %s %s\n", algo
, m
);
305 for (i
= 0; i
< tcount
; i
++) {
306 if (!(cipher_tv
[i
].np
)) {
308 printk("test %u (%d bit key):\n",
309 j
, cipher_tv
[i
].klen
* 8);
313 tfm
->crt_flags
|= CRYPTO_TFM_REQ_WEAK_KEY
;
314 key
= cipher_tv
[i
].key
;
316 ret
= crypto_cipher_setkey(tfm
, key
, cipher_tv
[i
].klen
);
318 printk("setkey() failed flags=%x\n", tfm
->crt_flags
);
320 if (!cipher_tv
[i
].fail
)
324 p
= cipher_tv
[i
].input
;
325 sg
[0].page
= virt_to_page(p
);
326 sg
[0].offset
= offset_in_page(p
);
327 sg
[0].length
= cipher_tv
[i
].ilen
;
330 crypto_cipher_set_iv(tfm
, cipher_tv
[i
].iv
,
331 crypto_tfm_alg_ivsize(tfm
));
335 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
337 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
341 printk("%s () failed flags=%x\n", e
, tfm
->crt_flags
);
345 q
= kmap(sg
[0].page
) + sg
[0].offset
;
346 hexdump(q
, cipher_tv
[i
].rlen
);
349 memcmp(q
, cipher_tv
[i
].result
,
350 cipher_tv
[i
].rlen
) ? "fail" : "pass");
354 printk("\ntesting %s %s %s across pages (chunking)\n", algo
, m
, e
);
355 memset(xbuf
, 0, XBUFSIZE
);
358 for (i
= 0; i
< tcount
; i
++) {
359 if (cipher_tv
[i
].np
) {
361 printk("test %u (%d bit key):\n",
362 j
, cipher_tv
[i
].klen
* 8);
366 tfm
->crt_flags
|= CRYPTO_TFM_REQ_WEAK_KEY
;
367 key
= cipher_tv
[i
].key
;
369 ret
= crypto_cipher_setkey(tfm
, key
, cipher_tv
[i
].klen
);
371 printk("setkey() failed flags=%x\n", tfm
->crt_flags
);
373 if (!cipher_tv
[i
].fail
)
378 for (k
= 0; k
< cipher_tv
[i
].np
; k
++) {
379 memcpy(&xbuf
[IDX
[k
]],
380 cipher_tv
[i
].input
+ temp
,
381 cipher_tv
[i
].tap
[k
]);
382 temp
+= cipher_tv
[i
].tap
[k
];
384 sg
[k
].page
= virt_to_page(p
);
385 sg
[k
].offset
= offset_in_page(p
);
386 sg
[k
].length
= cipher_tv
[i
].tap
[k
];
390 crypto_cipher_set_iv(tfm
, cipher_tv
[i
].iv
,
391 crypto_tfm_alg_ivsize(tfm
));
395 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
397 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
400 printk("%s () failed flags=%x\n", e
, tfm
->crt_flags
);
405 for (k
= 0; k
< cipher_tv
[i
].np
; k
++) {
406 printk("page %u\n", k
);
407 q
= kmap(sg
[k
].page
) + sg
[k
].offset
;
408 hexdump(q
, cipher_tv
[i
].tap
[k
]);
410 memcmp(q
, cipher_tv
[i
].result
+ temp
,
411 cipher_tv
[i
].tap
[k
]) ? "fail" :
413 temp
+= cipher_tv
[i
].tap
[k
];
419 crypto_free_tfm(tfm
);
422 static void test_deflate(void)
425 char result
[COMP_BUF_SIZE
];
426 struct crypto_tfm
*tfm
;
427 struct comp_testvec
*tv
;
430 printk("\ntesting deflate compression\n");
432 tsize
= sizeof (deflate_comp_tv_template
);
433 if (tsize
> TVMEMSIZE
) {
434 printk("template (%u) too big for tvmem (%u)\n", tsize
,
439 memcpy(tvmem
, deflate_comp_tv_template
, tsize
);
442 tfm
= crypto_alloc_tfm("deflate", 0);
444 printk("failed to load transform for deflate\n");
448 for (i
= 0; i
< DEFLATE_COMP_TEST_VECTORS
; i
++) {
449 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
451 printk("test %u:\n", i
+ 1);
452 memset(result
, 0, sizeof (result
));
455 ret
= crypto_comp_compress(tfm
, tv
[i
].input
,
456 ilen
, result
, &dlen
);
458 printk("fail: ret=%d\n", ret
);
461 hexdump(result
, dlen
);
462 printk("%s (ratio %d:%d)\n",
463 memcmp(result
, tv
[i
].output
, dlen
) ? "fail" : "pass",
467 printk("\ntesting deflate decompression\n");
469 tsize
= sizeof (deflate_decomp_tv_template
);
470 if (tsize
> TVMEMSIZE
) {
471 printk("template (%u) too big for tvmem (%u)\n", tsize
,
476 memcpy(tvmem
, deflate_decomp_tv_template
, tsize
);
479 for (i
= 0; i
< DEFLATE_DECOMP_TEST_VECTORS
; i
++) {
480 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
482 printk("test %u:\n", i
+ 1);
483 memset(result
, 0, sizeof (result
));
486 ret
= crypto_comp_decompress(tfm
, tv
[i
].input
,
487 ilen
, result
, &dlen
);
489 printk("fail: ret=%d\n", ret
);
492 hexdump(result
, dlen
);
493 printk("%s (ratio %d:%d)\n",
494 memcmp(result
, tv
[i
].output
, dlen
) ? "fail" : "pass",
498 crypto_free_tfm(tfm
);
501 static void test_crc32c(void)
508 u8 b
, test_vec
[NUMVEC
][VECSIZE
];
509 static u32 vec_results
[NUMVEC
] = {
510 0x0e2c157f, 0xe980ebf6, 0xde74bded,
511 0xd579c862, 0xba979ad0, 0x2b29d913
513 static u32 tot_vec_results
= 0x24c5d375;
515 struct scatterlist sg
[NUMVEC
];
516 struct crypto_tfm
*tfm
;
517 char *fmtdata
= "testing crc32c initialized to %08x: %s\n";
518 #define SEEDTESTVAL 0xedcba987
521 printk("\ntesting crc32c\n");
523 tfm
= crypto_alloc_tfm("crc32c", 0);
525 printk("failed to load transform for crc32c\n");
529 crypto_digest_init(tfm
);
530 crypto_digest_final(tfm
, (u8
*)&crc
);
531 printk(fmtdata
, crc
, (crc
== 0) ? "pass" : "ERROR");
534 * stuff test_vec with known values, simple incrementing
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
;
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)) ?
552 printk("testing crc32c using update/final:\n");
554 pass
= 1; /* assume all is well */
556 for (i
= 0; i
< NUMVEC
; i
++) {
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
);
564 printk(" %08x:BAD, wanted %08x\n", crc
, vec_results
[i
]);
569 printk("\ntesting crc32c using incremental accumulator:\n");
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
);
577 if (crc
== tot_vec_results
) {
578 printk(" %08x:OK", crc
);
580 printk(" %08x:BAD, wanted %08x\n", crc
, tot_vec_results
);
584 printk("\ntesting crc32c using digest:\n");
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
);
591 printk(" %08x:BAD, wanted %08x\n", crc
, tot_vec_results
);
595 printk("\n%s\n", pass
? "pass" : "ERROR");
597 crypto_free_tfm(tfm
);
598 printk("crc32c test complete\n");
601 static void test_available(void)
606 printk("alg %s ", *name
);
607 printk((crypto_alg_available(*name
, 0)) ?
608 "found\n" : "not found\n");
613 static void do_test(void)
618 test_hash("md5", md5_tv_template
, MD5_TEST_VECTORS
);
620 test_hash("sha1", sha1_tv_template
, SHA1_TEST_VECTORS
);
623 test_cipher ("des", MODE_ECB
, ENCRYPT
, des_enc_tv_template
, DES_ENC_TEST_VECTORS
);
624 test_cipher ("des", MODE_ECB
, DECRYPT
, des_dec_tv_template
, DES_DEC_TEST_VECTORS
);
625 test_cipher ("des", MODE_CBC
, ENCRYPT
, des_cbc_enc_tv_template
, DES_CBC_ENC_TEST_VECTORS
);
626 test_cipher ("des", MODE_CBC
, DECRYPT
, des_cbc_dec_tv_template
, DES_CBC_DEC_TEST_VECTORS
);
629 test_cipher ("des3_ede", MODE_ECB
, ENCRYPT
, des3_ede_enc_tv_template
, DES3_EDE_ENC_TEST_VECTORS
);
630 test_cipher ("des3_ede", MODE_ECB
, DECRYPT
, des3_ede_dec_tv_template
, DES3_EDE_DEC_TEST_VECTORS
);
632 test_hash("md4", md4_tv_template
, MD4_TEST_VECTORS
);
634 test_hash("sha256", sha256_tv_template
, SHA256_TEST_VECTORS
);
637 test_cipher ("blowfish", MODE_ECB
, ENCRYPT
, bf_enc_tv_template
, BF_ENC_TEST_VECTORS
);
638 test_cipher ("blowfish", MODE_ECB
, DECRYPT
, bf_dec_tv_template
, BF_DEC_TEST_VECTORS
);
639 test_cipher ("blowfish", MODE_CBC
, ENCRYPT
, bf_cbc_enc_tv_template
, BF_CBC_ENC_TEST_VECTORS
);
640 test_cipher ("blowfish", MODE_CBC
, DECRYPT
, bf_cbc_dec_tv_template
, BF_CBC_DEC_TEST_VECTORS
);
643 test_cipher ("twofish", MODE_ECB
, ENCRYPT
, tf_enc_tv_template
, TF_ENC_TEST_VECTORS
);
644 test_cipher ("twofish", MODE_ECB
, DECRYPT
, tf_dec_tv_template
, TF_DEC_TEST_VECTORS
);
645 test_cipher ("twofish", MODE_CBC
, ENCRYPT
, tf_cbc_enc_tv_template
, TF_CBC_ENC_TEST_VECTORS
);
646 test_cipher ("twofish", MODE_CBC
, DECRYPT
, tf_cbc_dec_tv_template
, TF_CBC_DEC_TEST_VECTORS
);
649 test_cipher ("serpent", MODE_ECB
, ENCRYPT
, serpent_enc_tv_template
, SERPENT_ENC_TEST_VECTORS
);
650 test_cipher ("serpent", MODE_ECB
, DECRYPT
, serpent_dec_tv_template
, SERPENT_DEC_TEST_VECTORS
);
653 test_cipher ("tnepres", MODE_ECB
, ENCRYPT
, tnepres_enc_tv_template
, TNEPRES_ENC_TEST_VECTORS
);
654 test_cipher ("tnepres", MODE_ECB
, DECRYPT
, tnepres_dec_tv_template
, TNEPRES_DEC_TEST_VECTORS
);
657 test_cipher ("aes", MODE_ECB
, ENCRYPT
, aes_enc_tv_template
, AES_ENC_TEST_VECTORS
);
658 test_cipher ("aes", MODE_ECB
, DECRYPT
, aes_dec_tv_template
, AES_DEC_TEST_VECTORS
);
661 test_cipher ("cast5", MODE_ECB
, ENCRYPT
, cast5_enc_tv_template
, CAST5_ENC_TEST_VECTORS
);
662 test_cipher ("cast5", MODE_ECB
, DECRYPT
, cast5_dec_tv_template
, CAST5_DEC_TEST_VECTORS
);
665 test_cipher ("cast6", MODE_ECB
, ENCRYPT
, cast6_enc_tv_template
, CAST6_ENC_TEST_VECTORS
);
666 test_cipher ("cast6", MODE_ECB
, DECRYPT
, cast6_dec_tv_template
, CAST6_DEC_TEST_VECTORS
);
669 test_cipher ("arc4", MODE_ECB
, ENCRYPT
, arc4_enc_tv_template
, ARC4_ENC_TEST_VECTORS
);
670 test_cipher ("arc4", MODE_ECB
, DECRYPT
, arc4_dec_tv_template
, ARC4_DEC_TEST_VECTORS
);
673 test_cipher ("tea", MODE_ECB
, ENCRYPT
, tea_enc_tv_template
, TEA_ENC_TEST_VECTORS
);
674 test_cipher ("tea", MODE_ECB
, DECRYPT
, tea_dec_tv_template
, TEA_DEC_TEST_VECTORS
);
678 test_cipher ("xtea", MODE_ECB
, ENCRYPT
, xtea_enc_tv_template
, XTEA_ENC_TEST_VECTORS
);
679 test_cipher ("xtea", MODE_ECB
, DECRYPT
, xtea_dec_tv_template
, XTEA_DEC_TEST_VECTORS
);
682 test_cipher ("khazad", MODE_ECB
, ENCRYPT
, khazad_enc_tv_template
, KHAZAD_ENC_TEST_VECTORS
);
683 test_cipher ("khazad", MODE_ECB
, DECRYPT
, khazad_dec_tv_template
, KHAZAD_DEC_TEST_VECTORS
);
686 test_cipher ("anubis", MODE_ECB
, ENCRYPT
, anubis_enc_tv_template
, ANUBIS_ENC_TEST_VECTORS
);
687 test_cipher ("anubis", MODE_ECB
, DECRYPT
, anubis_dec_tv_template
, ANUBIS_DEC_TEST_VECTORS
);
688 test_cipher ("anubis", MODE_CBC
, ENCRYPT
, anubis_cbc_enc_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
689 test_cipher ("anubis", MODE_CBC
, DECRYPT
, anubis_cbc_dec_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
691 test_hash("sha384", sha384_tv_template
, SHA384_TEST_VECTORS
);
692 test_hash("sha512", sha512_tv_template
, SHA512_TEST_VECTORS
);
693 test_hash("wp512", wp512_tv_template
, WP512_TEST_VECTORS
);
694 test_hash("wp384", wp384_tv_template
, WP384_TEST_VECTORS
);
695 test_hash("wp256", wp256_tv_template
, WP256_TEST_VECTORS
);
696 test_hash("tgr192", tgr192_tv_template
, TGR192_TEST_VECTORS
);
697 test_hash("tgr160", tgr160_tv_template
, TGR160_TEST_VECTORS
);
698 test_hash("tgr128", tgr128_tv_template
, TGR128_TEST_VECTORS
);
701 #ifdef CONFIG_CRYPTO_HMAC
702 test_hmac("md5", hmac_md5_tv_template
, HMAC_MD5_TEST_VECTORS
);
703 test_hmac("sha1", hmac_sha1_tv_template
, HMAC_SHA1_TEST_VECTORS
);
704 test_hmac("sha256", hmac_sha256_tv_template
, HMAC_SHA256_TEST_VECTORS
);
707 test_hash("michael_mic", michael_mic_tv_template
, MICHAEL_MIC_TEST_VECTORS
);
711 test_hash("md5", md5_tv_template
, MD5_TEST_VECTORS
);
715 test_hash("sha1", sha1_tv_template
, SHA1_TEST_VECTORS
);
719 test_cipher ("des", MODE_ECB
, ENCRYPT
, des_enc_tv_template
, DES_ENC_TEST_VECTORS
);
720 test_cipher ("des", MODE_ECB
, DECRYPT
, des_dec_tv_template
, DES_DEC_TEST_VECTORS
);
721 test_cipher ("des", MODE_CBC
, ENCRYPT
, des_cbc_enc_tv_template
, DES_CBC_ENC_TEST_VECTORS
);
722 test_cipher ("des", MODE_CBC
, DECRYPT
, des_cbc_dec_tv_template
, DES_CBC_DEC_TEST_VECTORS
);
726 test_cipher ("des3_ede", MODE_ECB
, ENCRYPT
, des3_ede_enc_tv_template
, DES3_EDE_ENC_TEST_VECTORS
);
727 test_cipher ("des3_ede", MODE_ECB
, DECRYPT
, des3_ede_dec_tv_template
, DES3_EDE_DEC_TEST_VECTORS
);
731 test_hash("md4", md4_tv_template
, MD4_TEST_VECTORS
);
735 test_hash("sha256", sha256_tv_template
, SHA256_TEST_VECTORS
);
739 test_cipher ("blowfish", MODE_ECB
, ENCRYPT
, bf_enc_tv_template
, BF_ENC_TEST_VECTORS
);
740 test_cipher ("blowfish", MODE_ECB
, DECRYPT
, bf_dec_tv_template
, BF_DEC_TEST_VECTORS
);
741 test_cipher ("blowfish", MODE_CBC
, ENCRYPT
, bf_cbc_enc_tv_template
, BF_CBC_ENC_TEST_VECTORS
);
742 test_cipher ("blowfish", MODE_CBC
, DECRYPT
, bf_cbc_dec_tv_template
, BF_CBC_DEC_TEST_VECTORS
);
746 test_cipher ("twofish", MODE_ECB
, ENCRYPT
, tf_enc_tv_template
, TF_ENC_TEST_VECTORS
);
747 test_cipher ("twofish", MODE_ECB
, DECRYPT
, tf_dec_tv_template
, TF_DEC_TEST_VECTORS
);
748 test_cipher ("twofish", MODE_CBC
, ENCRYPT
, tf_cbc_enc_tv_template
, TF_CBC_ENC_TEST_VECTORS
);
749 test_cipher ("twofish", MODE_CBC
, DECRYPT
, tf_cbc_dec_tv_template
, TF_CBC_DEC_TEST_VECTORS
);
753 test_cipher ("serpent", MODE_ECB
, ENCRYPT
, serpent_enc_tv_template
, SERPENT_ENC_TEST_VECTORS
);
754 test_cipher ("serpent", MODE_ECB
, DECRYPT
, serpent_dec_tv_template
, SERPENT_DEC_TEST_VECTORS
);
758 test_cipher ("aes", MODE_ECB
, ENCRYPT
, aes_enc_tv_template
, AES_ENC_TEST_VECTORS
);
759 test_cipher ("aes", MODE_ECB
, DECRYPT
, aes_dec_tv_template
, AES_DEC_TEST_VECTORS
);
763 test_hash("sha384", sha384_tv_template
, SHA384_TEST_VECTORS
);
767 test_hash("sha512", sha512_tv_template
, SHA512_TEST_VECTORS
);
775 test_cipher ("cast5", MODE_ECB
, ENCRYPT
, cast5_enc_tv_template
, CAST5_ENC_TEST_VECTORS
);
776 test_cipher ("cast5", MODE_ECB
, DECRYPT
, cast5_dec_tv_template
, CAST5_DEC_TEST_VECTORS
);
780 test_cipher ("cast6", MODE_ECB
, ENCRYPT
, cast6_enc_tv_template
, CAST6_ENC_TEST_VECTORS
);
781 test_cipher ("cast6", MODE_ECB
, DECRYPT
, cast6_dec_tv_template
, CAST6_DEC_TEST_VECTORS
);
785 test_cipher ("arc4", MODE_ECB
, ENCRYPT
, arc4_enc_tv_template
, ARC4_ENC_TEST_VECTORS
);
786 test_cipher ("arc4", MODE_ECB
, DECRYPT
, arc4_dec_tv_template
, ARC4_DEC_TEST_VECTORS
);
790 test_hash("michael_mic", michael_mic_tv_template
, MICHAEL_MIC_TEST_VECTORS
);
798 test_cipher ("tea", MODE_ECB
, ENCRYPT
, tea_enc_tv_template
, TEA_ENC_TEST_VECTORS
);
799 test_cipher ("tea", MODE_ECB
, DECRYPT
, tea_dec_tv_template
, TEA_DEC_TEST_VECTORS
);
803 test_cipher ("xtea", MODE_ECB
, ENCRYPT
, xtea_enc_tv_template
, XTEA_ENC_TEST_VECTORS
);
804 test_cipher ("xtea", MODE_ECB
, DECRYPT
, xtea_dec_tv_template
, XTEA_DEC_TEST_VECTORS
);
808 test_cipher ("khazad", MODE_ECB
, ENCRYPT
, khazad_enc_tv_template
, KHAZAD_ENC_TEST_VECTORS
);
809 test_cipher ("khazad", MODE_ECB
, DECRYPT
, khazad_dec_tv_template
, KHAZAD_DEC_TEST_VECTORS
);
813 test_hash("wp512", wp512_tv_template
, WP512_TEST_VECTORS
);
817 test_hash("wp384", wp384_tv_template
, WP384_TEST_VECTORS
);
821 test_hash("wp256", wp256_tv_template
, WP256_TEST_VECTORS
);
825 test_cipher ("tnepres", MODE_ECB
, ENCRYPT
, tnepres_enc_tv_template
, TNEPRES_ENC_TEST_VECTORS
);
826 test_cipher ("tnepres", MODE_ECB
, DECRYPT
, tnepres_dec_tv_template
, TNEPRES_DEC_TEST_VECTORS
);
830 test_cipher ("anubis", MODE_ECB
, ENCRYPT
, anubis_enc_tv_template
, ANUBIS_ENC_TEST_VECTORS
);
831 test_cipher ("anubis", MODE_ECB
, DECRYPT
, anubis_dec_tv_template
, ANUBIS_DEC_TEST_VECTORS
);
832 test_cipher ("anubis", MODE_CBC
, ENCRYPT
, anubis_cbc_enc_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
833 test_cipher ("anubis", MODE_CBC
, DECRYPT
, anubis_cbc_dec_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
837 test_hash("tgr192", tgr192_tv_template
, TGR192_TEST_VECTORS
);
842 test_hash("tgr160", tgr160_tv_template
, TGR160_TEST_VECTORS
);
846 test_hash("tgr128", tgr128_tv_template
, TGR128_TEST_VECTORS
);
849 #ifdef CONFIG_CRYPTO_HMAC
851 test_hmac("md5", hmac_md5_tv_template
, HMAC_MD5_TEST_VECTORS
);
855 test_hmac("sha1", hmac_sha1_tv_template
, HMAC_SHA1_TEST_VECTORS
);
859 test_hmac("sha256", hmac_sha256_tv_template
, HMAC_SHA256_TEST_VECTORS
);
869 /* useful for debugging */
870 printk("not testing anything\n");
875 static int __init
init(void)
877 tvmem
= kmalloc(TVMEMSIZE
, GFP_KERNEL
);
881 xbuf
= kmalloc(XBUFSIZE
, GFP_KERNEL
);
895 * If an init function is provided, an exit function must also be provided
896 * to allow module unload.
898 static void __exit
fini(void) { }
903 module_param(mode
, int, 0);
905 MODULE_LICENSE("GPL");
906 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
907 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");