]> Git Repo - linux.git/blame - crypto/testmgr.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
crypto: sm4 - introduce SM4 symmetric cipher algorithm
[linux.git] / crypto / testmgr.c
CommitLineData
da7f033d
HX		 1/*
2 * Algorithm testing framework and tests.
3 *
4 * Copyright (c) 2002 James Morris <[email protected]>
5 * Copyright (c) 2002 Jean-Francois Dive <[email protected]>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <[email protected]>
8 *
69435b94
AH		 9 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony ([email protected])
11 * Adrian Hoban <[email protected]>
12 * Gabriele Paoloni <[email protected]>
13 * Tadeusz Struk ([email protected])
14 * Copyright (c) 2010, Intel Corporation.
15 *
da7f033d
HX		 16 * 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
1ce33115 23#include <crypto/aead.h>
da7f033d 24#include <crypto/hash.h>
12773d93 25#include <crypto/skcipher.h>
da7f033d 26#include <linux/err.h>
1c41b882 27#include <linux/fips.h>
da7f033d
HX		 28#include <linux/module.h>
29#include <linux/scatterlist.h>
30#include <linux/slab.h>
31#include <linux/string.h>
7647d6ce 32#include <crypto/rng.h>
64d1cdfb 33#include <crypto/drbg.h>
946cc463 34#include <crypto/akcipher.h>
802c7f1c 35#include <crypto/kpp.h>
d7db7a88 36#include <crypto/acompress.h>
da7f033d
HX		 37
38#include "internal.h"
0b767f96 39
9e5c9fe4
RJ		 40static bool notests;
41module_param(notests, bool, 0644);
42MODULE_PARM_DESC(notests, "disable crypto self-tests");
43
326a6346 44#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
0b767f96
AS		 45
46/* a perfect nop */
47int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
48{
49 return 0;
50}
51
52#else
53
da7f033d
HX		 54#include "testmgr.h"
55
56/*
57 * Need slab memory for testing (size in number of pages).
58 */
59#define XBUFSIZE 8
60
61/*
62 * Indexes into the xbuf to simulate cross-page access.
63 */
64#define IDX1 32
65#define IDX2 32400
04b46fbd 66#define IDX3 1511
da7f033d
HX		 67#define IDX4 8193
68#define IDX5 22222
69#define IDX6 17101
70#define IDX7 27333
71#define IDX8 3000
72
73/*
74* Used by test_cipher()
75*/
76#define ENCRYPT 1
77#define DECRYPT 0
78
da7f033d
HX		 79struct aead_test_suite {
80 struct {
b13b1e0c 81 const struct aead_testvec *vecs;
da7f033d
HX		 82 unsigned int count;
83 } enc, dec;
84};
85
86struct cipher_test_suite {
87 struct {
b13b1e0c 88 const struct cipher_testvec *vecs;
da7f033d
HX		 89 unsigned int count;
90 } enc, dec;
91};
92
93struct comp_test_suite {
94 struct {
b13b1e0c 95 const struct comp_testvec *vecs;
da7f033d
HX		 96 unsigned int count;
97 } comp, decomp;
98};
99
100struct hash_test_suite {
b13b1e0c 101 const struct hash_testvec *vecs;
da7f033d
HX		 102 unsigned int count;
103};
104
7647d6ce 105struct cprng_test_suite {
b13b1e0c 106 const struct cprng_testvec *vecs;
7647d6ce
JW		 107 unsigned int count;
108};
109
64d1cdfb 110struct drbg_test_suite {
b13b1e0c 111 const struct drbg_testvec *vecs;
64d1cdfb
SM		 112 unsigned int count;
113};
114
946cc463 115struct akcipher_test_suite {
b13b1e0c 116 const struct akcipher_testvec *vecs;
946cc463
TS		 117 unsigned int count;
118};
119
802c7f1c 120struct kpp_test_suite {
b13b1e0c 121 const struct kpp_testvec *vecs;
802c7f1c
SB		 122 unsigned int count;
123};
124
da7f033d
HX		 125struct alg_test_desc {
126 const char *alg;
127 int (*test)(const struct alg_test_desc *desc, const char *driver,
128 u32 type, u32 mask);
a1915d51 129 int fips_allowed; /* set if alg is allowed in fips mode */
da7f033d
HX		 130
131 union {
132 struct aead_test_suite aead;
133 struct cipher_test_suite cipher;
134 struct comp_test_suite comp;
135 struct hash_test_suite hash;
7647d6ce 136 struct cprng_test_suite cprng;
64d1cdfb 137 struct drbg_test_suite drbg;
946cc463 138 struct akcipher_test_suite akcipher;
802c7f1c 139 struct kpp_test_suite kpp;
da7f033d
HX		 140 } suite;
141};
142
b13b1e0c
EB		 143static const unsigned int IDX[8] = {
144 IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
da7f033d 145
da7f033d
HX		 146static void hexdump(unsigned char *buf, unsigned int len)
147{
148 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
149 16, 1,
150 buf, len, false);
151}
152
f8b0d4d0
HX		 153static int testmgr_alloc_buf(char *buf[XBUFSIZE])
154{
155 int i;
156
157 for (i = 0; i < XBUFSIZE; i++) {
158 buf[i] = (void *)__get_free_page(GFP_KERNEL);
159 if (!buf[i])
160 goto err_free_buf;
161 }
162
163 return 0;
164
165err_free_buf:
166 while (i-- > 0)
167 free_page((unsigned long)buf[i]);
168
169 return -ENOMEM;
170}
171
172static void testmgr_free_buf(char *buf[XBUFSIZE])
173{
174 int i;
175
176 for (i = 0; i < XBUFSIZE; i++)
177 free_page((unsigned long)buf[i]);
178}
179
466d7b9f
KK		 180static int ahash_guard_result(char *result, char c, int size)
181{
182 int i;
183
184 for (i = 0; i < size; i++) {
185 if (result[i] != c)
186 return -EINVAL;
187 }
188
189 return 0;
190}
191
018ba95c 192static int ahash_partial_update(struct ahash_request **preq,
b13b1e0c 193 struct crypto_ahash *tfm, const struct hash_testvec *template,
018ba95c 194 void *hash_buff, int k, int temp, struct scatterlist *sg,
7f397136 195 const char *algo, char *result, struct crypto_wait *wait)
018ba95c
WR		 196{
197 char *state;
198 struct ahash_request *req;
199 int statesize, ret = -EINVAL;
da1729ce 200 static const unsigned char guard[] = { 0x00, 0xba, 0xad, 0x00 };
466d7b9f 201 int digestsize = crypto_ahash_digestsize(tfm);
018ba95c
WR		 202
203 req = *preq;
204 statesize = crypto_ahash_statesize(
205 crypto_ahash_reqtfm(req));
7bcb87bc 206 state = kmalloc(statesize + sizeof(guard), GFP_KERNEL);
018ba95c 207 if (!state) {
cf3f9609 208 pr_err("alg: hash: Failed to alloc state for %s\n", algo);
018ba95c
WR		 209 goto out_nostate;
210 }
7bcb87bc 211 memcpy(state + statesize, guard, sizeof(guard));
466d7b9f 212 memset(result, 1, digestsize);
018ba95c 213 ret = crypto_ahash_export(req, state);
7bcb87bc 214 WARN_ON(memcmp(state + statesize, guard, sizeof(guard)));
018ba95c 215 if (ret) {
cf3f9609 216 pr_err("alg: hash: Failed to export() for %s\n", algo);
018ba95c
WR		 217 goto out;
218 }
466d7b9f
KK		 219 ret = ahash_guard_result(result, 1, digestsize);
220 if (ret) {
221 pr_err("alg: hash: Failed, export used req->result for %s\n",
222 algo);
223 goto out;
224 }
018ba95c
WR		 225 ahash_request_free(req);
226 req = ahash_request_alloc(tfm, GFP_KERNEL);
227 if (!req) {
228 pr_err("alg: hash: Failed to alloc request for %s\n", algo);
229 goto out_noreq;
230 }
231 ahash_request_set_callback(req,
232 CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 233 crypto_req_done, wait);
018ba95c
WR		 234
235 memcpy(hash_buff, template->plaintext + temp,
236 template->tap[k]);
237 sg_init_one(&sg[0], hash_buff, template->tap[k]);
238 ahash_request_set_crypt(req, sg, result, template->tap[k]);
239 ret = crypto_ahash_import(req, state);
240 if (ret) {
241 pr_err("alg: hash: Failed to import() for %s\n", algo);
242 goto out;
243 }
466d7b9f
KK		 244 ret = ahash_guard_result(result, 1, digestsize);
245 if (ret) {
246 pr_err("alg: hash: Failed, import used req->result for %s\n",
247 algo);
248 goto out;
249 }
7f397136 250 ret = crypto_wait_req(crypto_ahash_update(req), wait);
018ba95c
WR		 251 if (ret)
252 goto out;
253 *preq = req;
254 ret = 0;
255 goto out_noreq;
256out:
257 ahash_request_free(req);
258out_noreq:
259 kfree(state);
260out_nostate:
261 return ret;
262}
263
b13b1e0c
EB		 264static int __test_hash(struct crypto_ahash *tfm,
265 const struct hash_testvec *template, unsigned int tcount,
266 bool use_digest, const int align_offset)
da7f033d
HX		 267{
268 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
e93acd6f 269 size_t digest_size = crypto_ahash_digestsize(tfm);
da7f033d
HX		 270 unsigned int i, j, k, temp;
271 struct scatterlist sg[8];
29b77e5d
HG		 272 char *result;
273 char *key;
da7f033d 274 struct ahash_request *req;
7f397136 275 struct crypto_wait wait;
da7f033d 276 void *hash_buff;
f8b0d4d0
HX		 277 char *xbuf[XBUFSIZE];
278 int ret = -ENOMEM;
279
e93acd6f 280 result = kmalloc(digest_size, GFP_KERNEL);
29b77e5d
HG		 281 if (!result)
282 return ret;
283 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
284 if (!key)
285 goto out_nobuf;
f8b0d4d0
HX		 286 if (testmgr_alloc_buf(xbuf))
287 goto out_nobuf;
da7f033d 288
7f397136 289 crypto_init_wait(&wait);
da7f033d
HX		 290
291 req = ahash_request_alloc(tfm, GFP_KERNEL);
292 if (!req) {
293 printk(KERN_ERR "alg: hash: Failed to allocate request for "
294 "%s\n", algo);
da7f033d
HX		 295 goto out_noreq;
296 }
297 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 298 crypto_req_done, &wait);
da7f033d 299
a0cfae59 300 j = 0;
da7f033d 301 for (i = 0; i < tcount; i++) {
a0cfae59
HX		 302 if (template[i].np)
303 continue;
304
da5ffe11
JK		 305 ret = -EINVAL;
306 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
307 goto out;
308
a0cfae59 309 j++;
e93acd6f 310 memset(result, 0, digest_size);
da7f033d
HX		 311
312 hash_buff = xbuf[0];
da5ffe11 313 hash_buff += align_offset;
da7f033d
HX		 314
315 memcpy(hash_buff, template[i].plaintext, template[i].psize);
316 sg_init_one(&sg[0], hash_buff, template[i].psize);
317
318 if (template[i].ksize) {
319 crypto_ahash_clear_flags(tfm, ~0);
29b77e5d
HG		 320 if (template[i].ksize > MAX_KEYLEN) {
321 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
322 j, algo, template[i].ksize, MAX_KEYLEN);
323 ret = -EINVAL;
324 goto out;
325 }
326 memcpy(key, template[i].key, template[i].ksize);
327 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
da7f033d
HX		 328 if (ret) {
329 printk(KERN_ERR "alg: hash: setkey failed on "
a0cfae59 330 "test %d for %s: ret=%d\n", j, algo,
da7f033d
HX		 331 -ret);
332 goto out;
333 }
334 }
335
336 ahash_request_set_crypt(req, sg, result, template[i].psize);
a8f1a052 337 if (use_digest) {
7f397136 338 ret = crypto_wait_req(crypto_ahash_digest(req), &wait);
a8f1a052
DM		 339 if (ret) {
340 pr_err("alg: hash: digest failed on test %d "
341 "for %s: ret=%d\n", j, algo, -ret);
342 goto out;
343 }
344 } else {
466d7b9f 345 memset(result, 1, digest_size);
7f397136 346 ret = crypto_wait_req(crypto_ahash_init(req), &wait);
a8f1a052 347 if (ret) {
cf3f9609 348 pr_err("alg: hash: init failed on test %d "
a8f1a052
DM		 349 "for %s: ret=%d\n", j, algo, -ret);
350 goto out;
351 }
466d7b9f
KK		 352 ret = ahash_guard_result(result, 1, digest_size);
353 if (ret) {
354 pr_err("alg: hash: init failed on test %d "
355 "for %s: used req->result\n", j, algo);
356 goto out;
357 }
7f397136 358 ret = crypto_wait_req(crypto_ahash_update(req), &wait);
a8f1a052 359 if (ret) {
cf3f9609 360 pr_err("alg: hash: update failed on test %d "
a8f1a052
DM		 361 "for %s: ret=%d\n", j, algo, -ret);
362 goto out;
363 }
466d7b9f
KK		 364 ret = ahash_guard_result(result, 1, digest_size);
365 if (ret) {
366 pr_err("alg: hash: update failed on test %d "
367 "for %s: used req->result\n", j, algo);
368 goto out;
369 }
7f397136 370 ret = crypto_wait_req(crypto_ahash_final(req), &wait);
a8f1a052 371 if (ret) {
cf3f9609 372 pr_err("alg: hash: final failed on test %d "
a8f1a052
DM		 373 "for %s: ret=%d\n", j, algo, -ret);
374 goto out;
da7f033d 375 }
da7f033d
HX		 376 }
377
378 if (memcmp(result, template[i].digest,
379 crypto_ahash_digestsize(tfm))) {
380 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
a0cfae59 381 j, algo);
da7f033d
HX		 382 hexdump(result, crypto_ahash_digestsize(tfm));
383 ret = -EINVAL;
384 goto out;
385 }
386 }
387
388 j = 0;
389 for (i = 0; i < tcount; i++) {
da5ffe11
JK		 390 /* alignment tests are only done with continuous buffers */
391 if (align_offset != 0)
392 break;
393
5f2b424e
CS		 394 if (!template[i].np)
395 continue;
da7f033d 396
5f2b424e 397 j++;
e93acd6f 398 memset(result, 0, digest_size);
da7f033d 399
5f2b424e
CS		 400 temp = 0;
401 sg_init_table(sg, template[i].np);
402 ret = -EINVAL;
403 for (k = 0; k < template[i].np; k++) {
404 if (WARN_ON(offset_in_page(IDX[k]) +
405 template[i].tap[k] > PAGE_SIZE))
406 goto out;
407 sg_set_buf(&sg[k],
408 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
409 offset_in_page(IDX[k]),
410 template[i].plaintext + temp,
411 template[i].tap[k]),
412 template[i].tap[k]);
413 temp += template[i].tap[k];
414 }
da7f033d 415
5f2b424e
CS		 416 if (template[i].ksize) {
417 if (template[i].ksize > MAX_KEYLEN) {
418 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
419 j, algo, template[i].ksize, MAX_KEYLEN);
420 ret = -EINVAL;
da7f033d
HX		 421 goto out;
422 }
5f2b424e
CS		 423 crypto_ahash_clear_flags(tfm, ~0);
424 memcpy(key, template[i].key, template[i].ksize);
425 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
da7f033d 426
5f2b424e
CS		 427 if (ret) {
428 printk(KERN_ERR "alg: hash: setkey "
429 "failed on chunking test %d "
430 "for %s: ret=%d\n", j, algo, -ret);
da7f033d
HX		 431 goto out;
432 }
433 }
5f2b424e
CS		 434
435 ahash_request_set_crypt(req, sg, result, template[i].psize);
7f397136
GBY		 436 ret = crypto_wait_req(crypto_ahash_digest(req), &wait);
437 if (ret) {
438 pr_err("alg: hash: digest failed on chunking test %d for %s: ret=%d\n",
439 j, algo, -ret);
5f2b424e
CS		 440 goto out;
441 }
442
443 if (memcmp(result, template[i].digest,
444 crypto_ahash_digestsize(tfm))) {
445 printk(KERN_ERR "alg: hash: Chunking test %d "
446 "failed for %s\n", j, algo);
447 hexdump(result, crypto_ahash_digestsize(tfm));
448 ret = -EINVAL;
018ba95c
WR		 449 goto out;
450 }
451 }
452
453 /* partial update exercise */
454 j = 0;
455 for (i = 0; i < tcount; i++) {
456 /* alignment tests are only done with continuous buffers */
457 if (align_offset != 0)
458 break;
459
460 if (template[i].np < 2)
461 continue;
462
463 j++;
e93acd6f 464 memset(result, 0, digest_size);
018ba95c
WR		 465
466 ret = -EINVAL;
467 hash_buff = xbuf[0];
468 memcpy(hash_buff, template[i].plaintext,
469 template[i].tap[0]);
470 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
471
472 if (template[i].ksize) {
473 crypto_ahash_clear_flags(tfm, ~0);
474 if (template[i].ksize > MAX_KEYLEN) {
475 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
476 j, algo, template[i].ksize, MAX_KEYLEN);
477 ret = -EINVAL;
478 goto out;
479 }
480 memcpy(key, template[i].key, template[i].ksize);
481 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
482 if (ret) {
483 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
484 j, algo, -ret);
485 goto out;
486 }
487 }
488
489 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
7f397136 490 ret = crypto_wait_req(crypto_ahash_init(req), &wait);
018ba95c 491 if (ret) {
cf3f9609 492 pr_err("alg: hash: init failed on test %d for %s: ret=%d\n",
018ba95c
WR		 493 j, algo, -ret);
494 goto out;
495 }
7f397136 496 ret = crypto_wait_req(crypto_ahash_update(req), &wait);
018ba95c 497 if (ret) {
cf3f9609 498 pr_err("alg: hash: update failed on test %d for %s: ret=%d\n",
018ba95c
WR		 499 j, algo, -ret);
500 goto out;
501 }
502
503 temp = template[i].tap[0];
504 for (k = 1; k < template[i].np; k++) {
505 ret = ahash_partial_update(&req, tfm, &template[i],
506 hash_buff, k, temp, &sg[0], algo, result,
7f397136 507 &wait);
018ba95c 508 if (ret) {
cf3f9609 509 pr_err("alg: hash: partial update failed on test %d for %s: ret=%d\n",
018ba95c
WR		 510 j, algo, -ret);
511 goto out_noreq;
512 }
513 temp += template[i].tap[k];
514 }
7f397136 515 ret = crypto_wait_req(crypto_ahash_final(req), &wait);
018ba95c 516 if (ret) {
cf3f9609 517 pr_err("alg: hash: final failed on test %d for %s: ret=%d\n",
018ba95c
WR		 518 j, algo, -ret);
519 goto out;
520 }
521 if (memcmp(result, template[i].digest,
522 crypto_ahash_digestsize(tfm))) {
523 pr_err("alg: hash: Partial Test %d failed for %s\n",
524 j, algo);
525 hexdump(result, crypto_ahash_digestsize(tfm));
526 ret = -EINVAL;
5f2b424e
CS		 527 goto out;
528 }
da7f033d
HX		 529 }
530
531 ret = 0;
532
533out:
534 ahash_request_free(req);
535out_noreq:
f8b0d4d0
HX		 536 testmgr_free_buf(xbuf);
537out_nobuf:
29b77e5d
HG		 538 kfree(key);
539 kfree(result);
da7f033d
HX		 540 return ret;
541}
542
b13b1e0c
EB		 543static int test_hash(struct crypto_ahash *tfm,
544 const struct hash_testvec *template,
da5ffe11
JK		 545 unsigned int tcount, bool use_digest)
546{
547 unsigned int alignmask;
548 int ret;
549
550 ret = __test_hash(tfm, template, tcount, use_digest, 0);
551 if (ret)
552 return ret;
553
554 /* test unaligned buffers, check with one byte offset */
555 ret = __test_hash(tfm, template, tcount, use_digest, 1);
556 if (ret)
557 return ret;
558
559 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
560 if (alignmask) {
561 /* Check if alignment mask for tfm is correctly set. */
562 ret = __test_hash(tfm, template, tcount, use_digest,
563 alignmask + 1);
564 if (ret)
565 return ret;
566 }
567
568 return 0;
569}
570
d8a32ac2 571static int __test_aead(struct crypto_aead *tfm, int enc,
b13b1e0c 572 const struct aead_testvec *template, unsigned int tcount,
58dcf548 573 const bool diff_dst, const int align_offset)
da7f033d
HX		 574{
575 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
576 unsigned int i, j, k, n, temp;
f8b0d4d0 577 int ret = -ENOMEM;
da7f033d
HX		 578 char *q;
579 char *key;
580 struct aead_request *req;
d8a32ac2 581 struct scatterlist *sg;
d8a32ac2
JK		 582 struct scatterlist *sgout;
583 const char *e, *d;
7f397136 584 struct crypto_wait wait;
424a5da6 585 unsigned int authsize, iv_len;
da7f033d 586 void *input;
d8a32ac2 587 void *output;
da7f033d 588 void *assoc;
9bac019d 589 char *iv;
f8b0d4d0 590 char *xbuf[XBUFSIZE];
d8a32ac2 591 char *xoutbuf[XBUFSIZE];
f8b0d4d0
HX		 592 char *axbuf[XBUFSIZE];
593
9bac019d
TS		 594 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
595 if (!iv)
596 return ret;
29b77e5d
HG		 597 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
598 if (!key)
599 goto out_noxbuf;
f8b0d4d0
HX		 600 if (testmgr_alloc_buf(xbuf))
601 goto out_noxbuf;
602 if (testmgr_alloc_buf(axbuf))
603 goto out_noaxbuf;
d8a32ac2
JK		 604 if (diff_dst && testmgr_alloc_buf(xoutbuf))
605 goto out_nooutbuf;
606
607 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
8a525fcd 608 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
d8a32ac2
JK		 609 if (!sg)
610 goto out_nosg;
8a525fcd 611 sgout = &sg[16];
d8a32ac2
JK		 612
613 if (diff_dst)
614 d = "-ddst";
615 else
616 d = "";
617
da7f033d
HX		 618 if (enc == ENCRYPT)
619 e = "encryption";
620 else
621 e = "decryption";
622
7f397136 623 crypto_init_wait(&wait);
da7f033d
HX		 624
625 req = aead_request_alloc(tfm, GFP_KERNEL);
626 if (!req) {
d8a32ac2
JK		 627 pr_err("alg: aead%s: Failed to allocate request for %s\n",
628 d, algo);
da7f033d
HX		 629 goto out;
630 }
631
632 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 633 crypto_req_done, &wait);
da7f033d 634
abfa7f43
JM		 635 iv_len = crypto_aead_ivsize(tfm);
636
da7f033d 637 for (i = 0, j = 0; i < tcount; i++) {
05b1d338
CS		 638 if (template[i].np)
639 continue;
da7f033d 640
05b1d338 641 j++;
fd57f22a 642
05b1d338
CS		 643 /* some templates have no input data but they will
644 * touch input
645 */
646 input = xbuf[0];
647 input += align_offset;
648 assoc = axbuf[0];
da7f033d 649
05b1d338
CS		 650 ret = -EINVAL;
651 if (WARN_ON(align_offset + template[i].ilen >
652 PAGE_SIZE || template[i].alen > PAGE_SIZE))
653 goto out;
da7f033d 654
05b1d338
CS		 655 memcpy(input, template[i].input, template[i].ilen);
656 memcpy(assoc, template[i].assoc, template[i].alen);
657 if (template[i].iv)
424a5da6 658 memcpy(iv, template[i].iv, iv_len);
05b1d338 659 else
424a5da6 660 memset(iv, 0, iv_len);
05b1d338
CS		 661
662 crypto_aead_clear_flags(tfm, ~0);
663 if (template[i].wk)
664 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
665
666 if (template[i].klen > MAX_KEYLEN) {
667 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
668 d, j, algo, template[i].klen,
669 MAX_KEYLEN);
670 ret = -EINVAL;
671 goto out;
672 }
673 memcpy(key, template[i].key, template[i].klen);
da7f033d 674
05b1d338 675 ret = crypto_aead_setkey(tfm, key, template[i].klen);
0fae0c1e 676 if (template[i].fail == !ret) {
05b1d338
CS		 677 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
678 d, j, algo, crypto_aead_get_flags(tfm));
679 goto out;
680 } else if (ret)
681 continue;
da7f033d 682
05b1d338
CS		 683 authsize = abs(template[i].rlen - template[i].ilen);
684 ret = crypto_aead_setauthsize(tfm, authsize);
685 if (ret) {
686 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
687 d, authsize, j, algo);
688 goto out;
689 }
da7f033d 690
8a525fcd
HX		 691 k = !!template[i].alen;
692 sg_init_table(sg, k + 1);
693 sg_set_buf(&sg[0], assoc, template[i].alen);
694 sg_set_buf(&sg[k], input,
695 template[i].ilen + (enc ? authsize : 0));
696 output = input;
697
05b1d338 698 if (diff_dst) {
8a525fcd
HX		 699 sg_init_table(sgout, k + 1);
700 sg_set_buf(&sgout[0], assoc, template[i].alen);
701
05b1d338
CS		 702 output = xoutbuf[0];
703 output += align_offset;
8a525fcd
HX		 704 sg_set_buf(&sgout[k], output,
705 template[i].rlen + (enc ? 0 : authsize));
05b1d338 706 }
d8a32ac2 707
05b1d338
CS		 708 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
709 template[i].ilen, iv);
da7f033d 710
8a525fcd 711 aead_request_set_ad(req, template[i].alen);
da7f033d 712
7f397136
GBY		 713 ret = crypto_wait_req(enc ? crypto_aead_encrypt(req)
714 : crypto_aead_decrypt(req), &wait);
da7f033d 715
05b1d338
CS		 716 switch (ret) {
717 case 0:
718 if (template[i].novrfy) {
719 /* verification was supposed to fail */
720 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
721 d, e, j, algo);
722 /* so really, we got a bad message */
723 ret = -EBADMSG;
da7f033d
HX		 724 goto out;
725 }
05b1d338 726 break;
05b1d338
CS		 727 case -EBADMSG:
728 if (template[i].novrfy)
729 /* verification failure was expected */
730 continue;
731 /* fall through */
732 default:
733 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
734 d, e, j, algo, -ret);
735 goto out;
736 }
737
738 q = output;
739 if (memcmp(q, template[i].result, template[i].rlen)) {
740 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
741 d, j, e, algo);
742 hexdump(q, template[i].rlen);
743 ret = -EINVAL;
744 goto out;
da7f033d
HX		 745 }
746 }
747
748 for (i = 0, j = 0; i < tcount; i++) {
58dcf548
JK		 749 /* alignment tests are only done with continuous buffers */
750 if (align_offset != 0)
751 break;
752
05b1d338
CS		 753 if (!template[i].np)
754 continue;
da7f033d 755
05b1d338 756 j++;
da7f033d 757
05b1d338 758 if (template[i].iv)
abfa7f43 759 memcpy(iv, template[i].iv, iv_len);
05b1d338
CS		 760 else
761 memset(iv, 0, MAX_IVLEN);
762
763 crypto_aead_clear_flags(tfm, ~0);
764 if (template[i].wk)
765 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
766 if (template[i].klen > MAX_KEYLEN) {
767 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
768 d, j, algo, template[i].klen, MAX_KEYLEN);
769 ret = -EINVAL;
770 goto out;
771 }
772 memcpy(key, template[i].key, template[i].klen);
da7f033d 773
05b1d338 774 ret = crypto_aead_setkey(tfm, key, template[i].klen);
0fae0c1e 775 if (template[i].fail == !ret) {
05b1d338
CS		 776 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
777 d, j, algo, crypto_aead_get_flags(tfm));
778 goto out;
779 } else if (ret)
780 continue;
da7f033d 781
05b1d338 782 authsize = abs(template[i].rlen - template[i].ilen);
da7f033d 783
05b1d338 784 ret = -EINVAL;
8a525fcd 785 sg_init_table(sg, template[i].anp + template[i].np);
05b1d338 786 if (diff_dst)
8a525fcd
HX		 787 sg_init_table(sgout, template[i].anp + template[i].np);
788
789 ret = -EINVAL;
790 for (k = 0, temp = 0; k < template[i].anp; k++) {
791 if (WARN_ON(offset_in_page(IDX[k]) +
792 template[i].atap[k] > PAGE_SIZE))
793 goto out;
794 sg_set_buf(&sg[k],
795 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
796 offset_in_page(IDX[k]),
797 template[i].assoc + temp,
798 template[i].atap[k]),
799 template[i].atap[k]);
800 if (diff_dst)
801 sg_set_buf(&sgout[k],
802 axbuf[IDX[k] >> PAGE_SHIFT] +
803 offset_in_page(IDX[k]),
804 template[i].atap[k]);
805 temp += template[i].atap[k];
806 }
807
05b1d338
CS		 808 for (k = 0, temp = 0; k < template[i].np; k++) {
809 if (WARN_ON(offset_in_page(IDX[k]) +
810 template[i].tap[k] > PAGE_SIZE))
811 goto out;
da7f033d 812
05b1d338
CS		 813 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
814 memcpy(q, template[i].input + temp, template[i].tap[k]);
8a525fcd
HX		 815 sg_set_buf(&sg[template[i].anp + k],
816 q, template[i].tap[k]);
da7f033d 817
05b1d338
CS		 818 if (diff_dst) {
819 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
820 offset_in_page(IDX[k]);
d8a32ac2 821
05b1d338 822 memset(q, 0, template[i].tap[k]);
d8a32ac2 823
8a525fcd
HX		 824 sg_set_buf(&sgout[template[i].anp + k],
825 q, template[i].tap[k]);
05b1d338 826 }
d8a32ac2 827
05b1d338
CS		 828 n = template[i].tap[k];
829 if (k == template[i].np - 1 && enc)
830 n += authsize;
831 if (offset_in_page(q) + n < PAGE_SIZE)
832 q[n] = 0;
d8a32ac2 833
05b1d338
CS		 834 temp += template[i].tap[k];
835 }
8ec25c51 836
05b1d338
CS		 837 ret = crypto_aead_setauthsize(tfm, authsize);
838 if (ret) {
839 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
840 d, authsize, j, algo);
841 goto out;
842 }
da7f033d 843
05b1d338 844 if (enc) {
8a525fcd
HX		 845 if (WARN_ON(sg[template[i].anp + k - 1].offset +
846 sg[template[i].anp + k - 1].length +
847 authsize > PAGE_SIZE)) {
05b1d338 848 ret = -EINVAL;
da7f033d
HX		 849 goto out;
850 }
851
05b1d338 852 if (diff_dst)
8a525fcd
HX		 853 sgout[template[i].anp + k - 1].length +=
854 authsize;
855 sg[template[i].anp + k - 1].length += authsize;
05b1d338 856 }
da7f033d 857
05b1d338
CS		 858 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
859 template[i].ilen,
860 iv);
da7f033d 861
8a525fcd 862 aead_request_set_ad(req, template[i].alen);
da7f033d 863
7f397136
GBY		 864 ret = crypto_wait_req(enc ? crypto_aead_encrypt(req)
865 : crypto_aead_decrypt(req), &wait);
da7f033d 866
05b1d338
CS		 867 switch (ret) {
868 case 0:
869 if (template[i].novrfy) {
870 /* verification was supposed to fail */
871 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
872 d, e, j, algo);
873 /* so really, we got a bad message */
874 ret = -EBADMSG;
da7f033d
HX		 875 goto out;
876 }
05b1d338 877 break;
05b1d338
CS		 878 case -EBADMSG:
879 if (template[i].novrfy)
880 /* verification failure was expected */
881 continue;
882 /* fall through */
883 default:
884 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
885 d, e, j, algo, -ret);
886 goto out;
887 }
da7f033d 888
05b1d338
CS		 889 ret = -EINVAL;
890 for (k = 0, temp = 0; k < template[i].np; k++) {
891 if (diff_dst)
892 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
893 offset_in_page(IDX[k]);
894 else
895 q = xbuf[IDX[k] >> PAGE_SHIFT] +
896 offset_in_page(IDX[k]);
da7f033d 897
05b1d338
CS		 898 n = template[i].tap[k];
899 if (k == template[i].np - 1)
900 n += enc ? authsize : -authsize;
da7f033d 901
05b1d338
CS		 902 if (memcmp(q, template[i].result + temp, n)) {
903 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
904 d, j, e, k, algo);
905 hexdump(q, n);
906 goto out;
907 }
da7f033d 908
05b1d338
CS		 909 q += n;
910 if (k == template[i].np - 1 && !enc) {
911 if (!diff_dst &&
912 memcmp(q, template[i].input +
913 temp + n, authsize))
914 n = authsize;
915 else
916 n = 0;
917 } else {
918 for (n = 0; offset_in_page(q + n) && q[n]; n++)
919 ;
920 }
921 if (n) {
922 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
923 d, j, e, k, algo, n);
924 hexdump(q, n);
925 goto out;
da7f033d 926 }
05b1d338
CS		 927
928 temp += template[i].tap[k];
da7f033d
HX		 929 }
930 }
931
932 ret = 0;
933
934out:
935 aead_request_free(req);
d8a32ac2
JK		 936 kfree(sg);
937out_nosg:
938 if (diff_dst)
939 testmgr_free_buf(xoutbuf);
940out_nooutbuf:
f8b0d4d0
HX		 941 testmgr_free_buf(axbuf);
942out_noaxbuf:
943 testmgr_free_buf(xbuf);
944out_noxbuf:
29b77e5d 945 kfree(key);
9bac019d 946 kfree(iv);
da7f033d
HX		 947 return ret;
948}
949
d8a32ac2 950static int test_aead(struct crypto_aead *tfm, int enc,
b13b1e0c 951 const struct aead_testvec *template, unsigned int tcount)
d8a32ac2 952{
58dcf548 953 unsigned int alignmask;
d8a32ac2
JK		 954 int ret;
955
956 /* test 'dst == src' case */
58dcf548 957 ret = __test_aead(tfm, enc, template, tcount, false, 0);
d8a32ac2
JK		 958 if (ret)
959 return ret;
960
961 /* test 'dst != src' case */
58dcf548
JK		 962 ret = __test_aead(tfm, enc, template, tcount, true, 0);
963 if (ret)
964 return ret;
965
966 /* test unaligned buffers, check with one byte offset */
967 ret = __test_aead(tfm, enc, template, tcount, true, 1);
968 if (ret)
969 return ret;
970
971 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
972 if (alignmask) {
973 /* Check if alignment mask for tfm is correctly set. */
974 ret = __test_aead(tfm, enc, template, tcount, true,
975 alignmask + 1);
976 if (ret)
977 return ret;
978 }
979
980 return 0;
d8a32ac2
JK		 981}
982
1aa4ecd9 983static int test_cipher(struct crypto_cipher *tfm, int enc,
b13b1e0c
EB		 984 const struct cipher_testvec *template,
985 unsigned int tcount)
1aa4ecd9
HX		 986{
987 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
988 unsigned int i, j, k;
1aa4ecd9
HX		 989 char *q;
990 const char *e;
991 void *data;
f8b0d4d0
HX		 992 char *xbuf[XBUFSIZE];
993 int ret = -ENOMEM;
994
995 if (testmgr_alloc_buf(xbuf))
996 goto out_nobuf;
1aa4ecd9
HX		 997
998 if (enc == ENCRYPT)
999 e = "encryption";
1000 else
1001 e = "decryption";
1002
1003 j = 0;
1004 for (i = 0; i < tcount; i++) {
1005 if (template[i].np)
1006 continue;
1007
10faa8c0
SM		 1008 if (fips_enabled && template[i].fips_skip)
1009 continue;
1010
1aa4ecd9
HX		 1011 j++;
1012
fd57f22a
HX		 1013 ret = -EINVAL;
1014 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1015 goto out;
1016
1aa4ecd9
HX		 1017 data = xbuf[0];
1018 memcpy(data, template[i].input, template[i].ilen);
1019
1020 crypto_cipher_clear_flags(tfm, ~0);
1021 if (template[i].wk)
1022 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1023
1024 ret = crypto_cipher_setkey(tfm, template[i].key,
1025 template[i].klen);
0fae0c1e 1026 if (template[i].fail == !ret) {
1aa4ecd9
HX		 1027 printk(KERN_ERR "alg: cipher: setkey failed "
1028 "on test %d for %s: flags=%x\n", j,
1029 algo, crypto_cipher_get_flags(tfm));
1030 goto out;
1031 } else if (ret)
1032 continue;
1033
1034 for (k = 0; k < template[i].ilen;
1035 k += crypto_cipher_blocksize(tfm)) {
1036 if (enc)
1037 crypto_cipher_encrypt_one(tfm, data + k,
1038 data + k);
1039 else
1040 crypto_cipher_decrypt_one(tfm, data + k,
1041 data + k);
1042 }
1043
1044 q = data;
1045 if (memcmp(q, template[i].result, template[i].rlen)) {
1046 printk(KERN_ERR "alg: cipher: Test %d failed "
1047 "on %s for %s\n", j, e, algo);
1048 hexdump(q, template[i].rlen);
1049 ret = -EINVAL;
1050 goto out;
1051 }
1052 }
1053
1054 ret = 0;
1055
1056out:
f8b0d4d0
HX		 1057 testmgr_free_buf(xbuf);
1058out_nobuf:
1aa4ecd9
HX		 1059 return ret;
1060}
1061
12773d93 1062static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
b13b1e0c
EB		 1063 const struct cipher_testvec *template,
1064 unsigned int tcount,
3a338f20 1065 const bool diff_dst, const int align_offset)
da7f033d
HX		 1066{
1067 const char *algo =
12773d93 1068 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
da7f033d 1069 unsigned int i, j, k, n, temp;
da7f033d 1070 char *q;
12773d93 1071 struct skcipher_request *req;
da7f033d 1072 struct scatterlist sg[8];
08d6af8c
JK		 1073 struct scatterlist sgout[8];
1074 const char *e, *d;
7f397136 1075 struct crypto_wait wait;
da7f033d
HX		 1076 void *data;
1077 char iv[MAX_IVLEN];
f8b0d4d0 1078 char *xbuf[XBUFSIZE];
08d6af8c 1079 char *xoutbuf[XBUFSIZE];
f8b0d4d0 1080 int ret = -ENOMEM;
84cba178 1081 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
f8b0d4d0
HX		 1082
1083 if (testmgr_alloc_buf(xbuf))
1084 goto out_nobuf;
da7f033d 1085
08d6af8c
JK		 1086 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1087 goto out_nooutbuf;
1088
1089 if (diff_dst)
1090 d = "-ddst";
1091 else
1092 d = "";
1093
da7f033d
HX		 1094 if (enc == ENCRYPT)
1095 e = "encryption";
1096 else
1097 e = "decryption";
1098
7f397136 1099 crypto_init_wait(&wait);
da7f033d 1100
12773d93 1101 req = skcipher_request_alloc(tfm, GFP_KERNEL);
da7f033d 1102 if (!req) {
08d6af8c
JK		 1103 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1104 d, algo);
da7f033d
HX		 1105 goto out;
1106 }
1107
12773d93 1108 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 1109 crypto_req_done, &wait);
da7f033d
HX		 1110
1111 j = 0;
1112 for (i = 0; i < tcount; i++) {
bbb9a7dd
CS		 1113 if (template[i].np && !template[i].also_non_np)
1114 continue;
1115
10faa8c0
SM		 1116 if (fips_enabled && template[i].fips_skip)
1117 continue;
1118
da7f033d 1119 if (template[i].iv)
84cba178 1120 memcpy(iv, template[i].iv, ivsize);
da7f033d
HX		 1121 else
1122 memset(iv, 0, MAX_IVLEN);
1123
a1aa44a2 1124 j++;
a1aa44a2
CS		 1125 ret = -EINVAL;
1126 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1127 goto out;
da7f033d 1128
a1aa44a2
CS		 1129 data = xbuf[0];
1130 data += align_offset;
1131 memcpy(data, template[i].input, template[i].ilen);
1132
12773d93 1133 crypto_skcipher_clear_flags(tfm, ~0);
a1aa44a2 1134 if (template[i].wk)
12773d93
HX		 1135 crypto_skcipher_set_flags(tfm,
1136 CRYPTO_TFM_REQ_WEAK_KEY);
da7f033d 1137
12773d93
HX		 1138 ret = crypto_skcipher_setkey(tfm, template[i].key,
1139 template[i].klen);
0fae0c1e 1140 if (template[i].fail == !ret) {
a1aa44a2 1141 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
12773d93 1142 d, j, algo, crypto_skcipher_get_flags(tfm));
a1aa44a2
CS		 1143 goto out;
1144 } else if (ret)
1145 continue;
1146
1147 sg_init_one(&sg[0], data, template[i].ilen);
1148 if (diff_dst) {
1149 data = xoutbuf[0];
1150 data += align_offset;
1151 sg_init_one(&sgout[0], data, template[i].ilen);
1152 }
da7f033d 1153
12773d93
HX		 1154 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1155 template[i].ilen, iv);
7f397136
GBY		 1156 ret = crypto_wait_req(enc ? crypto_skcipher_encrypt(req) :
1157 crypto_skcipher_decrypt(req), &wait);
a1aa44a2 1158
7f397136 1159 if (ret) {
a1aa44a2
CS		 1160 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1161 d, e, j, algo, -ret);
1162 goto out;
1163 }
da7f033d 1164
a1aa44a2
CS		 1165 q = data;
1166 if (memcmp(q, template[i].result, template[i].rlen)) {
8a826a34 1167 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
a1aa44a2
CS		 1168 d, j, e, algo);
1169 hexdump(q, template[i].rlen);
1170 ret = -EINVAL;
1171 goto out;
da7f033d 1172 }
8a826a34
BB		 1173
1174 if (template[i].iv_out &&
1175 memcmp(iv, template[i].iv_out,
1176 crypto_skcipher_ivsize(tfm))) {
1177 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1178 d, j, e, algo);
1179 hexdump(iv, crypto_skcipher_ivsize(tfm));
1180 ret = -EINVAL;
1181 goto out;
1182 }
da7f033d
HX		 1183 }
1184
1185 j = 0;
1186 for (i = 0; i < tcount; i++) {
3a338f20
JK		 1187 /* alignment tests are only done with continuous buffers */
1188 if (align_offset != 0)
1189 break;
da7f033d 1190
bbb9a7dd
CS		 1191 if (!template[i].np)
1192 continue;
1193
10faa8c0
SM		 1194 if (fips_enabled && template[i].fips_skip)
1195 continue;
1196
da7f033d 1197 if (template[i].iv)
84cba178 1198 memcpy(iv, template[i].iv, ivsize);
da7f033d
HX		 1199 else
1200 memset(iv, 0, MAX_IVLEN);
1201
a1aa44a2 1202 j++;
12773d93 1203 crypto_skcipher_clear_flags(tfm, ~0);
a1aa44a2 1204 if (template[i].wk)
12773d93
HX		 1205 crypto_skcipher_set_flags(tfm,
1206 CRYPTO_TFM_REQ_WEAK_KEY);
da7f033d 1207
12773d93
HX		 1208 ret = crypto_skcipher_setkey(tfm, template[i].key,
1209 template[i].klen);
0fae0c1e 1210 if (template[i].fail == !ret) {
a1aa44a2 1211 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
12773d93 1212 d, j, algo, crypto_skcipher_get_flags(tfm));
a1aa44a2
CS		 1213 goto out;
1214 } else if (ret)
1215 continue;
da7f033d 1216
a1aa44a2
CS		 1217 temp = 0;
1218 ret = -EINVAL;
1219 sg_init_table(sg, template[i].np);
1220 if (diff_dst)
1221 sg_init_table(sgout, template[i].np);
1222 for (k = 0; k < template[i].np; k++) {
1223 if (WARN_ON(offset_in_page(IDX[k]) +
1224 template[i].tap[k] > PAGE_SIZE))
da7f033d 1225 goto out;
da7f033d 1226
a1aa44a2 1227 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
da7f033d 1228
a1aa44a2
CS		 1229 memcpy(q, template[i].input + temp, template[i].tap[k]);
1230
1231 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1232 q[template[i].tap[k]] = 0;
1233
1234 sg_set_buf(&sg[k], q, template[i].tap[k]);
1235 if (diff_dst) {
1236 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
da7f033d
HX		 1237 offset_in_page(IDX[k]);
1238
a1aa44a2 1239 sg_set_buf(&sgout[k], q, template[i].tap[k]);
da7f033d 1240
a1aa44a2
CS		 1241 memset(q, 0, template[i].tap[k]);
1242 if (offset_in_page(q) +
1243 template[i].tap[k] < PAGE_SIZE)
da7f033d 1244 q[template[i].tap[k]] = 0;
a1aa44a2 1245 }
da7f033d 1246
a1aa44a2
CS		 1247 temp += template[i].tap[k];
1248 }
08d6af8c 1249
12773d93
HX		 1250 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1251 template[i].ilen, iv);
08d6af8c 1252
7f397136
GBY		 1253 ret = crypto_wait_req(enc ? crypto_skcipher_encrypt(req) :
1254 crypto_skcipher_decrypt(req), &wait);
da7f033d 1255
7f397136 1256 if (ret) {
a1aa44a2
CS		 1257 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1258 d, e, j, algo, -ret);
1259 goto out;
1260 }
da7f033d 1261
a1aa44a2
CS		 1262 temp = 0;
1263 ret = -EINVAL;
1264 for (k = 0; k < template[i].np; k++) {
1265 if (diff_dst)
1266 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1267 offset_in_page(IDX[k]);
1268 else
1269 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1270 offset_in_page(IDX[k]);
da7f033d 1271
a1aa44a2
CS		 1272 if (memcmp(q, template[i].result + temp,
1273 template[i].tap[k])) {
1274 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1275 d, j, e, k, algo);
1276 hexdump(q, template[i].tap[k]);
da7f033d
HX		 1277 goto out;
1278 }
1279
a1aa44a2
CS		 1280 q += template[i].tap[k];
1281 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1282 ;
1283 if (n) {
1284 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1285 d, j, e, k, algo, n);
1286 hexdump(q, n);
1287 goto out;
da7f033d 1288 }
a1aa44a2 1289 temp += template[i].tap[k];
da7f033d
HX		 1290 }
1291 }
1292
1293 ret = 0;
1294
1295out:
12773d93 1296 skcipher_request_free(req);
08d6af8c
JK		 1297 if (diff_dst)
1298 testmgr_free_buf(xoutbuf);
1299out_nooutbuf:
f8b0d4d0
HX		 1300 testmgr_free_buf(xbuf);
1301out_nobuf:
da7f033d
HX		 1302 return ret;
1303}
1304
12773d93 1305static int test_skcipher(struct crypto_skcipher *tfm, int enc,
b13b1e0c
EB		 1306 const struct cipher_testvec *template,
1307 unsigned int tcount)
08d6af8c 1308{
3a338f20 1309 unsigned int alignmask;
08d6af8c
JK		 1310 int ret;
1311
1312 /* test 'dst == src' case */
3a338f20 1313 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
08d6af8c
JK		 1314 if (ret)
1315 return ret;
1316
1317 /* test 'dst != src' case */
3a338f20
JK		 1318 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1319 if (ret)
1320 return ret;
1321
1322 /* test unaligned buffers, check with one byte offset */
1323 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1324 if (ret)
1325 return ret;
1326
1327 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1328 if (alignmask) {
1329 /* Check if alignment mask for tfm is correctly set. */
1330 ret = __test_skcipher(tfm, enc, template, tcount, true,
1331 alignmask + 1);
1332 if (ret)
1333 return ret;
1334 }
1335
1336 return 0;
08d6af8c
JK		 1337}
1338
b13b1e0c
EB		 1339static int test_comp(struct crypto_comp *tfm,
1340 const struct comp_testvec *ctemplate,
1341 const struct comp_testvec *dtemplate,
1342 int ctcount, int dtcount)
da7f033d
HX		 1343{
1344 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1345 unsigned int i;
1346 char result[COMP_BUF_SIZE];
1347 int ret;
1348
1349 for (i = 0; i < ctcount; i++) {
c79cf910
GU		 1350 int ilen;
1351 unsigned int dlen = COMP_BUF_SIZE;
da7f033d
HX		 1352
1353 memset(result, 0, sizeof (result));
1354
1355 ilen = ctemplate[i].inlen;
1356 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1357 ilen, result, &dlen);
1358 if (ret) {
1359 printk(KERN_ERR "alg: comp: compression failed "
1360 "on test %d for %s: ret=%d\n", i + 1, algo,
1361 -ret);
1362 goto out;
1363 }
1364
b812eb00
GU		 1365 if (dlen != ctemplate[i].outlen) {
1366 printk(KERN_ERR "alg: comp: Compression test %d "
1367 "failed for %s: output len = %d\n", i + 1, algo,
1368 dlen);
1369 ret = -EINVAL;
1370 goto out;
1371 }
1372
da7f033d
HX		 1373 if (memcmp(result, ctemplate[i].output, dlen)) {
1374 printk(KERN_ERR "alg: comp: Compression test %d "
1375 "failed for %s\n", i + 1, algo);
1376 hexdump(result, dlen);
1377 ret = -EINVAL;
1378 goto out;
1379 }
1380 }
1381
1382 for (i = 0; i < dtcount; i++) {
c79cf910
GU		 1383 int ilen;
1384 unsigned int dlen = COMP_BUF_SIZE;
da7f033d
HX		 1385
1386 memset(result, 0, sizeof (result));
1387
1388 ilen = dtemplate[i].inlen;
1389 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1390 ilen, result, &dlen);
1391 if (ret) {
1392 printk(KERN_ERR "alg: comp: decompression failed "
1393 "on test %d for %s: ret=%d\n", i + 1, algo,
1394 -ret);
1395 goto out;
1396 }
1397
b812eb00
GU		 1398 if (dlen != dtemplate[i].outlen) {
1399 printk(KERN_ERR "alg: comp: Decompression test %d "
1400 "failed for %s: output len = %d\n", i + 1, algo,
1401 dlen);
1402 ret = -EINVAL;
1403 goto out;
1404 }
1405
da7f033d
HX		 1406 if (memcmp(result, dtemplate[i].output, dlen)) {
1407 printk(KERN_ERR "alg: comp: Decompression test %d "
1408 "failed for %s\n", i + 1, algo);
1409 hexdump(result, dlen);
1410 ret = -EINVAL;
1411 goto out;
1412 }
1413 }
1414
1415 ret = 0;
1416
1417out:
1418 return ret;
1419}
1420
b13b1e0c
EB		 1421static int test_acomp(struct crypto_acomp *tfm,
1422 const struct comp_testvec *ctemplate,
1423 const struct comp_testvec *dtemplate,
1424 int ctcount, int dtcount)
d7db7a88
GC		 1425{
1426 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
1427 unsigned int i;
a9943a0a 1428 char *output, *decomp_out;
d7db7a88
GC		 1429 int ret;
1430 struct scatterlist src, dst;
1431 struct acomp_req *req;
7f397136 1432 struct crypto_wait wait;
d7db7a88 1433
eb095593
EB		 1434 output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
1435 if (!output)
1436 return -ENOMEM;
1437
a9943a0a
GC		 1438 decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
1439 if (!decomp_out) {
1440 kfree(output);
1441 return -ENOMEM;
1442 }
1443
d7db7a88
GC		 1444 for (i = 0; i < ctcount; i++) {
1445 unsigned int dlen = COMP_BUF_SIZE;
1446 int ilen = ctemplate[i].inlen;
02608e02 1447 void *input_vec;
d7db7a88 1448
d2110224 1449 input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
02608e02
LA		 1450 if (!input_vec) {
1451 ret = -ENOMEM;
1452 goto out;
1453 }
1454
eb095593 1455 memset(output, 0, dlen);
7f397136 1456 crypto_init_wait(&wait);
02608e02 1457 sg_init_one(&src, input_vec, ilen);
d7db7a88
GC		 1458 sg_init_one(&dst, output, dlen);
1459
1460 req = acomp_request_alloc(tfm);
1461 if (!req) {
1462 pr_err("alg: acomp: request alloc failed for %s\n",
1463 algo);
02608e02 1464 kfree(input_vec);
d7db7a88
GC		 1465 ret = -ENOMEM;
1466 goto out;
1467 }
1468
1469 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1470 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 1471 crypto_req_done, &wait);
d7db7a88 1472
7f397136 1473 ret = crypto_wait_req(crypto_acomp_compress(req), &wait);
d7db7a88
GC		 1474 if (ret) {
1475 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1476 i + 1, algo, -ret);
02608e02 1477 kfree(input_vec);
d7db7a88
GC		 1478 acomp_request_free(req);
1479 goto out;
1480 }
1481
a9943a0a
GC		 1482 ilen = req->dlen;
1483 dlen = COMP_BUF_SIZE;
1484 sg_init_one(&src, output, ilen);
1485 sg_init_one(&dst, decomp_out, dlen);
7f397136 1486 crypto_init_wait(&wait);
a9943a0a
GC		 1487 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1488
7f397136 1489 ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
a9943a0a
GC		 1490 if (ret) {
1491 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1492 i + 1, algo, -ret);
1493 kfree(input_vec);
1494 acomp_request_free(req);
1495 goto out;
1496 }
1497
1498 if (req->dlen != ctemplate[i].inlen) {
d7db7a88
GC		 1499 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1500 i + 1, algo, req->dlen);
1501 ret = -EINVAL;
02608e02 1502 kfree(input_vec);
d7db7a88
GC		 1503 acomp_request_free(req);
1504 goto out;
1505 }
1506
a9943a0a 1507 if (memcmp(input_vec, decomp_out, req->dlen)) {
d7db7a88
GC		 1508 pr_err("alg: acomp: Compression test %d failed for %s\n",
1509 i + 1, algo);
1510 hexdump(output, req->dlen);
1511 ret = -EINVAL;
02608e02 1512 kfree(input_vec);
d7db7a88
GC		 1513 acomp_request_free(req);
1514 goto out;
1515 }
1516
02608e02 1517 kfree(input_vec);
d7db7a88
GC		 1518 acomp_request_free(req);
1519 }
1520
1521 for (i = 0; i < dtcount; i++) {
1522 unsigned int dlen = COMP_BUF_SIZE;
1523 int ilen = dtemplate[i].inlen;
02608e02
LA		 1524 void *input_vec;
1525
d2110224 1526 input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
02608e02
LA		 1527 if (!input_vec) {
1528 ret = -ENOMEM;
1529 goto out;
1530 }
d7db7a88 1531
eb095593 1532 memset(output, 0, dlen);
7f397136 1533 crypto_init_wait(&wait);
02608e02 1534 sg_init_one(&src, input_vec, ilen);
d7db7a88
GC		 1535 sg_init_one(&dst, output, dlen);
1536
1537 req = acomp_request_alloc(tfm);
1538 if (!req) {
1539 pr_err("alg: acomp: request alloc failed for %s\n",
1540 algo);
02608e02 1541 kfree(input_vec);
d7db7a88
GC		 1542 ret = -ENOMEM;
1543 goto out;
1544 }
1545
1546 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1547 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 1548 crypto_req_done, &wait);
d7db7a88 1549
7f397136 1550 ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
d7db7a88
GC		 1551 if (ret) {
1552 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1553 i + 1, algo, -ret);
02608e02 1554 kfree(input_vec);
d7db7a88
GC		 1555 acomp_request_free(req);
1556 goto out;
1557 }
1558
1559 if (req->dlen != dtemplate[i].outlen) {
1560 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1561 i + 1, algo, req->dlen);
1562 ret = -EINVAL;
02608e02 1563 kfree(input_vec);
d7db7a88
GC		 1564 acomp_request_free(req);
1565 goto out;
1566 }
1567
1568 if (memcmp(output, dtemplate[i].output, req->dlen)) {
1569 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1570 i + 1, algo);
1571 hexdump(output, req->dlen);
1572 ret = -EINVAL;
02608e02 1573 kfree(input_vec);
d7db7a88
GC		 1574 acomp_request_free(req);
1575 goto out;
1576 }
1577
02608e02 1578 kfree(input_vec);
d7db7a88
GC		 1579 acomp_request_free(req);
1580 }
1581
1582 ret = 0;
1583
1584out:
a9943a0a 1585 kfree(decomp_out);
eb095593 1586 kfree(output);
d7db7a88
GC		 1587 return ret;
1588}
1589
b13b1e0c
EB		 1590static int test_cprng(struct crypto_rng *tfm,
1591 const struct cprng_testvec *template,
7647d6ce
JW		 1592 unsigned int tcount)
1593{
1594 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
fa4ef8a6 1595 int err = 0, i, j, seedsize;
7647d6ce
JW		 1596 u8 *seed;
1597 char result[32];
1598
1599 seedsize = crypto_rng_seedsize(tfm);
1600
1601 seed = kmalloc(seedsize, GFP_KERNEL);
1602 if (!seed) {
1603 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1604 "for %s\n", algo);
1605 return -ENOMEM;
1606 }
1607
1608 for (i = 0; i < tcount; i++) {
1609 memset(result, 0, 32);
1610
1611 memcpy(seed, template[i].v, template[i].vlen);
1612 memcpy(seed + template[i].vlen, template[i].key,
1613 template[i].klen);
1614 memcpy(seed + template[i].vlen + template[i].klen,
1615 template[i].dt, template[i].dtlen);
1616
1617 err = crypto_rng_reset(tfm, seed, seedsize);
1618 if (err) {
1619 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1620 "for %s\n", algo);
1621 goto out;
1622 }
1623
1624 for (j = 0; j < template[i].loops; j++) {
1625 err = crypto_rng_get_bytes(tfm, result,
1626 template[i].rlen);
19e60e13 1627 if (err < 0) {
7647d6ce
JW		 1628 printk(KERN_ERR "alg: cprng: Failed to obtain "
1629 "the correct amount of random data for "
19e60e13
SM		 1630 "%s (requested %d)\n", algo,
1631 template[i].rlen);
7647d6ce
JW		 1632 goto out;
1633 }
1634 }
1635
1636 err = memcmp(result, template[i].result,
1637 template[i].rlen);
1638 if (err) {
1639 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1640 i, algo);
1641 hexdump(result, template[i].rlen);
1642 err = -EINVAL;
1643 goto out;
1644 }
1645 }
1646
1647out:
1648 kfree(seed);
1649 return err;
1650}
1651
da7f033d
HX		 1652static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1653 u32 type, u32 mask)
1654{
1655 struct crypto_aead *tfm;
1656 int err = 0;
1657
eed93e0c 1658 tfm = crypto_alloc_aead(driver, type, mask);
da7f033d
HX		 1659 if (IS_ERR(tfm)) {
1660 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1661 "%ld\n", driver, PTR_ERR(tfm));
1662 return PTR_ERR(tfm);
1663 }
1664
1665 if (desc->suite.aead.enc.vecs) {
1666 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1667 desc->suite.aead.enc.count);
1668 if (err)
1669 goto out;
1670 }
1671
1672 if (!err && desc->suite.aead.dec.vecs)
1673 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1674 desc->suite.aead.dec.count);
1675
1676out:
1677 crypto_free_aead(tfm);
1678 return err;
1679}
1680
1681static int alg_test_cipher(const struct alg_test_desc *desc,
1682 const char *driver, u32 type, u32 mask)
1683{
1aa4ecd9 1684 struct crypto_cipher *tfm;
da7f033d
HX		 1685 int err = 0;
1686
eed93e0c 1687 tfm = crypto_alloc_cipher(driver, type, mask);
da7f033d
HX		 1688 if (IS_ERR(tfm)) {
1689 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1690 "%s: %ld\n", driver, PTR_ERR(tfm));
1691 return PTR_ERR(tfm);
1692 }
1693
1694 if (desc->suite.cipher.enc.vecs) {
1695 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1696 desc->suite.cipher.enc.count);
1697 if (err)
1698 goto out;
1699 }
1700
1701 if (desc->suite.cipher.dec.vecs)
1702 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1703 desc->suite.cipher.dec.count);
1704
1aa4ecd9
HX		 1705out:
1706 crypto_free_cipher(tfm);
1707 return err;
1708}
1709
1710static int alg_test_skcipher(const struct alg_test_desc *desc,
1711 const char *driver, u32 type, u32 mask)
1712{
12773d93 1713 struct crypto_skcipher *tfm;
1aa4ecd9
HX		 1714 int err = 0;
1715
eed93e0c 1716 tfm = crypto_alloc_skcipher(driver, type, mask);
1aa4ecd9
HX		 1717 if (IS_ERR(tfm)) {
1718 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1719 "%s: %ld\n", driver, PTR_ERR(tfm));
1720 return PTR_ERR(tfm);
1721 }
1722
1723 if (desc->suite.cipher.enc.vecs) {
1724 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1725 desc->suite.cipher.enc.count);
1726 if (err)
1727 goto out;
1728 }
1729
1730 if (desc->suite.cipher.dec.vecs)
1731 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1732 desc->suite.cipher.dec.count);
1733
da7f033d 1734out:
12773d93 1735 crypto_free_skcipher(tfm);
da7f033d
HX		 1736 return err;
1737}
1738
1739static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1740 u32 type, u32 mask)
1741{
d7db7a88
GC		 1742 struct crypto_comp *comp;
1743 struct crypto_acomp *acomp;
da7f033d 1744 int err;
d7db7a88
GC		 1745 u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK;
1746
1747 if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
1748 acomp = crypto_alloc_acomp(driver, type, mask);
1749 if (IS_ERR(acomp)) {
1750 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1751 driver, PTR_ERR(acomp));
1752 return PTR_ERR(acomp);
1753 }
1754 err = test_acomp(acomp, desc->suite.comp.comp.vecs,
1755 desc->suite.comp.decomp.vecs,
1756 desc->suite.comp.comp.count,
1757 desc->suite.comp.decomp.count);
1758 crypto_free_acomp(acomp);
1759 } else {
1760 comp = crypto_alloc_comp(driver, type, mask);
1761 if (IS_ERR(comp)) {
1762 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1763 driver, PTR_ERR(comp));
1764 return PTR_ERR(comp);
1765 }
da7f033d 1766
d7db7a88
GC		 1767 err = test_comp(comp, desc->suite.comp.comp.vecs,
1768 desc->suite.comp.decomp.vecs,
1769 desc->suite.comp.comp.count,
1770 desc->suite.comp.decomp.count);
da7f033d 1771
d7db7a88
GC		 1772 crypto_free_comp(comp);
1773 }
da7f033d
HX		 1774 return err;
1775}
1776
1777static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1778 u32 type, u32 mask)
1779{
1780 struct crypto_ahash *tfm;
1781 int err;
1782
eed93e0c 1783 tfm = crypto_alloc_ahash(driver, type, mask);
da7f033d
HX		 1784 if (IS_ERR(tfm)) {
1785 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1786 "%ld\n", driver, PTR_ERR(tfm));
1787 return PTR_ERR(tfm);
1788 }
1789
a8f1a052
DM		 1790 err = test_hash(tfm, desc->suite.hash.vecs,
1791 desc->suite.hash.count, true);
1792 if (!err)
1793 err = test_hash(tfm, desc->suite.hash.vecs,
1794 desc->suite.hash.count, false);
da7f033d
HX		 1795
1796 crypto_free_ahash(tfm);
1797 return err;
1798}
1799
8e3ee85e
HX		 1800static int alg_test_crc32c(const struct alg_test_desc *desc,
1801 const char *driver, u32 type, u32 mask)
1802{
1803 struct crypto_shash *tfm;
1804 u32 val;
1805 int err;
1806
1807 err = alg_test_hash(desc, driver, type, mask);
1808 if (err)
1809 goto out;
1810
eed93e0c 1811 tfm = crypto_alloc_shash(driver, type, mask);
8e3ee85e
HX		 1812 if (IS_ERR(tfm)) {
1813 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1814 "%ld\n", driver, PTR_ERR(tfm));
1815 err = PTR_ERR(tfm);
1816 goto out;
1817 }
1818
1819 do {
4c5c3024
JSM		 1820 SHASH_DESC_ON_STACK(shash, tfm);
1821 u32 *ctx = (u32 *)shash_desc_ctx(shash);
8e3ee85e 1822
4c5c3024
JSM		 1823 shash->tfm = tfm;
1824 shash->flags = 0;
8e3ee85e 1825
4c5c3024
JSM		 1826 *ctx = le32_to_cpu(420553207);
1827 err = crypto_shash_final(shash, (u8 *)&val);
8e3ee85e
HX		 1828 if (err) {
1829 printk(KERN_ERR "alg: crc32c: Operation failed for "
1830 "%s: %d\n", driver, err);
1831 break;
1832 }
1833
1834 if (val != ~420553207) {
1835 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1836 "%d\n", driver, val);
1837 err = -EINVAL;
1838 }
1839 } while (0);
1840
1841 crypto_free_shash(tfm);
1842
1843out:
1844 return err;
1845}
1846
7647d6ce
JW		 1847static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1848 u32 type, u32 mask)
1849{
1850 struct crypto_rng *rng;
1851 int err;
1852
eed93e0c 1853 rng = crypto_alloc_rng(driver, type, mask);
7647d6ce
JW		 1854 if (IS_ERR(rng)) {
1855 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1856 "%ld\n", driver, PTR_ERR(rng));
1857 return PTR_ERR(rng);
1858 }
1859
1860 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1861
1862 crypto_free_rng(rng);
1863
1864 return err;
1865}
1866
64d1cdfb 1867
b13b1e0c 1868static int drbg_cavs_test(const struct drbg_testvec *test, int pr,
64d1cdfb
SM		 1869 const char *driver, u32 type, u32 mask)
1870{
1871 int ret = -EAGAIN;
1872 struct crypto_rng *drng;
1873 struct drbg_test_data test_data;
1874 struct drbg_string addtl, pers, testentropy;
1875 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1876
1877 if (!buf)
1878 return -ENOMEM;
1879
eed93e0c 1880 drng = crypto_alloc_rng(driver, type, mask);
64d1cdfb 1881 if (IS_ERR(drng)) {
2fc0d258 1882 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
64d1cdfb
SM		 1883 "%s\n", driver);
1884 kzfree(buf);
1885 return -ENOMEM;
1886 }
1887
1888 test_data.testentropy = &testentropy;
1889 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1890 drbg_string_fill(&pers, test->pers, test->perslen);
1891 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1892 if (ret) {
1893 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1894 goto outbuf;
1895 }
1896
1897 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1898 if (pr) {
1899 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1900 ret = crypto_drbg_get_bytes_addtl_test(drng,
1901 buf, test->expectedlen, &addtl, &test_data);
1902 } else {
1903 ret = crypto_drbg_get_bytes_addtl(drng,
1904 buf, test->expectedlen, &addtl);
1905 }
19e60e13 1906 if (ret < 0) {
2fc0d258 1907 printk(KERN_ERR "alg: drbg: could not obtain random data for "
64d1cdfb
SM		 1908 "driver %s\n", driver);
1909 goto outbuf;
1910 }
1911
1912 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1913 if (pr) {
1914 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1915 ret = crypto_drbg_get_bytes_addtl_test(drng,
1916 buf, test->expectedlen, &addtl, &test_data);
1917 } else {
1918 ret = crypto_drbg_get_bytes_addtl(drng,
1919 buf, test->expectedlen, &addtl);
1920 }
19e60e13 1921 if (ret < 0) {
2fc0d258 1922 printk(KERN_ERR "alg: drbg: could not obtain random data for "
64d1cdfb
SM		 1923 "driver %s\n", driver);
1924 goto outbuf;
1925 }
1926
1927 ret = memcmp(test->expected, buf, test->expectedlen);
1928
1929outbuf:
1930 crypto_free_rng(drng);
1931 kzfree(buf);
1932 return ret;
1933}
1934
1935
1936static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1937 u32 type, u32 mask)
1938{
1939 int err = 0;
1940 int pr = 0;
1941 int i = 0;
b13b1e0c 1942 const struct drbg_testvec *template = desc->suite.drbg.vecs;
64d1cdfb
SM		 1943 unsigned int tcount = desc->suite.drbg.count;
1944
1945 if (0 == memcmp(driver, "drbg_pr_", 8))
1946 pr = 1;
1947
1948 for (i = 0; i < tcount; i++) {
1949 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1950 if (err) {
1951 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1952 i, driver);
1953 err = -EINVAL;
1954 break;
1955 }
1956 }
1957 return err;
1958
1959}
1960
b13b1e0c 1961static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
802c7f1c
SB		 1962 const char *alg)
1963{
1964 struct kpp_request *req;
1965 void *input_buf = NULL;
1966 void *output_buf = NULL;
47d3fd39
TA		 1967 void *a_public = NULL;
1968 void *a_ss = NULL;
1969 void *shared_secret = NULL;
7f397136 1970 struct crypto_wait wait;
802c7f1c
SB		 1971 unsigned int out_len_max;
1972 int err = -ENOMEM;
1973 struct scatterlist src, dst;
1974
1975 req = kpp_request_alloc(tfm, GFP_KERNEL);
1976 if (!req)
1977 return err;
1978
7f397136 1979 crypto_init_wait(&wait);
802c7f1c
SB		 1980
1981 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
1982 if (err < 0)
1983 goto free_req;
1984
1985 out_len_max = crypto_kpp_maxsize(tfm);
1986 output_buf = kzalloc(out_len_max, GFP_KERNEL);
1987 if (!output_buf) {
1988 err = -ENOMEM;
1989 goto free_req;
1990 }
1991
1992 /* Use appropriate parameter as base */
1993 kpp_request_set_input(req, NULL, 0);
1994 sg_init_one(&dst, output_buf, out_len_max);
1995 kpp_request_set_output(req, &dst, out_len_max);
1996 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 1997 crypto_req_done, &wait);
802c7f1c 1998
47d3fd39 1999 /* Compute party A's public key */
7f397136 2000 err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait);
802c7f1c 2001 if (err) {
47d3fd39 2002 pr_err("alg: %s: Party A: generate public key test failed. err %d\n",
802c7f1c
SB		 2003 alg, err);
2004 goto free_output;
2005 }
47d3fd39
TA		 2006
2007 if (vec->genkey) {
2008 /* Save party A's public key */
2009 a_public = kzalloc(out_len_max, GFP_KERNEL);
2010 if (!a_public) {
2011 err = -ENOMEM;
2012 goto free_output;
2013 }
2014 memcpy(a_public, sg_virt(req->dst), out_len_max);
2015 } else {
2016 /* Verify calculated public key */
2017 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
2018 vec->expected_a_public_size)) {
2019 pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n",
2020 alg);
2021 err = -EINVAL;
2022 goto free_output;
2023 }
802c7f1c
SB		 2024 }
2025
2026 /* Calculate shared secret key by using counter part (b) public key. */
2027 input_buf = kzalloc(vec->b_public_size, GFP_KERNEL);
2028 if (!input_buf) {
2029 err = -ENOMEM;
2030 goto free_output;
2031 }
2032
2033 memcpy(input_buf, vec->b_public, vec->b_public_size);
2034 sg_init_one(&src, input_buf, vec->b_public_size);
2035 sg_init_one(&dst, output_buf, out_len_max);
2036 kpp_request_set_input(req, &src, vec->b_public_size);
2037 kpp_request_set_output(req, &dst, out_len_max);
2038 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136
GBY		 2039 crypto_req_done, &wait);
2040 err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait);
802c7f1c 2041 if (err) {
47d3fd39 2042 pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n",
802c7f1c
SB		 2043 alg, err);
2044 goto free_all;
2045 }
47d3fd39
TA		 2046
2047 if (vec->genkey) {
2048 /* Save the shared secret obtained by party A */
2049 a_ss = kzalloc(vec->expected_ss_size, GFP_KERNEL);
2050 if (!a_ss) {
2051 err = -ENOMEM;
2052 goto free_all;
2053 }
2054 memcpy(a_ss, sg_virt(req->dst), vec->expected_ss_size);
2055
2056 /*
2057 * Calculate party B's shared secret by using party A's
2058 * public key.
2059 */
2060 err = crypto_kpp_set_secret(tfm, vec->b_secret,
2061 vec->b_secret_size);
2062 if (err < 0)
2063 goto free_all;
2064
2065 sg_init_one(&src, a_public, vec->expected_a_public_size);
2066 sg_init_one(&dst, output_buf, out_len_max);
2067 kpp_request_set_input(req, &src, vec->expected_a_public_size);
2068 kpp_request_set_output(req, &dst, out_len_max);
2069 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136
GBY		 2070 crypto_req_done, &wait);
2071 err = crypto_wait_req(crypto_kpp_compute_shared_secret(req),
2072 &wait);
47d3fd39
TA		 2073 if (err) {
2074 pr_err("alg: %s: Party B: compute shared secret failed. err %d\n",
2075 alg, err);
2076 goto free_all;
2077 }
2078
2079 shared_secret = a_ss;
2080 } else {
2081 shared_secret = (void *)vec->expected_ss;
2082 }
2083
802c7f1c
SB		 2084 /*
2085 * verify shared secret from which the user will derive
2086 * secret key by executing whatever hash it has chosen
2087 */
47d3fd39 2088 if (memcmp(shared_secret, sg_virt(req->dst),
802c7f1c
SB		 2089 vec->expected_ss_size)) {
2090 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2091 alg);
2092 err = -EINVAL;
2093 }
2094
2095free_all:
47d3fd39 2096 kfree(a_ss);
802c7f1c
SB		 2097 kfree(input_buf);
2098free_output:
47d3fd39 2099 kfree(a_public);
802c7f1c
SB		 2100 kfree(output_buf);
2101free_req:
2102 kpp_request_free(req);
2103 return err;
2104}
2105
2106static int test_kpp(struct crypto_kpp *tfm, const char *alg,
b13b1e0c 2107 const struct kpp_testvec *vecs, unsigned int tcount)
802c7f1c
SB		 2108{
2109 int ret, i;
2110
2111 for (i = 0; i < tcount; i++) {
2112 ret = do_test_kpp(tfm, vecs++, alg);
2113 if (ret) {
2114 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2115 alg, i + 1, ret);
2116 return ret;
2117 }
2118 }
2119 return 0;
2120}
2121
2122static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
2123 u32 type, u32 mask)
2124{
2125 struct crypto_kpp *tfm;
2126 int err = 0;
2127
eed93e0c 2128 tfm = crypto_alloc_kpp(driver, type, mask);
802c7f1c
SB		 2129 if (IS_ERR(tfm)) {
2130 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2131 driver, PTR_ERR(tfm));
2132 return PTR_ERR(tfm);
2133 }
2134 if (desc->suite.kpp.vecs)
2135 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
2136 desc->suite.kpp.count);
2137
2138 crypto_free_kpp(tfm);
2139 return err;
2140}
2141
50d2b643 2142static int test_akcipher_one(struct crypto_akcipher *tfm,
b13b1e0c 2143 const struct akcipher_testvec *vecs)
946cc463 2144{
df27b26f 2145 char *xbuf[XBUFSIZE];
946cc463
TS		 2146 struct akcipher_request *req;
2147 void *outbuf_enc = NULL;
2148 void *outbuf_dec = NULL;
7f397136 2149 struct crypto_wait wait;
946cc463
TS		 2150 unsigned int out_len_max, out_len = 0;
2151 int err = -ENOMEM;
22287b0b 2152 struct scatterlist src, dst, src_tab[2];
946cc463 2153
df27b26f
HX		 2154 if (testmgr_alloc_buf(xbuf))
2155 return err;
2156
946cc463
TS		 2157 req = akcipher_request_alloc(tfm, GFP_KERNEL);
2158 if (!req)
df27b26f 2159 goto free_xbuf;
946cc463 2160
7f397136 2161 crypto_init_wait(&wait);
946cc463 2162
22287b0b
TS		 2163 if (vecs->public_key_vec)
2164 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
2165 vecs->key_len);
2166 else
2167 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
2168 vecs->key_len);
2169 if (err)
946cc463 2170 goto free_req;
946cc463 2171
57763f5e 2172 err = -ENOMEM;
22287b0b 2173 out_len_max = crypto_akcipher_maxsize(tfm);
946cc463
TS		 2174 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
2175 if (!outbuf_enc)
2176 goto free_req;
2177
df27b26f
HX		 2178 if (WARN_ON(vecs->m_size > PAGE_SIZE))
2179 goto free_all;
2180
2181 memcpy(xbuf[0], vecs->m, vecs->m_size);
2182
22287b0b 2183 sg_init_table(src_tab, 2);
df27b26f
HX		 2184 sg_set_buf(&src_tab[0], xbuf[0], 8);
2185 sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
22287b0b
TS		 2186 sg_init_one(&dst, outbuf_enc, out_len_max);
2187 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
2188 out_len_max);
946cc463 2189 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
7f397136 2190 crypto_req_done, &wait);
946cc463 2191
7f397136
GBY		 2192 err = crypto_wait_req(vecs->siggen_sigver_test ?
2193 /* Run asymmetric signature generation */
2194 crypto_akcipher_sign(req) :
2195 /* Run asymmetric encrypt */
2196 crypto_akcipher_encrypt(req), &wait);
946cc463 2197 if (err) {
50d2b643 2198 pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
946cc463
TS		 2199 goto free_all;
2200 }
22287b0b 2201 if (req->dst_len != vecs->c_size) {
50d2b643 2202 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
946cc463
TS		 2203 err = -EINVAL;
2204 goto free_all;
2205 }
2206 /* verify that encrypted message is equal to expected */
df27b26f 2207 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
50d2b643
HX		 2208 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2209 hexdump(outbuf_enc, vecs->c_size);
946cc463
TS		 2210 err = -EINVAL;
2211 goto free_all;
2212 }
2213 /* Don't invoke decrypt for vectors with public key */
2214 if (vecs->public_key_vec) {
2215 err = 0;
2216 goto free_all;
2217 }
2218 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
2219 if (!outbuf_dec) {
2220 err = -ENOMEM;
2221 goto free_all;
2222 }
df27b26f
HX		 2223
2224 if (WARN_ON(vecs->c_size > PAGE_SIZE))
2225 goto free_all;
2226
2227 memcpy(xbuf[0], vecs->c, vecs->c_size);
2228
2229 sg_init_one(&src, xbuf[0], vecs->c_size);
22287b0b 2230 sg_init_one(&dst, outbuf_dec, out_len_max);
7f397136 2231 crypto_init_wait(&wait);
22287b0b 2232 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
946cc463 2233
7f397136
GBY		 2234 err = crypto_wait_req(vecs->siggen_sigver_test ?
2235 /* Run asymmetric signature verification */
2236 crypto_akcipher_verify(req) :
2237 /* Run asymmetric decrypt */
2238 crypto_akcipher_decrypt(req), &wait);
946cc463 2239 if (err) {
50d2b643 2240 pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
946cc463
TS		 2241 goto free_all;
2242 }
2243 out_len = req->dst_len;
50d2b643
HX		 2244 if (out_len < vecs->m_size) {
2245 pr_err("alg: akcipher: decrypt test failed. "
2246 "Invalid output len %u\n", out_len);
946cc463
TS		 2247 err = -EINVAL;
2248 goto free_all;
2249 }
2250 /* verify that decrypted message is equal to the original msg */
50d2b643
HX		 2251 if (memchr_inv(outbuf_dec, 0, out_len - vecs->m_size) ||
2252 memcmp(vecs->m, outbuf_dec + out_len - vecs->m_size,
2253 vecs->m_size)) {
2254 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2255 hexdump(outbuf_dec, out_len);
946cc463
TS		 2256 err = -EINVAL;
2257 }
2258free_all:
2259 kfree(outbuf_dec);
2260 kfree(outbuf_enc);
2261free_req:
2262 akcipher_request_free(req);
df27b26f
HX		 2263free_xbuf:
2264 testmgr_free_buf(xbuf);
946cc463
TS		 2265 return err;
2266}
2267
50d2b643 2268static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
b13b1e0c
EB		 2269 const struct akcipher_testvec *vecs,
2270 unsigned int tcount)
946cc463 2271{
15226e48
HX		 2272 const char *algo =
2273 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
946cc463
TS		 2274 int ret, i;
2275
2276 for (i = 0; i < tcount; i++) {
50d2b643
HX		 2277 ret = test_akcipher_one(tfm, vecs++);
2278 if (!ret)
2279 continue;
946cc463 2280
15226e48
HX		 2281 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2282 i + 1, algo, ret);
50d2b643
HX		 2283 return ret;
2284 }
946cc463
TS		 2285 return 0;
2286}
2287
2288static int alg_test_akcipher(const struct alg_test_desc *desc,
2289 const char *driver, u32 type, u32 mask)
2290{
2291 struct crypto_akcipher *tfm;
2292 int err = 0;
2293
eed93e0c 2294 tfm = crypto_alloc_akcipher(driver, type, mask);
946cc463
TS		 2295 if (IS_ERR(tfm)) {
2296 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2297 driver, PTR_ERR(tfm));
2298 return PTR_ERR(tfm);
2299 }
2300 if (desc->suite.akcipher.vecs)
2301 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
2302 desc->suite.akcipher.count);
2303
2304 crypto_free_akcipher(tfm);
2305 return err;
2306}
2307
863b557a
YS		 2308static int alg_test_null(const struct alg_test_desc *desc,
2309 const char *driver, u32 type, u32 mask)
2310{
2311 return 0;
2312}
2313
21c8e720
AB		 2314#define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) }
2315
da7f033d
HX		 2316/* Please keep this list sorted by algorithm name. */
2317static const struct alg_test_desc alg_test_descs[] = {
2318 {
e08ca2da
JW		 2319 .alg = "ansi_cprng",
2320 .test = alg_test_cprng,
2321 .suite = {
21c8e720 2322 .cprng = __VECS(ansi_cprng_aes_tv_template)
e08ca2da 2323 }
bca4feb0
HG		 2324 }, {
2325 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2326 .test = alg_test_aead,
bca4feb0
HG		 2327 .suite = {
2328 .aead = {
21c8e720
AB		 2329 .enc = __VECS(hmac_md5_ecb_cipher_null_enc_tv_template),
2330 .dec = __VECS(hmac_md5_ecb_cipher_null_dec_tv_template)
bca4feb0
HG		 2331 }
2332 }
e46e9a46 2333 }, {
a4198fd4 2334 .alg = "authenc(hmac(sha1),cbc(aes))",
e46e9a46 2335 .test = alg_test_aead,
bcf741cb 2336 .fips_allowed = 1,
e46e9a46
HG		 2337 .suite = {
2338 .aead = {
21c8e720 2339 .enc = __VECS(hmac_sha1_aes_cbc_enc_tv_temp)
5208ed2c
NL		 2340 }
2341 }
2342 }, {
a4198fd4 2343 .alg = "authenc(hmac(sha1),cbc(des))",
5208ed2c 2344 .test = alg_test_aead,
5208ed2c
NL		 2345 .suite = {
2346 .aead = {
21c8e720 2347 .enc = __VECS(hmac_sha1_des_cbc_enc_tv_temp)
5208ed2c
NL		 2348 }
2349 }
2350 }, {
a4198fd4 2351 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
5208ed2c 2352 .test = alg_test_aead,
ed1afac9 2353 .fips_allowed = 1,
5208ed2c
NL		 2354 .suite = {
2355 .aead = {
21c8e720 2356 .enc = __VECS(hmac_sha1_des3_ede_cbc_enc_tv_temp)
e46e9a46
HG		 2357 }
2358 }
fb16abc2
MM		 2359 }, {
2360 .alg = "authenc(hmac(sha1),ctr(aes))",
2361 .test = alg_test_null,
2362 .fips_allowed = 1,
bca4feb0
HG		 2363 }, {
2364 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2365 .test = alg_test_aead,
bca4feb0
HG		 2366 .suite = {
2367 .aead = {
21c8e720
AB		 2368 .enc = __VECS(hmac_sha1_ecb_cipher_null_enc_tv_temp),
2369 .dec = __VECS(hmac_sha1_ecb_cipher_null_dec_tv_temp)
5208ed2c
NL		 2370 }
2371 }
8888690e
MM		 2372 }, {
2373 .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2374 .test = alg_test_null,
2375 .fips_allowed = 1,
5208ed2c 2376 }, {
a4198fd4 2377 .alg = "authenc(hmac(sha224),cbc(des))",
5208ed2c 2378 .test = alg_test_aead,
5208ed2c
NL		 2379 .suite = {
2380 .aead = {
21c8e720 2381 .enc = __VECS(hmac_sha224_des_cbc_enc_tv_temp)
5208ed2c
NL		 2382 }
2383 }
2384 }, {
a4198fd4 2385 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
5208ed2c 2386 .test = alg_test_aead,
ed1afac9 2387 .fips_allowed = 1,
5208ed2c
NL		 2388 .suite = {
2389 .aead = {
21c8e720 2390 .enc = __VECS(hmac_sha224_des3_ede_cbc_enc_tv_temp)
bca4feb0
HG		 2391 }
2392 }
e46e9a46 2393 }, {
a4198fd4 2394 .alg = "authenc(hmac(sha256),cbc(aes))",
e46e9a46 2395 .test = alg_test_aead,
ed1afac9 2396 .fips_allowed = 1,
e46e9a46
HG		 2397 .suite = {
2398 .aead = {
21c8e720 2399 .enc = __VECS(hmac_sha256_aes_cbc_enc_tv_temp)
5208ed2c
NL		 2400 }
2401 }
2402 }, {
a4198fd4 2403 .alg = "authenc(hmac(sha256),cbc(des))",
5208ed2c 2404 .test = alg_test_aead,
5208ed2c
NL		 2405 .suite = {
2406 .aead = {
21c8e720 2407 .enc = __VECS(hmac_sha256_des_cbc_enc_tv_temp)
5208ed2c
NL		 2408 }
2409 }
2410 }, {
a4198fd4 2411 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
5208ed2c 2412 .test = alg_test_aead,
ed1afac9 2413 .fips_allowed = 1,
5208ed2c
NL		 2414 .suite = {
2415 .aead = {
21c8e720 2416 .enc = __VECS(hmac_sha256_des3_ede_cbc_enc_tv_temp)
5208ed2c
NL		 2417 }
2418 }
fb16abc2
MM		 2419 }, {
2420 .alg = "authenc(hmac(sha256),ctr(aes))",
2421 .test = alg_test_null,
2422 .fips_allowed = 1,
8888690e
MM		 2423 }, {
2424 .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2425 .test = alg_test_null,
2426 .fips_allowed = 1,
5208ed2c 2427 }, {
a4198fd4 2428 .alg = "authenc(hmac(sha384),cbc(des))",
5208ed2c 2429 .test = alg_test_aead,
5208ed2c
NL		 2430 .suite = {
2431 .aead = {
21c8e720 2432 .enc = __VECS(hmac_sha384_des_cbc_enc_tv_temp)
5208ed2c
NL		 2433 }
2434 }
2435 }, {
a4198fd4 2436 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
5208ed2c 2437 .test = alg_test_aead,
ed1afac9 2438 .fips_allowed = 1,
5208ed2c
NL		 2439 .suite = {
2440 .aead = {
21c8e720 2441 .enc = __VECS(hmac_sha384_des3_ede_cbc_enc_tv_temp)
e46e9a46
HG		 2442 }
2443 }
fb16abc2
MM		 2444 }, {
2445 .alg = "authenc(hmac(sha384),ctr(aes))",
2446 .test = alg_test_null,
2447 .fips_allowed = 1,
8888690e
MM		 2448 }, {
2449 .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2450 .test = alg_test_null,
2451 .fips_allowed = 1,
e46e9a46 2452 }, {
a4198fd4 2453 .alg = "authenc(hmac(sha512),cbc(aes))",
ed1afac9 2454 .fips_allowed = 1,
e46e9a46 2455 .test = alg_test_aead,
e46e9a46
HG		 2456 .suite = {
2457 .aead = {
21c8e720 2458 .enc = __VECS(hmac_sha512_aes_cbc_enc_tv_temp)
5208ed2c
NL		 2459 }
2460 }
2461 }, {
a4198fd4 2462 .alg = "authenc(hmac(sha512),cbc(des))",
5208ed2c 2463 .test = alg_test_aead,
5208ed2c
NL		 2464 .suite = {
2465 .aead = {
21c8e720 2466 .enc = __VECS(hmac_sha512_des_cbc_enc_tv_temp)
5208ed2c
NL		 2467 }
2468 }
2469 }, {
a4198fd4 2470 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
5208ed2c 2471 .test = alg_test_aead,
ed1afac9 2472 .fips_allowed = 1,
5208ed2c
NL		 2473 .suite = {
2474 .aead = {
21c8e720 2475 .enc = __VECS(hmac_sha512_des3_ede_cbc_enc_tv_temp)
e46e9a46
HG		 2476 }
2477 }
fb16abc2
MM		 2478 }, {
2479 .alg = "authenc(hmac(sha512),ctr(aes))",
2480 .test = alg_test_null,
2481 .fips_allowed = 1,
8888690e
MM		 2482 }, {
2483 .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2484 .test = alg_test_null,
2485 .fips_allowed = 1,
e08ca2da 2486 }, {
da7f033d 2487 .alg = "cbc(aes)",
1aa4ecd9 2488 .test = alg_test_skcipher,
a1915d51 2489 .fips_allowed = 1,
da7f033d
HX		 2490 .suite = {
2491 .cipher = {
21c8e720
AB		 2492 .enc = __VECS(aes_cbc_enc_tv_template),
2493 .dec = __VECS(aes_cbc_dec_tv_template)
da7f033d
HX		 2494 }
2495 }
2496 }, {
2497 .alg = "cbc(anubis)",
1aa4ecd9 2498 .test = alg_test_skcipher,
da7f033d
HX		 2499 .suite = {
2500 .cipher = {
21c8e720
AB		 2501 .enc = __VECS(anubis_cbc_enc_tv_template),
2502 .dec = __VECS(anubis_cbc_dec_tv_template)
da7f033d
HX		 2503 }
2504 }
2505 }, {
2506 .alg = "cbc(blowfish)",
1aa4ecd9 2507 .test = alg_test_skcipher,
da7f033d
HX		 2508 .suite = {
2509 .cipher = {
21c8e720
AB		 2510 .enc = __VECS(bf_cbc_enc_tv_template),
2511 .dec = __VECS(bf_cbc_dec_tv_template)
da7f033d
HX		 2512 }
2513 }
2514 }, {
2515 .alg = "cbc(camellia)",
1aa4ecd9 2516 .test = alg_test_skcipher,
da7f033d
HX		 2517 .suite = {
2518 .cipher = {
21c8e720
AB		 2519 .enc = __VECS(camellia_cbc_enc_tv_template),
2520 .dec = __VECS(camellia_cbc_dec_tv_template)
da7f033d
HX		 2521 }
2522 }
a2c58260
JG		 2523 }, {
2524 .alg = "cbc(cast5)",
2525 .test = alg_test_skcipher,
2526 .suite = {
2527 .cipher = {
21c8e720
AB		 2528 .enc = __VECS(cast5_cbc_enc_tv_template),
2529 .dec = __VECS(cast5_cbc_dec_tv_template)
a2c58260
JG		 2530 }
2531 }
9b8b0405
JG		 2532 }, {
2533 .alg = "cbc(cast6)",
2534 .test = alg_test_skcipher,
2535 .suite = {
2536 .cipher = {
21c8e720
AB		 2537 .enc = __VECS(cast6_cbc_enc_tv_template),
2538 .dec = __VECS(cast6_cbc_dec_tv_template)
9b8b0405
JG		 2539 }
2540 }
da7f033d
HX		 2541 }, {
2542 .alg = "cbc(des)",
1aa4ecd9 2543 .test = alg_test_skcipher,
da7f033d
HX		 2544 .suite = {
2545 .cipher = {
21c8e720
AB		 2546 .enc = __VECS(des_cbc_enc_tv_template),
2547 .dec = __VECS(des_cbc_dec_tv_template)
da7f033d
HX		 2548 }
2549 }
2550 }, {
2551 .alg = "cbc(des3_ede)",
1aa4ecd9 2552 .test = alg_test_skcipher,
a1915d51 2553 .fips_allowed = 1,
da7f033d
HX		 2554 .suite = {
2555 .cipher = {
21c8e720
AB		 2556 .enc = __VECS(des3_ede_cbc_enc_tv_template),
2557 .dec = __VECS(des3_ede_cbc_dec_tv_template)
da7f033d
HX		 2558 }
2559 }
9d25917d
JK		 2560 }, {
2561 .alg = "cbc(serpent)",
2562 .test = alg_test_skcipher,
2563 .suite = {
2564 .cipher = {
21c8e720
AB		 2565 .enc = __VECS(serpent_cbc_enc_tv_template),
2566 .dec = __VECS(serpent_cbc_dec_tv_template)
9d25917d
JK		 2567 }
2568 }
da7f033d
HX		 2569 }, {
2570 .alg = "cbc(twofish)",
1aa4ecd9 2571 .test = alg_test_skcipher,
da7f033d
HX		 2572 .suite = {
2573 .cipher = {
21c8e720
AB		 2574 .enc = __VECS(tf_cbc_enc_tv_template),
2575 .dec = __VECS(tf_cbc_dec_tv_template)
da7f033d
HX		 2576 }
2577 }
092acf06
AB		 2578 }, {
2579 .alg = "cbcmac(aes)",
2580 .fips_allowed = 1,
2581 .test = alg_test_hash,
2582 .suite = {
2583 .hash = __VECS(aes_cbcmac_tv_template)
2584 }
da7f033d
HX		 2585 }, {
2586 .alg = "ccm(aes)",
2587 .test = alg_test_aead,
a1915d51 2588 .fips_allowed = 1,
da7f033d
HX		 2589 .suite = {
2590 .aead = {
21c8e720
AB		 2591 .enc = __VECS(aes_ccm_enc_tv_template),
2592 .dec = __VECS(aes_ccm_dec_tv_template)
da7f033d
HX		 2593 }
2594 }
3590ebf2
MW		 2595 }, {
2596 .alg = "chacha20",
2597 .test = alg_test_skcipher,
2598 .suite = {
2599 .cipher = {
21c8e720
AB		 2600 .enc = __VECS(chacha20_enc_tv_template),
2601 .dec = __VECS(chacha20_enc_tv_template),
3590ebf2
MW		 2602 }
2603 }
93b5e86a
JK		 2604 }, {
2605 .alg = "cmac(aes)",
8f183751 2606 .fips_allowed = 1,
93b5e86a
JK		 2607 .test = alg_test_hash,
2608 .suite = {
21c8e720 2609 .hash = __VECS(aes_cmac128_tv_template)
93b5e86a
JK		 2610 }
2611 }, {
2612 .alg = "cmac(des3_ede)",
8f183751 2613 .fips_allowed = 1,
93b5e86a
JK		 2614 .test = alg_test_hash,
2615 .suite = {
21c8e720 2616 .hash = __VECS(des3_ede_cmac64_tv_template)
93b5e86a 2617 }
e448370d
JK		 2618 }, {
2619 .alg = "compress_null",
2620 .test = alg_test_null,
ebb3472f
AB		 2621 }, {
2622 .alg = "crc32",
2623 .test = alg_test_hash,
2624 .suite = {
21c8e720 2625 .hash = __VECS(crc32_tv_template)
ebb3472f 2626 }
da7f033d
HX		 2627 }, {
2628 .alg = "crc32c",
8e3ee85e 2629 .test = alg_test_crc32c,
a1915d51 2630 .fips_allowed = 1,
da7f033d 2631 .suite = {
21c8e720 2632 .hash = __VECS(crc32c_tv_template)
da7f033d 2633 }
68411521
HX		 2634 }, {
2635 .alg = "crct10dif",
2636 .test = alg_test_hash,
2637 .fips_allowed = 1,
2638 .suite = {
21c8e720 2639 .hash = __VECS(crct10dif_tv_template)
68411521 2640 }
f7cb80f2
JW		 2641 }, {
2642 .alg = "ctr(aes)",
2643 .test = alg_test_skcipher,
a1915d51 2644 .fips_allowed = 1,
f7cb80f2
JW		 2645 .suite = {
2646 .cipher = {
21c8e720
AB		 2647 .enc = __VECS(aes_ctr_enc_tv_template),
2648 .dec = __VECS(aes_ctr_dec_tv_template)
f7cb80f2
JW		 2649 }
2650 }
85b63e34
JK		 2651 }, {
2652 .alg = "ctr(blowfish)",
2653 .test = alg_test_skcipher,
2654 .suite = {
2655 .cipher = {
21c8e720
AB		 2656 .enc = __VECS(bf_ctr_enc_tv_template),
2657 .dec = __VECS(bf_ctr_dec_tv_template)
85b63e34
JK		 2658 }
2659 }
0840605e
JK		 2660 }, {
2661 .alg = "ctr(camellia)",
2662 .test = alg_test_skcipher,
2663 .suite = {
2664 .cipher = {
21c8e720
AB		 2665 .enc = __VECS(camellia_ctr_enc_tv_template),
2666 .dec = __VECS(camellia_ctr_dec_tv_template)
0840605e
JK		 2667 }
2668 }
a2c58260
JG		 2669 }, {
2670 .alg = "ctr(cast5)",
2671 .test = alg_test_skcipher,
2672 .suite = {
2673 .cipher = {
21c8e720
AB		 2674 .enc = __VECS(cast5_ctr_enc_tv_template),
2675 .dec = __VECS(cast5_ctr_dec_tv_template)
a2c58260
JG		 2676 }
2677 }
9b8b0405
JG		 2678 }, {
2679 .alg = "ctr(cast6)",
2680 .test = alg_test_skcipher,
2681 .suite = {
2682 .cipher = {
21c8e720
AB		 2683 .enc = __VECS(cast6_ctr_enc_tv_template),
2684 .dec = __VECS(cast6_ctr_dec_tv_template)
9b8b0405
JG		 2685 }
2686 }
8163fc30
JK		 2687 }, {
2688 .alg = "ctr(des)",
2689 .test = alg_test_skcipher,
2690 .suite = {
2691 .cipher = {
21c8e720
AB		 2692 .enc = __VECS(des_ctr_enc_tv_template),
2693 .dec = __VECS(des_ctr_dec_tv_template)
8163fc30
JK		 2694 }
2695 }
e080b17a
JK		 2696 }, {
2697 .alg = "ctr(des3_ede)",
2698 .test = alg_test_skcipher,
0d8da104 2699 .fips_allowed = 1,
e080b17a
JK		 2700 .suite = {
2701 .cipher = {
21c8e720
AB		 2702 .enc = __VECS(des3_ede_ctr_enc_tv_template),
2703 .dec = __VECS(des3_ede_ctr_dec_tv_template)
e080b17a
JK		 2704 }
2705 }
9d25917d
JK		 2706 }, {
2707 .alg = "ctr(serpent)",
2708 .test = alg_test_skcipher,
2709 .suite = {
2710 .cipher = {
21c8e720
AB		 2711 .enc = __VECS(serpent_ctr_enc_tv_template),
2712 .dec = __VECS(serpent_ctr_dec_tv_template)
9d25917d
JK		 2713 }
2714 }
573da620
JK		 2715 }, {
2716 .alg = "ctr(twofish)",
2717 .test = alg_test_skcipher,
2718 .suite = {
2719 .cipher = {
21c8e720
AB		 2720 .enc = __VECS(tf_ctr_enc_tv_template),
2721 .dec = __VECS(tf_ctr_dec_tv_template)
573da620
JK		 2722 }
2723 }
da7f033d
HX		 2724 }, {
2725 .alg = "cts(cbc(aes))",
1aa4ecd9 2726 .test = alg_test_skcipher,
da7f033d
HX		 2727 .suite = {
2728 .cipher = {
21c8e720
AB		 2729 .enc = __VECS(cts_mode_enc_tv_template),
2730 .dec = __VECS(cts_mode_dec_tv_template)
da7f033d
HX		 2731 }
2732 }
2733 }, {
2734 .alg = "deflate",
2735 .test = alg_test_comp,
0818904d 2736 .fips_allowed = 1,
da7f033d
HX		 2737 .suite = {
2738 .comp = {
21c8e720
AB		 2739 .comp = __VECS(deflate_comp_tv_template),
2740 .decomp = __VECS(deflate_decomp_tv_template)
da7f033d
HX		 2741 }
2742 }
802c7f1c
SB		 2743 }, {
2744 .alg = "dh",
2745 .test = alg_test_kpp,
2746 .fips_allowed = 1,
2747 .suite = {
21c8e720 2748 .kpp = __VECS(dh_tv_template)
802c7f1c 2749 }
e448370d
JK		 2750 }, {
2751 .alg = "digest_null",
2752 .test = alg_test_null,
64d1cdfb
SM		 2753 }, {
2754 .alg = "drbg_nopr_ctr_aes128",
2755 .test = alg_test_drbg,
2756 .fips_allowed = 1,
2757 .suite = {
21c8e720 2758 .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template)
64d1cdfb
SM		 2759 }
2760 }, {
2761 .alg = "drbg_nopr_ctr_aes192",
2762 .test = alg_test_drbg,
2763 .fips_allowed = 1,
2764 .suite = {
21c8e720 2765 .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template)
64d1cdfb
SM		 2766 }
2767 }, {
2768 .alg = "drbg_nopr_ctr_aes256",
2769 .test = alg_test_drbg,
2770 .fips_allowed = 1,
2771 .suite = {
21c8e720 2772 .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template)
64d1cdfb
SM		 2773 }
2774 }, {
2775 /*
2776 * There is no need to specifically test the DRBG with every
2777 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2778 */
2779 .alg = "drbg_nopr_hmac_sha1",
2780 .fips_allowed = 1,
2781 .test = alg_test_null,
2782 }, {
2783 .alg = "drbg_nopr_hmac_sha256",
2784 .test = alg_test_drbg,
2785 .fips_allowed = 1,
2786 .suite = {
21c8e720 2787 .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template)
64d1cdfb
SM		 2788 }
2789 }, {
2790 /* covered by drbg_nopr_hmac_sha256 test */
2791 .alg = "drbg_nopr_hmac_sha384",
2792 .fips_allowed = 1,
2793 .test = alg_test_null,
2794 }, {
2795 .alg = "drbg_nopr_hmac_sha512",
2796 .test = alg_test_null,
2797 .fips_allowed = 1,
2798 }, {
2799 .alg = "drbg_nopr_sha1",
2800 .fips_allowed = 1,
2801 .test = alg_test_null,
2802 }, {
2803 .alg = "drbg_nopr_sha256",
2804 .test = alg_test_drbg,
2805 .fips_allowed = 1,
2806 .suite = {
21c8e720 2807 .drbg = __VECS(drbg_nopr_sha256_tv_template)
64d1cdfb
SM		 2808 }
2809 }, {
2810 /* covered by drbg_nopr_sha256 test */
2811 .alg = "drbg_nopr_sha384",
2812 .fips_allowed = 1,
2813 .test = alg_test_null,
2814 }, {
2815 .alg = "drbg_nopr_sha512",
2816 .fips_allowed = 1,
2817 .test = alg_test_null,
2818 }, {
2819 .alg = "drbg_pr_ctr_aes128",
2820 .test = alg_test_drbg,
2821 .fips_allowed = 1,
2822 .suite = {
21c8e720 2823 .drbg = __VECS(drbg_pr_ctr_aes128_tv_template)
64d1cdfb
SM		 2824 }
2825 }, {
2826 /* covered by drbg_pr_ctr_aes128 test */
2827 .alg = "drbg_pr_ctr_aes192",
2828 .fips_allowed = 1,
2829 .test = alg_test_null,
2830 }, {
2831 .alg = "drbg_pr_ctr_aes256",
2832 .fips_allowed = 1,
2833 .test = alg_test_null,
2834 }, {
2835 .alg = "drbg_pr_hmac_sha1",
2836 .fips_allowed = 1,
2837 .test = alg_test_null,
2838 }, {
2839 .alg = "drbg_pr_hmac_sha256",
2840 .test = alg_test_drbg,
2841 .fips_allowed = 1,
2842 .suite = {
21c8e720 2843 .drbg = __VECS(drbg_pr_hmac_sha256_tv_template)
64d1cdfb
SM		 2844 }
2845 }, {
2846 /* covered by drbg_pr_hmac_sha256 test */
2847 .alg = "drbg_pr_hmac_sha384",
2848 .fips_allowed = 1,
2849 .test = alg_test_null,
2850 }, {
2851 .alg = "drbg_pr_hmac_sha512",
2852 .test = alg_test_null,
2853 .fips_allowed = 1,
2854 }, {
2855 .alg = "drbg_pr_sha1",
2856 .fips_allowed = 1,
2857 .test = alg_test_null,
2858 }, {
2859 .alg = "drbg_pr_sha256",
2860 .test = alg_test_drbg,
2861 .fips_allowed = 1,
2862 .suite = {
21c8e720 2863 .drbg = __VECS(drbg_pr_sha256_tv_template)
64d1cdfb
SM		 2864 }
2865 }, {
2866 /* covered by drbg_pr_sha256 test */
2867 .alg = "drbg_pr_sha384",
2868 .fips_allowed = 1,
2869 .test = alg_test_null,
2870 }, {
2871 .alg = "drbg_pr_sha512",
2872 .fips_allowed = 1,
2873 .test = alg_test_null,
da7f033d
HX		 2874 }, {
2875 .alg = "ecb(aes)",
1aa4ecd9 2876 .test = alg_test_skcipher,
a1915d51 2877 .fips_allowed = 1,
da7f033d
HX		 2878 .suite = {
2879 .cipher = {
21c8e720
AB		 2880 .enc = __VECS(aes_enc_tv_template),
2881 .dec = __VECS(aes_dec_tv_template)
da7f033d
HX		 2882 }
2883 }
2884 }, {
2885 .alg = "ecb(anubis)",
1aa4ecd9 2886 .test = alg_test_skcipher,
da7f033d
HX		 2887 .suite = {
2888 .cipher = {
21c8e720
AB		 2889 .enc = __VECS(anubis_enc_tv_template),
2890 .dec = __VECS(anubis_dec_tv_template)
da7f033d
HX		 2891 }
2892 }
2893 }, {
2894 .alg = "ecb(arc4)",
1aa4ecd9 2895 .test = alg_test_skcipher,
da7f033d
HX		 2896 .suite = {
2897 .cipher = {
21c8e720
AB		 2898 .enc = __VECS(arc4_enc_tv_template),
2899 .dec = __VECS(arc4_dec_tv_template)
da7f033d
HX		 2900 }
2901 }
2902 }, {
2903 .alg = "ecb(blowfish)",
1aa4ecd9 2904 .test = alg_test_skcipher,
da7f033d
HX		 2905 .suite = {
2906 .cipher = {
21c8e720
AB		 2907 .enc = __VECS(bf_enc_tv_template),
2908 .dec = __VECS(bf_dec_tv_template)
da7f033d
HX		 2909 }
2910 }
2911 }, {
2912 .alg = "ecb(camellia)",
1aa4ecd9 2913 .test = alg_test_skcipher,
da7f033d
HX		 2914 .suite = {
2915 .cipher = {
21c8e720
AB		 2916 .enc = __VECS(camellia_enc_tv_template),
2917 .dec = __VECS(camellia_dec_tv_template)
da7f033d
HX		 2918 }
2919 }
2920 }, {
2921 .alg = "ecb(cast5)",
1aa4ecd9 2922 .test = alg_test_skcipher,
da7f033d
HX		 2923 .suite = {
2924 .cipher = {
21c8e720
AB		 2925 .enc = __VECS(cast5_enc_tv_template),
2926 .dec = __VECS(cast5_dec_tv_template)
da7f033d
HX		 2927 }
2928 }
2929 }, {
2930 .alg = "ecb(cast6)",
1aa4ecd9 2931 .test = alg_test_skcipher,
da7f033d
HX		 2932 .suite = {
2933 .cipher = {
21c8e720
AB		 2934 .enc = __VECS(cast6_enc_tv_template),
2935 .dec = __VECS(cast6_dec_tv_template)
da7f033d
HX		 2936 }
2937 }
e448370d
JK		 2938 }, {
2939 .alg = "ecb(cipher_null)",
2940 .test = alg_test_null,
6175ca2b 2941 .fips_allowed = 1,
da7f033d
HX		 2942 }, {
2943 .alg = "ecb(des)",
1aa4ecd9 2944 .test = alg_test_skcipher,
da7f033d
HX		 2945 .suite = {
2946 .cipher = {
21c8e720
AB		 2947 .enc = __VECS(des_enc_tv_template),
2948 .dec = __VECS(des_dec_tv_template)
da7f033d
HX		 2949 }
2950 }
2951 }, {
2952 .alg = "ecb(des3_ede)",
1aa4ecd9 2953 .test = alg_test_skcipher,
a1915d51 2954 .fips_allowed = 1,
da7f033d
HX		 2955 .suite = {
2956 .cipher = {
21c8e720
AB		 2957 .enc = __VECS(des3_ede_enc_tv_template),
2958 .dec = __VECS(des3_ede_dec_tv_template)
da7f033d
HX		 2959 }
2960 }
66e5bd00
JK		 2961 }, {
2962 .alg = "ecb(fcrypt)",
2963 .test = alg_test_skcipher,
2964 .suite = {
2965 .cipher = {
2966 .enc = {
2967 .vecs = fcrypt_pcbc_enc_tv_template,
2968 .count = 1
2969 },
2970 .dec = {
2971 .vecs = fcrypt_pcbc_dec_tv_template,
2972 .count = 1
2973 }
2974 }
2975 }
da7f033d
HX		 2976 }, {
2977 .alg = "ecb(khazad)",
1aa4ecd9 2978 .test = alg_test_skcipher,
da7f033d
HX		 2979 .suite = {
2980 .cipher = {
21c8e720
AB		 2981 .enc = __VECS(khazad_enc_tv_template),
2982 .dec = __VECS(khazad_dec_tv_template)
da7f033d
HX		 2983 }
2984 }
2985 }, {
2986 .alg = "ecb(seed)",
1aa4ecd9 2987 .test = alg_test_skcipher,
da7f033d
HX		 2988 .suite = {
2989 .cipher = {
21c8e720
AB		 2990 .enc = __VECS(seed_enc_tv_template),
2991 .dec = __VECS(seed_dec_tv_template)
da7f033d
HX		 2992 }
2993 }
2994 }, {
2995 .alg = "ecb(serpent)",
1aa4ecd9 2996 .test = alg_test_skcipher,
da7f033d
HX		 2997 .suite = {
2998 .cipher = {
21c8e720
AB		 2999 .enc = __VECS(serpent_enc_tv_template),
3000 .dec = __VECS(serpent_dec_tv_template)
da7f033d
HX		 3001 }
3002 }
da7a0ab5
EB		 3003 }, {
3004 .alg = "ecb(speck128)",
3005 .test = alg_test_skcipher,
3006 .suite = {
3007 .cipher = {
3008 .enc = __VECS(speck128_enc_tv_template),
3009 .dec = __VECS(speck128_dec_tv_template)
3010 }
3011 }
3012 }, {
3013 .alg = "ecb(speck64)",
3014 .test = alg_test_skcipher,
3015 .suite = {
3016 .cipher = {
3017 .enc = __VECS(speck64_enc_tv_template),
3018 .dec = __VECS(speck64_dec_tv_template)
3019 }
3020 }
da7f033d
HX		 3021 }, {
3022 .alg = "ecb(tea)",
1aa4ecd9 3023 .test = alg_test_skcipher,
da7f033d
HX		 3024 .suite = {
3025 .cipher = {
21c8e720
AB		 3026 .enc = __VECS(tea_enc_tv_template),
3027 .dec = __VECS(tea_dec_tv_template)
da7f033d
HX		 3028 }
3029 }
3030 }, {
3031 .alg = "ecb(tnepres)",
1aa4ecd9 3032 .test = alg_test_skcipher,
da7f033d
HX		 3033 .suite = {
3034 .cipher = {
21c8e720
AB		 3035 .enc = __VECS(tnepres_enc_tv_template),
3036 .dec = __VECS(tnepres_dec_tv_template)
da7f033d
HX		 3037 }
3038 }
3039 }, {
3040 .alg = "ecb(twofish)",
1aa4ecd9 3041 .test = alg_test_skcipher,
da7f033d
HX		 3042 .suite = {
3043 .cipher = {
21c8e720
AB		 3044 .enc = __VECS(tf_enc_tv_template),
3045 .dec = __VECS(tf_dec_tv_template)
da7f033d
HX		 3046 }
3047 }
3048 }, {
3049 .alg = "ecb(xeta)",
1aa4ecd9 3050 .test = alg_test_skcipher,
da7f033d
HX		 3051 .suite = {
3052 .cipher = {
21c8e720
AB		 3053 .enc = __VECS(xeta_enc_tv_template),
3054 .dec = __VECS(xeta_dec_tv_template)
da7f033d
HX		 3055 }
3056 }
3057 }, {
3058 .alg = "ecb(xtea)",
1aa4ecd9 3059 .test = alg_test_skcipher,
da7f033d
HX		 3060 .suite = {
3061 .cipher = {
21c8e720
AB		 3062 .enc = __VECS(xtea_enc_tv_template),
3063 .dec = __VECS(xtea_dec_tv_template)
da7f033d
HX		 3064 }
3065 }
3c4b2390
SB		 3066 }, {
3067 .alg = "ecdh",
3068 .test = alg_test_kpp,
3069 .fips_allowed = 1,
3070 .suite = {
21c8e720 3071 .kpp = __VECS(ecdh_tv_template)
3c4b2390 3072 }
da7f033d
HX		 3073 }, {
3074 .alg = "gcm(aes)",
3075 .test = alg_test_aead,
a1915d51 3076 .fips_allowed = 1,
da7f033d
HX		 3077 .suite = {
3078 .aead = {
21c8e720
AB		 3079 .enc = __VECS(aes_gcm_enc_tv_template),
3080 .dec = __VECS(aes_gcm_dec_tv_template)
da7f033d
HX		 3081 }
3082 }
507069c9
YS		 3083 }, {
3084 .alg = "ghash",
3085 .test = alg_test_hash,
18c0ebd2 3086 .fips_allowed = 1,
507069c9 3087 .suite = {
21c8e720 3088 .hash = __VECS(ghash_tv_template)
507069c9 3089 }
a482b081
SZ		 3090 }, {
3091 .alg = "hmac(crc32)",
3092 .test = alg_test_hash,
3093 .suite = {
21c8e720 3094 .hash = __VECS(bfin_crc_tv_template)
a482b081 3095 }
da7f033d
HX		 3096 }, {
3097 .alg = "hmac(md5)",
3098 .test = alg_test_hash,
3099 .suite = {
21c8e720 3100 .hash = __VECS(hmac_md5_tv_template)
da7f033d
HX		 3101 }
3102 }, {
3103 .alg = "hmac(rmd128)",
3104 .test = alg_test_hash,
3105 .suite = {
21c8e720 3106 .hash = __VECS(hmac_rmd128_tv_template)
da7f033d
HX		 3107 }
3108 }, {
3109 .alg = "hmac(rmd160)",
3110 .test = alg_test_hash,
3111 .suite = {
21c8e720 3112 .hash = __VECS(hmac_rmd160_tv_template)
da7f033d
HX		 3113 }
3114 }, {
3115 .alg = "hmac(sha1)",
3116 .test = alg_test_hash,
a1915d51 3117 .fips_allowed = 1,
da7f033d 3118 .suite = {
21c8e720 3119 .hash = __VECS(hmac_sha1_tv_template)
da7f033d
HX		 3120 }
3121 }, {
3122 .alg = "hmac(sha224)",
3123 .test = alg_test_hash,
a1915d51 3124 .fips_allowed = 1,
da7f033d 3125 .suite = {
21c8e720 3126 .hash = __VECS(hmac_sha224_tv_template)
da7f033d
HX		 3127 }
3128 }, {
3129 .alg = "hmac(sha256)",
3130 .test = alg_test_hash,
a1915d51 3131 .fips_allowed = 1,
da7f033d 3132 .suite = {
21c8e720 3133 .hash = __VECS(hmac_sha256_tv_template)
da7f033d 3134 }
98eca72f 3135 }, {
3136 .alg = "hmac(sha3-224)",
3137 .test = alg_test_hash,
3138 .fips_allowed = 1,
3139 .suite = {
21c8e720 3140 .hash = __VECS(hmac_sha3_224_tv_template)
98eca72f 3141 }
3142 }, {
3143 .alg = "hmac(sha3-256)",
3144 .test = alg_test_hash,
3145 .fips_allowed = 1,
3146 .suite = {
21c8e720 3147 .hash = __VECS(hmac_sha3_256_tv_template)
98eca72f 3148 }
3149 }, {
3150 .alg = "hmac(sha3-384)",
3151 .test = alg_test_hash,
3152 .fips_allowed = 1,
3153 .suite = {
21c8e720 3154 .hash = __VECS(hmac_sha3_384_tv_template)
98eca72f 3155 }
3156 }, {
3157 .alg = "hmac(sha3-512)",
3158 .test = alg_test_hash,
3159 .fips_allowed = 1,
3160 .suite = {
21c8e720 3161 .hash = __VECS(hmac_sha3_512_tv_template)
98eca72f 3162 }
da7f033d
HX		 3163 }, {
3164 .alg = "hmac(sha384)",
3165 .test = alg_test_hash,
a1915d51 3166 .fips_allowed = 1,
da7f033d 3167 .suite = {
21c8e720 3168 .hash = __VECS(hmac_sha384_tv_template)
da7f033d
HX		 3169 }
3170 }, {
3171 .alg = "hmac(sha512)",
3172 .test = alg_test_hash,
a1915d51 3173 .fips_allowed = 1,
da7f033d 3174 .suite = {
21c8e720 3175 .hash = __VECS(hmac_sha512_tv_template)
da7f033d 3176 }
bb5530e4
SM		 3177 }, {
3178 .alg = "jitterentropy_rng",
3179 .fips_allowed = 1,
3180 .test = alg_test_null,
35351988
SM		 3181 }, {
3182 .alg = "kw(aes)",
3183 .test = alg_test_skcipher,
3184 .fips_allowed = 1,
3185 .suite = {
3186 .cipher = {
21c8e720
AB		 3187 .enc = __VECS(aes_kw_enc_tv_template),
3188 .dec = __VECS(aes_kw_dec_tv_template)
35351988
SM		 3189 }
3190 }
da7f033d
HX		 3191 }, {
3192 .alg = "lrw(aes)",
1aa4ecd9 3193 .test = alg_test_skcipher,
da7f033d
HX		 3194 .suite = {
3195 .cipher = {
21c8e720
AB		 3196 .enc = __VECS(aes_lrw_enc_tv_template),
3197 .dec = __VECS(aes_lrw_dec_tv_template)
da7f033d
HX		 3198 }
3199 }
0840605e
JK		 3200 }, {
3201 .alg = "lrw(camellia)",
3202 .test = alg_test_skcipher,
3203 .suite = {
3204 .cipher = {
21c8e720
AB		 3205 .enc = __VECS(camellia_lrw_enc_tv_template),
3206 .dec = __VECS(camellia_lrw_dec_tv_template)
0840605e
JK		 3207 }
3208 }
9b8b0405
JG		 3209 }, {
3210 .alg = "lrw(cast6)",
3211 .test = alg_test_skcipher,
3212 .suite = {
3213 .cipher = {
21c8e720
AB		 3214 .enc = __VECS(cast6_lrw_enc_tv_template),
3215 .dec = __VECS(cast6_lrw_dec_tv_template)
9b8b0405
JG		 3216 }
3217 }
d7bfc0fa
JK		 3218 }, {
3219 .alg = "lrw(serpent)",
3220 .test = alg_test_skcipher,
3221 .suite = {
3222 .cipher = {
21c8e720
AB		 3223 .enc = __VECS(serpent_lrw_enc_tv_template),
3224 .dec = __VECS(serpent_lrw_dec_tv_template)
d7bfc0fa
JK		 3225 }
3226 }
0b2a1551
JK		 3227 }, {
3228 .alg = "lrw(twofish)",
3229 .test = alg_test_skcipher,
3230 .suite = {
3231 .cipher = {
21c8e720
AB		 3232 .enc = __VECS(tf_lrw_enc_tv_template),
3233 .dec = __VECS(tf_lrw_dec_tv_template)
0b2a1551
JK		 3234 }
3235 }
1443cc9b
KK		 3236 }, {
3237 .alg = "lz4",
3238 .test = alg_test_comp,
3239 .fips_allowed = 1,
3240 .suite = {
3241 .comp = {
21c8e720
AB		 3242 .comp = __VECS(lz4_comp_tv_template),
3243 .decomp = __VECS(lz4_decomp_tv_template)
1443cc9b
KK		 3244 }
3245 }
3246 }, {
3247 .alg = "lz4hc",
3248 .test = alg_test_comp,
3249 .fips_allowed = 1,
3250 .suite = {
3251 .comp = {
21c8e720
AB		 3252 .comp = __VECS(lz4hc_comp_tv_template),
3253 .decomp = __VECS(lz4hc_decomp_tv_template)
1443cc9b
KK		 3254 }
3255 }
da7f033d
HX		 3256 }, {
3257 .alg = "lzo",
3258 .test = alg_test_comp,
0818904d 3259 .fips_allowed = 1,
da7f033d
HX		 3260 .suite = {
3261 .comp = {
21c8e720
AB		 3262 .comp = __VECS(lzo_comp_tv_template),
3263 .decomp = __VECS(lzo_decomp_tv_template)
da7f033d
HX		 3264 }
3265 }
3266 }, {
3267 .alg = "md4",
3268 .test = alg_test_hash,
3269 .suite = {
21c8e720 3270 .hash = __VECS(md4_tv_template)
da7f033d
HX		 3271 }
3272 }, {
3273 .alg = "md5",
3274 .test = alg_test_hash,
3275 .suite = {
21c8e720 3276 .hash = __VECS(md5_tv_template)
da7f033d
HX		 3277 }
3278 }, {
3279 .alg = "michael_mic",
3280 .test = alg_test_hash,
3281 .suite = {
21c8e720 3282 .hash = __VECS(michael_mic_tv_template)
da7f033d 3283 }
ba0e14ac
PS		 3284 }, {
3285 .alg = "ofb(aes)",
3286 .test = alg_test_skcipher,
3287 .fips_allowed = 1,
3288 .suite = {
3289 .cipher = {
21c8e720
AB		 3290 .enc = __VECS(aes_ofb_enc_tv_template),
3291 .dec = __VECS(aes_ofb_dec_tv_template)
ba0e14ac
PS		 3292 }
3293 }
da7f033d
HX		 3294 }, {
3295 .alg = "pcbc(fcrypt)",
1aa4ecd9 3296 .test = alg_test_skcipher,
da7f033d
HX		 3297 .suite = {
3298 .cipher = {
21c8e720
AB		 3299 .enc = __VECS(fcrypt_pcbc_enc_tv_template),
3300 .dec = __VECS(fcrypt_pcbc_dec_tv_template)
da7f033d
HX		 3301 }
3302 }
1207107c
SM		 3303 }, {
3304 .alg = "pkcs1pad(rsa,sha224)",
3305 .test = alg_test_null,
3306 .fips_allowed = 1,
3307 }, {
3308 .alg = "pkcs1pad(rsa,sha256)",
3309 .test = alg_test_akcipher,
3310 .fips_allowed = 1,
3311 .suite = {
3312 .akcipher = __VECS(pkcs1pad_rsa_tv_template)
3313 }
3314 }, {
3315 .alg = "pkcs1pad(rsa,sha384)",
3316 .test = alg_test_null,
3317 .fips_allowed = 1,
3318 }, {
3319 .alg = "pkcs1pad(rsa,sha512)",
3320 .test = alg_test_null,
3321 .fips_allowed = 1,
eee9dc61
MW		 3322 }, {
3323 .alg = "poly1305",
3324 .test = alg_test_hash,
3325 .suite = {
21c8e720 3326 .hash = __VECS(poly1305_tv_template)
eee9dc61 3327 }
da7f033d
HX		 3328 }, {
3329 .alg = "rfc3686(ctr(aes))",
1aa4ecd9 3330 .test = alg_test_skcipher,
a1915d51 3331 .fips_allowed = 1,
da7f033d
HX		 3332 .suite = {
3333 .cipher = {
21c8e720
AB		 3334 .enc = __VECS(aes_ctr_rfc3686_enc_tv_template),
3335 .dec = __VECS(aes_ctr_rfc3686_dec_tv_template)
da7f033d
HX		 3336 }
3337 }
5d667322 3338 }, {
3f31a740 3339 .alg = "rfc4106(gcm(aes))",
69435b94 3340 .test = alg_test_aead,
db71f29a 3341 .fips_allowed = 1,
69435b94
AH		 3342 .suite = {
3343 .aead = {
21c8e720
AB		 3344 .enc = __VECS(aes_gcm_rfc4106_enc_tv_template),
3345 .dec = __VECS(aes_gcm_rfc4106_dec_tv_template)
69435b94
AH		 3346 }
3347 }
3348 }, {
544c436a 3349 .alg = "rfc4309(ccm(aes))",
5d667322 3350 .test = alg_test_aead,
a1915d51 3351 .fips_allowed = 1,
5d667322
JW		 3352 .suite = {
3353 .aead = {
21c8e720
AB		 3354 .enc = __VECS(aes_ccm_rfc4309_enc_tv_template),
3355 .dec = __VECS(aes_ccm_rfc4309_dec_tv_template)
5d667322
JW		 3356 }
3357 }
e9b7441a 3358 }, {
bb68745e 3359 .alg = "rfc4543(gcm(aes))",
e9b7441a
JK		 3360 .test = alg_test_aead,
3361 .suite = {
3362 .aead = {
21c8e720
AB		 3363 .enc = __VECS(aes_gcm_rfc4543_enc_tv_template),
3364 .dec = __VECS(aes_gcm_rfc4543_dec_tv_template),
e9b7441a
JK		 3365 }
3366 }
af2b76b5
MW		 3367 }, {
3368 .alg = "rfc7539(chacha20,poly1305)",
3369 .test = alg_test_aead,
3370 .suite = {
3371 .aead = {
21c8e720
AB		 3372 .enc = __VECS(rfc7539_enc_tv_template),
3373 .dec = __VECS(rfc7539_dec_tv_template),
af2b76b5
MW		 3374 }
3375 }
5900758d
MW		 3376 }, {
3377 .alg = "rfc7539esp(chacha20,poly1305)",
3378 .test = alg_test_aead,
3379 .suite = {
3380 .aead = {
21c8e720
AB		 3381 .enc = __VECS(rfc7539esp_enc_tv_template),
3382 .dec = __VECS(rfc7539esp_dec_tv_template),
5900758d
MW		 3383 }
3384 }
da7f033d
HX		 3385 }, {
3386 .alg = "rmd128",
3387 .test = alg_test_hash,
3388 .suite = {
21c8e720 3389 .hash = __VECS(rmd128_tv_template)
da7f033d
HX		 3390 }
3391 }, {
3392 .alg = "rmd160",
3393 .test = alg_test_hash,
3394 .suite = {
21c8e720 3395 .hash = __VECS(rmd160_tv_template)
da7f033d
HX		 3396 }
3397 }, {
3398 .alg = "rmd256",
3399 .test = alg_test_hash,
3400 .suite = {
21c8e720 3401 .hash = __VECS(rmd256_tv_template)
da7f033d
HX		 3402 }
3403 }, {
3404 .alg = "rmd320",
3405 .test = alg_test_hash,
3406 .suite = {
21c8e720 3407 .hash = __VECS(rmd320_tv_template)
da7f033d 3408 }
946cc463
TS		 3409 }, {
3410 .alg = "rsa",
3411 .test = alg_test_akcipher,
3412 .fips_allowed = 1,
3413 .suite = {
21c8e720 3414 .akcipher = __VECS(rsa_tv_template)
946cc463 3415 }
da7f033d
HX		 3416 }, {
3417 .alg = "salsa20",
1aa4ecd9 3418 .test = alg_test_skcipher,
da7f033d
HX		 3419 .suite = {
3420 .cipher = {
21c8e720 3421 .enc = __VECS(salsa20_stream_enc_tv_template)
da7f033d
HX		 3422 }
3423 }
3424 }, {
3425 .alg = "sha1",
3426 .test = alg_test_hash,
a1915d51 3427 .fips_allowed = 1,
da7f033d 3428 .suite = {
21c8e720 3429 .hash = __VECS(sha1_tv_template)
da7f033d
HX		 3430 }
3431 }, {
3432 .alg = "sha224",
3433 .test = alg_test_hash,
a1915d51 3434 .fips_allowed = 1,
da7f033d 3435 .suite = {
21c8e720 3436 .hash = __VECS(sha224_tv_template)
da7f033d
HX		 3437 }
3438 }, {
3439 .alg = "sha256",
3440 .test = alg_test_hash,
a1915d51 3441 .fips_allowed = 1,
da7f033d 3442 .suite = {
21c8e720 3443 .hash = __VECS(sha256_tv_template)
da7f033d 3444 }
79cc6ab8 3445 }, {
3446 .alg = "sha3-224",
3447 .test = alg_test_hash,
3448 .fips_allowed = 1,
3449 .suite = {
21c8e720 3450 .hash = __VECS(sha3_224_tv_template)
79cc6ab8 3451 }
3452 }, {
3453 .alg = "sha3-256",
3454 .test = alg_test_hash,
3455 .fips_allowed = 1,
3456 .suite = {
21c8e720 3457 .hash = __VECS(sha3_256_tv_template)
79cc6ab8 3458 }
3459 }, {
3460 .alg = "sha3-384",
3461 .test = alg_test_hash,
3462 .fips_allowed = 1,
3463 .suite = {
21c8e720 3464 .hash = __VECS(sha3_384_tv_template)
79cc6ab8 3465 }
3466 }, {
3467 .alg = "sha3-512",
3468 .test = alg_test_hash,
3469 .fips_allowed = 1,
3470 .suite = {
21c8e720 3471 .hash = __VECS(sha3_512_tv_template)
79cc6ab8 3472 }
da7f033d
HX		 3473 }, {
3474 .alg = "sha384",
3475 .test = alg_test_hash,
a1915d51 3476 .fips_allowed = 1,
da7f033d 3477 .suite = {
21c8e720 3478 .hash = __VECS(sha384_tv_template)
da7f033d
HX		 3479 }
3480 }, {
3481 .alg = "sha512",
3482 .test = alg_test_hash,
a1915d51 3483 .fips_allowed = 1,
da7f033d 3484 .suite = {
21c8e720 3485 .hash = __VECS(sha512_tv_template)
da7f033d 3486 }
b7e27530
GBY		 3487 }, {
3488 .alg = "sm3",
3489 .test = alg_test_hash,
3490 .suite = {
3491 .hash = __VECS(sm3_tv_template)
3492 }
da7f033d
HX		 3493 }, {
3494 .alg = "tgr128",
3495 .test = alg_test_hash,
3496 .suite = {
21c8e720 3497 .hash = __VECS(tgr128_tv_template)
da7f033d
HX		 3498 }
3499 }, {
3500 .alg = "tgr160",
3501 .test = alg_test_hash,
3502 .suite = {
21c8e720 3503 .hash = __VECS(tgr160_tv_template)
da7f033d
HX		 3504 }
3505 }, {
3506 .alg = "tgr192",
3507 .test = alg_test_hash,
3508 .suite = {
21c8e720 3509 .hash = __VECS(tgr192_tv_template)
da7f033d 3510 }
f1939f7c
SW		 3511 }, {
3512 .alg = "vmac(aes)",
3513 .test = alg_test_hash,
3514 .suite = {
21c8e720 3515 .hash = __VECS(aes_vmac128_tv_template)
f1939f7c 3516 }
da7f033d
HX		 3517 }, {
3518 .alg = "wp256",
3519 .test = alg_test_hash,
3520 .suite = {
21c8e720 3521 .hash = __VECS(wp256_tv_template)
da7f033d
HX		 3522 }
3523 }, {
3524 .alg = "wp384",
3525 .test = alg_test_hash,
3526 .suite = {
21c8e720 3527 .hash = __VECS(wp384_tv_template)
da7f033d
HX		 3528 }
3529 }, {
3530 .alg = "wp512",
3531 .test = alg_test_hash,
3532 .suite = {
21c8e720 3533 .hash = __VECS(wp512_tv_template)
da7f033d
HX		 3534 }
3535 }, {
3536 .alg = "xcbc(aes)",
3537 .test = alg_test_hash,
3538 .suite = {
21c8e720 3539 .hash = __VECS(aes_xcbc128_tv_template)
da7f033d
HX		 3540 }
3541 }, {
3542 .alg = "xts(aes)",
1aa4ecd9 3543 .test = alg_test_skcipher,
2918aa8d 3544 .fips_allowed = 1,
da7f033d
HX		 3545 .suite = {
3546 .cipher = {
21c8e720
AB		 3547 .enc = __VECS(aes_xts_enc_tv_template),
3548 .dec = __VECS(aes_xts_dec_tv_template)
da7f033d
HX		 3549 }
3550 }
0840605e
JK		 3551 }, {
3552 .alg = "xts(camellia)",
3553 .test = alg_test_skcipher,
3554 .suite = {
3555 .cipher = {
21c8e720
AB		 3556 .enc = __VECS(camellia_xts_enc_tv_template),
3557 .dec = __VECS(camellia_xts_dec_tv_template)
0840605e
JK		 3558 }
3559 }
9b8b0405
JG		 3560 }, {
3561 .alg = "xts(cast6)",
3562 .test = alg_test_skcipher,
3563 .suite = {
3564 .cipher = {
21c8e720
AB		 3565 .enc = __VECS(cast6_xts_enc_tv_template),
3566 .dec = __VECS(cast6_xts_dec_tv_template)
9b8b0405
JG		 3567 }
3568 }
18be20b9
JK		 3569 }, {
3570 .alg = "xts(serpent)",
3571 .test = alg_test_skcipher,
3572 .suite = {
3573 .cipher = {
21c8e720
AB		 3574 .enc = __VECS(serpent_xts_enc_tv_template),
3575 .dec = __VECS(serpent_xts_dec_tv_template)
18be20b9
JK		 3576 }
3577 }
c3bb521b
EB		 3578 }, {
3579 .alg = "xts(speck128)",
3580 .test = alg_test_skcipher,
3581 .suite = {
3582 .cipher = {
3583 .enc = __VECS(speck128_xts_enc_tv_template),
3584 .dec = __VECS(speck128_xts_dec_tv_template)
3585 }
3586 }
41b3316e
EB		 3587 }, {
3588 .alg = "xts(speck64)",
3589 .test = alg_test_skcipher,
3590 .suite = {
3591 .cipher = {
3592 .enc = __VECS(speck64_xts_enc_tv_template),
3593 .dec = __VECS(speck64_xts_dec_tv_template)
3594 }
3595 }
aed265b9
JK		 3596 }, {
3597 .alg = "xts(twofish)",
3598 .test = alg_test_skcipher,
3599 .suite = {
3600 .cipher = {
21c8e720
AB		 3601 .enc = __VECS(tf_xts_enc_tv_template),
3602 .dec = __VECS(tf_xts_dec_tv_template)
aed265b9
JK		 3603 }
3604 }
a368f43d
GC		 3605 }, {
3606 .alg = "zlib-deflate",
3607 .test = alg_test_comp,
3608 .fips_allowed = 1,
3609 .suite = {
3610 .comp = {
3611 .comp = __VECS(zlib_deflate_comp_tv_template),
3612 .decomp = __VECS(zlib_deflate_decomp_tv_template)
3613 }
3614 }
da7f033d
HX		 3615 }
3616};
3617
5714758b
JK		 3618static bool alg_test_descs_checked;
3619
3620static void alg_test_descs_check_order(void)
3621{
3622 int i;
3623
3624 /* only check once */
3625 if (alg_test_descs_checked)
3626 return;
3627
3628 alg_test_descs_checked = true;
3629
3630 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3631 int diff = strcmp(alg_test_descs[i - 1].alg,
3632 alg_test_descs[i].alg);
3633
3634 if (WARN_ON(diff > 0)) {
3635 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3636 alg_test_descs[i - 1].alg,
3637 alg_test_descs[i].alg);
3638 }
3639
3640 if (WARN_ON(diff == 0)) {
3641 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3642 alg_test_descs[i].alg);
3643 }
3644 }
3645}
3646
1aa4ecd9 3647static int alg_find_test(const char *alg)
da7f033d
HX		 3648{
3649 int start = 0;
3650 int end = ARRAY_SIZE(alg_test_descs);
3651
3652 while (start < end) {
3653 int i = (start + end) / 2;
3654 int diff = strcmp(alg_test_descs[i].alg, alg);
3655
3656 if (diff > 0) {
3657 end = i;
3658 continue;
3659 }
3660
3661 if (diff < 0) {
3662 start = i + 1;
3663 continue;
3664 }
3665
1aa4ecd9
HX		 3666 return i;
3667 }
3668
3669 return -1;
3670}
3671
3672int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3673{
3674 int i;
a68f6610 3675 int j;
d12d6b6d 3676 int rc;
1aa4ecd9 3677
9e5c9fe4
RJ		 3678 if (!fips_enabled && notests) {
3679 printk_once(KERN_INFO "alg: self-tests disabled\n");
3680 return 0;
3681 }
3682
5714758b
JK		 3683 alg_test_descs_check_order();
3684
1aa4ecd9
HX		 3685 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3686 char nalg[CRYPTO_MAX_ALG_NAME];
3687
3688 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3689 sizeof(nalg))
3690 return -ENAMETOOLONG;
3691
3692 i = alg_find_test(nalg);
3693 if (i < 0)
3694 goto notest;
3695
a3bef3a3
JW		 3696 if (fips_enabled && !alg_test_descs[i].fips_allowed)
3697 goto non_fips_alg;
3698
941fb328
JW		 3699 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3700 goto test_done;
da7f033d
HX		 3701 }
3702
1aa4ecd9 3703 i = alg_find_test(alg);
a68f6610
HX		 3704 j = alg_find_test(driver);
3705 if (i < 0 && j < 0)
1aa4ecd9
HX		 3706 goto notest;
3707
a68f6610
HX		 3708 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3709 (j >= 0 && !alg_test_descs[j].fips_allowed)))
a3bef3a3
JW		 3710 goto non_fips_alg;
3711
a68f6610
HX		 3712 rc = 0;
3713 if (i >= 0)
3714 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3715 type, mask);
032c8cac 3716 if (j >= 0 && j != i)
a68f6610
HX		 3717 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3718 type, mask);
3719
941fb328 3720test_done:
d12d6b6d
NH		 3721 if (fips_enabled && rc)
3722 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3723
29ecd4ab 3724 if (fips_enabled && !rc)
3e8cffd4 3725 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
29ecd4ab 3726
d12d6b6d 3727 return rc;
1aa4ecd9
HX		 3728
3729notest:
da7f033d
HX		 3730 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3731 return 0;
a3bef3a3
JW		 3732non_fips_alg:
3733 return -EINVAL;
da7f033d 3734}
0b767f96 3735
326a6346 3736#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
0b767f96 3737
da7f033d 3738EXPORT_SYMBOL_GPL(alg_test);
Empty description
This page took 0.871517 seconds and 4 git commands to generate.