2 * Algorithm testing framework and tests.
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
16 #include <crypto/hash.h>
17 #include <linux/err.h>
18 #include <linux/module.h>
19 #include <linux/scatterlist.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
27 * Need slab memory for testing (size in number of pages).
32 * Indexes into the xbuf to simulate cross-page access.
44 * Used by test_cipher()
49 struct tcrypt_result
{
50 struct completion completion
;
54 struct aead_test_suite
{
56 struct aead_testvec
*vecs
;
61 struct cipher_test_suite
{
63 struct cipher_testvec
*vecs
;
68 struct comp_test_suite
{
70 struct comp_testvec
*vecs
;
75 struct hash_test_suite
{
76 struct hash_testvec
*vecs
;
80 struct alg_test_desc
{
82 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
86 struct aead_test_suite aead
;
87 struct cipher_test_suite cipher
;
88 struct comp_test_suite comp
;
89 struct hash_test_suite hash
;
93 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
95 static char *xbuf
[XBUFSIZE
];
96 static char *axbuf
[XBUFSIZE
];
98 static void hexdump(unsigned char *buf
, unsigned int len
)
100 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
105 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
107 struct tcrypt_result
*res
= req
->data
;
109 if (err
== -EINPROGRESS
)
113 complete(&res
->completion
);
116 static int test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
119 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
120 unsigned int i
, j
, k
, temp
;
121 struct scatterlist sg
[8];
123 struct ahash_request
*req
;
124 struct tcrypt_result tresult
;
128 init_completion(&tresult
.completion
);
130 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
132 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
137 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
138 tcrypt_complete
, &tresult
);
140 for (i
= 0; i
< tcount
; i
++) {
141 memset(result
, 0, 64);
145 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
146 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
148 if (template[i
].ksize
) {
149 crypto_ahash_clear_flags(tfm
, ~0);
150 ret
= crypto_ahash_setkey(tfm
, template[i
].key
,
153 printk(KERN_ERR
"alg: hash: setkey failed on "
154 "test %d for %s: ret=%d\n", i
+ 1, algo
,
160 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
161 ret
= crypto_ahash_digest(req
);
167 ret
= wait_for_completion_interruptible(
168 &tresult
.completion
);
169 if (!ret
&& !(ret
= tresult
.err
)) {
170 INIT_COMPLETION(tresult
.completion
);
175 printk(KERN_ERR
"alg: hash: digest failed on test %d "
176 "for %s: ret=%d\n", i
+ 1, algo
, -ret
);
180 if (memcmp(result
, template[i
].digest
,
181 crypto_ahash_digestsize(tfm
))) {
182 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
184 hexdump(result
, crypto_ahash_digestsize(tfm
));
191 for (i
= 0; i
< tcount
; i
++) {
192 if (template[i
].np
) {
194 memset(result
, 0, 64);
197 sg_init_table(sg
, template[i
].np
);
198 for (k
= 0; k
< template[i
].np
; k
++) {
200 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
201 offset_in_page(IDX
[k
]),
202 template[i
].plaintext
+ temp
,
205 temp
+= template[i
].tap
[k
];
208 if (template[i
].ksize
) {
209 crypto_ahash_clear_flags(tfm
, ~0);
210 ret
= crypto_ahash_setkey(tfm
, template[i
].key
,
214 printk(KERN_ERR
"alg: hash: setkey "
215 "failed on chunking test %d "
216 "for %s: ret=%d\n", j
, algo
,
222 ahash_request_set_crypt(req
, sg
, result
,
224 ret
= crypto_ahash_digest(req
);
230 ret
= wait_for_completion_interruptible(
231 &tresult
.completion
);
232 if (!ret
&& !(ret
= tresult
.err
)) {
233 INIT_COMPLETION(tresult
.completion
);
238 printk(KERN_ERR
"alg: hash: digest failed "
239 "on chunking test %d for %s: "
240 "ret=%d\n", j
, algo
, -ret
);
244 if (memcmp(result
, template[i
].digest
,
245 crypto_ahash_digestsize(tfm
))) {
246 printk(KERN_ERR
"alg: hash: Chunking test %d "
247 "failed for %s\n", j
, algo
);
248 hexdump(result
, crypto_ahash_digestsize(tfm
));
258 ahash_request_free(req
);
263 static int test_aead(struct crypto_aead
*tfm
, int enc
,
264 struct aead_testvec
*template, unsigned int tcount
)
266 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
267 unsigned int i
, j
, k
, n
, temp
;
271 struct aead_request
*req
;
272 struct scatterlist sg
[8];
273 struct scatterlist asg
[8];
275 struct tcrypt_result result
;
276 unsigned int authsize
;
286 init_completion(&result
.completion
);
288 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
290 printk(KERN_ERR
"alg: aead: Failed to allocate request for "
296 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
297 tcrypt_complete
, &result
);
299 for (i
= 0, j
= 0; i
< tcount
; i
++) {
300 if (!template[i
].np
) {
303 /* some tepmplates have no input data but they will
309 memcpy(input
, template[i
].input
, template[i
].ilen
);
310 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
312 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
314 memset(iv
, 0, MAX_IVLEN
);
316 crypto_aead_clear_flags(tfm
, ~0);
318 crypto_aead_set_flags(
319 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
321 key
= template[i
].key
;
323 ret
= crypto_aead_setkey(tfm
, key
,
325 if (!ret
== template[i
].fail
) {
326 printk(KERN_ERR
"alg: aead: setkey failed on "
327 "test %d for %s: flags=%x\n", j
, algo
,
328 crypto_aead_get_flags(tfm
));
333 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
334 ret
= crypto_aead_setauthsize(tfm
, authsize
);
336 printk(KERN_ERR
"alg: aead: Failed to set "
337 "authsize to %u on test %d for %s\n",
342 sg_init_one(&sg
[0], input
,
343 template[i
].ilen
+ (enc
? authsize
: 0));
345 sg_init_one(&asg
[0], assoc
, template[i
].alen
);
347 aead_request_set_crypt(req
, sg
, sg
,
348 template[i
].ilen
, iv
);
350 aead_request_set_assoc(req
, asg
, template[i
].alen
);
353 crypto_aead_encrypt(req
) :
354 crypto_aead_decrypt(req
);
361 ret
= wait_for_completion_interruptible(
363 if (!ret
&& !(ret
= result
.err
)) {
364 INIT_COMPLETION(result
.completion
);
369 printk(KERN_ERR
"alg: aead: %s failed on test "
370 "%d for %s: ret=%d\n", e
, j
, algo
, -ret
);
375 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
376 printk(KERN_ERR
"alg: aead: Test %d failed on "
377 "%s for %s\n", j
, e
, algo
);
378 hexdump(q
, template[i
].rlen
);
385 for (i
= 0, j
= 0; i
< tcount
; i
++) {
386 if (template[i
].np
) {
390 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
392 memset(iv
, 0, MAX_IVLEN
);
394 crypto_aead_clear_flags(tfm
, ~0);
396 crypto_aead_set_flags(
397 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
398 key
= template[i
].key
;
400 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
401 if (!ret
== template[i
].fail
) {
402 printk(KERN_ERR
"alg: aead: setkey failed on "
403 "chunk test %d for %s: flags=%x\n", j
,
404 algo
, crypto_aead_get_flags(tfm
));
409 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
412 sg_init_table(sg
, template[i
].np
);
413 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
414 if (WARN_ON(offset_in_page(IDX
[k
]) +
415 template[i
].tap
[k
] > PAGE_SIZE
))
418 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
419 offset_in_page(IDX
[k
]);
421 memcpy(q
, template[i
].input
+ temp
,
424 n
= template[i
].tap
[k
];
425 if (k
== template[i
].np
- 1 && enc
)
427 if (offset_in_page(q
) + n
< PAGE_SIZE
)
430 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
431 temp
+= template[i
].tap
[k
];
434 ret
= crypto_aead_setauthsize(tfm
, authsize
);
436 printk(KERN_ERR
"alg: aead: Failed to set "
437 "authsize to %u on chunk test %d for "
438 "%s\n", authsize
, j
, algo
);
443 if (WARN_ON(sg
[k
- 1].offset
+
444 sg
[k
- 1].length
+ authsize
>
450 sg
[k
- 1].length
+= authsize
;
453 sg_init_table(asg
, template[i
].anp
);
454 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
456 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
457 offset_in_page(IDX
[k
]),
458 template[i
].assoc
+ temp
,
459 template[i
].atap
[k
]),
460 template[i
].atap
[k
]);
461 temp
+= template[i
].atap
[k
];
464 aead_request_set_crypt(req
, sg
, sg
,
468 aead_request_set_assoc(req
, asg
, template[i
].alen
);
471 crypto_aead_encrypt(req
) :
472 crypto_aead_decrypt(req
);
479 ret
= wait_for_completion_interruptible(
481 if (!ret
&& !(ret
= result
.err
)) {
482 INIT_COMPLETION(result
.completion
);
487 printk(KERN_ERR
"alg: aead: %s failed on "
488 "chunk test %d for %s: ret=%d\n", e
, j
,
494 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
495 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
496 offset_in_page(IDX
[k
]);
498 n
= template[i
].tap
[k
];
499 if (k
== template[i
].np
- 1)
500 n
+= enc
? authsize
: -authsize
;
502 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
503 printk(KERN_ERR
"alg: aead: Chunk "
504 "test %d failed on %s at page "
505 "%u for %s\n", j
, e
, k
, algo
);
511 if (k
== template[i
].np
- 1 && !enc
) {
512 if (memcmp(q
, template[i
].input
+
518 for (n
= 0; offset_in_page(q
+ n
) &&
523 printk(KERN_ERR
"alg: aead: Result "
524 "buffer corruption in chunk "
525 "test %d on %s at page %u for "
526 "%s: %u bytes:\n", j
, e
, k
,
532 temp
+= template[i
].tap
[k
];
540 aead_request_free(req
);
544 static int test_cipher(struct crypto_ablkcipher
*tfm
, int enc
,
545 struct cipher_testvec
*template, unsigned int tcount
)
548 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm
));
549 unsigned int i
, j
, k
, n
, temp
;
552 struct ablkcipher_request
*req
;
553 struct scatterlist sg
[8];
555 struct tcrypt_result result
;
564 init_completion(&result
.completion
);
566 req
= ablkcipher_request_alloc(tfm
, GFP_KERNEL
);
568 printk(KERN_ERR
"alg: cipher: Failed to allocate request for "
574 ablkcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
575 tcrypt_complete
, &result
);
578 for (i
= 0; i
< tcount
; i
++) {
580 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
582 memset(iv
, 0, MAX_IVLEN
);
584 if (!(template[i
].np
)) {
588 memcpy(data
, template[i
].input
, template[i
].ilen
);
590 crypto_ablkcipher_clear_flags(tfm
, ~0);
592 crypto_ablkcipher_set_flags(
593 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
595 ret
= crypto_ablkcipher_setkey(tfm
, template[i
].key
,
597 if (!ret
== template[i
].fail
) {
598 printk(KERN_ERR
"alg: cipher: setkey failed "
599 "on test %d for %s: flags=%x\n", j
,
600 algo
, crypto_ablkcipher_get_flags(tfm
));
605 sg_init_one(&sg
[0], data
, template[i
].ilen
);
607 ablkcipher_request_set_crypt(req
, sg
, sg
,
608 template[i
].ilen
, iv
);
610 crypto_ablkcipher_encrypt(req
) :
611 crypto_ablkcipher_decrypt(req
);
618 ret
= wait_for_completion_interruptible(
620 if (!ret
&& !((ret
= result
.err
))) {
621 INIT_COMPLETION(result
.completion
);
626 printk(KERN_ERR
"alg: cipher: %s failed on "
627 "test %d for %s: ret=%d\n", e
, j
, algo
,
633 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
634 printk(KERN_ERR
"alg: cipher: Test %d failed "
635 "on %s for %s\n", j
, e
, algo
);
636 hexdump(q
, template[i
].rlen
);
644 for (i
= 0; i
< tcount
; i
++) {
647 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
649 memset(iv
, 0, MAX_IVLEN
);
651 if (template[i
].np
) {
654 crypto_ablkcipher_clear_flags(tfm
, ~0);
656 crypto_ablkcipher_set_flags(
657 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
659 ret
= crypto_ablkcipher_setkey(tfm
, template[i
].key
,
661 if (!ret
== template[i
].fail
) {
662 printk(KERN_ERR
"alg: cipher: setkey failed "
663 "on chunk test %d for %s: flags=%x\n",
665 crypto_ablkcipher_get_flags(tfm
));
672 sg_init_table(sg
, template[i
].np
);
673 for (k
= 0; k
< template[i
].np
; k
++) {
674 if (WARN_ON(offset_in_page(IDX
[k
]) +
675 template[i
].tap
[k
] > PAGE_SIZE
))
678 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
679 offset_in_page(IDX
[k
]);
681 memcpy(q
, template[i
].input
+ temp
,
684 if (offset_in_page(q
) + template[i
].tap
[k
] <
686 q
[template[i
].tap
[k
]] = 0;
688 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
690 temp
+= template[i
].tap
[k
];
693 ablkcipher_request_set_crypt(req
, sg
, sg
,
694 template[i
].ilen
, iv
);
697 crypto_ablkcipher_encrypt(req
) :
698 crypto_ablkcipher_decrypt(req
);
705 ret
= wait_for_completion_interruptible(
707 if (!ret
&& !((ret
= result
.err
))) {
708 INIT_COMPLETION(result
.completion
);
713 printk(KERN_ERR
"alg: cipher: %s failed on "
714 "chunk test %d for %s: ret=%d\n", e
, j
,
721 for (k
= 0; k
< template[i
].np
; k
++) {
722 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
723 offset_in_page(IDX
[k
]);
725 if (memcmp(q
, template[i
].result
+ temp
,
726 template[i
].tap
[k
])) {
727 printk(KERN_ERR
"alg: cipher: Chunk "
728 "test %d failed on %s at page "
729 "%u for %s\n", j
, e
, k
, algo
);
730 hexdump(q
, template[i
].tap
[k
]);
734 q
+= template[i
].tap
[k
];
735 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
738 printk(KERN_ERR
"alg: cipher: "
739 "Result buffer corruption in "
740 "chunk test %d on %s at page "
741 "%u for %s: %u bytes:\n", j
, e
,
746 temp
+= template[i
].tap
[k
];
754 ablkcipher_request_free(req
);
758 static int test_comp(struct crypto_comp
*tfm
, struct comp_testvec
*ctemplate
,
759 struct comp_testvec
*dtemplate
, int ctcount
, int dtcount
)
761 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
763 char result
[COMP_BUF_SIZE
];
766 for (i
= 0; i
< ctcount
; i
++) {
767 int ilen
, dlen
= COMP_BUF_SIZE
;
769 memset(result
, 0, sizeof (result
));
771 ilen
= ctemplate
[i
].inlen
;
772 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
773 ilen
, result
, &dlen
);
775 printk(KERN_ERR
"alg: comp: compression failed "
776 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
781 if (memcmp(result
, ctemplate
[i
].output
, dlen
)) {
782 printk(KERN_ERR
"alg: comp: Compression test %d "
783 "failed for %s\n", i
+ 1, algo
);
784 hexdump(result
, dlen
);
790 for (i
= 0; i
< dtcount
; i
++) {
791 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
793 memset(result
, 0, sizeof (result
));
795 ilen
= dtemplate
[i
].inlen
;
796 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
797 ilen
, result
, &dlen
);
799 printk(KERN_ERR
"alg: comp: decompression failed "
800 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
805 if (memcmp(result
, dtemplate
[i
].output
, dlen
)) {
806 printk(KERN_ERR
"alg: comp: Decompression test %d "
807 "failed for %s\n", i
+ 1, algo
);
808 hexdump(result
, dlen
);
820 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
823 struct crypto_aead
*tfm
;
826 tfm
= crypto_alloc_aead(driver
, type
, mask
);
828 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
829 "%ld\n", driver
, PTR_ERR(tfm
));
833 if (desc
->suite
.aead
.enc
.vecs
) {
834 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
835 desc
->suite
.aead
.enc
.count
);
840 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
841 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
842 desc
->suite
.aead
.dec
.count
);
845 crypto_free_aead(tfm
);
849 static int alg_test_cipher(const struct alg_test_desc
*desc
,
850 const char *driver
, u32 type
, u32 mask
)
852 struct crypto_ablkcipher
*tfm
;
855 tfm
= crypto_alloc_ablkcipher(driver
, type
, mask
);
857 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
858 "%s: %ld\n", driver
, PTR_ERR(tfm
));
862 if (desc
->suite
.cipher
.enc
.vecs
) {
863 err
= test_cipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
864 desc
->suite
.cipher
.enc
.count
);
869 if (desc
->suite
.cipher
.dec
.vecs
)
870 err
= test_cipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
871 desc
->suite
.cipher
.dec
.count
);
874 crypto_free_ablkcipher(tfm
);
878 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
881 struct crypto_comp
*tfm
;
884 tfm
= crypto_alloc_comp(driver
, type
, mask
);
886 printk(KERN_ERR
"alg: comp: Failed to load transform for %s: "
887 "%ld\n", driver
, PTR_ERR(tfm
));
891 err
= test_comp(tfm
, desc
->suite
.comp
.comp
.vecs
,
892 desc
->suite
.comp
.decomp
.vecs
,
893 desc
->suite
.comp
.comp
.count
,
894 desc
->suite
.comp
.decomp
.count
);
896 crypto_free_comp(tfm
);
900 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
903 struct crypto_ahash
*tfm
;
906 tfm
= crypto_alloc_ahash(driver
, type
, mask
);
908 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
909 "%ld\n", driver
, PTR_ERR(tfm
));
913 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
, desc
->suite
.hash
.count
);
915 crypto_free_ahash(tfm
);
919 /* Please keep this list sorted by algorithm name. */
920 static const struct alg_test_desc alg_test_descs
[] = {
923 .test
= alg_test_cipher
,
927 .vecs
= aes_cbc_enc_tv_template
,
928 .count
= AES_CBC_ENC_TEST_VECTORS
931 .vecs
= aes_cbc_dec_tv_template
,
932 .count
= AES_CBC_DEC_TEST_VECTORS
937 .alg
= "cbc(anubis)",
938 .test
= alg_test_cipher
,
942 .vecs
= anubis_cbc_enc_tv_template
,
943 .count
= ANUBIS_CBC_ENC_TEST_VECTORS
946 .vecs
= anubis_cbc_dec_tv_template
,
947 .count
= ANUBIS_CBC_DEC_TEST_VECTORS
952 .alg
= "cbc(blowfish)",
953 .test
= alg_test_cipher
,
957 .vecs
= bf_cbc_enc_tv_template
,
958 .count
= BF_CBC_ENC_TEST_VECTORS
961 .vecs
= bf_cbc_dec_tv_template
,
962 .count
= BF_CBC_DEC_TEST_VECTORS
967 .alg
= "cbc(camellia)",
968 .test
= alg_test_cipher
,
972 .vecs
= camellia_cbc_enc_tv_template
,
973 .count
= CAMELLIA_CBC_ENC_TEST_VECTORS
976 .vecs
= camellia_cbc_dec_tv_template
,
977 .count
= CAMELLIA_CBC_DEC_TEST_VECTORS
983 .test
= alg_test_cipher
,
987 .vecs
= des_cbc_enc_tv_template
,
988 .count
= DES_CBC_ENC_TEST_VECTORS
991 .vecs
= des_cbc_dec_tv_template
,
992 .count
= DES_CBC_DEC_TEST_VECTORS
997 .alg
= "cbc(des3_ede)",
998 .test
= alg_test_cipher
,
1002 .vecs
= des3_ede_cbc_enc_tv_template
,
1003 .count
= DES3_EDE_CBC_ENC_TEST_VECTORS
1006 .vecs
= des3_ede_cbc_dec_tv_template
,
1007 .count
= DES3_EDE_CBC_DEC_TEST_VECTORS
1012 .alg
= "cbc(twofish)",
1013 .test
= alg_test_cipher
,
1017 .vecs
= tf_cbc_enc_tv_template
,
1018 .count
= TF_CBC_ENC_TEST_VECTORS
1021 .vecs
= tf_cbc_dec_tv_template
,
1022 .count
= TF_CBC_DEC_TEST_VECTORS
1028 .test
= alg_test_aead
,
1032 .vecs
= aes_ccm_enc_tv_template
,
1033 .count
= AES_CCM_ENC_TEST_VECTORS
1036 .vecs
= aes_ccm_dec_tv_template
,
1037 .count
= AES_CCM_DEC_TEST_VECTORS
1043 .test
= alg_test_hash
,
1046 .vecs
= crc32c_tv_template
,
1047 .count
= CRC32C_TEST_VECTORS
1051 .alg
= "cts(cbc(aes))",
1052 .test
= alg_test_cipher
,
1056 .vecs
= cts_mode_enc_tv_template
,
1057 .count
= CTS_MODE_ENC_TEST_VECTORS
1060 .vecs
= cts_mode_dec_tv_template
,
1061 .count
= CTS_MODE_DEC_TEST_VECTORS
1067 .test
= alg_test_comp
,
1071 .vecs
= deflate_comp_tv_template
,
1072 .count
= DEFLATE_COMP_TEST_VECTORS
1075 .vecs
= deflate_decomp_tv_template
,
1076 .count
= DEFLATE_DECOMP_TEST_VECTORS
1082 .test
= alg_test_cipher
,
1086 .vecs
= aes_enc_tv_template
,
1087 .count
= AES_ENC_TEST_VECTORS
1090 .vecs
= aes_dec_tv_template
,
1091 .count
= AES_DEC_TEST_VECTORS
1096 .alg
= "ecb(anubis)",
1097 .test
= alg_test_cipher
,
1101 .vecs
= anubis_enc_tv_template
,
1102 .count
= ANUBIS_ENC_TEST_VECTORS
1105 .vecs
= anubis_dec_tv_template
,
1106 .count
= ANUBIS_DEC_TEST_VECTORS
1112 .test
= alg_test_cipher
,
1116 .vecs
= arc4_enc_tv_template
,
1117 .count
= ARC4_ENC_TEST_VECTORS
1120 .vecs
= arc4_dec_tv_template
,
1121 .count
= ARC4_DEC_TEST_VECTORS
1126 .alg
= "ecb(blowfish)",
1127 .test
= alg_test_cipher
,
1131 .vecs
= bf_enc_tv_template
,
1132 .count
= BF_ENC_TEST_VECTORS
1135 .vecs
= bf_dec_tv_template
,
1136 .count
= BF_DEC_TEST_VECTORS
1141 .alg
= "ecb(camellia)",
1142 .test
= alg_test_cipher
,
1146 .vecs
= camellia_enc_tv_template
,
1147 .count
= CAMELLIA_ENC_TEST_VECTORS
1150 .vecs
= camellia_dec_tv_template
,
1151 .count
= CAMELLIA_DEC_TEST_VECTORS
1156 .alg
= "ecb(cast5)",
1157 .test
= alg_test_cipher
,
1161 .vecs
= cast5_enc_tv_template
,
1162 .count
= CAST5_ENC_TEST_VECTORS
1165 .vecs
= cast5_dec_tv_template
,
1166 .count
= CAST5_DEC_TEST_VECTORS
1171 .alg
= "ecb(cast6)",
1172 .test
= alg_test_cipher
,
1176 .vecs
= cast6_enc_tv_template
,
1177 .count
= CAST6_ENC_TEST_VECTORS
1180 .vecs
= cast6_dec_tv_template
,
1181 .count
= CAST6_DEC_TEST_VECTORS
1187 .test
= alg_test_cipher
,
1191 .vecs
= des_enc_tv_template
,
1192 .count
= DES_ENC_TEST_VECTORS
1195 .vecs
= des_dec_tv_template
,
1196 .count
= DES_DEC_TEST_VECTORS
1201 .alg
= "ecb(des3_ede)",
1202 .test
= alg_test_cipher
,
1206 .vecs
= des3_ede_enc_tv_template
,
1207 .count
= DES3_EDE_ENC_TEST_VECTORS
1210 .vecs
= des3_ede_dec_tv_template
,
1211 .count
= DES3_EDE_DEC_TEST_VECTORS
1216 .alg
= "ecb(khazad)",
1217 .test
= alg_test_cipher
,
1221 .vecs
= khazad_enc_tv_template
,
1222 .count
= KHAZAD_ENC_TEST_VECTORS
1225 .vecs
= khazad_dec_tv_template
,
1226 .count
= KHAZAD_DEC_TEST_VECTORS
1232 .test
= alg_test_cipher
,
1236 .vecs
= seed_enc_tv_template
,
1237 .count
= SEED_ENC_TEST_VECTORS
1240 .vecs
= seed_dec_tv_template
,
1241 .count
= SEED_DEC_TEST_VECTORS
1246 .alg
= "ecb(serpent)",
1247 .test
= alg_test_cipher
,
1251 .vecs
= serpent_enc_tv_template
,
1252 .count
= SERPENT_ENC_TEST_VECTORS
1255 .vecs
= serpent_dec_tv_template
,
1256 .count
= SERPENT_DEC_TEST_VECTORS
1262 .test
= alg_test_cipher
,
1266 .vecs
= tea_enc_tv_template
,
1267 .count
= TEA_ENC_TEST_VECTORS
1270 .vecs
= tea_dec_tv_template
,
1271 .count
= TEA_DEC_TEST_VECTORS
1276 .alg
= "ecb(tnepres)",
1277 .test
= alg_test_cipher
,
1281 .vecs
= tnepres_enc_tv_template
,
1282 .count
= TNEPRES_ENC_TEST_VECTORS
1285 .vecs
= tnepres_dec_tv_template
,
1286 .count
= TNEPRES_DEC_TEST_VECTORS
1291 .alg
= "ecb(twofish)",
1292 .test
= alg_test_cipher
,
1296 .vecs
= tf_enc_tv_template
,
1297 .count
= TF_ENC_TEST_VECTORS
1300 .vecs
= tf_dec_tv_template
,
1301 .count
= TF_DEC_TEST_VECTORS
1307 .test
= alg_test_cipher
,
1311 .vecs
= xeta_enc_tv_template
,
1312 .count
= XETA_ENC_TEST_VECTORS
1315 .vecs
= xeta_dec_tv_template
,
1316 .count
= XETA_DEC_TEST_VECTORS
1322 .test
= alg_test_cipher
,
1326 .vecs
= xtea_enc_tv_template
,
1327 .count
= XTEA_ENC_TEST_VECTORS
1330 .vecs
= xtea_dec_tv_template
,
1331 .count
= XTEA_DEC_TEST_VECTORS
1337 .test
= alg_test_aead
,
1341 .vecs
= aes_gcm_enc_tv_template
,
1342 .count
= AES_GCM_ENC_TEST_VECTORS
1345 .vecs
= aes_gcm_dec_tv_template
,
1346 .count
= AES_GCM_DEC_TEST_VECTORS
1352 .test
= alg_test_hash
,
1355 .vecs
= hmac_md5_tv_template
,
1356 .count
= HMAC_MD5_TEST_VECTORS
1360 .alg
= "hmac(rmd128)",
1361 .test
= alg_test_hash
,
1364 .vecs
= hmac_rmd128_tv_template
,
1365 .count
= HMAC_RMD128_TEST_VECTORS
1369 .alg
= "hmac(rmd160)",
1370 .test
= alg_test_hash
,
1373 .vecs
= hmac_rmd160_tv_template
,
1374 .count
= HMAC_RMD160_TEST_VECTORS
1378 .alg
= "hmac(sha1)",
1379 .test
= alg_test_hash
,
1382 .vecs
= hmac_sha1_tv_template
,
1383 .count
= HMAC_SHA1_TEST_VECTORS
1387 .alg
= "hmac(sha224)",
1388 .test
= alg_test_hash
,
1391 .vecs
= hmac_sha224_tv_template
,
1392 .count
= HMAC_SHA224_TEST_VECTORS
1396 .alg
= "hmac(sha256)",
1397 .test
= alg_test_hash
,
1400 .vecs
= hmac_sha256_tv_template
,
1401 .count
= HMAC_SHA256_TEST_VECTORS
1405 .alg
= "hmac(sha384)",
1406 .test
= alg_test_hash
,
1409 .vecs
= hmac_sha384_tv_template
,
1410 .count
= HMAC_SHA384_TEST_VECTORS
1414 .alg
= "hmac(sha512)",
1415 .test
= alg_test_hash
,
1418 .vecs
= hmac_sha512_tv_template
,
1419 .count
= HMAC_SHA512_TEST_VECTORS
1424 .test
= alg_test_cipher
,
1428 .vecs
= aes_lrw_enc_tv_template
,
1429 .count
= AES_LRW_ENC_TEST_VECTORS
1432 .vecs
= aes_lrw_dec_tv_template
,
1433 .count
= AES_LRW_DEC_TEST_VECTORS
1439 .test
= alg_test_comp
,
1443 .vecs
= lzo_comp_tv_template
,
1444 .count
= LZO_COMP_TEST_VECTORS
1447 .vecs
= lzo_decomp_tv_template
,
1448 .count
= LZO_DECOMP_TEST_VECTORS
1454 .test
= alg_test_hash
,
1457 .vecs
= md4_tv_template
,
1458 .count
= MD4_TEST_VECTORS
1463 .test
= alg_test_hash
,
1466 .vecs
= md5_tv_template
,
1467 .count
= MD5_TEST_VECTORS
1471 .alg
= "michael_mic",
1472 .test
= alg_test_hash
,
1475 .vecs
= michael_mic_tv_template
,
1476 .count
= MICHAEL_MIC_TEST_VECTORS
1480 .alg
= "pcbc(fcrypt)",
1481 .test
= alg_test_cipher
,
1485 .vecs
= fcrypt_pcbc_enc_tv_template
,
1486 .count
= FCRYPT_ENC_TEST_VECTORS
1489 .vecs
= fcrypt_pcbc_dec_tv_template
,
1490 .count
= FCRYPT_DEC_TEST_VECTORS
1495 .alg
= "rfc3686(ctr(aes))",
1496 .test
= alg_test_cipher
,
1500 .vecs
= aes_ctr_enc_tv_template
,
1501 .count
= AES_CTR_ENC_TEST_VECTORS
1504 .vecs
= aes_ctr_dec_tv_template
,
1505 .count
= AES_CTR_DEC_TEST_VECTORS
1511 .test
= alg_test_hash
,
1514 .vecs
= rmd128_tv_template
,
1515 .count
= RMD128_TEST_VECTORS
1520 .test
= alg_test_hash
,
1523 .vecs
= rmd160_tv_template
,
1524 .count
= RMD160_TEST_VECTORS
1529 .test
= alg_test_hash
,
1532 .vecs
= rmd256_tv_template
,
1533 .count
= RMD256_TEST_VECTORS
1538 .test
= alg_test_hash
,
1541 .vecs
= rmd320_tv_template
,
1542 .count
= RMD320_TEST_VECTORS
1547 .test
= alg_test_cipher
,
1551 .vecs
= salsa20_stream_enc_tv_template
,
1552 .count
= SALSA20_STREAM_ENC_TEST_VECTORS
1558 .test
= alg_test_hash
,
1561 .vecs
= sha1_tv_template
,
1562 .count
= SHA1_TEST_VECTORS
1567 .test
= alg_test_hash
,
1570 .vecs
= sha224_tv_template
,
1571 .count
= SHA224_TEST_VECTORS
1576 .test
= alg_test_hash
,
1579 .vecs
= sha256_tv_template
,
1580 .count
= SHA256_TEST_VECTORS
1585 .test
= alg_test_hash
,
1588 .vecs
= sha384_tv_template
,
1589 .count
= SHA384_TEST_VECTORS
1594 .test
= alg_test_hash
,
1597 .vecs
= sha512_tv_template
,
1598 .count
= SHA512_TEST_VECTORS
1603 .test
= alg_test_hash
,
1606 .vecs
= tgr128_tv_template
,
1607 .count
= TGR128_TEST_VECTORS
1612 .test
= alg_test_hash
,
1615 .vecs
= tgr160_tv_template
,
1616 .count
= TGR160_TEST_VECTORS
1621 .test
= alg_test_hash
,
1624 .vecs
= tgr192_tv_template
,
1625 .count
= TGR192_TEST_VECTORS
1630 .test
= alg_test_hash
,
1633 .vecs
= wp256_tv_template
,
1634 .count
= WP256_TEST_VECTORS
1639 .test
= alg_test_hash
,
1642 .vecs
= wp384_tv_template
,
1643 .count
= WP384_TEST_VECTORS
1648 .test
= alg_test_hash
,
1651 .vecs
= wp512_tv_template
,
1652 .count
= WP512_TEST_VECTORS
1657 .test
= alg_test_hash
,
1660 .vecs
= aes_xcbc128_tv_template
,
1661 .count
= XCBC_AES_TEST_VECTORS
1666 .test
= alg_test_cipher
,
1670 .vecs
= aes_xts_enc_tv_template
,
1671 .count
= AES_XTS_ENC_TEST_VECTORS
1674 .vecs
= aes_xts_dec_tv_template
,
1675 .count
= AES_XTS_DEC_TEST_VECTORS
1682 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
1685 int end
= ARRAY_SIZE(alg_test_descs
);
1687 while (start
< end
) {
1688 int i
= (start
+ end
) / 2;
1689 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
1701 return alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
1705 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
1708 EXPORT_SYMBOL_GPL(alg_test
);
1710 int __init
testmgr_init(void)
1714 for (i
= 0; i
< XBUFSIZE
; i
++) {
1715 xbuf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
1720 for (i
= 0; i
< XBUFSIZE
; i
++) {
1721 axbuf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
1723 goto err_free_axbuf
;
1729 for (i
= 0; i
< XBUFSIZE
&& axbuf
[i
]; i
++)
1730 free_page((unsigned long)axbuf
[i
]);
1732 for (i
= 0; i
< XBUFSIZE
&& xbuf
[i
]; i
++)
1733 free_page((unsigned long)xbuf
[i
]);
1738 void testmgr_exit(void)
1742 for (i
= 0; i
< XBUFSIZE
; i
++)
1743 free_page((unsigned long)axbuf
[i
]);
1744 for (i
= 0; i
< XBUFSIZE
; i
++)
1745 free_page((unsigned long)xbuf
[i
]);