blob: 54681838da6c35023915da4da2d549f16987217d [file] [log] [blame]
Herbert Xuda7f0332008-07-31 17:08:25 +08001/*
2 * Algorithm testing framework and tests.
3 *
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>
8 *
Adrian Hoban69435b92010-11-04 15:02:04 -04009 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation.
15 *
Herbert Xuda7f0332008-07-31 17:08:25 +080016 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
19 * any later version.
20 *
21 */
22
Herbert Xu1ce33112015-04-22 15:06:31 +080023#include <crypto/aead.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080024#include <crypto/hash.h>
Herbert Xu12773d92015-08-20 15:21:46 +080025#include <crypto/skcipher.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080026#include <linux/err.h>
Herbert Xu1c41b882015-04-22 13:25:58 +080027#include <linux/fips.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080028#include <linux/module.h>
29#include <linux/scatterlist.h>
30#include <linux/slab.h>
31#include <linux/string.h>
Jarod Wilson7647d6c2009-05-04 19:44:50 +080032#include <crypto/rng.h>
Stephan Mueller64d1cdf2014-05-31 17:25:36 +020033#include <crypto/drbg.h>
Tadeusz Struk946cc462015-06-16 10:31:06 -070034#include <crypto/akcipher.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080035
36#include "internal.h"
Alexander Shishkin0b767f92010-06-03 20:53:43 +100037
Herbert Xu326a6342010-08-06 09:40:28 +080038#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
Alexander Shishkin0b767f92010-06-03 20:53:43 +100039
40/* a perfect nop */
41int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
42{
43 return 0;
44}
45
46#else
47
Herbert Xuda7f0332008-07-31 17:08:25 +080048#include "testmgr.h"
49
50/*
51 * Need slab memory for testing (size in number of pages).
52 */
53#define XBUFSIZE 8
54
55/*
56 * Indexes into the xbuf to simulate cross-page access.
57 */
58#define IDX1 32
59#define IDX2 32400
60#define IDX3 1
61#define IDX4 8193
62#define IDX5 22222
63#define IDX6 17101
64#define IDX7 27333
65#define IDX8 3000
66
67/*
68* Used by test_cipher()
69*/
70#define ENCRYPT 1
71#define DECRYPT 0
72
73struct tcrypt_result {
74 struct completion completion;
75 int err;
76};
77
78struct aead_test_suite {
79 struct {
80 struct aead_testvec *vecs;
81 unsigned int count;
82 } enc, dec;
83};
84
85struct cipher_test_suite {
86 struct {
87 struct cipher_testvec *vecs;
88 unsigned int count;
89 } enc, dec;
90};
91
92struct comp_test_suite {
93 struct {
94 struct comp_testvec *vecs;
95 unsigned int count;
96 } comp, decomp;
97};
98
99struct hash_test_suite {
100 struct hash_testvec *vecs;
101 unsigned int count;
102};
103
Jarod Wilson7647d6c2009-05-04 19:44:50 +0800104struct cprng_test_suite {
105 struct cprng_testvec *vecs;
106 unsigned int count;
107};
108
Stephan Mueller64d1cdf2014-05-31 17:25:36 +0200109struct drbg_test_suite {
110 struct drbg_testvec *vecs;
111 unsigned int count;
112};
113
Tadeusz Struk946cc462015-06-16 10:31:06 -0700114struct akcipher_test_suite {
115 struct akcipher_testvec *vecs;
116 unsigned int count;
117};
118
Herbert Xuda7f0332008-07-31 17:08:25 +0800119struct alg_test_desc {
120 const char *alg;
121 int (*test)(const struct alg_test_desc *desc, const char *driver,
122 u32 type, u32 mask);
Jarod Wilsona1915d52009-05-15 15:16:03 +1000123 int fips_allowed; /* set if alg is allowed in fips mode */
Herbert Xuda7f0332008-07-31 17:08:25 +0800124
125 union {
126 struct aead_test_suite aead;
127 struct cipher_test_suite cipher;
128 struct comp_test_suite comp;
129 struct hash_test_suite hash;
Jarod Wilson7647d6c2009-05-04 19:44:50 +0800130 struct cprng_test_suite cprng;
Stephan Mueller64d1cdf2014-05-31 17:25:36 +0200131 struct drbg_test_suite drbg;
Tadeusz Struk946cc462015-06-16 10:31:06 -0700132 struct akcipher_test_suite akcipher;
Herbert Xuda7f0332008-07-31 17:08:25 +0800133 } suite;
134};
135
136static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
137
Herbert Xuda7f0332008-07-31 17:08:25 +0800138static void hexdump(unsigned char *buf, unsigned int len)
139{
140 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
141 16, 1,
142 buf, len, false);
143}
144
145static void tcrypt_complete(struct crypto_async_request *req, int err)
146{
147 struct tcrypt_result *res = req->data;
148
149 if (err == -EINPROGRESS)
150 return;
151
152 res->err = err;
153 complete(&res->completion);
154}
155
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800156static int testmgr_alloc_buf(char *buf[XBUFSIZE])
157{
158 int i;
159
160 for (i = 0; i < XBUFSIZE; i++) {
161 buf[i] = (void *)__get_free_page(GFP_KERNEL);
162 if (!buf[i])
163 goto err_free_buf;
164 }
165
166 return 0;
167
168err_free_buf:
169 while (i-- > 0)
170 free_page((unsigned long)buf[i]);
171
172 return -ENOMEM;
173}
174
175static void testmgr_free_buf(char *buf[XBUFSIZE])
176{
177 int i;
178
179 for (i = 0; i < XBUFSIZE; i++)
180 free_page((unsigned long)buf[i]);
181}
182
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300183static int wait_async_op(struct tcrypt_result *tr, int ret)
David S. Millera8f1a052010-05-19 14:12:03 +1000184{
185 if (ret == -EINPROGRESS || ret == -EBUSY) {
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100186 wait_for_completion(&tr->completion);
Wolfram Sang16735d02013-11-14 14:32:02 -0800187 reinit_completion(&tr->completion);
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100188 ret = tr->err;
David S. Millera8f1a052010-05-19 14:12:03 +1000189 }
190 return ret;
191}
192
Wang, Rui Y018ba952016-02-03 18:26:57 +0800193static int ahash_partial_update(struct ahash_request **preq,
194 struct crypto_ahash *tfm, struct hash_testvec *template,
195 void *hash_buff, int k, int temp, struct scatterlist *sg,
196 const char *algo, char *result, struct tcrypt_result *tresult)
197{
198 char *state;
199 struct ahash_request *req;
200 int statesize, ret = -EINVAL;
201
202 req = *preq;
203 statesize = crypto_ahash_statesize(
204 crypto_ahash_reqtfm(req));
205 state = kmalloc(statesize, GFP_KERNEL);
206 if (!state) {
207 pr_err("alt: hash: Failed to alloc state for %s\n", algo);
208 goto out_nostate;
209 }
210 ret = crypto_ahash_export(req, state);
211 if (ret) {
212 pr_err("alt: hash: Failed to export() for %s\n", algo);
213 goto out;
214 }
215 ahash_request_free(req);
216 req = ahash_request_alloc(tfm, GFP_KERNEL);
217 if (!req) {
218 pr_err("alg: hash: Failed to alloc request for %s\n", algo);
219 goto out_noreq;
220 }
221 ahash_request_set_callback(req,
222 CRYPTO_TFM_REQ_MAY_BACKLOG,
223 tcrypt_complete, tresult);
224
225 memcpy(hash_buff, template->plaintext + temp,
226 template->tap[k]);
227 sg_init_one(&sg[0], hash_buff, template->tap[k]);
228 ahash_request_set_crypt(req, sg, result, template->tap[k]);
229 ret = crypto_ahash_import(req, state);
230 if (ret) {
231 pr_err("alg: hash: Failed to import() for %s\n", algo);
232 goto out;
233 }
234 ret = wait_async_op(tresult, crypto_ahash_update(req));
235 if (ret)
236 goto out;
237 *preq = req;
238 ret = 0;
239 goto out_noreq;
240out:
241 ahash_request_free(req);
242out_noreq:
243 kfree(state);
244out_nostate:
245 return ret;
246}
247
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300248static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
249 unsigned int tcount, bool use_digest,
250 const int align_offset)
Herbert Xuda7f0332008-07-31 17:08:25 +0800251{
252 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
253 unsigned int i, j, k, temp;
254 struct scatterlist sg[8];
Horia Geanta29b77e52014-07-23 11:59:38 +0300255 char *result;
256 char *key;
Herbert Xuda7f0332008-07-31 17:08:25 +0800257 struct ahash_request *req;
258 struct tcrypt_result tresult;
Herbert Xuda7f0332008-07-31 17:08:25 +0800259 void *hash_buff;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800260 char *xbuf[XBUFSIZE];
261 int ret = -ENOMEM;
262
Horia Geanta29b77e52014-07-23 11:59:38 +0300263 result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
264 if (!result)
265 return ret;
266 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
267 if (!key)
268 goto out_nobuf;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800269 if (testmgr_alloc_buf(xbuf))
270 goto out_nobuf;
Herbert Xuda7f0332008-07-31 17:08:25 +0800271
272 init_completion(&tresult.completion);
273
274 req = ahash_request_alloc(tfm, GFP_KERNEL);
275 if (!req) {
276 printk(KERN_ERR "alg: hash: Failed to allocate request for "
277 "%s\n", algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800278 goto out_noreq;
279 }
280 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
281 tcrypt_complete, &tresult);
282
Herbert Xua0cfae52009-05-29 16:23:12 +1000283 j = 0;
Herbert Xuda7f0332008-07-31 17:08:25 +0800284 for (i = 0; i < tcount; i++) {
Herbert Xua0cfae52009-05-29 16:23:12 +1000285 if (template[i].np)
286 continue;
287
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300288 ret = -EINVAL;
289 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
290 goto out;
291
Herbert Xua0cfae52009-05-29 16:23:12 +1000292 j++;
Horia Geanta29b77e52014-07-23 11:59:38 +0300293 memset(result, 0, MAX_DIGEST_SIZE);
Herbert Xuda7f0332008-07-31 17:08:25 +0800294
295 hash_buff = xbuf[0];
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300296 hash_buff += align_offset;
Herbert Xuda7f0332008-07-31 17:08:25 +0800297
298 memcpy(hash_buff, template[i].plaintext, template[i].psize);
299 sg_init_one(&sg[0], hash_buff, template[i].psize);
300
301 if (template[i].ksize) {
302 crypto_ahash_clear_flags(tfm, ~0);
Horia Geanta29b77e52014-07-23 11:59:38 +0300303 if (template[i].ksize > MAX_KEYLEN) {
304 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
305 j, algo, template[i].ksize, MAX_KEYLEN);
306 ret = -EINVAL;
307 goto out;
308 }
309 memcpy(key, template[i].key, template[i].ksize);
310 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
Herbert Xuda7f0332008-07-31 17:08:25 +0800311 if (ret) {
312 printk(KERN_ERR "alg: hash: setkey failed on "
Herbert Xua0cfae52009-05-29 16:23:12 +1000313 "test %d for %s: ret=%d\n", j, algo,
Herbert Xuda7f0332008-07-31 17:08:25 +0800314 -ret);
315 goto out;
316 }
317 }
318
319 ahash_request_set_crypt(req, sg, result, template[i].psize);
David S. Millera8f1a052010-05-19 14:12:03 +1000320 if (use_digest) {
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300321 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000322 if (ret) {
323 pr_err("alg: hash: digest failed on test %d "
324 "for %s: ret=%d\n", j, algo, -ret);
325 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800326 }
David S. Millera8f1a052010-05-19 14:12:03 +1000327 } else {
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300328 ret = wait_async_op(&tresult, crypto_ahash_init(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000329 if (ret) {
330 pr_err("alt: hash: init failed on test %d "
331 "for %s: ret=%d\n", j, algo, -ret);
332 goto out;
333 }
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300334 ret = wait_async_op(&tresult, crypto_ahash_update(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000335 if (ret) {
336 pr_err("alt: hash: update failed on test %d "
337 "for %s: ret=%d\n", j, algo, -ret);
338 goto out;
339 }
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300340 ret = wait_async_op(&tresult, crypto_ahash_final(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000341 if (ret) {
342 pr_err("alt: hash: final failed on test %d "
343 "for %s: ret=%d\n", j, algo, -ret);
344 goto out;
345 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800346 }
347
348 if (memcmp(result, template[i].digest,
349 crypto_ahash_digestsize(tfm))) {
350 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
Herbert Xua0cfae52009-05-29 16:23:12 +1000351 j, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800352 hexdump(result, crypto_ahash_digestsize(tfm));
353 ret = -EINVAL;
354 goto out;
355 }
356 }
357
358 j = 0;
359 for (i = 0; i < tcount; i++) {
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300360 /* alignment tests are only done with continuous buffers */
361 if (align_offset != 0)
362 break;
363
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300364 if (!template[i].np)
365 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800366
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300367 j++;
368 memset(result, 0, MAX_DIGEST_SIZE);
Herbert Xuda7f0332008-07-31 17:08:25 +0800369
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300370 temp = 0;
371 sg_init_table(sg, template[i].np);
372 ret = -EINVAL;
373 for (k = 0; k < template[i].np; k++) {
374 if (WARN_ON(offset_in_page(IDX[k]) +
375 template[i].tap[k] > PAGE_SIZE))
Herbert Xuda7f0332008-07-31 17:08:25 +0800376 goto out;
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300377 sg_set_buf(&sg[k],
378 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
379 offset_in_page(IDX[k]),
380 template[i].plaintext + temp,
381 template[i].tap[k]),
382 template[i].tap[k]);
383 temp += template[i].tap[k];
384 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800385
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300386 if (template[i].ksize) {
387 if (template[i].ksize > MAX_KEYLEN) {
388 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
389 j, algo, template[i].ksize, MAX_KEYLEN);
Herbert Xuda7f0332008-07-31 17:08:25 +0800390 ret = -EINVAL;
391 goto out;
392 }
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300393 crypto_ahash_clear_flags(tfm, ~0);
394 memcpy(key, template[i].key, template[i].ksize);
395 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
396
397 if (ret) {
398 printk(KERN_ERR "alg: hash: setkey "
399 "failed on chunking test %d "
400 "for %s: ret=%d\n", j, algo, -ret);
401 goto out;
402 }
403 }
404
405 ahash_request_set_crypt(req, sg, result, template[i].psize);
406 ret = crypto_ahash_digest(req);
407 switch (ret) {
408 case 0:
409 break;
410 case -EINPROGRESS:
411 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100412 wait_for_completion(&tresult.completion);
413 reinit_completion(&tresult.completion);
414 ret = tresult.err;
415 if (!ret)
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300416 break;
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300417 /* fall through */
418 default:
419 printk(KERN_ERR "alg: hash: digest failed "
420 "on chunking test %d for %s: "
421 "ret=%d\n", j, algo, -ret);
422 goto out;
423 }
424
425 if (memcmp(result, template[i].digest,
426 crypto_ahash_digestsize(tfm))) {
427 printk(KERN_ERR "alg: hash: Chunking test %d "
428 "failed for %s\n", j, algo);
429 hexdump(result, crypto_ahash_digestsize(tfm));
430 ret = -EINVAL;
431 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800432 }
433 }
434
Wang, Rui Y018ba952016-02-03 18:26:57 +0800435 /* partial update exercise */
436 j = 0;
437 for (i = 0; i < tcount; i++) {
438 /* alignment tests are only done with continuous buffers */
439 if (align_offset != 0)
440 break;
441
442 if (template[i].np < 2)
443 continue;
444
445 j++;
446 memset(result, 0, MAX_DIGEST_SIZE);
447
448 ret = -EINVAL;
449 hash_buff = xbuf[0];
450 memcpy(hash_buff, template[i].plaintext,
451 template[i].tap[0]);
452 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
453
454 if (template[i].ksize) {
455 crypto_ahash_clear_flags(tfm, ~0);
456 if (template[i].ksize > MAX_KEYLEN) {
457 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
458 j, algo, template[i].ksize, MAX_KEYLEN);
459 ret = -EINVAL;
460 goto out;
461 }
462 memcpy(key, template[i].key, template[i].ksize);
463 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
464 if (ret) {
465 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
466 j, algo, -ret);
467 goto out;
468 }
469 }
470
471 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
472 ret = wait_async_op(&tresult, crypto_ahash_init(req));
473 if (ret) {
474 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
475 j, algo, -ret);
476 goto out;
477 }
478 ret = wait_async_op(&tresult, crypto_ahash_update(req));
479 if (ret) {
480 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
481 j, algo, -ret);
482 goto out;
483 }
484
485 temp = template[i].tap[0];
486 for (k = 1; k < template[i].np; k++) {
487 ret = ahash_partial_update(&req, tfm, &template[i],
488 hash_buff, k, temp, &sg[0], algo, result,
489 &tresult);
490 if (ret) {
491 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
492 j, algo, -ret);
493 goto out_noreq;
494 }
495 temp += template[i].tap[k];
496 }
497 ret = wait_async_op(&tresult, crypto_ahash_final(req));
498 if (ret) {
499 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
500 j, algo, -ret);
501 goto out;
502 }
503 if (memcmp(result, template[i].digest,
504 crypto_ahash_digestsize(tfm))) {
505 pr_err("alg: hash: Partial Test %d failed for %s\n",
506 j, algo);
507 hexdump(result, crypto_ahash_digestsize(tfm));
508 ret = -EINVAL;
509 goto out;
510 }
511 }
512
Herbert Xuda7f0332008-07-31 17:08:25 +0800513 ret = 0;
514
515out:
516 ahash_request_free(req);
517out_noreq:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800518 testmgr_free_buf(xbuf);
519out_nobuf:
Horia Geanta29b77e52014-07-23 11:59:38 +0300520 kfree(key);
521 kfree(result);
Herbert Xuda7f0332008-07-31 17:08:25 +0800522 return ret;
523}
524
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300525static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
526 unsigned int tcount, bool use_digest)
527{
528 unsigned int alignmask;
529 int ret;
530
531 ret = __test_hash(tfm, template, tcount, use_digest, 0);
532 if (ret)
533 return ret;
534
535 /* test unaligned buffers, check with one byte offset */
536 ret = __test_hash(tfm, template, tcount, use_digest, 1);
537 if (ret)
538 return ret;
539
540 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
541 if (alignmask) {
542 /* Check if alignment mask for tfm is correctly set. */
543 ret = __test_hash(tfm, template, tcount, use_digest,
544 alignmask + 1);
545 if (ret)
546 return ret;
547 }
548
549 return 0;
550}
551
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300552static int __test_aead(struct crypto_aead *tfm, int enc,
553 struct aead_testvec *template, unsigned int tcount,
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300554 const bool diff_dst, const int align_offset)
Herbert Xuda7f0332008-07-31 17:08:25 +0800555{
556 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
557 unsigned int i, j, k, n, temp;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800558 int ret = -ENOMEM;
Herbert Xuda7f0332008-07-31 17:08:25 +0800559 char *q;
560 char *key;
561 struct aead_request *req;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300562 struct scatterlist *sg;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300563 struct scatterlist *sgout;
564 const char *e, *d;
Herbert Xuda7f0332008-07-31 17:08:25 +0800565 struct tcrypt_result result;
Cristian Stoica424a5da2015-01-28 11:03:05 +0200566 unsigned int authsize, iv_len;
Herbert Xuda7f0332008-07-31 17:08:25 +0800567 void *input;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300568 void *output;
Herbert Xuda7f0332008-07-31 17:08:25 +0800569 void *assoc;
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700570 char *iv;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800571 char *xbuf[XBUFSIZE];
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300572 char *xoutbuf[XBUFSIZE];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800573 char *axbuf[XBUFSIZE];
574
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700575 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
576 if (!iv)
577 return ret;
Horia Geanta29b77e52014-07-23 11:59:38 +0300578 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
579 if (!key)
580 goto out_noxbuf;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800581 if (testmgr_alloc_buf(xbuf))
582 goto out_noxbuf;
583 if (testmgr_alloc_buf(axbuf))
584 goto out_noaxbuf;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300585 if (diff_dst && testmgr_alloc_buf(xoutbuf))
586 goto out_nooutbuf;
587
588 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800589 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300590 if (!sg)
591 goto out_nosg;
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800592 sgout = &sg[16];
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300593
594 if (diff_dst)
595 d = "-ddst";
596 else
597 d = "";
598
Herbert Xuda7f0332008-07-31 17:08:25 +0800599 if (enc == ENCRYPT)
600 e = "encryption";
601 else
602 e = "decryption";
603
604 init_completion(&result.completion);
605
606 req = aead_request_alloc(tfm, GFP_KERNEL);
607 if (!req) {
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300608 pr_err("alg: aead%s: Failed to allocate request for %s\n",
609 d, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800610 goto out;
611 }
612
613 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
614 tcrypt_complete, &result);
615
Jerome Marchandabfa7f42016-02-03 13:58:12 +0100616 iv_len = crypto_aead_ivsize(tfm);
617
Herbert Xuda7f0332008-07-31 17:08:25 +0800618 for (i = 0, j = 0; i < tcount; i++) {
Cristian Stoica05b1d332014-07-28 13:11:23 +0300619 if (template[i].np)
620 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800621
Cristian Stoica05b1d332014-07-28 13:11:23 +0300622 j++;
Herbert Xuda7f0332008-07-31 17:08:25 +0800623
Cristian Stoica05b1d332014-07-28 13:11:23 +0300624 /* some templates have no input data but they will
625 * touch input
626 */
627 input = xbuf[0];
628 input += align_offset;
629 assoc = axbuf[0];
630
631 ret = -EINVAL;
632 if (WARN_ON(align_offset + template[i].ilen >
633 PAGE_SIZE || template[i].alen > PAGE_SIZE))
634 goto out;
635
636 memcpy(input, template[i].input, template[i].ilen);
637 memcpy(assoc, template[i].assoc, template[i].alen);
638 if (template[i].iv)
Cristian Stoica424a5da2015-01-28 11:03:05 +0200639 memcpy(iv, template[i].iv, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300640 else
Cristian Stoica424a5da2015-01-28 11:03:05 +0200641 memset(iv, 0, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300642
643 crypto_aead_clear_flags(tfm, ~0);
644 if (template[i].wk)
645 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
646
647 if (template[i].klen > MAX_KEYLEN) {
648 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
649 d, j, algo, template[i].klen,
650 MAX_KEYLEN);
Herbert Xufd57f222009-05-29 16:05:42 +1000651 ret = -EINVAL;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300652 goto out;
653 }
654 memcpy(key, template[i].key, template[i].klen);
Herbert Xufd57f222009-05-29 16:05:42 +1000655
Cristian Stoica05b1d332014-07-28 13:11:23 +0300656 ret = crypto_aead_setkey(tfm, key, template[i].klen);
657 if (!ret == template[i].fail) {
658 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
659 d, j, algo, crypto_aead_get_flags(tfm));
660 goto out;
661 } else if (ret)
662 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800663
Cristian Stoica05b1d332014-07-28 13:11:23 +0300664 authsize = abs(template[i].rlen - template[i].ilen);
665 ret = crypto_aead_setauthsize(tfm, authsize);
666 if (ret) {
667 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
668 d, authsize, j, algo);
669 goto out;
670 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800671
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800672 k = !!template[i].alen;
673 sg_init_table(sg, k + 1);
674 sg_set_buf(&sg[0], assoc, template[i].alen);
675 sg_set_buf(&sg[k], input,
676 template[i].ilen + (enc ? authsize : 0));
677 output = input;
678
Cristian Stoica05b1d332014-07-28 13:11:23 +0300679 if (diff_dst) {
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800680 sg_init_table(sgout, k + 1);
681 sg_set_buf(&sgout[0], assoc, template[i].alen);
682
Cristian Stoica05b1d332014-07-28 13:11:23 +0300683 output = xoutbuf[0];
684 output += align_offset;
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800685 sg_set_buf(&sgout[k], output,
686 template[i].rlen + (enc ? 0 : authsize));
Cristian Stoica05b1d332014-07-28 13:11:23 +0300687 }
688
Cristian Stoica05b1d332014-07-28 13:11:23 +0300689 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
690 template[i].ilen, iv);
691
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800692 aead_request_set_ad(req, template[i].alen);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300693
694 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
695
696 switch (ret) {
697 case 0:
698 if (template[i].novrfy) {
699 /* verification was supposed to fail */
700 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
701 d, e, j, algo);
702 /* so really, we got a bad message */
703 ret = -EBADMSG;
Horia Geanta29b77e52014-07-23 11:59:38 +0300704 goto out;
705 }
Cristian Stoica05b1d332014-07-28 13:11:23 +0300706 break;
707 case -EINPROGRESS:
708 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100709 wait_for_completion(&result.completion);
710 reinit_completion(&result.completion);
711 ret = result.err;
712 if (!ret)
Herbert Xuda7f0332008-07-31 17:08:25 +0800713 break;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300714 case -EBADMSG:
715 if (template[i].novrfy)
716 /* verification failure was expected */
717 continue;
718 /* fall through */
719 default:
720 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
721 d, e, j, algo, -ret);
722 goto out;
723 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800724
Cristian Stoica05b1d332014-07-28 13:11:23 +0300725 q = output;
726 if (memcmp(q, template[i].result, template[i].rlen)) {
727 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
728 d, j, e, algo);
729 hexdump(q, template[i].rlen);
730 ret = -EINVAL;
731 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800732 }
733 }
734
735 for (i = 0, j = 0; i < tcount; i++) {
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300736 /* alignment tests are only done with continuous buffers */
737 if (align_offset != 0)
738 break;
739
Cristian Stoica05b1d332014-07-28 13:11:23 +0300740 if (!template[i].np)
741 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800742
Cristian Stoica05b1d332014-07-28 13:11:23 +0300743 j++;
Herbert Xuda7f0332008-07-31 17:08:25 +0800744
Cristian Stoica05b1d332014-07-28 13:11:23 +0300745 if (template[i].iv)
Jerome Marchandabfa7f42016-02-03 13:58:12 +0100746 memcpy(iv, template[i].iv, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300747 else
748 memset(iv, 0, MAX_IVLEN);
749
750 crypto_aead_clear_flags(tfm, ~0);
751 if (template[i].wk)
752 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
753 if (template[i].klen > MAX_KEYLEN) {
754 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
755 d, j, algo, template[i].klen, MAX_KEYLEN);
756 ret = -EINVAL;
757 goto out;
758 }
759 memcpy(key, template[i].key, template[i].klen);
760
761 ret = crypto_aead_setkey(tfm, key, template[i].klen);
762 if (!ret == template[i].fail) {
763 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
764 d, j, algo, crypto_aead_get_flags(tfm));
765 goto out;
766 } else if (ret)
767 continue;
768
769 authsize = abs(template[i].rlen - template[i].ilen);
770
771 ret = -EINVAL;
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800772 sg_init_table(sg, template[i].anp + template[i].np);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300773 if (diff_dst)
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800774 sg_init_table(sgout, template[i].anp + template[i].np);
775
776 ret = -EINVAL;
777 for (k = 0, temp = 0; k < template[i].anp; k++) {
778 if (WARN_ON(offset_in_page(IDX[k]) +
779 template[i].atap[k] > PAGE_SIZE))
780 goto out;
781 sg_set_buf(&sg[k],
782 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
783 offset_in_page(IDX[k]),
784 template[i].assoc + temp,
785 template[i].atap[k]),
786 template[i].atap[k]);
787 if (diff_dst)
788 sg_set_buf(&sgout[k],
789 axbuf[IDX[k] >> PAGE_SHIFT] +
790 offset_in_page(IDX[k]),
791 template[i].atap[k]);
792 temp += template[i].atap[k];
793 }
794
Cristian Stoica05b1d332014-07-28 13:11:23 +0300795 for (k = 0, temp = 0; k < template[i].np; k++) {
796 if (WARN_ON(offset_in_page(IDX[k]) +
797 template[i].tap[k] > PAGE_SIZE))
798 goto out;
799
800 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
801 memcpy(q, template[i].input + temp, template[i].tap[k]);
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800802 sg_set_buf(&sg[template[i].anp + k],
803 q, template[i].tap[k]);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300804
805 if (diff_dst) {
806 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
807 offset_in_page(IDX[k]);
808
809 memset(q, 0, template[i].tap[k]);
810
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800811 sg_set_buf(&sgout[template[i].anp + k],
812 q, template[i].tap[k]);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300813 }
814
815 n = template[i].tap[k];
816 if (k == template[i].np - 1 && enc)
817 n += authsize;
818 if (offset_in_page(q) + n < PAGE_SIZE)
819 q[n] = 0;
820
821 temp += template[i].tap[k];
822 }
823
824 ret = crypto_aead_setauthsize(tfm, authsize);
825 if (ret) {
826 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
827 d, authsize, j, algo);
828 goto out;
829 }
830
831 if (enc) {
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800832 if (WARN_ON(sg[template[i].anp + k - 1].offset +
833 sg[template[i].anp + k - 1].length +
834 authsize > PAGE_SIZE)) {
Horia Geanta29b77e52014-07-23 11:59:38 +0300835 ret = -EINVAL;
836 goto out;
837 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800838
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300839 if (diff_dst)
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800840 sgout[template[i].anp + k - 1].length +=
841 authsize;
842 sg[template[i].anp + k - 1].length += authsize;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300843 }
844
845 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
846 template[i].ilen,
847 iv);
848
Herbert Xu8a525fcd2015-05-27 16:03:43 +0800849 aead_request_set_ad(req, template[i].alen);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300850
851 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
852
853 switch (ret) {
854 case 0:
855 if (template[i].novrfy) {
856 /* verification was supposed to fail */
857 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
858 d, e, j, algo);
859 /* so really, we got a bad message */
860 ret = -EBADMSG;
861 goto out;
862 }
863 break;
864 case -EINPROGRESS:
865 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100866 wait_for_completion(&result.completion);
867 reinit_completion(&result.completion);
868 ret = result.err;
869 if (!ret)
Cristian Stoica05b1d332014-07-28 13:11:23 +0300870 break;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300871 case -EBADMSG:
872 if (template[i].novrfy)
873 /* verification failure was expected */
874 continue;
875 /* fall through */
876 default:
877 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
878 d, e, j, algo, -ret);
879 goto out;
880 }
881
882 ret = -EINVAL;
883 for (k = 0, temp = 0; k < template[i].np; k++) {
884 if (diff_dst)
885 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
886 offset_in_page(IDX[k]);
887 else
Herbert Xuda7f0332008-07-31 17:08:25 +0800888 q = xbuf[IDX[k] >> PAGE_SHIFT] +
889 offset_in_page(IDX[k]);
890
Cristian Stoica05b1d332014-07-28 13:11:23 +0300891 n = template[i].tap[k];
892 if (k == template[i].np - 1)
893 n += enc ? authsize : -authsize;
Herbert Xuda7f0332008-07-31 17:08:25 +0800894
Cristian Stoica05b1d332014-07-28 13:11:23 +0300895 if (memcmp(q, template[i].result + temp, n)) {
896 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
897 d, j, e, k, algo);
898 hexdump(q, n);
Herbert Xuda7f0332008-07-31 17:08:25 +0800899 goto out;
900 }
901
Cristian Stoica05b1d332014-07-28 13:11:23 +0300902 q += n;
903 if (k == template[i].np - 1 && !enc) {
904 if (!diff_dst &&
905 memcmp(q, template[i].input +
906 temp + n, authsize))
907 n = authsize;
Horia Geanta8ec25c52013-11-28 15:11:18 +0200908 else
Cristian Stoica05b1d332014-07-28 13:11:23 +0300909 n = 0;
910 } else {
911 for (n = 0; offset_in_page(q + n) && q[n]; n++)
912 ;
Herbert Xuda7f0332008-07-31 17:08:25 +0800913 }
Cristian Stoica05b1d332014-07-28 13:11:23 +0300914 if (n) {
915 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
916 d, j, e, k, algo, n);
917 hexdump(q, n);
Herbert Xuda7f0332008-07-31 17:08:25 +0800918 goto out;
919 }
920
Cristian Stoica05b1d332014-07-28 13:11:23 +0300921 temp += template[i].tap[k];
Herbert Xuda7f0332008-07-31 17:08:25 +0800922 }
923 }
924
925 ret = 0;
926
927out:
928 aead_request_free(req);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300929 kfree(sg);
930out_nosg:
931 if (diff_dst)
932 testmgr_free_buf(xoutbuf);
933out_nooutbuf:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800934 testmgr_free_buf(axbuf);
935out_noaxbuf:
936 testmgr_free_buf(xbuf);
937out_noxbuf:
Horia Geanta29b77e52014-07-23 11:59:38 +0300938 kfree(key);
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700939 kfree(iv);
Herbert Xuda7f0332008-07-31 17:08:25 +0800940 return ret;
941}
942
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300943static int test_aead(struct crypto_aead *tfm, int enc,
944 struct aead_testvec *template, unsigned int tcount)
945{
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300946 unsigned int alignmask;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300947 int ret;
948
949 /* test 'dst == src' case */
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300950 ret = __test_aead(tfm, enc, template, tcount, false, 0);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300951 if (ret)
952 return ret;
953
954 /* test 'dst != src' case */
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300955 ret = __test_aead(tfm, enc, template, tcount, true, 0);
956 if (ret)
957 return ret;
958
959 /* test unaligned buffers, check with one byte offset */
960 ret = __test_aead(tfm, enc, template, tcount, true, 1);
961 if (ret)
962 return ret;
963
964 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
965 if (alignmask) {
966 /* Check if alignment mask for tfm is correctly set. */
967 ret = __test_aead(tfm, enc, template, tcount, true,
968 alignmask + 1);
969 if (ret)
970 return ret;
971 }
972
973 return 0;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300974}
975
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000976static int test_cipher(struct crypto_cipher *tfm, int enc,
Herbert Xuda7f0332008-07-31 17:08:25 +0800977 struct cipher_testvec *template, unsigned int tcount)
978{
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000979 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
980 unsigned int i, j, k;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000981 char *q;
982 const char *e;
983 void *data;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800984 char *xbuf[XBUFSIZE];
985 int ret = -ENOMEM;
986
987 if (testmgr_alloc_buf(xbuf))
988 goto out_nobuf;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000989
990 if (enc == ENCRYPT)
991 e = "encryption";
992 else
993 e = "decryption";
994
995 j = 0;
996 for (i = 0; i < tcount; i++) {
997 if (template[i].np)
998 continue;
999
1000 j++;
1001
Herbert Xufd57f222009-05-29 16:05:42 +10001002 ret = -EINVAL;
1003 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1004 goto out;
1005
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001006 data = xbuf[0];
1007 memcpy(data, template[i].input, template[i].ilen);
1008
1009 crypto_cipher_clear_flags(tfm, ~0);
1010 if (template[i].wk)
1011 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1012
1013 ret = crypto_cipher_setkey(tfm, template[i].key,
1014 template[i].klen);
1015 if (!ret == template[i].fail) {
1016 printk(KERN_ERR "alg: cipher: setkey failed "
1017 "on test %d for %s: flags=%x\n", j,
1018 algo, crypto_cipher_get_flags(tfm));
1019 goto out;
1020 } else if (ret)
1021 continue;
1022
1023 for (k = 0; k < template[i].ilen;
1024 k += crypto_cipher_blocksize(tfm)) {
1025 if (enc)
1026 crypto_cipher_encrypt_one(tfm, data + k,
1027 data + k);
1028 else
1029 crypto_cipher_decrypt_one(tfm, data + k,
1030 data + k);
1031 }
1032
1033 q = data;
1034 if (memcmp(q, template[i].result, template[i].rlen)) {
1035 printk(KERN_ERR "alg: cipher: Test %d failed "
1036 "on %s for %s\n", j, e, algo);
1037 hexdump(q, template[i].rlen);
1038 ret = -EINVAL;
1039 goto out;
1040 }
1041 }
1042
1043 ret = 0;
1044
1045out:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001046 testmgr_free_buf(xbuf);
1047out_nobuf:
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001048 return ret;
1049}
1050
Herbert Xu12773d92015-08-20 15:21:46 +08001051static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001052 struct cipher_testvec *template, unsigned int tcount,
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001053 const bool diff_dst, const int align_offset)
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001054{
Herbert Xuda7f0332008-07-31 17:08:25 +08001055 const char *algo =
Herbert Xu12773d92015-08-20 15:21:46 +08001056 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
Herbert Xuda7f0332008-07-31 17:08:25 +08001057 unsigned int i, j, k, n, temp;
Herbert Xuda7f0332008-07-31 17:08:25 +08001058 char *q;
Herbert Xu12773d92015-08-20 15:21:46 +08001059 struct skcipher_request *req;
Herbert Xuda7f0332008-07-31 17:08:25 +08001060 struct scatterlist sg[8];
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001061 struct scatterlist sgout[8];
1062 const char *e, *d;
Herbert Xuda7f0332008-07-31 17:08:25 +08001063 struct tcrypt_result result;
1064 void *data;
1065 char iv[MAX_IVLEN];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001066 char *xbuf[XBUFSIZE];
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001067 char *xoutbuf[XBUFSIZE];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001068 int ret = -ENOMEM;
Andrey Ryabinin84cba172015-09-10 13:11:55 +03001069 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001070
1071 if (testmgr_alloc_buf(xbuf))
1072 goto out_nobuf;
Herbert Xuda7f0332008-07-31 17:08:25 +08001073
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001074 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1075 goto out_nooutbuf;
1076
1077 if (diff_dst)
1078 d = "-ddst";
1079 else
1080 d = "";
1081
Herbert Xuda7f0332008-07-31 17:08:25 +08001082 if (enc == ENCRYPT)
1083 e = "encryption";
1084 else
1085 e = "decryption";
1086
1087 init_completion(&result.completion);
1088
Herbert Xu12773d92015-08-20 15:21:46 +08001089 req = skcipher_request_alloc(tfm, GFP_KERNEL);
Herbert Xuda7f0332008-07-31 17:08:25 +08001090 if (!req) {
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001091 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1092 d, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +08001093 goto out;
1094 }
1095
Herbert Xu12773d92015-08-20 15:21:46 +08001096 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1097 tcrypt_complete, &result);
Herbert Xuda7f0332008-07-31 17:08:25 +08001098
1099 j = 0;
1100 for (i = 0; i < tcount; i++) {
Cristian Stoicabbb9a7d2014-08-08 14:27:52 +03001101 if (template[i].np && !template[i].also_non_np)
1102 continue;
1103
Herbert Xuda7f0332008-07-31 17:08:25 +08001104 if (template[i].iv)
Andrey Ryabinin84cba172015-09-10 13:11:55 +03001105 memcpy(iv, template[i].iv, ivsize);
Herbert Xuda7f0332008-07-31 17:08:25 +08001106 else
1107 memset(iv, 0, MAX_IVLEN);
1108
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001109 j++;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001110 ret = -EINVAL;
1111 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1112 goto out;
1113
1114 data = xbuf[0];
1115 data += align_offset;
1116 memcpy(data, template[i].input, template[i].ilen);
1117
Herbert Xu12773d92015-08-20 15:21:46 +08001118 crypto_skcipher_clear_flags(tfm, ~0);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001119 if (template[i].wk)
Herbert Xu12773d92015-08-20 15:21:46 +08001120 crypto_skcipher_set_flags(tfm,
1121 CRYPTO_TFM_REQ_WEAK_KEY);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001122
Herbert Xu12773d92015-08-20 15:21:46 +08001123 ret = crypto_skcipher_setkey(tfm, template[i].key,
1124 template[i].klen);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001125 if (!ret == template[i].fail) {
1126 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
Herbert Xu12773d92015-08-20 15:21:46 +08001127 d, j, algo, crypto_skcipher_get_flags(tfm));
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001128 goto out;
1129 } else if (ret)
1130 continue;
1131
1132 sg_init_one(&sg[0], data, template[i].ilen);
1133 if (diff_dst) {
1134 data = xoutbuf[0];
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001135 data += align_offset;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001136 sg_init_one(&sgout[0], data, template[i].ilen);
1137 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001138
Herbert Xu12773d92015-08-20 15:21:46 +08001139 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1140 template[i].ilen, iv);
1141 ret = enc ? crypto_skcipher_encrypt(req) :
1142 crypto_skcipher_decrypt(req);
Herbert Xuda7f0332008-07-31 17:08:25 +08001143
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001144 switch (ret) {
1145 case 0:
1146 break;
1147 case -EINPROGRESS:
1148 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +01001149 wait_for_completion(&result.completion);
1150 reinit_completion(&result.completion);
1151 ret = result.err;
1152 if (!ret)
Herbert Xuda7f0332008-07-31 17:08:25 +08001153 break;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001154 /* fall through */
1155 default:
1156 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1157 d, e, j, algo, -ret);
1158 goto out;
1159 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001160
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001161 q = data;
1162 if (memcmp(q, template[i].result, template[i].rlen)) {
Boris BREZILLON8a826a32015-06-16 11:46:46 +02001163 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001164 d, j, e, algo);
1165 hexdump(q, template[i].rlen);
1166 ret = -EINVAL;
1167 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001168 }
Boris BREZILLON8a826a32015-06-16 11:46:46 +02001169
1170 if (template[i].iv_out &&
1171 memcmp(iv, template[i].iv_out,
1172 crypto_skcipher_ivsize(tfm))) {
1173 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1174 d, j, e, algo);
1175 hexdump(iv, crypto_skcipher_ivsize(tfm));
1176 ret = -EINVAL;
1177 goto out;
1178 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001179 }
1180
1181 j = 0;
1182 for (i = 0; i < tcount; i++) {
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001183 /* alignment tests are only done with continuous buffers */
1184 if (align_offset != 0)
1185 break;
Herbert Xuda7f0332008-07-31 17:08:25 +08001186
Cristian Stoicabbb9a7d2014-08-08 14:27:52 +03001187 if (!template[i].np)
1188 continue;
1189
Herbert Xuda7f0332008-07-31 17:08:25 +08001190 if (template[i].iv)
Andrey Ryabinin84cba172015-09-10 13:11:55 +03001191 memcpy(iv, template[i].iv, ivsize);
Herbert Xuda7f0332008-07-31 17:08:25 +08001192 else
1193 memset(iv, 0, MAX_IVLEN);
1194
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001195 j++;
Herbert Xu12773d92015-08-20 15:21:46 +08001196 crypto_skcipher_clear_flags(tfm, ~0);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001197 if (template[i].wk)
Herbert Xu12773d92015-08-20 15:21:46 +08001198 crypto_skcipher_set_flags(tfm,
1199 CRYPTO_TFM_REQ_WEAK_KEY);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001200
Herbert Xu12773d92015-08-20 15:21:46 +08001201 ret = crypto_skcipher_setkey(tfm, template[i].key,
1202 template[i].klen);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001203 if (!ret == template[i].fail) {
1204 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
Herbert Xu12773d92015-08-20 15:21:46 +08001205 d, j, algo, crypto_skcipher_get_flags(tfm));
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001206 goto out;
1207 } else if (ret)
1208 continue;
1209
1210 temp = 0;
1211 ret = -EINVAL;
1212 sg_init_table(sg, template[i].np);
1213 if (diff_dst)
1214 sg_init_table(sgout, template[i].np);
1215 for (k = 0; k < template[i].np; k++) {
1216 if (WARN_ON(offset_in_page(IDX[k]) +
1217 template[i].tap[k] > PAGE_SIZE))
Herbert Xuda7f0332008-07-31 17:08:25 +08001218 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001219
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001220 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1221
1222 memcpy(q, template[i].input + temp, template[i].tap[k]);
1223
1224 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1225 q[template[i].tap[k]] = 0;
1226
1227 sg_set_buf(&sg[k], q, template[i].tap[k]);
1228 if (diff_dst) {
1229 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1230 offset_in_page(IDX[k]);
1231
1232 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1233
1234 memset(q, 0, template[i].tap[k]);
1235 if (offset_in_page(q) +
1236 template[i].tap[k] < PAGE_SIZE)
1237 q[template[i].tap[k]] = 0;
1238 }
1239
1240 temp += template[i].tap[k];
1241 }
1242
Herbert Xu12773d92015-08-20 15:21:46 +08001243 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1244 template[i].ilen, iv);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001245
Herbert Xu12773d92015-08-20 15:21:46 +08001246 ret = enc ? crypto_skcipher_encrypt(req) :
1247 crypto_skcipher_decrypt(req);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001248
1249 switch (ret) {
1250 case 0:
1251 break;
1252 case -EINPROGRESS:
1253 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +01001254 wait_for_completion(&result.completion);
1255 reinit_completion(&result.completion);
1256 ret = result.err;
1257 if (!ret)
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001258 break;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001259 /* fall through */
1260 default:
1261 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1262 d, e, j, algo, -ret);
1263 goto out;
1264 }
1265
1266 temp = 0;
1267 ret = -EINVAL;
1268 for (k = 0; k < template[i].np; k++) {
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001269 if (diff_dst)
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001270 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1271 offset_in_page(IDX[k]);
1272 else
Herbert Xuda7f0332008-07-31 17:08:25 +08001273 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1274 offset_in_page(IDX[k]);
1275
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001276 if (memcmp(q, template[i].result + temp,
1277 template[i].tap[k])) {
1278 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1279 d, j, e, k, algo);
1280 hexdump(q, template[i].tap[k]);
Herbert Xuda7f0332008-07-31 17:08:25 +08001281 goto out;
1282 }
1283
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001284 q += template[i].tap[k];
1285 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1286 ;
1287 if (n) {
1288 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1289 d, j, e, k, algo, n);
1290 hexdump(q, n);
1291 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001292 }
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001293 temp += template[i].tap[k];
Herbert Xuda7f0332008-07-31 17:08:25 +08001294 }
1295 }
1296
1297 ret = 0;
1298
1299out:
Herbert Xu12773d92015-08-20 15:21:46 +08001300 skcipher_request_free(req);
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001301 if (diff_dst)
1302 testmgr_free_buf(xoutbuf);
1303out_nooutbuf:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001304 testmgr_free_buf(xbuf);
1305out_nobuf:
Herbert Xuda7f0332008-07-31 17:08:25 +08001306 return ret;
1307}
1308
Herbert Xu12773d92015-08-20 15:21:46 +08001309static int test_skcipher(struct crypto_skcipher *tfm, int enc,
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001310 struct cipher_testvec *template, unsigned int tcount)
1311{
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001312 unsigned int alignmask;
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001313 int ret;
1314
1315 /* test 'dst == src' case */
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001316 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001317 if (ret)
1318 return ret;
1319
1320 /* test 'dst != src' case */
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001321 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1322 if (ret)
1323 return ret;
1324
1325 /* test unaligned buffers, check with one byte offset */
1326 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1327 if (ret)
1328 return ret;
1329
1330 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1331 if (alignmask) {
1332 /* Check if alignment mask for tfm is correctly set. */
1333 ret = __test_skcipher(tfm, enc, template, tcount, true,
1334 alignmask + 1);
1335 if (ret)
1336 return ret;
1337 }
1338
1339 return 0;
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001340}
1341
Herbert Xuda7f0332008-07-31 17:08:25 +08001342static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1343 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1344{
1345 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1346 unsigned int i;
1347 char result[COMP_BUF_SIZE];
1348 int ret;
1349
1350 for (i = 0; i < ctcount; i++) {
Geert Uytterhoevenc79cf912009-03-29 15:44:19 +08001351 int ilen;
1352 unsigned int dlen = COMP_BUF_SIZE;
Herbert Xuda7f0332008-07-31 17:08:25 +08001353
1354 memset(result, 0, sizeof (result));
1355
1356 ilen = ctemplate[i].inlen;
1357 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1358 ilen, result, &dlen);
1359 if (ret) {
1360 printk(KERN_ERR "alg: comp: compression failed "
1361 "on test %d for %s: ret=%d\n", i + 1, algo,
1362 -ret);
1363 goto out;
1364 }
1365
Geert Uytterhoevenb812eb02008-11-28 20:51:28 +08001366 if (dlen != ctemplate[i].outlen) {
1367 printk(KERN_ERR "alg: comp: Compression test %d "
1368 "failed for %s: output len = %d\n", i + 1, algo,
1369 dlen);
1370 ret = -EINVAL;
1371 goto out;
1372 }
1373
Herbert Xuda7f0332008-07-31 17:08:25 +08001374 if (memcmp(result, ctemplate[i].output, dlen)) {
1375 printk(KERN_ERR "alg: comp: Compression test %d "
1376 "failed for %s\n", i + 1, algo);
1377 hexdump(result, dlen);
1378 ret = -EINVAL;
1379 goto out;
1380 }
1381 }
1382
1383 for (i = 0; i < dtcount; i++) {
Geert Uytterhoevenc79cf912009-03-29 15:44:19 +08001384 int ilen;
1385 unsigned int dlen = COMP_BUF_SIZE;
Herbert Xuda7f0332008-07-31 17:08:25 +08001386
1387 memset(result, 0, sizeof (result));
1388
1389 ilen = dtemplate[i].inlen;
1390 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1391 ilen, result, &dlen);
1392 if (ret) {
1393 printk(KERN_ERR "alg: comp: decompression failed "
1394 "on test %d for %s: ret=%d\n", i + 1, algo,
1395 -ret);
1396 goto out;
1397 }
1398
Geert Uytterhoevenb812eb02008-11-28 20:51:28 +08001399 if (dlen != dtemplate[i].outlen) {
1400 printk(KERN_ERR "alg: comp: Decompression test %d "
1401 "failed for %s: output len = %d\n", i + 1, algo,
1402 dlen);
1403 ret = -EINVAL;
1404 goto out;
1405 }
1406
Herbert Xuda7f0332008-07-31 17:08:25 +08001407 if (memcmp(result, dtemplate[i].output, dlen)) {
1408 printk(KERN_ERR "alg: comp: Decompression test %d "
1409 "failed for %s\n", i + 1, algo);
1410 hexdump(result, dlen);
1411 ret = -EINVAL;
1412 goto out;
1413 }
1414 }
1415
1416 ret = 0;
1417
1418out:
1419 return ret;
1420}
1421
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001422static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1423 unsigned int tcount)
1424{
1425 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
Felipe Contrerasfa4ef8a2009-10-27 19:04:42 +08001426 int err = 0, i, j, seedsize;
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001427 u8 *seed;
1428 char result[32];
1429
1430 seedsize = crypto_rng_seedsize(tfm);
1431
1432 seed = kmalloc(seedsize, GFP_KERNEL);
1433 if (!seed) {
1434 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1435 "for %s\n", algo);
1436 return -ENOMEM;
1437 }
1438
1439 for (i = 0; i < tcount; i++) {
1440 memset(result, 0, 32);
1441
1442 memcpy(seed, template[i].v, template[i].vlen);
1443 memcpy(seed + template[i].vlen, template[i].key,
1444 template[i].klen);
1445 memcpy(seed + template[i].vlen + template[i].klen,
1446 template[i].dt, template[i].dtlen);
1447
1448 err = crypto_rng_reset(tfm, seed, seedsize);
1449 if (err) {
1450 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1451 "for %s\n", algo);
1452 goto out;
1453 }
1454
1455 for (j = 0; j < template[i].loops; j++) {
1456 err = crypto_rng_get_bytes(tfm, result,
1457 template[i].rlen);
Stephan Mueller19e60e12015-03-10 17:00:36 +01001458 if (err < 0) {
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001459 printk(KERN_ERR "alg: cprng: Failed to obtain "
1460 "the correct amount of random data for "
Stephan Mueller19e60e12015-03-10 17:00:36 +01001461 "%s (requested %d)\n", algo,
1462 template[i].rlen);
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001463 goto out;
1464 }
1465 }
1466
1467 err = memcmp(result, template[i].result,
1468 template[i].rlen);
1469 if (err) {
1470 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1471 i, algo);
1472 hexdump(result, template[i].rlen);
1473 err = -EINVAL;
1474 goto out;
1475 }
1476 }
1477
1478out:
1479 kfree(seed);
1480 return err;
1481}
1482
Herbert Xuda7f0332008-07-31 17:08:25 +08001483static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1484 u32 type, u32 mask)
1485{
1486 struct crypto_aead *tfm;
1487 int err = 0;
1488
Stephan Mueller425a8822015-03-30 21:56:31 +02001489 tfm = crypto_alloc_aead(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001490 if (IS_ERR(tfm)) {
1491 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1492 "%ld\n", driver, PTR_ERR(tfm));
1493 return PTR_ERR(tfm);
1494 }
1495
1496 if (desc->suite.aead.enc.vecs) {
1497 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1498 desc->suite.aead.enc.count);
1499 if (err)
1500 goto out;
1501 }
1502
1503 if (!err && desc->suite.aead.dec.vecs)
1504 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1505 desc->suite.aead.dec.count);
1506
1507out:
1508 crypto_free_aead(tfm);
1509 return err;
1510}
1511
1512static int alg_test_cipher(const struct alg_test_desc *desc,
1513 const char *driver, u32 type, u32 mask)
1514{
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001515 struct crypto_cipher *tfm;
Herbert Xuda7f0332008-07-31 17:08:25 +08001516 int err = 0;
1517
Stephan Mueller425a8822015-03-30 21:56:31 +02001518 tfm = crypto_alloc_cipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001519 if (IS_ERR(tfm)) {
1520 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1521 "%s: %ld\n", driver, PTR_ERR(tfm));
1522 return PTR_ERR(tfm);
1523 }
1524
1525 if (desc->suite.cipher.enc.vecs) {
1526 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1527 desc->suite.cipher.enc.count);
1528 if (err)
1529 goto out;
1530 }
1531
1532 if (desc->suite.cipher.dec.vecs)
1533 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1534 desc->suite.cipher.dec.count);
1535
1536out:
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001537 crypto_free_cipher(tfm);
1538 return err;
1539}
1540
1541static int alg_test_skcipher(const struct alg_test_desc *desc,
1542 const char *driver, u32 type, u32 mask)
1543{
Herbert Xu12773d92015-08-20 15:21:46 +08001544 struct crypto_skcipher *tfm;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001545 int err = 0;
1546
Herbert Xu12773d92015-08-20 15:21:46 +08001547 tfm = crypto_alloc_skcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001548 if (IS_ERR(tfm)) {
1549 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1550 "%s: %ld\n", driver, PTR_ERR(tfm));
1551 return PTR_ERR(tfm);
1552 }
1553
1554 if (desc->suite.cipher.enc.vecs) {
1555 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1556 desc->suite.cipher.enc.count);
1557 if (err)
1558 goto out;
1559 }
1560
1561 if (desc->suite.cipher.dec.vecs)
1562 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1563 desc->suite.cipher.dec.count);
1564
1565out:
Herbert Xu12773d92015-08-20 15:21:46 +08001566 crypto_free_skcipher(tfm);
Herbert Xuda7f0332008-07-31 17:08:25 +08001567 return err;
1568}
1569
1570static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1571 u32 type, u32 mask)
1572{
1573 struct crypto_comp *tfm;
1574 int err;
1575
1576 tfm = crypto_alloc_comp(driver, type, mask);
1577 if (IS_ERR(tfm)) {
1578 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1579 "%ld\n", driver, PTR_ERR(tfm));
1580 return PTR_ERR(tfm);
1581 }
1582
1583 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1584 desc->suite.comp.decomp.vecs,
1585 desc->suite.comp.comp.count,
1586 desc->suite.comp.decomp.count);
1587
1588 crypto_free_comp(tfm);
1589 return err;
1590}
1591
1592static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1593 u32 type, u32 mask)
1594{
1595 struct crypto_ahash *tfm;
1596 int err;
1597
Stephan Mueller425a8822015-03-30 21:56:31 +02001598 tfm = crypto_alloc_ahash(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001599 if (IS_ERR(tfm)) {
1600 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1601 "%ld\n", driver, PTR_ERR(tfm));
1602 return PTR_ERR(tfm);
1603 }
1604
David S. Millera8f1a052010-05-19 14:12:03 +10001605 err = test_hash(tfm, desc->suite.hash.vecs,
1606 desc->suite.hash.count, true);
1607 if (!err)
1608 err = test_hash(tfm, desc->suite.hash.vecs,
1609 desc->suite.hash.count, false);
Herbert Xuda7f0332008-07-31 17:08:25 +08001610
1611 crypto_free_ahash(tfm);
1612 return err;
1613}
1614
Herbert Xu8e3ee852008-11-07 14:58:52 +08001615static int alg_test_crc32c(const struct alg_test_desc *desc,
1616 const char *driver, u32 type, u32 mask)
1617{
1618 struct crypto_shash *tfm;
1619 u32 val;
1620 int err;
1621
1622 err = alg_test_hash(desc, driver, type, mask);
1623 if (err)
1624 goto out;
1625
Stephan Mueller425a8822015-03-30 21:56:31 +02001626 tfm = crypto_alloc_shash(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001627 if (IS_ERR(tfm)) {
1628 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1629 "%ld\n", driver, PTR_ERR(tfm));
1630 err = PTR_ERR(tfm);
1631 goto out;
1632 }
1633
1634 do {
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001635 SHASH_DESC_ON_STACK(shash, tfm);
1636 u32 *ctx = (u32 *)shash_desc_ctx(shash);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001637
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001638 shash->tfm = tfm;
1639 shash->flags = 0;
Herbert Xu8e3ee852008-11-07 14:58:52 +08001640
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001641 *ctx = le32_to_cpu(420553207);
1642 err = crypto_shash_final(shash, (u8 *)&val);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001643 if (err) {
1644 printk(KERN_ERR "alg: crc32c: Operation failed for "
1645 "%s: %d\n", driver, err);
1646 break;
1647 }
1648
1649 if (val != ~420553207) {
1650 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1651 "%d\n", driver, val);
1652 err = -EINVAL;
1653 }
1654 } while (0);
1655
1656 crypto_free_shash(tfm);
1657
1658out:
1659 return err;
1660}
1661
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001662static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1663 u32 type, u32 mask)
1664{
1665 struct crypto_rng *rng;
1666 int err;
1667
Stephan Mueller425a8822015-03-30 21:56:31 +02001668 rng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001669 if (IS_ERR(rng)) {
1670 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1671 "%ld\n", driver, PTR_ERR(rng));
1672 return PTR_ERR(rng);
1673 }
1674
1675 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1676
1677 crypto_free_rng(rng);
1678
1679 return err;
1680}
1681
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001682
1683static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1684 const char *driver, u32 type, u32 mask)
1685{
1686 int ret = -EAGAIN;
1687 struct crypto_rng *drng;
1688 struct drbg_test_data test_data;
1689 struct drbg_string addtl, pers, testentropy;
1690 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1691
1692 if (!buf)
1693 return -ENOMEM;
1694
Stephan Mueller425a8822015-03-30 21:56:31 +02001695 drng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001696 if (IS_ERR(drng)) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001697 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001698 "%s\n", driver);
1699 kzfree(buf);
1700 return -ENOMEM;
1701 }
1702
1703 test_data.testentropy = &testentropy;
1704 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1705 drbg_string_fill(&pers, test->pers, test->perslen);
1706 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1707 if (ret) {
1708 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1709 goto outbuf;
1710 }
1711
1712 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1713 if (pr) {
1714 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1715 ret = crypto_drbg_get_bytes_addtl_test(drng,
1716 buf, test->expectedlen, &addtl, &test_data);
1717 } else {
1718 ret = crypto_drbg_get_bytes_addtl(drng,
1719 buf, test->expectedlen, &addtl);
1720 }
Stephan Mueller19e60e12015-03-10 17:00:36 +01001721 if (ret < 0) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001722 printk(KERN_ERR "alg: drbg: could not obtain random data for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001723 "driver %s\n", driver);
1724 goto outbuf;
1725 }
1726
1727 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1728 if (pr) {
1729 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1730 ret = crypto_drbg_get_bytes_addtl_test(drng,
1731 buf, test->expectedlen, &addtl, &test_data);
1732 } else {
1733 ret = crypto_drbg_get_bytes_addtl(drng,
1734 buf, test->expectedlen, &addtl);
1735 }
Stephan Mueller19e60e12015-03-10 17:00:36 +01001736 if (ret < 0) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001737 printk(KERN_ERR "alg: drbg: could not obtain random data for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001738 "driver %s\n", driver);
1739 goto outbuf;
1740 }
1741
1742 ret = memcmp(test->expected, buf, test->expectedlen);
1743
1744outbuf:
1745 crypto_free_rng(drng);
1746 kzfree(buf);
1747 return ret;
1748}
1749
1750
1751static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1752 u32 type, u32 mask)
1753{
1754 int err = 0;
1755 int pr = 0;
1756 int i = 0;
1757 struct drbg_testvec *template = desc->suite.drbg.vecs;
1758 unsigned int tcount = desc->suite.drbg.count;
1759
1760 if (0 == memcmp(driver, "drbg_pr_", 8))
1761 pr = 1;
1762
1763 for (i = 0; i < tcount; i++) {
1764 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1765 if (err) {
1766 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1767 i, driver);
1768 err = -EINVAL;
1769 break;
1770 }
1771 }
1772 return err;
1773
1774}
1775
Tadeusz Struk946cc462015-06-16 10:31:06 -07001776static int do_test_rsa(struct crypto_akcipher *tfm,
1777 struct akcipher_testvec *vecs)
1778{
1779 struct akcipher_request *req;
1780 void *outbuf_enc = NULL;
1781 void *outbuf_dec = NULL;
1782 struct tcrypt_result result;
1783 unsigned int out_len_max, out_len = 0;
1784 int err = -ENOMEM;
Tadeusz Struk22287b02015-10-08 09:26:55 -07001785 struct scatterlist src, dst, src_tab[2];
Tadeusz Struk946cc462015-06-16 10:31:06 -07001786
1787 req = akcipher_request_alloc(tfm, GFP_KERNEL);
1788 if (!req)
1789 return err;
1790
1791 init_completion(&result.completion);
Tadeusz Struk22287b02015-10-08 09:26:55 -07001792
1793 if (vecs->public_key_vec)
1794 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
1795 vecs->key_len);
1796 else
1797 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
1798 vecs->key_len);
Tadeusz Struk946cc462015-06-16 10:31:06 -07001799 if (err)
1800 goto free_req;
1801
Tadeusz Struk22287b02015-10-08 09:26:55 -07001802 out_len_max = crypto_akcipher_maxsize(tfm);
Tadeusz Struk946cc462015-06-16 10:31:06 -07001803 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
1804 if (!outbuf_enc)
1805 goto free_req;
1806
Tadeusz Struk22287b02015-10-08 09:26:55 -07001807 sg_init_table(src_tab, 2);
1808 sg_set_buf(&src_tab[0], vecs->m, 8);
1809 sg_set_buf(&src_tab[1], vecs->m + 8, vecs->m_size - 8);
1810 sg_init_one(&dst, outbuf_enc, out_len_max);
1811 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
1812 out_len_max);
Tadeusz Struk946cc462015-06-16 10:31:06 -07001813 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1814 tcrypt_complete, &result);
1815
1816 /* Run RSA encrypt - c = m^e mod n;*/
1817 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
1818 if (err) {
1819 pr_err("alg: rsa: encrypt test failed. err %d\n", err);
1820 goto free_all;
1821 }
Tadeusz Struk22287b02015-10-08 09:26:55 -07001822 if (req->dst_len != vecs->c_size) {
Tadeusz Struk946cc462015-06-16 10:31:06 -07001823 pr_err("alg: rsa: encrypt test failed. Invalid output len\n");
1824 err = -EINVAL;
1825 goto free_all;
1826 }
1827 /* verify that encrypted message is equal to expected */
Tadeusz Struk22287b02015-10-08 09:26:55 -07001828 if (memcmp(vecs->c, sg_virt(req->dst), vecs->c_size)) {
Tadeusz Struk946cc462015-06-16 10:31:06 -07001829 pr_err("alg: rsa: encrypt test failed. Invalid output\n");
1830 err = -EINVAL;
1831 goto free_all;
1832 }
1833 /* Don't invoke decrypt for vectors with public key */
1834 if (vecs->public_key_vec) {
1835 err = 0;
1836 goto free_all;
1837 }
1838 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
1839 if (!outbuf_dec) {
1840 err = -ENOMEM;
1841 goto free_all;
1842 }
Tadeusz Struk22287b02015-10-08 09:26:55 -07001843 sg_init_one(&src, vecs->c, vecs->c_size);
1844 sg_init_one(&dst, outbuf_dec, out_len_max);
Tadeusz Struk946cc462015-06-16 10:31:06 -07001845 init_completion(&result.completion);
Tadeusz Struk22287b02015-10-08 09:26:55 -07001846 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
Tadeusz Struk946cc462015-06-16 10:31:06 -07001847
1848 /* Run RSA decrypt - m = c^d mod n;*/
1849 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
1850 if (err) {
1851 pr_err("alg: rsa: decrypt test failed. err %d\n", err);
1852 goto free_all;
1853 }
1854 out_len = req->dst_len;
1855 if (out_len != vecs->m_size) {
1856 pr_err("alg: rsa: decrypt test failed. Invalid output len\n");
1857 err = -EINVAL;
1858 goto free_all;
1859 }
1860 /* verify that decrypted message is equal to the original msg */
1861 if (memcmp(vecs->m, outbuf_dec, vecs->m_size)) {
1862 pr_err("alg: rsa: decrypt test failed. Invalid output\n");
1863 err = -EINVAL;
1864 }
1865free_all:
1866 kfree(outbuf_dec);
1867 kfree(outbuf_enc);
1868free_req:
1869 akcipher_request_free(req);
1870 return err;
1871}
1872
1873static int test_rsa(struct crypto_akcipher *tfm, struct akcipher_testvec *vecs,
1874 unsigned int tcount)
1875{
1876 int ret, i;
1877
1878 for (i = 0; i < tcount; i++) {
1879 ret = do_test_rsa(tfm, vecs++);
1880 if (ret) {
1881 pr_err("alg: rsa: test failed on vector %d, err=%d\n",
1882 i + 1, ret);
1883 return ret;
1884 }
1885 }
1886 return 0;
1887}
1888
1889static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
1890 struct akcipher_testvec *vecs, unsigned int tcount)
1891{
1892 if (strncmp(alg, "rsa", 3) == 0)
1893 return test_rsa(tfm, vecs, tcount);
1894
1895 return 0;
1896}
1897
1898static int alg_test_akcipher(const struct alg_test_desc *desc,
1899 const char *driver, u32 type, u32 mask)
1900{
1901 struct crypto_akcipher *tfm;
1902 int err = 0;
1903
1904 tfm = crypto_alloc_akcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1905 if (IS_ERR(tfm)) {
1906 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
1907 driver, PTR_ERR(tfm));
1908 return PTR_ERR(tfm);
1909 }
1910 if (desc->suite.akcipher.vecs)
1911 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
1912 desc->suite.akcipher.count);
1913
1914 crypto_free_akcipher(tfm);
1915 return err;
1916}
1917
Youquan, Song863b5572009-12-23 19:45:20 +08001918static int alg_test_null(const struct alg_test_desc *desc,
1919 const char *driver, u32 type, u32 mask)
1920{
1921 return 0;
1922}
1923
Herbert Xuda7f0332008-07-31 17:08:25 +08001924/* Please keep this list sorted by algorithm name. */
1925static const struct alg_test_desc alg_test_descs[] = {
1926 {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001927 .alg = "__cbc-cast5-avx",
1928 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001929 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001930 .alg = "__cbc-cast6-avx",
1931 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001932 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001933 .alg = "__cbc-serpent-avx",
1934 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001935 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03001936 .alg = "__cbc-serpent-avx2",
1937 .test = alg_test_null,
1938 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001939 .alg = "__cbc-serpent-sse2",
1940 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001941 }, {
Johannes Goetzfried107778b52012-05-28 15:54:24 +02001942 .alg = "__cbc-twofish-avx",
1943 .test = alg_test_null,
Johannes Goetzfried107778b52012-05-28 15:54:24 +02001944 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08001945 .alg = "__driver-cbc-aes-aesni",
1946 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02001947 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08001948 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03001949 .alg = "__driver-cbc-camellia-aesni",
1950 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03001951 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03001952 .alg = "__driver-cbc-camellia-aesni-avx2",
1953 .test = alg_test_null,
1954 }, {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001955 .alg = "__driver-cbc-cast5-avx",
1956 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001957 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001958 .alg = "__driver-cbc-cast6-avx",
1959 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001960 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001961 .alg = "__driver-cbc-serpent-avx",
1962 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001963 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03001964 .alg = "__driver-cbc-serpent-avx2",
1965 .test = alg_test_null,
1966 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001967 .alg = "__driver-cbc-serpent-sse2",
1968 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001969 }, {
Johannes Goetzfried107778b52012-05-28 15:54:24 +02001970 .alg = "__driver-cbc-twofish-avx",
1971 .test = alg_test_null,
Johannes Goetzfried107778b52012-05-28 15:54:24 +02001972 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08001973 .alg = "__driver-ecb-aes-aesni",
1974 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02001975 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08001976 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03001977 .alg = "__driver-ecb-camellia-aesni",
1978 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03001979 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03001980 .alg = "__driver-ecb-camellia-aesni-avx2",
1981 .test = alg_test_null,
1982 }, {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001983 .alg = "__driver-ecb-cast5-avx",
1984 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001985 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001986 .alg = "__driver-ecb-cast6-avx",
1987 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001988 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001989 .alg = "__driver-ecb-serpent-avx",
1990 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001991 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03001992 .alg = "__driver-ecb-serpent-avx2",
1993 .test = alg_test_null,
1994 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001995 .alg = "__driver-ecb-serpent-sse2",
1996 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001997 }, {
Johannes Goetzfried107778b52012-05-28 15:54:24 +02001998 .alg = "__driver-ecb-twofish-avx",
1999 .test = alg_test_null,
Johannes Goetzfried107778b52012-05-28 15:54:24 +02002000 }, {
Tadeusz Struk9d77b6c2015-06-24 09:01:30 -07002001 .alg = "__driver-gcm-aes-aesni",
2002 .test = alg_test_null,
2003 .fips_allowed = 1,
2004 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002005 .alg = "__ghash-pclmulqdqni",
2006 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002007 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002008 }, {
Jarod Wilsone08ca2d2009-05-04 19:46:29 +08002009 .alg = "ansi_cprng",
2010 .test = alg_test_cprng,
2011 .suite = {
2012 .cprng = {
2013 .vecs = ansi_cprng_aes_tv_template,
2014 .count = ANSI_CPRNG_AES_TEST_VECTORS
2015 }
2016 }
2017 }, {
Horia Geantabca4feb2014-03-14 17:46:51 +02002018 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2019 .test = alg_test_aead,
Horia Geantabca4feb2014-03-14 17:46:51 +02002020 .suite = {
2021 .aead = {
2022 .enc = {
2023 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2024 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2025 },
2026 .dec = {
2027 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2028 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2029 }
2030 }
2031 }
2032 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002033 .alg = "authenc(hmac(sha1),cbc(aes))",
Horia Geantae46e9a42012-07-03 19:16:54 +03002034 .test = alg_test_aead,
Horia Geantae46e9a42012-07-03 19:16:54 +03002035 .suite = {
2036 .aead = {
2037 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302038 .vecs =
2039 hmac_sha1_aes_cbc_enc_tv_temp,
2040 .count =
2041 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2042 }
2043 }
2044 }
2045 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002046 .alg = "authenc(hmac(sha1),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302047 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302048 .suite = {
2049 .aead = {
2050 .enc = {
2051 .vecs =
2052 hmac_sha1_des_cbc_enc_tv_temp,
2053 .count =
2054 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2055 }
2056 }
2057 }
2058 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002059 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302060 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302061 .suite = {
2062 .aead = {
2063 .enc = {
2064 .vecs =
2065 hmac_sha1_des3_ede_cbc_enc_tv_temp,
2066 .count =
2067 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantae46e9a42012-07-03 19:16:54 +03002068 }
2069 }
2070 }
2071 }, {
Horia Geantabca4feb2014-03-14 17:46:51 +02002072 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2073 .test = alg_test_aead,
Horia Geantabca4feb2014-03-14 17:46:51 +02002074 .suite = {
2075 .aead = {
2076 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302077 .vecs =
2078 hmac_sha1_ecb_cipher_null_enc_tv_temp,
2079 .count =
2080 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
Horia Geantabca4feb2014-03-14 17:46:51 +02002081 },
2082 .dec = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302083 .vecs =
2084 hmac_sha1_ecb_cipher_null_dec_tv_temp,
2085 .count =
2086 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2087 }
2088 }
2089 }
2090 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002091 .alg = "authenc(hmac(sha224),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302092 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302093 .suite = {
2094 .aead = {
2095 .enc = {
2096 .vecs =
2097 hmac_sha224_des_cbc_enc_tv_temp,
2098 .count =
2099 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2100 }
2101 }
2102 }
2103 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002104 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302105 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302106 .suite = {
2107 .aead = {
2108 .enc = {
2109 .vecs =
2110 hmac_sha224_des3_ede_cbc_enc_tv_temp,
2111 .count =
2112 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantabca4feb2014-03-14 17:46:51 +02002113 }
2114 }
2115 }
2116 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002117 .alg = "authenc(hmac(sha256),cbc(aes))",
Horia Geantae46e9a42012-07-03 19:16:54 +03002118 .test = alg_test_aead,
Horia Geantae46e9a42012-07-03 19:16:54 +03002119 .suite = {
2120 .aead = {
2121 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302122 .vecs =
2123 hmac_sha256_aes_cbc_enc_tv_temp,
2124 .count =
2125 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2126 }
2127 }
2128 }
2129 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002130 .alg = "authenc(hmac(sha256),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302131 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302132 .suite = {
2133 .aead = {
2134 .enc = {
2135 .vecs =
2136 hmac_sha256_des_cbc_enc_tv_temp,
2137 .count =
2138 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2139 }
2140 }
2141 }
2142 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002143 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302144 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302145 .suite = {
2146 .aead = {
2147 .enc = {
2148 .vecs =
2149 hmac_sha256_des3_ede_cbc_enc_tv_temp,
2150 .count =
2151 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2152 }
2153 }
2154 }
2155 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002156 .alg = "authenc(hmac(sha384),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302157 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302158 .suite = {
2159 .aead = {
2160 .enc = {
2161 .vecs =
2162 hmac_sha384_des_cbc_enc_tv_temp,
2163 .count =
2164 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2165 }
2166 }
2167 }
2168 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002169 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302170 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302171 .suite = {
2172 .aead = {
2173 .enc = {
2174 .vecs =
2175 hmac_sha384_des3_ede_cbc_enc_tv_temp,
2176 .count =
2177 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantae46e9a42012-07-03 19:16:54 +03002178 }
2179 }
2180 }
2181 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002182 .alg = "authenc(hmac(sha512),cbc(aes))",
Horia Geantae46e9a42012-07-03 19:16:54 +03002183 .test = alg_test_aead,
Horia Geantae46e9a42012-07-03 19:16:54 +03002184 .suite = {
2185 .aead = {
2186 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302187 .vecs =
2188 hmac_sha512_aes_cbc_enc_tv_temp,
2189 .count =
2190 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2191 }
2192 }
2193 }
2194 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002195 .alg = "authenc(hmac(sha512),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302196 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302197 .suite = {
2198 .aead = {
2199 .enc = {
2200 .vecs =
2201 hmac_sha512_des_cbc_enc_tv_temp,
2202 .count =
2203 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2204 }
2205 }
2206 }
2207 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002208 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302209 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302210 .suite = {
2211 .aead = {
2212 .enc = {
2213 .vecs =
2214 hmac_sha512_des3_ede_cbc_enc_tv_temp,
2215 .count =
2216 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantae46e9a42012-07-03 19:16:54 +03002217 }
2218 }
2219 }
2220 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002221 .alg = "cbc(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002222 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002223 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002224 .suite = {
2225 .cipher = {
2226 .enc = {
2227 .vecs = aes_cbc_enc_tv_template,
2228 .count = AES_CBC_ENC_TEST_VECTORS
2229 },
2230 .dec = {
2231 .vecs = aes_cbc_dec_tv_template,
2232 .count = AES_CBC_DEC_TEST_VECTORS
2233 }
2234 }
2235 }
2236 }, {
2237 .alg = "cbc(anubis)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002238 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002239 .suite = {
2240 .cipher = {
2241 .enc = {
2242 .vecs = anubis_cbc_enc_tv_template,
2243 .count = ANUBIS_CBC_ENC_TEST_VECTORS
2244 },
2245 .dec = {
2246 .vecs = anubis_cbc_dec_tv_template,
2247 .count = ANUBIS_CBC_DEC_TEST_VECTORS
2248 }
2249 }
2250 }
2251 }, {
2252 .alg = "cbc(blowfish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002253 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002254 .suite = {
2255 .cipher = {
2256 .enc = {
2257 .vecs = bf_cbc_enc_tv_template,
2258 .count = BF_CBC_ENC_TEST_VECTORS
2259 },
2260 .dec = {
2261 .vecs = bf_cbc_dec_tv_template,
2262 .count = BF_CBC_DEC_TEST_VECTORS
2263 }
2264 }
2265 }
2266 }, {
2267 .alg = "cbc(camellia)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002268 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002269 .suite = {
2270 .cipher = {
2271 .enc = {
2272 .vecs = camellia_cbc_enc_tv_template,
2273 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2274 },
2275 .dec = {
2276 .vecs = camellia_cbc_dec_tv_template,
2277 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2278 }
2279 }
2280 }
2281 }, {
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002282 .alg = "cbc(cast5)",
2283 .test = alg_test_skcipher,
2284 .suite = {
2285 .cipher = {
2286 .enc = {
2287 .vecs = cast5_cbc_enc_tv_template,
2288 .count = CAST5_CBC_ENC_TEST_VECTORS
2289 },
2290 .dec = {
2291 .vecs = cast5_cbc_dec_tv_template,
2292 .count = CAST5_CBC_DEC_TEST_VECTORS
2293 }
2294 }
2295 }
2296 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002297 .alg = "cbc(cast6)",
2298 .test = alg_test_skcipher,
2299 .suite = {
2300 .cipher = {
2301 .enc = {
2302 .vecs = cast6_cbc_enc_tv_template,
2303 .count = CAST6_CBC_ENC_TEST_VECTORS
2304 },
2305 .dec = {
2306 .vecs = cast6_cbc_dec_tv_template,
2307 .count = CAST6_CBC_DEC_TEST_VECTORS
2308 }
2309 }
2310 }
2311 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002312 .alg = "cbc(des)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002313 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002314 .suite = {
2315 .cipher = {
2316 .enc = {
2317 .vecs = des_cbc_enc_tv_template,
2318 .count = DES_CBC_ENC_TEST_VECTORS
2319 },
2320 .dec = {
2321 .vecs = des_cbc_dec_tv_template,
2322 .count = DES_CBC_DEC_TEST_VECTORS
2323 }
2324 }
2325 }
2326 }, {
2327 .alg = "cbc(des3_ede)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002328 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002329 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002330 .suite = {
2331 .cipher = {
2332 .enc = {
2333 .vecs = des3_ede_cbc_enc_tv_template,
2334 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2335 },
2336 .dec = {
2337 .vecs = des3_ede_cbc_dec_tv_template,
2338 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2339 }
2340 }
2341 }
2342 }, {
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002343 .alg = "cbc(serpent)",
2344 .test = alg_test_skcipher,
2345 .suite = {
2346 .cipher = {
2347 .enc = {
2348 .vecs = serpent_cbc_enc_tv_template,
2349 .count = SERPENT_CBC_ENC_TEST_VECTORS
2350 },
2351 .dec = {
2352 .vecs = serpent_cbc_dec_tv_template,
2353 .count = SERPENT_CBC_DEC_TEST_VECTORS
2354 }
2355 }
2356 }
2357 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002358 .alg = "cbc(twofish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002359 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002360 .suite = {
2361 .cipher = {
2362 .enc = {
2363 .vecs = tf_cbc_enc_tv_template,
2364 .count = TF_CBC_ENC_TEST_VECTORS
2365 },
2366 .dec = {
2367 .vecs = tf_cbc_dec_tv_template,
2368 .count = TF_CBC_DEC_TEST_VECTORS
2369 }
2370 }
2371 }
2372 }, {
2373 .alg = "ccm(aes)",
2374 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002375 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002376 .suite = {
2377 .aead = {
2378 .enc = {
2379 .vecs = aes_ccm_enc_tv_template,
2380 .count = AES_CCM_ENC_TEST_VECTORS
2381 },
2382 .dec = {
2383 .vecs = aes_ccm_dec_tv_template,
2384 .count = AES_CCM_DEC_TEST_VECTORS
2385 }
2386 }
2387 }
2388 }, {
Martin Willi3590ebf2015-06-01 13:43:57 +02002389 .alg = "chacha20",
2390 .test = alg_test_skcipher,
2391 .suite = {
2392 .cipher = {
2393 .enc = {
2394 .vecs = chacha20_enc_tv_template,
2395 .count = CHACHA20_ENC_TEST_VECTORS
2396 },
2397 .dec = {
2398 .vecs = chacha20_enc_tv_template,
2399 .count = CHACHA20_ENC_TEST_VECTORS
2400 },
2401 }
2402 }
2403 }, {
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002404 .alg = "cmac(aes)",
Stephan Mueller8f183752015-08-19 08:42:07 +02002405 .fips_allowed = 1,
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002406 .test = alg_test_hash,
2407 .suite = {
2408 .hash = {
2409 .vecs = aes_cmac128_tv_template,
2410 .count = CMAC_AES_TEST_VECTORS
2411 }
2412 }
2413 }, {
2414 .alg = "cmac(des3_ede)",
Stephan Mueller8f183752015-08-19 08:42:07 +02002415 .fips_allowed = 1,
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002416 .test = alg_test_hash,
2417 .suite = {
2418 .hash = {
2419 .vecs = des3_ede_cmac64_tv_template,
2420 .count = CMAC_DES3_EDE_TEST_VECTORS
2421 }
2422 }
2423 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002424 .alg = "compress_null",
2425 .test = alg_test_null,
2426 }, {
Ard Biesheuvelebb34722015-05-04 11:00:17 +02002427 .alg = "crc32",
2428 .test = alg_test_hash,
2429 .suite = {
2430 .hash = {
2431 .vecs = crc32_tv_template,
2432 .count = CRC32_TEST_VECTORS
2433 }
2434 }
2435 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002436 .alg = "crc32c",
Herbert Xu8e3ee852008-11-07 14:58:52 +08002437 .test = alg_test_crc32c,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002438 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002439 .suite = {
2440 .hash = {
2441 .vecs = crc32c_tv_template,
2442 .count = CRC32C_TEST_VECTORS
2443 }
2444 }
2445 }, {
Herbert Xu684115212013-09-07 12:56:26 +10002446 .alg = "crct10dif",
2447 .test = alg_test_hash,
2448 .fips_allowed = 1,
2449 .suite = {
2450 .hash = {
2451 .vecs = crct10dif_tv_template,
2452 .count = CRCT10DIF_TEST_VECTORS
2453 }
2454 }
2455 }, {
Milan Broz6c792942012-06-29 22:08:09 +02002456 .alg = "cryptd(__driver-cbc-aes-aesni)",
2457 .test = alg_test_null,
2458 .fips_allowed = 1,
Milan Broz6c792942012-06-29 22:08:09 +02002459 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002460 .alg = "cryptd(__driver-cbc-camellia-aesni)",
2461 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002462 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03002463 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2464 .test = alg_test_null,
2465 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03002466 .alg = "cryptd(__driver-cbc-serpent-avx2)",
2467 .test = alg_test_null,
2468 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002469 .alg = "cryptd(__driver-ecb-aes-aesni)",
2470 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002471 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002472 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002473 .alg = "cryptd(__driver-ecb-camellia-aesni)",
2474 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002475 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03002476 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2477 .test = alg_test_null,
2478 }, {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002479 .alg = "cryptd(__driver-ecb-cast5-avx)",
2480 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002481 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002482 .alg = "cryptd(__driver-ecb-cast6-avx)",
2483 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002484 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002485 .alg = "cryptd(__driver-ecb-serpent-avx)",
2486 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002487 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03002488 .alg = "cryptd(__driver-ecb-serpent-avx2)",
2489 .test = alg_test_null,
2490 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002491 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2492 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002493 }, {
Johannes Goetzfried107778b52012-05-28 15:54:24 +02002494 .alg = "cryptd(__driver-ecb-twofish-avx)",
2495 .test = alg_test_null,
Johannes Goetzfried107778b52012-05-28 15:54:24 +02002496 }, {
Milan Broz6c792942012-06-29 22:08:09 +02002497 .alg = "cryptd(__driver-gcm-aes-aesni)",
2498 .test = alg_test_null,
2499 .fips_allowed = 1,
Milan Broz6c792942012-06-29 22:08:09 +02002500 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002501 .alg = "cryptd(__ghash-pclmulqdqni)",
2502 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002503 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002504 }, {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002505 .alg = "ctr(aes)",
2506 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002507 .fips_allowed = 1,
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002508 .suite = {
2509 .cipher = {
2510 .enc = {
2511 .vecs = aes_ctr_enc_tv_template,
2512 .count = AES_CTR_ENC_TEST_VECTORS
2513 },
2514 .dec = {
2515 .vecs = aes_ctr_dec_tv_template,
2516 .count = AES_CTR_DEC_TEST_VECTORS
2517 }
2518 }
2519 }
2520 }, {
Jussi Kivilinna85b63e32011-10-10 23:03:03 +03002521 .alg = "ctr(blowfish)",
2522 .test = alg_test_skcipher,
2523 .suite = {
2524 .cipher = {
2525 .enc = {
2526 .vecs = bf_ctr_enc_tv_template,
2527 .count = BF_CTR_ENC_TEST_VECTORS
2528 },
2529 .dec = {
2530 .vecs = bf_ctr_dec_tv_template,
2531 .count = BF_CTR_DEC_TEST_VECTORS
2532 }
2533 }
2534 }
2535 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02002536 .alg = "ctr(camellia)",
2537 .test = alg_test_skcipher,
2538 .suite = {
2539 .cipher = {
2540 .enc = {
2541 .vecs = camellia_ctr_enc_tv_template,
2542 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2543 },
2544 .dec = {
2545 .vecs = camellia_ctr_dec_tv_template,
2546 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2547 }
2548 }
2549 }
2550 }, {
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002551 .alg = "ctr(cast5)",
2552 .test = alg_test_skcipher,
2553 .suite = {
2554 .cipher = {
2555 .enc = {
2556 .vecs = cast5_ctr_enc_tv_template,
2557 .count = CAST5_CTR_ENC_TEST_VECTORS
2558 },
2559 .dec = {
2560 .vecs = cast5_ctr_dec_tv_template,
2561 .count = CAST5_CTR_DEC_TEST_VECTORS
2562 }
2563 }
2564 }
2565 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002566 .alg = "ctr(cast6)",
2567 .test = alg_test_skcipher,
2568 .suite = {
2569 .cipher = {
2570 .enc = {
2571 .vecs = cast6_ctr_enc_tv_template,
2572 .count = CAST6_CTR_ENC_TEST_VECTORS
2573 },
2574 .dec = {
2575 .vecs = cast6_ctr_dec_tv_template,
2576 .count = CAST6_CTR_DEC_TEST_VECTORS
2577 }
2578 }
2579 }
2580 }, {
Jussi Kivilinna8163fc32012-10-20 14:53:07 +03002581 .alg = "ctr(des)",
2582 .test = alg_test_skcipher,
2583 .suite = {
2584 .cipher = {
2585 .enc = {
2586 .vecs = des_ctr_enc_tv_template,
2587 .count = DES_CTR_ENC_TEST_VECTORS
2588 },
2589 .dec = {
2590 .vecs = des_ctr_dec_tv_template,
2591 .count = DES_CTR_DEC_TEST_VECTORS
2592 }
2593 }
2594 }
2595 }, {
Jussi Kivilinnae080b172012-10-20 14:53:12 +03002596 .alg = "ctr(des3_ede)",
2597 .test = alg_test_skcipher,
2598 .suite = {
2599 .cipher = {
2600 .enc = {
2601 .vecs = des3_ede_ctr_enc_tv_template,
2602 .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2603 },
2604 .dec = {
2605 .vecs = des3_ede_ctr_dec_tv_template,
2606 .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2607 }
2608 }
2609 }
2610 }, {
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002611 .alg = "ctr(serpent)",
2612 .test = alg_test_skcipher,
2613 .suite = {
2614 .cipher = {
2615 .enc = {
2616 .vecs = serpent_ctr_enc_tv_template,
2617 .count = SERPENT_CTR_ENC_TEST_VECTORS
2618 },
2619 .dec = {
2620 .vecs = serpent_ctr_dec_tv_template,
2621 .count = SERPENT_CTR_DEC_TEST_VECTORS
2622 }
2623 }
2624 }
2625 }, {
Jussi Kivilinna573da622011-10-10 23:03:12 +03002626 .alg = "ctr(twofish)",
2627 .test = alg_test_skcipher,
2628 .suite = {
2629 .cipher = {
2630 .enc = {
2631 .vecs = tf_ctr_enc_tv_template,
2632 .count = TF_CTR_ENC_TEST_VECTORS
2633 },
2634 .dec = {
2635 .vecs = tf_ctr_dec_tv_template,
2636 .count = TF_CTR_DEC_TEST_VECTORS
2637 }
2638 }
2639 }
2640 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002641 .alg = "cts(cbc(aes))",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002642 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002643 .suite = {
2644 .cipher = {
2645 .enc = {
2646 .vecs = cts_mode_enc_tv_template,
2647 .count = CTS_MODE_ENC_TEST_VECTORS
2648 },
2649 .dec = {
2650 .vecs = cts_mode_dec_tv_template,
2651 .count = CTS_MODE_DEC_TEST_VECTORS
2652 }
2653 }
2654 }
2655 }, {
2656 .alg = "deflate",
2657 .test = alg_test_comp,
Milan Broz08189042012-12-06 17:16:28 +08002658 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002659 .suite = {
2660 .comp = {
2661 .comp = {
2662 .vecs = deflate_comp_tv_template,
2663 .count = DEFLATE_COMP_TEST_VECTORS
2664 },
2665 .decomp = {
2666 .vecs = deflate_decomp_tv_template,
2667 .count = DEFLATE_DECOMP_TEST_VECTORS
2668 }
2669 }
2670 }
2671 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002672 .alg = "digest_null",
2673 .test = alg_test_null,
2674 }, {
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002675 .alg = "drbg_nopr_ctr_aes128",
2676 .test = alg_test_drbg,
2677 .fips_allowed = 1,
2678 .suite = {
2679 .drbg = {
2680 .vecs = drbg_nopr_ctr_aes128_tv_template,
2681 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2682 }
2683 }
2684 }, {
2685 .alg = "drbg_nopr_ctr_aes192",
2686 .test = alg_test_drbg,
2687 .fips_allowed = 1,
2688 .suite = {
2689 .drbg = {
2690 .vecs = drbg_nopr_ctr_aes192_tv_template,
2691 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2692 }
2693 }
2694 }, {
2695 .alg = "drbg_nopr_ctr_aes256",
2696 .test = alg_test_drbg,
2697 .fips_allowed = 1,
2698 .suite = {
2699 .drbg = {
2700 .vecs = drbg_nopr_ctr_aes256_tv_template,
2701 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2702 }
2703 }
2704 }, {
2705 /*
2706 * There is no need to specifically test the DRBG with every
2707 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2708 */
2709 .alg = "drbg_nopr_hmac_sha1",
2710 .fips_allowed = 1,
2711 .test = alg_test_null,
2712 }, {
2713 .alg = "drbg_nopr_hmac_sha256",
2714 .test = alg_test_drbg,
2715 .fips_allowed = 1,
2716 .suite = {
2717 .drbg = {
2718 .vecs = drbg_nopr_hmac_sha256_tv_template,
2719 .count =
2720 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2721 }
2722 }
2723 }, {
2724 /* covered by drbg_nopr_hmac_sha256 test */
2725 .alg = "drbg_nopr_hmac_sha384",
2726 .fips_allowed = 1,
2727 .test = alg_test_null,
2728 }, {
2729 .alg = "drbg_nopr_hmac_sha512",
2730 .test = alg_test_null,
2731 .fips_allowed = 1,
2732 }, {
2733 .alg = "drbg_nopr_sha1",
2734 .fips_allowed = 1,
2735 .test = alg_test_null,
2736 }, {
2737 .alg = "drbg_nopr_sha256",
2738 .test = alg_test_drbg,
2739 .fips_allowed = 1,
2740 .suite = {
2741 .drbg = {
2742 .vecs = drbg_nopr_sha256_tv_template,
2743 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2744 }
2745 }
2746 }, {
2747 /* covered by drbg_nopr_sha256 test */
2748 .alg = "drbg_nopr_sha384",
2749 .fips_allowed = 1,
2750 .test = alg_test_null,
2751 }, {
2752 .alg = "drbg_nopr_sha512",
2753 .fips_allowed = 1,
2754 .test = alg_test_null,
2755 }, {
2756 .alg = "drbg_pr_ctr_aes128",
2757 .test = alg_test_drbg,
2758 .fips_allowed = 1,
2759 .suite = {
2760 .drbg = {
2761 .vecs = drbg_pr_ctr_aes128_tv_template,
2762 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
2763 }
2764 }
2765 }, {
2766 /* covered by drbg_pr_ctr_aes128 test */
2767 .alg = "drbg_pr_ctr_aes192",
2768 .fips_allowed = 1,
2769 .test = alg_test_null,
2770 }, {
2771 .alg = "drbg_pr_ctr_aes256",
2772 .fips_allowed = 1,
2773 .test = alg_test_null,
2774 }, {
2775 .alg = "drbg_pr_hmac_sha1",
2776 .fips_allowed = 1,
2777 .test = alg_test_null,
2778 }, {
2779 .alg = "drbg_pr_hmac_sha256",
2780 .test = alg_test_drbg,
2781 .fips_allowed = 1,
2782 .suite = {
2783 .drbg = {
2784 .vecs = drbg_pr_hmac_sha256_tv_template,
2785 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
2786 }
2787 }
2788 }, {
2789 /* covered by drbg_pr_hmac_sha256 test */
2790 .alg = "drbg_pr_hmac_sha384",
2791 .fips_allowed = 1,
2792 .test = alg_test_null,
2793 }, {
2794 .alg = "drbg_pr_hmac_sha512",
2795 .test = alg_test_null,
2796 .fips_allowed = 1,
2797 }, {
2798 .alg = "drbg_pr_sha1",
2799 .fips_allowed = 1,
2800 .test = alg_test_null,
2801 }, {
2802 .alg = "drbg_pr_sha256",
2803 .test = alg_test_drbg,
2804 .fips_allowed = 1,
2805 .suite = {
2806 .drbg = {
2807 .vecs = drbg_pr_sha256_tv_template,
2808 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
2809 }
2810 }
2811 }, {
2812 /* covered by drbg_pr_sha256 test */
2813 .alg = "drbg_pr_sha384",
2814 .fips_allowed = 1,
2815 .test = alg_test_null,
2816 }, {
2817 .alg = "drbg_pr_sha512",
2818 .fips_allowed = 1,
2819 .test = alg_test_null,
2820 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002821 .alg = "ecb(__aes-aesni)",
2822 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002823 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002824 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002825 .alg = "ecb(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002826 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002827 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002828 .suite = {
2829 .cipher = {
2830 .enc = {
2831 .vecs = aes_enc_tv_template,
2832 .count = AES_ENC_TEST_VECTORS
2833 },
2834 .dec = {
2835 .vecs = aes_dec_tv_template,
2836 .count = AES_DEC_TEST_VECTORS
2837 }
2838 }
2839 }
2840 }, {
2841 .alg = "ecb(anubis)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002842 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002843 .suite = {
2844 .cipher = {
2845 .enc = {
2846 .vecs = anubis_enc_tv_template,
2847 .count = ANUBIS_ENC_TEST_VECTORS
2848 },
2849 .dec = {
2850 .vecs = anubis_dec_tv_template,
2851 .count = ANUBIS_DEC_TEST_VECTORS
2852 }
2853 }
2854 }
2855 }, {
2856 .alg = "ecb(arc4)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002857 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002858 .suite = {
2859 .cipher = {
2860 .enc = {
2861 .vecs = arc4_enc_tv_template,
2862 .count = ARC4_ENC_TEST_VECTORS
2863 },
2864 .dec = {
2865 .vecs = arc4_dec_tv_template,
2866 .count = ARC4_DEC_TEST_VECTORS
2867 }
2868 }
2869 }
2870 }, {
2871 .alg = "ecb(blowfish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002872 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002873 .suite = {
2874 .cipher = {
2875 .enc = {
2876 .vecs = bf_enc_tv_template,
2877 .count = BF_ENC_TEST_VECTORS
2878 },
2879 .dec = {
2880 .vecs = bf_dec_tv_template,
2881 .count = BF_DEC_TEST_VECTORS
2882 }
2883 }
2884 }
2885 }, {
2886 .alg = "ecb(camellia)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002887 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002888 .suite = {
2889 .cipher = {
2890 .enc = {
2891 .vecs = camellia_enc_tv_template,
2892 .count = CAMELLIA_ENC_TEST_VECTORS
2893 },
2894 .dec = {
2895 .vecs = camellia_dec_tv_template,
2896 .count = CAMELLIA_DEC_TEST_VECTORS
2897 }
2898 }
2899 }
2900 }, {
2901 .alg = "ecb(cast5)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002902 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002903 .suite = {
2904 .cipher = {
2905 .enc = {
2906 .vecs = cast5_enc_tv_template,
2907 .count = CAST5_ENC_TEST_VECTORS
2908 },
2909 .dec = {
2910 .vecs = cast5_dec_tv_template,
2911 .count = CAST5_DEC_TEST_VECTORS
2912 }
2913 }
2914 }
2915 }, {
2916 .alg = "ecb(cast6)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002917 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002918 .suite = {
2919 .cipher = {
2920 .enc = {
2921 .vecs = cast6_enc_tv_template,
2922 .count = CAST6_ENC_TEST_VECTORS
2923 },
2924 .dec = {
2925 .vecs = cast6_dec_tv_template,
2926 .count = CAST6_DEC_TEST_VECTORS
2927 }
2928 }
2929 }
2930 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002931 .alg = "ecb(cipher_null)",
2932 .test = alg_test_null,
2933 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002934 .alg = "ecb(des)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002935 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002936 .suite = {
2937 .cipher = {
2938 .enc = {
2939 .vecs = des_enc_tv_template,
2940 .count = DES_ENC_TEST_VECTORS
2941 },
2942 .dec = {
2943 .vecs = des_dec_tv_template,
2944 .count = DES_DEC_TEST_VECTORS
2945 }
2946 }
2947 }
2948 }, {
2949 .alg = "ecb(des3_ede)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002950 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002951 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002952 .suite = {
2953 .cipher = {
2954 .enc = {
2955 .vecs = des3_ede_enc_tv_template,
2956 .count = DES3_EDE_ENC_TEST_VECTORS
2957 },
2958 .dec = {
2959 .vecs = des3_ede_dec_tv_template,
2960 .count = DES3_EDE_DEC_TEST_VECTORS
2961 }
2962 }
2963 }
2964 }, {
Jussi Kivilinna66e5bd02013-01-19 13:31:36 +02002965 .alg = "ecb(fcrypt)",
2966 .test = alg_test_skcipher,
2967 .suite = {
2968 .cipher = {
2969 .enc = {
2970 .vecs = fcrypt_pcbc_enc_tv_template,
2971 .count = 1
2972 },
2973 .dec = {
2974 .vecs = fcrypt_pcbc_dec_tv_template,
2975 .count = 1
2976 }
2977 }
2978 }
2979 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002980 .alg = "ecb(khazad)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002981 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002982 .suite = {
2983 .cipher = {
2984 .enc = {
2985 .vecs = khazad_enc_tv_template,
2986 .count = KHAZAD_ENC_TEST_VECTORS
2987 },
2988 .dec = {
2989 .vecs = khazad_dec_tv_template,
2990 .count = KHAZAD_DEC_TEST_VECTORS
2991 }
2992 }
2993 }
2994 }, {
2995 .alg = "ecb(seed)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002996 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002997 .suite = {
2998 .cipher = {
2999 .enc = {
3000 .vecs = seed_enc_tv_template,
3001 .count = SEED_ENC_TEST_VECTORS
3002 },
3003 .dec = {
3004 .vecs = seed_dec_tv_template,
3005 .count = SEED_DEC_TEST_VECTORS
3006 }
3007 }
3008 }
3009 }, {
3010 .alg = "ecb(serpent)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003011 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003012 .suite = {
3013 .cipher = {
3014 .enc = {
3015 .vecs = serpent_enc_tv_template,
3016 .count = SERPENT_ENC_TEST_VECTORS
3017 },
3018 .dec = {
3019 .vecs = serpent_dec_tv_template,
3020 .count = SERPENT_DEC_TEST_VECTORS
3021 }
3022 }
3023 }
3024 }, {
3025 .alg = "ecb(tea)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003026 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003027 .suite = {
3028 .cipher = {
3029 .enc = {
3030 .vecs = tea_enc_tv_template,
3031 .count = TEA_ENC_TEST_VECTORS
3032 },
3033 .dec = {
3034 .vecs = tea_dec_tv_template,
3035 .count = TEA_DEC_TEST_VECTORS
3036 }
3037 }
3038 }
3039 }, {
3040 .alg = "ecb(tnepres)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003041 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003042 .suite = {
3043 .cipher = {
3044 .enc = {
3045 .vecs = tnepres_enc_tv_template,
3046 .count = TNEPRES_ENC_TEST_VECTORS
3047 },
3048 .dec = {
3049 .vecs = tnepres_dec_tv_template,
3050 .count = TNEPRES_DEC_TEST_VECTORS
3051 }
3052 }
3053 }
3054 }, {
3055 .alg = "ecb(twofish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003056 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003057 .suite = {
3058 .cipher = {
3059 .enc = {
3060 .vecs = tf_enc_tv_template,
3061 .count = TF_ENC_TEST_VECTORS
3062 },
3063 .dec = {
3064 .vecs = tf_dec_tv_template,
3065 .count = TF_DEC_TEST_VECTORS
3066 }
3067 }
3068 }
3069 }, {
3070 .alg = "ecb(xeta)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003071 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003072 .suite = {
3073 .cipher = {
3074 .enc = {
3075 .vecs = xeta_enc_tv_template,
3076 .count = XETA_ENC_TEST_VECTORS
3077 },
3078 .dec = {
3079 .vecs = xeta_dec_tv_template,
3080 .count = XETA_DEC_TEST_VECTORS
3081 }
3082 }
3083 }
3084 }, {
3085 .alg = "ecb(xtea)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003086 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003087 .suite = {
3088 .cipher = {
3089 .enc = {
3090 .vecs = xtea_enc_tv_template,
3091 .count = XTEA_ENC_TEST_VECTORS
3092 },
3093 .dec = {
3094 .vecs = xtea_dec_tv_template,
3095 .count = XTEA_DEC_TEST_VECTORS
3096 }
3097 }
3098 }
3099 }, {
3100 .alg = "gcm(aes)",
3101 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003102 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003103 .suite = {
3104 .aead = {
3105 .enc = {
3106 .vecs = aes_gcm_enc_tv_template,
3107 .count = AES_GCM_ENC_TEST_VECTORS
3108 },
3109 .dec = {
3110 .vecs = aes_gcm_dec_tv_template,
3111 .count = AES_GCM_DEC_TEST_VECTORS
3112 }
3113 }
3114 }
3115 }, {
Youquan, Song507069c2009-11-23 20:23:04 +08003116 .alg = "ghash",
3117 .test = alg_test_hash,
Jarod Wilson18c0ebd2011-01-29 15:14:35 +11003118 .fips_allowed = 1,
Youquan, Song507069c2009-11-23 20:23:04 +08003119 .suite = {
3120 .hash = {
3121 .vecs = ghash_tv_template,
3122 .count = GHASH_TEST_VECTORS
3123 }
3124 }
3125 }, {
Sonic Zhanga482b082012-05-25 17:54:13 +08003126 .alg = "hmac(crc32)",
3127 .test = alg_test_hash,
3128 .suite = {
3129 .hash = {
3130 .vecs = bfin_crc_tv_template,
3131 .count = BFIN_CRC_TEST_VECTORS
3132 }
3133 }
3134 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003135 .alg = "hmac(md5)",
3136 .test = alg_test_hash,
3137 .suite = {
3138 .hash = {
3139 .vecs = hmac_md5_tv_template,
3140 .count = HMAC_MD5_TEST_VECTORS
3141 }
3142 }
3143 }, {
3144 .alg = "hmac(rmd128)",
3145 .test = alg_test_hash,
3146 .suite = {
3147 .hash = {
3148 .vecs = hmac_rmd128_tv_template,
3149 .count = HMAC_RMD128_TEST_VECTORS
3150 }
3151 }
3152 }, {
3153 .alg = "hmac(rmd160)",
3154 .test = alg_test_hash,
3155 .suite = {
3156 .hash = {
3157 .vecs = hmac_rmd160_tv_template,
3158 .count = HMAC_RMD160_TEST_VECTORS
3159 }
3160 }
3161 }, {
3162 .alg = "hmac(sha1)",
3163 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003164 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003165 .suite = {
3166 .hash = {
3167 .vecs = hmac_sha1_tv_template,
3168 .count = HMAC_SHA1_TEST_VECTORS
3169 }
3170 }
3171 }, {
3172 .alg = "hmac(sha224)",
3173 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003174 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003175 .suite = {
3176 .hash = {
3177 .vecs = hmac_sha224_tv_template,
3178 .count = HMAC_SHA224_TEST_VECTORS
3179 }
3180 }
3181 }, {
3182 .alg = "hmac(sha256)",
3183 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003184 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003185 .suite = {
3186 .hash = {
3187 .vecs = hmac_sha256_tv_template,
3188 .count = HMAC_SHA256_TEST_VECTORS
3189 }
3190 }
3191 }, {
3192 .alg = "hmac(sha384)",
3193 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003194 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003195 .suite = {
3196 .hash = {
3197 .vecs = hmac_sha384_tv_template,
3198 .count = HMAC_SHA384_TEST_VECTORS
3199 }
3200 }
3201 }, {
3202 .alg = "hmac(sha512)",
3203 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003204 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003205 .suite = {
3206 .hash = {
3207 .vecs = hmac_sha512_tv_template,
3208 .count = HMAC_SHA512_TEST_VECTORS
3209 }
3210 }
3211 }, {
Stephan Muellerbb5530e2015-05-25 15:10:20 +02003212 .alg = "jitterentropy_rng",
3213 .fips_allowed = 1,
3214 .test = alg_test_null,
3215 }, {
Stephan Mueller35351982015-09-21 20:59:56 +02003216 .alg = "kw(aes)",
3217 .test = alg_test_skcipher,
3218 .fips_allowed = 1,
3219 .suite = {
3220 .cipher = {
3221 .enc = {
3222 .vecs = aes_kw_enc_tv_template,
3223 .count = ARRAY_SIZE(aes_kw_enc_tv_template)
3224 },
3225 .dec = {
3226 .vecs = aes_kw_dec_tv_template,
3227 .count = ARRAY_SIZE(aes_kw_dec_tv_template)
3228 }
3229 }
3230 }
3231 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003232 .alg = "lrw(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003233 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003234 .suite = {
3235 .cipher = {
3236 .enc = {
3237 .vecs = aes_lrw_enc_tv_template,
3238 .count = AES_LRW_ENC_TEST_VECTORS
3239 },
3240 .dec = {
3241 .vecs = aes_lrw_dec_tv_template,
3242 .count = AES_LRW_DEC_TEST_VECTORS
3243 }
3244 }
3245 }
3246 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02003247 .alg = "lrw(camellia)",
3248 .test = alg_test_skcipher,
3249 .suite = {
3250 .cipher = {
3251 .enc = {
3252 .vecs = camellia_lrw_enc_tv_template,
3253 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
3254 },
3255 .dec = {
3256 .vecs = camellia_lrw_dec_tv_template,
3257 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
3258 }
3259 }
3260 }
3261 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003262 .alg = "lrw(cast6)",
3263 .test = alg_test_skcipher,
3264 .suite = {
3265 .cipher = {
3266 .enc = {
3267 .vecs = cast6_lrw_enc_tv_template,
3268 .count = CAST6_LRW_ENC_TEST_VECTORS
3269 },
3270 .dec = {
3271 .vecs = cast6_lrw_dec_tv_template,
3272 .count = CAST6_LRW_DEC_TEST_VECTORS
3273 }
3274 }
3275 }
3276 }, {
Jussi Kivilinnad7bfc0f2011-10-18 13:32:34 +03003277 .alg = "lrw(serpent)",
3278 .test = alg_test_skcipher,
3279 .suite = {
3280 .cipher = {
3281 .enc = {
3282 .vecs = serpent_lrw_enc_tv_template,
3283 .count = SERPENT_LRW_ENC_TEST_VECTORS
3284 },
3285 .dec = {
3286 .vecs = serpent_lrw_dec_tv_template,
3287 .count = SERPENT_LRW_DEC_TEST_VECTORS
3288 }
3289 }
3290 }
3291 }, {
Jussi Kivilinna0b2a1552011-10-18 13:32:50 +03003292 .alg = "lrw(twofish)",
3293 .test = alg_test_skcipher,
3294 .suite = {
3295 .cipher = {
3296 .enc = {
3297 .vecs = tf_lrw_enc_tv_template,
3298 .count = TF_LRW_ENC_TEST_VECTORS
3299 },
3300 .dec = {
3301 .vecs = tf_lrw_dec_tv_template,
3302 .count = TF_LRW_DEC_TEST_VECTORS
3303 }
3304 }
3305 }
3306 }, {
KOVACS Krisztian1443cc92014-08-22 10:44:36 +02003307 .alg = "lz4",
3308 .test = alg_test_comp,
3309 .fips_allowed = 1,
3310 .suite = {
3311 .comp = {
3312 .comp = {
3313 .vecs = lz4_comp_tv_template,
3314 .count = LZ4_COMP_TEST_VECTORS
3315 },
3316 .decomp = {
3317 .vecs = lz4_decomp_tv_template,
3318 .count = LZ4_DECOMP_TEST_VECTORS
3319 }
3320 }
3321 }
3322 }, {
3323 .alg = "lz4hc",
3324 .test = alg_test_comp,
3325 .fips_allowed = 1,
3326 .suite = {
3327 .comp = {
3328 .comp = {
3329 .vecs = lz4hc_comp_tv_template,
3330 .count = LZ4HC_COMP_TEST_VECTORS
3331 },
3332 .decomp = {
3333 .vecs = lz4hc_decomp_tv_template,
3334 .count = LZ4HC_DECOMP_TEST_VECTORS
3335 }
3336 }
3337 }
3338 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003339 .alg = "lzo",
3340 .test = alg_test_comp,
Milan Broz08189042012-12-06 17:16:28 +08003341 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003342 .suite = {
3343 .comp = {
3344 .comp = {
3345 .vecs = lzo_comp_tv_template,
3346 .count = LZO_COMP_TEST_VECTORS
3347 },
3348 .decomp = {
3349 .vecs = lzo_decomp_tv_template,
3350 .count = LZO_DECOMP_TEST_VECTORS
3351 }
3352 }
3353 }
3354 }, {
3355 .alg = "md4",
3356 .test = alg_test_hash,
3357 .suite = {
3358 .hash = {
3359 .vecs = md4_tv_template,
3360 .count = MD4_TEST_VECTORS
3361 }
3362 }
3363 }, {
3364 .alg = "md5",
3365 .test = alg_test_hash,
3366 .suite = {
3367 .hash = {
3368 .vecs = md5_tv_template,
3369 .count = MD5_TEST_VECTORS
3370 }
3371 }
3372 }, {
3373 .alg = "michael_mic",
3374 .test = alg_test_hash,
3375 .suite = {
3376 .hash = {
3377 .vecs = michael_mic_tv_template,
3378 .count = MICHAEL_MIC_TEST_VECTORS
3379 }
3380 }
3381 }, {
Puneet Saxenaba0e14a2011-05-04 15:04:10 +10003382 .alg = "ofb(aes)",
3383 .test = alg_test_skcipher,
3384 .fips_allowed = 1,
3385 .suite = {
3386 .cipher = {
3387 .enc = {
3388 .vecs = aes_ofb_enc_tv_template,
3389 .count = AES_OFB_ENC_TEST_VECTORS
3390 },
3391 .dec = {
3392 .vecs = aes_ofb_dec_tv_template,
3393 .count = AES_OFB_DEC_TEST_VECTORS
3394 }
3395 }
3396 }
3397 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003398 .alg = "pcbc(fcrypt)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003399 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003400 .suite = {
3401 .cipher = {
3402 .enc = {
3403 .vecs = fcrypt_pcbc_enc_tv_template,
3404 .count = FCRYPT_ENC_TEST_VECTORS
3405 },
3406 .dec = {
3407 .vecs = fcrypt_pcbc_dec_tv_template,
3408 .count = FCRYPT_DEC_TEST_VECTORS
3409 }
3410 }
3411 }
3412 }, {
Martin Willieee9dc62015-06-01 13:43:59 +02003413 .alg = "poly1305",
3414 .test = alg_test_hash,
3415 .suite = {
3416 .hash = {
3417 .vecs = poly1305_tv_template,
3418 .count = POLY1305_TEST_VECTORS
3419 }
3420 }
3421 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003422 .alg = "rfc3686(ctr(aes))",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003423 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003424 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003425 .suite = {
3426 .cipher = {
3427 .enc = {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08003428 .vecs = aes_ctr_rfc3686_enc_tv_template,
3429 .count = AES_CTR_3686_ENC_TEST_VECTORS
Herbert Xuda7f0332008-07-31 17:08:25 +08003430 },
3431 .dec = {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08003432 .vecs = aes_ctr_rfc3686_dec_tv_template,
3433 .count = AES_CTR_3686_DEC_TEST_VECTORS
Herbert Xuda7f0332008-07-31 17:08:25 +08003434 }
3435 }
3436 }
3437 }, {
Herbert Xu3f31a742015-07-09 07:17:34 +08003438 .alg = "rfc4106(gcm(aes))",
Adrian Hoban69435b92010-11-04 15:02:04 -04003439 .test = alg_test_aead,
Jarod Wilsondb71f29a2015-01-23 12:42:15 -05003440 .fips_allowed = 1,
Adrian Hoban69435b92010-11-04 15:02:04 -04003441 .suite = {
3442 .aead = {
3443 .enc = {
3444 .vecs = aes_gcm_rfc4106_enc_tv_template,
3445 .count = AES_GCM_4106_ENC_TEST_VECTORS
3446 },
3447 .dec = {
3448 .vecs = aes_gcm_rfc4106_dec_tv_template,
3449 .count = AES_GCM_4106_DEC_TEST_VECTORS
3450 }
3451 }
3452 }
3453 }, {
Herbert Xu544c4362015-07-14 16:53:22 +08003454 .alg = "rfc4309(ccm(aes))",
Jarod Wilson5d667322009-05-04 19:23:40 +08003455 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003456 .fips_allowed = 1,
Jarod Wilson5d667322009-05-04 19:23:40 +08003457 .suite = {
3458 .aead = {
3459 .enc = {
3460 .vecs = aes_ccm_rfc4309_enc_tv_template,
3461 .count = AES_CCM_4309_ENC_TEST_VECTORS
3462 },
3463 .dec = {
3464 .vecs = aes_ccm_rfc4309_dec_tv_template,
3465 .count = AES_CCM_4309_DEC_TEST_VECTORS
3466 }
3467 }
3468 }
3469 }, {
Herbert Xubb687452015-06-16 13:54:24 +08003470 .alg = "rfc4543(gcm(aes))",
Jussi Kivilinnae9b74412013-04-07 16:43:51 +03003471 .test = alg_test_aead,
3472 .suite = {
3473 .aead = {
3474 .enc = {
3475 .vecs = aes_gcm_rfc4543_enc_tv_template,
3476 .count = AES_GCM_4543_ENC_TEST_VECTORS
3477 },
3478 .dec = {
3479 .vecs = aes_gcm_rfc4543_dec_tv_template,
3480 .count = AES_GCM_4543_DEC_TEST_VECTORS
3481 },
3482 }
3483 }
3484 }, {
Martin Williaf2b76b2015-06-01 13:44:01 +02003485 .alg = "rfc7539(chacha20,poly1305)",
3486 .test = alg_test_aead,
3487 .suite = {
3488 .aead = {
3489 .enc = {
3490 .vecs = rfc7539_enc_tv_template,
3491 .count = RFC7539_ENC_TEST_VECTORS
3492 },
3493 .dec = {
3494 .vecs = rfc7539_dec_tv_template,
3495 .count = RFC7539_DEC_TEST_VECTORS
3496 },
3497 }
3498 }
3499 }, {
Martin Willi59007582015-06-01 13:44:03 +02003500 .alg = "rfc7539esp(chacha20,poly1305)",
3501 .test = alg_test_aead,
3502 .suite = {
3503 .aead = {
3504 .enc = {
3505 .vecs = rfc7539esp_enc_tv_template,
3506 .count = RFC7539ESP_ENC_TEST_VECTORS
3507 },
3508 .dec = {
3509 .vecs = rfc7539esp_dec_tv_template,
3510 .count = RFC7539ESP_DEC_TEST_VECTORS
3511 },
3512 }
3513 }
3514 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003515 .alg = "rmd128",
3516 .test = alg_test_hash,
3517 .suite = {
3518 .hash = {
3519 .vecs = rmd128_tv_template,
3520 .count = RMD128_TEST_VECTORS
3521 }
3522 }
3523 }, {
3524 .alg = "rmd160",
3525 .test = alg_test_hash,
3526 .suite = {
3527 .hash = {
3528 .vecs = rmd160_tv_template,
3529 .count = RMD160_TEST_VECTORS
3530 }
3531 }
3532 }, {
3533 .alg = "rmd256",
3534 .test = alg_test_hash,
3535 .suite = {
3536 .hash = {
3537 .vecs = rmd256_tv_template,
3538 .count = RMD256_TEST_VECTORS
3539 }
3540 }
3541 }, {
3542 .alg = "rmd320",
3543 .test = alg_test_hash,
3544 .suite = {
3545 .hash = {
3546 .vecs = rmd320_tv_template,
3547 .count = RMD320_TEST_VECTORS
3548 }
3549 }
3550 }, {
Tadeusz Struk946cc462015-06-16 10:31:06 -07003551 .alg = "rsa",
3552 .test = alg_test_akcipher,
3553 .fips_allowed = 1,
3554 .suite = {
3555 .akcipher = {
3556 .vecs = rsa_tv_template,
3557 .count = RSA_TEST_VECTORS
3558 }
3559 }
3560 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003561 .alg = "salsa20",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003562 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003563 .suite = {
3564 .cipher = {
3565 .enc = {
3566 .vecs = salsa20_stream_enc_tv_template,
3567 .count = SALSA20_STREAM_ENC_TEST_VECTORS
3568 }
3569 }
3570 }
3571 }, {
3572 .alg = "sha1",
3573 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003574 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003575 .suite = {
3576 .hash = {
3577 .vecs = sha1_tv_template,
3578 .count = SHA1_TEST_VECTORS
3579 }
3580 }
3581 }, {
3582 .alg = "sha224",
3583 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003584 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003585 .suite = {
3586 .hash = {
3587 .vecs = sha224_tv_template,
3588 .count = SHA224_TEST_VECTORS
3589 }
3590 }
3591 }, {
3592 .alg = "sha256",
3593 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003594 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003595 .suite = {
3596 .hash = {
3597 .vecs = sha256_tv_template,
3598 .count = SHA256_TEST_VECTORS
3599 }
3600 }
3601 }, {
3602 .alg = "sha384",
3603 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003604 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003605 .suite = {
3606 .hash = {
3607 .vecs = sha384_tv_template,
3608 .count = SHA384_TEST_VECTORS
3609 }
3610 }
3611 }, {
3612 .alg = "sha512",
3613 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003614 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003615 .suite = {
3616 .hash = {
3617 .vecs = sha512_tv_template,
3618 .count = SHA512_TEST_VECTORS
3619 }
3620 }
3621 }, {
3622 .alg = "tgr128",
3623 .test = alg_test_hash,
3624 .suite = {
3625 .hash = {
3626 .vecs = tgr128_tv_template,
3627 .count = TGR128_TEST_VECTORS
3628 }
3629 }
3630 }, {
3631 .alg = "tgr160",
3632 .test = alg_test_hash,
3633 .suite = {
3634 .hash = {
3635 .vecs = tgr160_tv_template,
3636 .count = TGR160_TEST_VECTORS
3637 }
3638 }
3639 }, {
3640 .alg = "tgr192",
3641 .test = alg_test_hash,
3642 .suite = {
3643 .hash = {
3644 .vecs = tgr192_tv_template,
3645 .count = TGR192_TEST_VECTORS
3646 }
3647 }
3648 }, {
Shane Wangf1939f72009-09-02 20:05:22 +10003649 .alg = "vmac(aes)",
3650 .test = alg_test_hash,
3651 .suite = {
3652 .hash = {
3653 .vecs = aes_vmac128_tv_template,
3654 .count = VMAC_AES_TEST_VECTORS
3655 }
3656 }
3657 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003658 .alg = "wp256",
3659 .test = alg_test_hash,
3660 .suite = {
3661 .hash = {
3662 .vecs = wp256_tv_template,
3663 .count = WP256_TEST_VECTORS
3664 }
3665 }
3666 }, {
3667 .alg = "wp384",
3668 .test = alg_test_hash,
3669 .suite = {
3670 .hash = {
3671 .vecs = wp384_tv_template,
3672 .count = WP384_TEST_VECTORS
3673 }
3674 }
3675 }, {
3676 .alg = "wp512",
3677 .test = alg_test_hash,
3678 .suite = {
3679 .hash = {
3680 .vecs = wp512_tv_template,
3681 .count = WP512_TEST_VECTORS
3682 }
3683 }
3684 }, {
3685 .alg = "xcbc(aes)",
3686 .test = alg_test_hash,
3687 .suite = {
3688 .hash = {
3689 .vecs = aes_xcbc128_tv_template,
3690 .count = XCBC_AES_TEST_VECTORS
3691 }
3692 }
3693 }, {
3694 .alg = "xts(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003695 .test = alg_test_skcipher,
Jarod Wilson2918aa82011-01-29 15:14:01 +11003696 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003697 .suite = {
3698 .cipher = {
3699 .enc = {
3700 .vecs = aes_xts_enc_tv_template,
3701 .count = AES_XTS_ENC_TEST_VECTORS
3702 },
3703 .dec = {
3704 .vecs = aes_xts_dec_tv_template,
3705 .count = AES_XTS_DEC_TEST_VECTORS
3706 }
3707 }
3708 }
Geert Uytterhoeven0c01aed2009-03-04 15:42:15 +08003709 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02003710 .alg = "xts(camellia)",
3711 .test = alg_test_skcipher,
3712 .suite = {
3713 .cipher = {
3714 .enc = {
3715 .vecs = camellia_xts_enc_tv_template,
3716 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
3717 },
3718 .dec = {
3719 .vecs = camellia_xts_dec_tv_template,
3720 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
3721 }
3722 }
3723 }
3724 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003725 .alg = "xts(cast6)",
3726 .test = alg_test_skcipher,
3727 .suite = {
3728 .cipher = {
3729 .enc = {
3730 .vecs = cast6_xts_enc_tv_template,
3731 .count = CAST6_XTS_ENC_TEST_VECTORS
3732 },
3733 .dec = {
3734 .vecs = cast6_xts_dec_tv_template,
3735 .count = CAST6_XTS_DEC_TEST_VECTORS
3736 }
3737 }
3738 }
3739 }, {
Jussi Kivilinna18be20b92011-10-18 13:33:17 +03003740 .alg = "xts(serpent)",
3741 .test = alg_test_skcipher,
3742 .suite = {
3743 .cipher = {
3744 .enc = {
3745 .vecs = serpent_xts_enc_tv_template,
3746 .count = SERPENT_XTS_ENC_TEST_VECTORS
3747 },
3748 .dec = {
3749 .vecs = serpent_xts_dec_tv_template,
3750 .count = SERPENT_XTS_DEC_TEST_VECTORS
3751 }
3752 }
3753 }
3754 }, {
Jussi Kivilinnaaed265b2011-10-18 13:33:33 +03003755 .alg = "xts(twofish)",
3756 .test = alg_test_skcipher,
3757 .suite = {
3758 .cipher = {
3759 .enc = {
3760 .vecs = tf_xts_enc_tv_template,
3761 .count = TF_XTS_ENC_TEST_VECTORS
3762 },
3763 .dec = {
3764 .vecs = tf_xts_dec_tv_template,
3765 .count = TF_XTS_DEC_TEST_VECTORS
3766 }
3767 }
3768 }
Herbert Xuda7f0332008-07-31 17:08:25 +08003769 }
3770};
3771
Jussi Kivilinna57147582013-06-13 17:37:40 +03003772static bool alg_test_descs_checked;
3773
3774static void alg_test_descs_check_order(void)
3775{
3776 int i;
3777
3778 /* only check once */
3779 if (alg_test_descs_checked)
3780 return;
3781
3782 alg_test_descs_checked = true;
3783
3784 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3785 int diff = strcmp(alg_test_descs[i - 1].alg,
3786 alg_test_descs[i].alg);
3787
3788 if (WARN_ON(diff > 0)) {
3789 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3790 alg_test_descs[i - 1].alg,
3791 alg_test_descs[i].alg);
3792 }
3793
3794 if (WARN_ON(diff == 0)) {
3795 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3796 alg_test_descs[i].alg);
3797 }
3798 }
3799}
3800
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003801static int alg_find_test(const char *alg)
Herbert Xuda7f0332008-07-31 17:08:25 +08003802{
3803 int start = 0;
3804 int end = ARRAY_SIZE(alg_test_descs);
3805
3806 while (start < end) {
3807 int i = (start + end) / 2;
3808 int diff = strcmp(alg_test_descs[i].alg, alg);
3809
3810 if (diff > 0) {
3811 end = i;
3812 continue;
3813 }
3814
3815 if (diff < 0) {
3816 start = i + 1;
3817 continue;
3818 }
3819
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003820 return i;
Herbert Xuda7f0332008-07-31 17:08:25 +08003821 }
3822
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003823 return -1;
3824}
3825
3826int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3827{
3828 int i;
Herbert Xua68f6612009-07-02 16:32:12 +08003829 int j;
Neil Hormand12d6b62008-10-12 20:36:51 +08003830 int rc;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003831
Jussi Kivilinna57147582013-06-13 17:37:40 +03003832 alg_test_descs_check_order();
3833
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003834 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3835 char nalg[CRYPTO_MAX_ALG_NAME];
3836
3837 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3838 sizeof(nalg))
3839 return -ENAMETOOLONG;
3840
3841 i = alg_find_test(nalg);
3842 if (i < 0)
3843 goto notest;
3844
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003845 if (fips_enabled && !alg_test_descs[i].fips_allowed)
3846 goto non_fips_alg;
3847
Jarod Wilson941fb322009-05-04 19:49:23 +08003848 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3849 goto test_done;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003850 }
3851
3852 i = alg_find_test(alg);
Herbert Xua68f6612009-07-02 16:32:12 +08003853 j = alg_find_test(driver);
3854 if (i < 0 && j < 0)
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003855 goto notest;
3856
Herbert Xua68f6612009-07-02 16:32:12 +08003857 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3858 (j >= 0 && !alg_test_descs[j].fips_allowed)))
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003859 goto non_fips_alg;
3860
Herbert Xua68f6612009-07-02 16:32:12 +08003861 rc = 0;
3862 if (i >= 0)
3863 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3864 type, mask);
Cristian Stoica032c8ca2013-07-18 18:57:07 +03003865 if (j >= 0 && j != i)
Herbert Xua68f6612009-07-02 16:32:12 +08003866 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3867 type, mask);
3868
Jarod Wilson941fb322009-05-04 19:49:23 +08003869test_done:
Neil Hormand12d6b62008-10-12 20:36:51 +08003870 if (fips_enabled && rc)
3871 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3872
Jarod Wilson29ecd4a2009-05-04 19:51:17 +08003873 if (fips_enabled && !rc)
Masanari Iida3e8cffd2014-10-07 00:37:54 +09003874 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
Jarod Wilson29ecd4a2009-05-04 19:51:17 +08003875
Neil Hormand12d6b62008-10-12 20:36:51 +08003876 return rc;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003877
3878notest:
Herbert Xuda7f0332008-07-31 17:08:25 +08003879 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3880 return 0;
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003881non_fips_alg:
3882 return -EINVAL;
Herbert Xuda7f0332008-07-31 17:08:25 +08003883}
Alexander Shishkin0b767f92010-06-03 20:53:43 +10003884
Herbert Xu326a6342010-08-06 09:40:28 +08003885#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
Alexander Shishkin0b767f92010-06-03 20:53:43 +10003886
Herbert Xuda7f0332008-07-31 17:08:25 +08003887EXPORT_SYMBOL_GPL(alg_test);