blob: d0a42bd3aae926fcfef0624c6497452e9a0741c5 [file] [log] [blame]
Herbert Xuda7f0332008-07-31 17:08:25 +08001/*
2 * Algorithm testing framework and tests.
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8 *
Adrian Hoban69435b92010-11-04 15:02:04 -04009 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation.
15 *
Herbert Xuda7f0332008-07-31 17:08:25 +080016 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
19 * any later version.
20 *
21 */
22
Herbert Xu1ce33112015-04-22 15:06:31 +080023#include <crypto/aead.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080024#include <crypto/hash.h>
25#include <linux/err.h>
Herbert Xu1c41b882015-04-22 13:25:58 +080026#include <linux/fips.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080027#include <linux/module.h>
28#include <linux/scatterlist.h>
29#include <linux/slab.h>
30#include <linux/string.h>
Jarod Wilson7647d6c2009-05-04 19:44:50 +080031#include <crypto/rng.h>
Stephan Mueller64d1cdf2014-05-31 17:25:36 +020032#include <crypto/drbg.h>
Tadeusz Struk946cc462015-06-16 10:31:06 -070033#include <crypto/akcipher.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080034
35#include "internal.h"
Alexander Shishkin0b767f92010-06-03 20:53:43 +100036
Herbert Xu326a6342010-08-06 09:40:28 +080037#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
Alexander Shishkin0b767f92010-06-03 20:53:43 +100038
39/* a perfect nop */
40int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
41{
42 return 0;
43}
44
45#else
46
Herbert Xuda7f0332008-07-31 17:08:25 +080047#include "testmgr.h"
48
49/*
50 * Need slab memory for testing (size in number of pages).
51 */
52#define XBUFSIZE 8
53
54/*
55 * Indexes into the xbuf to simulate cross-page access.
56 */
57#define IDX1 32
58#define IDX2 32400
59#define IDX3 1
60#define IDX4 8193
61#define IDX5 22222
62#define IDX6 17101
63#define IDX7 27333
64#define IDX8 3000
65
66/*
67* Used by test_cipher()
68*/
69#define ENCRYPT 1
70#define DECRYPT 0
71
72struct tcrypt_result {
73 struct completion completion;
74 int err;
75};
76
77struct aead_test_suite {
78 struct {
79 struct aead_testvec *vecs;
80 unsigned int count;
81 } enc, dec;
82};
83
84struct cipher_test_suite {
85 struct {
86 struct cipher_testvec *vecs;
87 unsigned int count;
88 } enc, dec;
89};
90
91struct comp_test_suite {
92 struct {
93 struct comp_testvec *vecs;
94 unsigned int count;
95 } comp, decomp;
96};
97
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +080098struct pcomp_test_suite {
99 struct {
100 struct pcomp_testvec *vecs;
101 unsigned int count;
102 } comp, decomp;
103};
104
Herbert Xuda7f0332008-07-31 17:08:25 +0800105struct hash_test_suite {
106 struct hash_testvec *vecs;
107 unsigned int count;
108};
109
Jarod Wilson7647d6c2009-05-04 19:44:50 +0800110struct cprng_test_suite {
111 struct cprng_testvec *vecs;
112 unsigned int count;
113};
114
Stephan Mueller64d1cdf2014-05-31 17:25:36 +0200115struct drbg_test_suite {
116 struct drbg_testvec *vecs;
117 unsigned int count;
118};
119
Tadeusz Struk946cc462015-06-16 10:31:06 -0700120struct akcipher_test_suite {
121 struct akcipher_testvec *vecs;
122 unsigned int count;
123};
124
Herbert Xuda7f0332008-07-31 17:08:25 +0800125struct alg_test_desc {
126 const char *alg;
127 int (*test)(const struct alg_test_desc *desc, const char *driver,
128 u32 type, u32 mask);
Jarod Wilsona1915d52009-05-15 15:16:03 +1000129 int fips_allowed; /* set if alg is allowed in fips mode */
Herbert Xuda7f0332008-07-31 17:08:25 +0800130
131 union {
132 struct aead_test_suite aead;
133 struct cipher_test_suite cipher;
134 struct comp_test_suite comp;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +0800135 struct pcomp_test_suite pcomp;
Herbert Xuda7f0332008-07-31 17:08:25 +0800136 struct hash_test_suite hash;
Jarod Wilson7647d6c2009-05-04 19:44:50 +0800137 struct cprng_test_suite cprng;
Stephan Mueller64d1cdf2014-05-31 17:25:36 +0200138 struct drbg_test_suite drbg;
Tadeusz Struk946cc462015-06-16 10:31:06 -0700139 struct akcipher_test_suite akcipher;
Herbert Xuda7f0332008-07-31 17:08:25 +0800140 } suite;
141};
142
143static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
144
Herbert Xuda7f0332008-07-31 17:08:25 +0800145static void hexdump(unsigned char *buf, unsigned int len)
146{
147 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
148 16, 1,
149 buf, len, false);
150}
151
152static void tcrypt_complete(struct crypto_async_request *req, int err)
153{
154 struct tcrypt_result *res = req->data;
155
156 if (err == -EINPROGRESS)
157 return;
158
159 res->err = err;
160 complete(&res->completion);
161}
162
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800163static int testmgr_alloc_buf(char *buf[XBUFSIZE])
164{
165 int i;
166
167 for (i = 0; i < XBUFSIZE; i++) {
168 buf[i] = (void *)__get_free_page(GFP_KERNEL);
169 if (!buf[i])
170 goto err_free_buf;
171 }
172
173 return 0;
174
175err_free_buf:
176 while (i-- > 0)
177 free_page((unsigned long)buf[i]);
178
179 return -ENOMEM;
180}
181
182static void testmgr_free_buf(char *buf[XBUFSIZE])
183{
184 int i;
185
186 for (i = 0; i < XBUFSIZE; i++)
187 free_page((unsigned long)buf[i]);
188}
189
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300190static int wait_async_op(struct tcrypt_result *tr, int ret)
David S. Millera8f1a052010-05-19 14:12:03 +1000191{
192 if (ret == -EINPROGRESS || ret == -EBUSY) {
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100193 wait_for_completion(&tr->completion);
Wolfram Sang16735d02013-11-14 14:32:02 -0800194 reinit_completion(&tr->completion);
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100195 ret = tr->err;
David S. Millera8f1a052010-05-19 14:12:03 +1000196 }
197 return ret;
198}
199
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300200static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
201 unsigned int tcount, bool use_digest,
202 const int align_offset)
Herbert Xuda7f0332008-07-31 17:08:25 +0800203{
204 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
205 unsigned int i, j, k, temp;
206 struct scatterlist sg[8];
Horia Geanta29b77e52014-07-23 11:59:38 +0300207 char *result;
208 char *key;
Herbert Xuda7f0332008-07-31 17:08:25 +0800209 struct ahash_request *req;
210 struct tcrypt_result tresult;
Herbert Xuda7f0332008-07-31 17:08:25 +0800211 void *hash_buff;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800212 char *xbuf[XBUFSIZE];
213 int ret = -ENOMEM;
214
Horia Geanta29b77e52014-07-23 11:59:38 +0300215 result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
216 if (!result)
217 return ret;
218 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
219 if (!key)
220 goto out_nobuf;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800221 if (testmgr_alloc_buf(xbuf))
222 goto out_nobuf;
Herbert Xuda7f0332008-07-31 17:08:25 +0800223
224 init_completion(&tresult.completion);
225
226 req = ahash_request_alloc(tfm, GFP_KERNEL);
227 if (!req) {
228 printk(KERN_ERR "alg: hash: Failed to allocate request for "
229 "%s\n", algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800230 goto out_noreq;
231 }
232 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
233 tcrypt_complete, &tresult);
234
Herbert Xua0cfae52009-05-29 16:23:12 +1000235 j = 0;
Herbert Xuda7f0332008-07-31 17:08:25 +0800236 for (i = 0; i < tcount; i++) {
Herbert Xua0cfae52009-05-29 16:23:12 +1000237 if (template[i].np)
238 continue;
239
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300240 ret = -EINVAL;
241 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
242 goto out;
243
Herbert Xua0cfae52009-05-29 16:23:12 +1000244 j++;
Horia Geanta29b77e52014-07-23 11:59:38 +0300245 memset(result, 0, MAX_DIGEST_SIZE);
Herbert Xuda7f0332008-07-31 17:08:25 +0800246
247 hash_buff = xbuf[0];
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300248 hash_buff += align_offset;
Herbert Xuda7f0332008-07-31 17:08:25 +0800249
250 memcpy(hash_buff, template[i].plaintext, template[i].psize);
251 sg_init_one(&sg[0], hash_buff, template[i].psize);
252
253 if (template[i].ksize) {
254 crypto_ahash_clear_flags(tfm, ~0);
Horia Geanta29b77e52014-07-23 11:59:38 +0300255 if (template[i].ksize > MAX_KEYLEN) {
256 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
257 j, algo, template[i].ksize, MAX_KEYLEN);
258 ret = -EINVAL;
259 goto out;
260 }
261 memcpy(key, template[i].key, template[i].ksize);
262 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
Herbert Xuda7f0332008-07-31 17:08:25 +0800263 if (ret) {
264 printk(KERN_ERR "alg: hash: setkey failed on "
Herbert Xua0cfae52009-05-29 16:23:12 +1000265 "test %d for %s: ret=%d\n", j, algo,
Herbert Xuda7f0332008-07-31 17:08:25 +0800266 -ret);
267 goto out;
268 }
269 }
270
271 ahash_request_set_crypt(req, sg, result, template[i].psize);
David S. Millera8f1a052010-05-19 14:12:03 +1000272 if (use_digest) {
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300273 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000274 if (ret) {
275 pr_err("alg: hash: digest failed on test %d "
276 "for %s: ret=%d\n", j, algo, -ret);
277 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800278 }
David S. Millera8f1a052010-05-19 14:12:03 +1000279 } else {
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300280 ret = wait_async_op(&tresult, crypto_ahash_init(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000281 if (ret) {
282 pr_err("alt: hash: init failed on test %d "
283 "for %s: ret=%d\n", j, algo, -ret);
284 goto out;
285 }
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300286 ret = wait_async_op(&tresult, crypto_ahash_update(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000287 if (ret) {
288 pr_err("alt: hash: update failed on test %d "
289 "for %s: ret=%d\n", j, algo, -ret);
290 goto out;
291 }
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300292 ret = wait_async_op(&tresult, crypto_ahash_final(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000293 if (ret) {
294 pr_err("alt: hash: final failed on test %d "
295 "for %s: ret=%d\n", j, algo, -ret);
296 goto out;
297 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800298 }
299
300 if (memcmp(result, template[i].digest,
301 crypto_ahash_digestsize(tfm))) {
302 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
Herbert Xua0cfae52009-05-29 16:23:12 +1000303 j, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800304 hexdump(result, crypto_ahash_digestsize(tfm));
305 ret = -EINVAL;
306 goto out;
307 }
308 }
309
310 j = 0;
311 for (i = 0; i < tcount; i++) {
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300312 /* alignment tests are only done with continuous buffers */
313 if (align_offset != 0)
314 break;
315
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300316 if (!template[i].np)
317 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800318
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300319 j++;
320 memset(result, 0, MAX_DIGEST_SIZE);
Herbert Xuda7f0332008-07-31 17:08:25 +0800321
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300322 temp = 0;
323 sg_init_table(sg, template[i].np);
324 ret = -EINVAL;
325 for (k = 0; k < template[i].np; k++) {
326 if (WARN_ON(offset_in_page(IDX[k]) +
327 template[i].tap[k] > PAGE_SIZE))
Herbert Xuda7f0332008-07-31 17:08:25 +0800328 goto out;
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300329 sg_set_buf(&sg[k],
330 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
331 offset_in_page(IDX[k]),
332 template[i].plaintext + temp,
333 template[i].tap[k]),
334 template[i].tap[k]);
335 temp += template[i].tap[k];
336 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800337
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300338 if (template[i].ksize) {
339 if (template[i].ksize > MAX_KEYLEN) {
340 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
341 j, algo, template[i].ksize, MAX_KEYLEN);
Herbert Xuda7f0332008-07-31 17:08:25 +0800342 ret = -EINVAL;
343 goto out;
344 }
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300345 crypto_ahash_clear_flags(tfm, ~0);
346 memcpy(key, template[i].key, template[i].ksize);
347 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
348
349 if (ret) {
350 printk(KERN_ERR "alg: hash: setkey "
351 "failed on chunking test %d "
352 "for %s: ret=%d\n", j, algo, -ret);
353 goto out;
354 }
355 }
356
357 ahash_request_set_crypt(req, sg, result, template[i].psize);
358 ret = crypto_ahash_digest(req);
359 switch (ret) {
360 case 0:
361 break;
362 case -EINPROGRESS:
363 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100364 wait_for_completion(&tresult.completion);
365 reinit_completion(&tresult.completion);
366 ret = tresult.err;
367 if (!ret)
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300368 break;
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300369 /* fall through */
370 default:
371 printk(KERN_ERR "alg: hash: digest failed "
372 "on chunking test %d for %s: "
373 "ret=%d\n", j, algo, -ret);
374 goto out;
375 }
376
377 if (memcmp(result, template[i].digest,
378 crypto_ahash_digestsize(tfm))) {
379 printk(KERN_ERR "alg: hash: Chunking test %d "
380 "failed for %s\n", j, algo);
381 hexdump(result, crypto_ahash_digestsize(tfm));
382 ret = -EINVAL;
383 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800384 }
385 }
386
387 ret = 0;
388
389out:
390 ahash_request_free(req);
391out_noreq:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800392 testmgr_free_buf(xbuf);
393out_nobuf:
Horia Geanta29b77e52014-07-23 11:59:38 +0300394 kfree(key);
395 kfree(result);
Herbert Xuda7f0332008-07-31 17:08:25 +0800396 return ret;
397}
398
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300399static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
400 unsigned int tcount, bool use_digest)
401{
402 unsigned int alignmask;
403 int ret;
404
405 ret = __test_hash(tfm, template, tcount, use_digest, 0);
406 if (ret)
407 return ret;
408
409 /* test unaligned buffers, check with one byte offset */
410 ret = __test_hash(tfm, template, tcount, use_digest, 1);
411 if (ret)
412 return ret;
413
414 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
415 if (alignmask) {
416 /* Check if alignment mask for tfm is correctly set. */
417 ret = __test_hash(tfm, template, tcount, use_digest,
418 alignmask + 1);
419 if (ret)
420 return ret;
421 }
422
423 return 0;
424}
425
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300426static int __test_aead(struct crypto_aead *tfm, int enc,
427 struct aead_testvec *template, unsigned int tcount,
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300428 const bool diff_dst, const int align_offset)
Herbert Xuda7f0332008-07-31 17:08:25 +0800429{
430 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
431 unsigned int i, j, k, n, temp;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800432 int ret = -ENOMEM;
Herbert Xuda7f0332008-07-31 17:08:25 +0800433 char *q;
434 char *key;
435 struct aead_request *req;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300436 struct scatterlist *sg;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300437 struct scatterlist *sgout;
438 const char *e, *d;
Herbert Xuda7f0332008-07-31 17:08:25 +0800439 struct tcrypt_result result;
Cristian Stoica424a5da2015-01-28 11:03:05 +0200440 unsigned int authsize, iv_len;
Herbert Xuda7f0332008-07-31 17:08:25 +0800441 void *input;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300442 void *output;
Herbert Xuda7f0332008-07-31 17:08:25 +0800443 void *assoc;
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700444 char *iv;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800445 char *xbuf[XBUFSIZE];
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300446 char *xoutbuf[XBUFSIZE];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800447 char *axbuf[XBUFSIZE];
448
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700449 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
450 if (!iv)
451 return ret;
Horia Geanta29b77e52014-07-23 11:59:38 +0300452 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
453 if (!key)
454 goto out_noxbuf;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800455 if (testmgr_alloc_buf(xbuf))
456 goto out_noxbuf;
457 if (testmgr_alloc_buf(axbuf))
458 goto out_noaxbuf;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300459 if (diff_dst && testmgr_alloc_buf(xoutbuf))
460 goto out_nooutbuf;
461
462 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
Herbert Xu8a525fc2015-05-27 16:03:43 +0800463 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300464 if (!sg)
465 goto out_nosg;
Herbert Xu8a525fc2015-05-27 16:03:43 +0800466 sgout = &sg[16];
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300467
468 if (diff_dst)
469 d = "-ddst";
470 else
471 d = "";
472
Herbert Xuda7f0332008-07-31 17:08:25 +0800473 if (enc == ENCRYPT)
474 e = "encryption";
475 else
476 e = "decryption";
477
478 init_completion(&result.completion);
479
480 req = aead_request_alloc(tfm, GFP_KERNEL);
481 if (!req) {
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300482 pr_err("alg: aead%s: Failed to allocate request for %s\n",
483 d, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800484 goto out;
485 }
486
487 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
488 tcrypt_complete, &result);
489
490 for (i = 0, j = 0; i < tcount; i++) {
Cristian Stoica05b1d332014-07-28 13:11:23 +0300491 if (template[i].np)
492 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800493
Cristian Stoica05b1d332014-07-28 13:11:23 +0300494 j++;
Herbert Xuda7f0332008-07-31 17:08:25 +0800495
Cristian Stoica05b1d332014-07-28 13:11:23 +0300496 /* some templates have no input data but they will
497 * touch input
498 */
499 input = xbuf[0];
500 input += align_offset;
501 assoc = axbuf[0];
502
503 ret = -EINVAL;
504 if (WARN_ON(align_offset + template[i].ilen >
505 PAGE_SIZE || template[i].alen > PAGE_SIZE))
506 goto out;
507
508 memcpy(input, template[i].input, template[i].ilen);
509 memcpy(assoc, template[i].assoc, template[i].alen);
Cristian Stoica424a5da2015-01-28 11:03:05 +0200510 iv_len = crypto_aead_ivsize(tfm);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300511 if (template[i].iv)
Cristian Stoica424a5da2015-01-28 11:03:05 +0200512 memcpy(iv, template[i].iv, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300513 else
Cristian Stoica424a5da2015-01-28 11:03:05 +0200514 memset(iv, 0, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300515
516 crypto_aead_clear_flags(tfm, ~0);
517 if (template[i].wk)
518 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
519
520 if (template[i].klen > MAX_KEYLEN) {
521 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
522 d, j, algo, template[i].klen,
523 MAX_KEYLEN);
Herbert Xufd57f222009-05-29 16:05:42 +1000524 ret = -EINVAL;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300525 goto out;
526 }
527 memcpy(key, template[i].key, template[i].klen);
Herbert Xufd57f222009-05-29 16:05:42 +1000528
Cristian Stoica05b1d332014-07-28 13:11:23 +0300529 ret = crypto_aead_setkey(tfm, key, template[i].klen);
530 if (!ret == template[i].fail) {
531 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
532 d, j, algo, crypto_aead_get_flags(tfm));
533 goto out;
534 } else if (ret)
535 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800536
Cristian Stoica05b1d332014-07-28 13:11:23 +0300537 authsize = abs(template[i].rlen - template[i].ilen);
538 ret = crypto_aead_setauthsize(tfm, authsize);
539 if (ret) {
540 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
541 d, authsize, j, algo);
542 goto out;
543 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800544
Herbert Xu8a525fc2015-05-27 16:03:43 +0800545 k = !!template[i].alen;
546 sg_init_table(sg, k + 1);
547 sg_set_buf(&sg[0], assoc, template[i].alen);
548 sg_set_buf(&sg[k], input,
549 template[i].ilen + (enc ? authsize : 0));
550 output = input;
551
Cristian Stoica05b1d332014-07-28 13:11:23 +0300552 if (diff_dst) {
Herbert Xu8a525fc2015-05-27 16:03:43 +0800553 sg_init_table(sgout, k + 1);
554 sg_set_buf(&sgout[0], assoc, template[i].alen);
555
Cristian Stoica05b1d332014-07-28 13:11:23 +0300556 output = xoutbuf[0];
557 output += align_offset;
Herbert Xu8a525fc2015-05-27 16:03:43 +0800558 sg_set_buf(&sgout[k], output,
559 template[i].rlen + (enc ? 0 : authsize));
Cristian Stoica05b1d332014-07-28 13:11:23 +0300560 }
561
Cristian Stoica05b1d332014-07-28 13:11:23 +0300562 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
563 template[i].ilen, iv);
564
Herbert Xu8a525fc2015-05-27 16:03:43 +0800565 aead_request_set_ad(req, template[i].alen);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300566
567 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
568
569 switch (ret) {
570 case 0:
571 if (template[i].novrfy) {
572 /* verification was supposed to fail */
573 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
574 d, e, j, algo);
575 /* so really, we got a bad message */
576 ret = -EBADMSG;
Horia Geanta29b77e52014-07-23 11:59:38 +0300577 goto out;
578 }
Cristian Stoica05b1d332014-07-28 13:11:23 +0300579 break;
580 case -EINPROGRESS:
581 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100582 wait_for_completion(&result.completion);
583 reinit_completion(&result.completion);
584 ret = result.err;
585 if (!ret)
Herbert Xuda7f0332008-07-31 17:08:25 +0800586 break;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300587 case -EBADMSG:
588 if (template[i].novrfy)
589 /* verification failure was expected */
590 continue;
591 /* fall through */
592 default:
593 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
594 d, e, j, algo, -ret);
595 goto out;
596 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800597
Cristian Stoica05b1d332014-07-28 13:11:23 +0300598 q = output;
599 if (memcmp(q, template[i].result, template[i].rlen)) {
600 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
601 d, j, e, algo);
602 hexdump(q, template[i].rlen);
603 ret = -EINVAL;
604 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800605 }
606 }
607
608 for (i = 0, j = 0; i < tcount; i++) {
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300609 /* alignment tests are only done with continuous buffers */
610 if (align_offset != 0)
611 break;
612
Cristian Stoica05b1d332014-07-28 13:11:23 +0300613 if (!template[i].np)
614 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800615
Cristian Stoica05b1d332014-07-28 13:11:23 +0300616 j++;
Herbert Xuda7f0332008-07-31 17:08:25 +0800617
Cristian Stoica05b1d332014-07-28 13:11:23 +0300618 if (template[i].iv)
619 memcpy(iv, template[i].iv, MAX_IVLEN);
620 else
621 memset(iv, 0, MAX_IVLEN);
622
623 crypto_aead_clear_flags(tfm, ~0);
624 if (template[i].wk)
625 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
626 if (template[i].klen > MAX_KEYLEN) {
627 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
628 d, j, algo, template[i].klen, MAX_KEYLEN);
629 ret = -EINVAL;
630 goto out;
631 }
632 memcpy(key, template[i].key, template[i].klen);
633
634 ret = crypto_aead_setkey(tfm, key, template[i].klen);
635 if (!ret == template[i].fail) {
636 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
637 d, j, algo, crypto_aead_get_flags(tfm));
638 goto out;
639 } else if (ret)
640 continue;
641
642 authsize = abs(template[i].rlen - template[i].ilen);
643
644 ret = -EINVAL;
Herbert Xu8a525fc2015-05-27 16:03:43 +0800645 sg_init_table(sg, template[i].anp + template[i].np);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300646 if (diff_dst)
Herbert Xu8a525fc2015-05-27 16:03:43 +0800647 sg_init_table(sgout, template[i].anp + template[i].np);
648
649 ret = -EINVAL;
650 for (k = 0, temp = 0; k < template[i].anp; k++) {
651 if (WARN_ON(offset_in_page(IDX[k]) +
652 template[i].atap[k] > PAGE_SIZE))
653 goto out;
654 sg_set_buf(&sg[k],
655 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
656 offset_in_page(IDX[k]),
657 template[i].assoc + temp,
658 template[i].atap[k]),
659 template[i].atap[k]);
660 if (diff_dst)
661 sg_set_buf(&sgout[k],
662 axbuf[IDX[k] >> PAGE_SHIFT] +
663 offset_in_page(IDX[k]),
664 template[i].atap[k]);
665 temp += template[i].atap[k];
666 }
667
Cristian Stoica05b1d332014-07-28 13:11:23 +0300668 for (k = 0, temp = 0; k < template[i].np; k++) {
669 if (WARN_ON(offset_in_page(IDX[k]) +
670 template[i].tap[k] > PAGE_SIZE))
671 goto out;
672
673 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
674 memcpy(q, template[i].input + temp, template[i].tap[k]);
Herbert Xu8a525fc2015-05-27 16:03:43 +0800675 sg_set_buf(&sg[template[i].anp + k],
676 q, template[i].tap[k]);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300677
678 if (diff_dst) {
679 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
680 offset_in_page(IDX[k]);
681
682 memset(q, 0, template[i].tap[k]);
683
Herbert Xu8a525fc2015-05-27 16:03:43 +0800684 sg_set_buf(&sgout[template[i].anp + k],
685 q, template[i].tap[k]);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300686 }
687
688 n = template[i].tap[k];
689 if (k == template[i].np - 1 && enc)
690 n += authsize;
691 if (offset_in_page(q) + n < PAGE_SIZE)
692 q[n] = 0;
693
694 temp += template[i].tap[k];
695 }
696
697 ret = crypto_aead_setauthsize(tfm, authsize);
698 if (ret) {
699 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
700 d, authsize, j, algo);
701 goto out;
702 }
703
704 if (enc) {
Herbert Xu8a525fc2015-05-27 16:03:43 +0800705 if (WARN_ON(sg[template[i].anp + k - 1].offset +
706 sg[template[i].anp + k - 1].length +
707 authsize > PAGE_SIZE)) {
Horia Geanta29b77e52014-07-23 11:59:38 +0300708 ret = -EINVAL;
709 goto out;
710 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800711
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300712 if (diff_dst)
Herbert Xu8a525fc2015-05-27 16:03:43 +0800713 sgout[template[i].anp + k - 1].length +=
714 authsize;
715 sg[template[i].anp + k - 1].length += authsize;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300716 }
717
718 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
719 template[i].ilen,
720 iv);
721
Herbert Xu8a525fc2015-05-27 16:03:43 +0800722 aead_request_set_ad(req, template[i].alen);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300723
724 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
725
726 switch (ret) {
727 case 0:
728 if (template[i].novrfy) {
729 /* verification was supposed to fail */
730 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
731 d, e, j, algo);
732 /* so really, we got a bad message */
733 ret = -EBADMSG;
734 goto out;
735 }
736 break;
737 case -EINPROGRESS:
738 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100739 wait_for_completion(&result.completion);
740 reinit_completion(&result.completion);
741 ret = result.err;
742 if (!ret)
Cristian Stoica05b1d332014-07-28 13:11:23 +0300743 break;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300744 case -EBADMSG:
745 if (template[i].novrfy)
746 /* verification failure was expected */
747 continue;
748 /* fall through */
749 default:
750 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
751 d, e, j, algo, -ret);
752 goto out;
753 }
754
755 ret = -EINVAL;
756 for (k = 0, temp = 0; k < template[i].np; k++) {
757 if (diff_dst)
758 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
759 offset_in_page(IDX[k]);
760 else
Herbert Xuda7f0332008-07-31 17:08:25 +0800761 q = xbuf[IDX[k] >> PAGE_SHIFT] +
762 offset_in_page(IDX[k]);
763
Cristian Stoica05b1d332014-07-28 13:11:23 +0300764 n = template[i].tap[k];
765 if (k == template[i].np - 1)
766 n += enc ? authsize : -authsize;
Herbert Xuda7f0332008-07-31 17:08:25 +0800767
Cristian Stoica05b1d332014-07-28 13:11:23 +0300768 if (memcmp(q, template[i].result + temp, n)) {
769 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
770 d, j, e, k, algo);
771 hexdump(q, n);
Herbert Xuda7f0332008-07-31 17:08:25 +0800772 goto out;
773 }
774
Cristian Stoica05b1d332014-07-28 13:11:23 +0300775 q += n;
776 if (k == template[i].np - 1 && !enc) {
777 if (!diff_dst &&
778 memcmp(q, template[i].input +
779 temp + n, authsize))
780 n = authsize;
Horia Geanta8ec25c52013-11-28 15:11:18 +0200781 else
Cristian Stoica05b1d332014-07-28 13:11:23 +0300782 n = 0;
783 } else {
784 for (n = 0; offset_in_page(q + n) && q[n]; n++)
785 ;
Herbert Xuda7f0332008-07-31 17:08:25 +0800786 }
Cristian Stoica05b1d332014-07-28 13:11:23 +0300787 if (n) {
788 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
789 d, j, e, k, algo, n);
790 hexdump(q, n);
Herbert Xuda7f0332008-07-31 17:08:25 +0800791 goto out;
792 }
793
Cristian Stoica05b1d332014-07-28 13:11:23 +0300794 temp += template[i].tap[k];
Herbert Xuda7f0332008-07-31 17:08:25 +0800795 }
796 }
797
798 ret = 0;
799
800out:
801 aead_request_free(req);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300802 kfree(sg);
803out_nosg:
804 if (diff_dst)
805 testmgr_free_buf(xoutbuf);
806out_nooutbuf:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800807 testmgr_free_buf(axbuf);
808out_noaxbuf:
809 testmgr_free_buf(xbuf);
810out_noxbuf:
Horia Geanta29b77e52014-07-23 11:59:38 +0300811 kfree(key);
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700812 kfree(iv);
Herbert Xuda7f0332008-07-31 17:08:25 +0800813 return ret;
814}
815
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300816static int test_aead(struct crypto_aead *tfm, int enc,
817 struct aead_testvec *template, unsigned int tcount)
818{
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300819 unsigned int alignmask;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300820 int ret;
821
822 /* test 'dst == src' case */
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300823 ret = __test_aead(tfm, enc, template, tcount, false, 0);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300824 if (ret)
825 return ret;
826
827 /* test 'dst != src' case */
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300828 ret = __test_aead(tfm, enc, template, tcount, true, 0);
829 if (ret)
830 return ret;
831
832 /* test unaligned buffers, check with one byte offset */
833 ret = __test_aead(tfm, enc, template, tcount, true, 1);
834 if (ret)
835 return ret;
836
837 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
838 if (alignmask) {
839 /* Check if alignment mask for tfm is correctly set. */
840 ret = __test_aead(tfm, enc, template, tcount, true,
841 alignmask + 1);
842 if (ret)
843 return ret;
844 }
845
846 return 0;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300847}
848
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000849static int test_cipher(struct crypto_cipher *tfm, int enc,
Herbert Xuda7f0332008-07-31 17:08:25 +0800850 struct cipher_testvec *template, unsigned int tcount)
851{
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000852 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
853 unsigned int i, j, k;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000854 char *q;
855 const char *e;
856 void *data;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800857 char *xbuf[XBUFSIZE];
858 int ret = -ENOMEM;
859
860 if (testmgr_alloc_buf(xbuf))
861 goto out_nobuf;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000862
863 if (enc == ENCRYPT)
864 e = "encryption";
865 else
866 e = "decryption";
867
868 j = 0;
869 for (i = 0; i < tcount; i++) {
870 if (template[i].np)
871 continue;
872
873 j++;
874
Herbert Xufd57f222009-05-29 16:05:42 +1000875 ret = -EINVAL;
876 if (WARN_ON(template[i].ilen > PAGE_SIZE))
877 goto out;
878
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000879 data = xbuf[0];
880 memcpy(data, template[i].input, template[i].ilen);
881
882 crypto_cipher_clear_flags(tfm, ~0);
883 if (template[i].wk)
884 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
885
886 ret = crypto_cipher_setkey(tfm, template[i].key,
887 template[i].klen);
888 if (!ret == template[i].fail) {
889 printk(KERN_ERR "alg: cipher: setkey failed "
890 "on test %d for %s: flags=%x\n", j,
891 algo, crypto_cipher_get_flags(tfm));
892 goto out;
893 } else if (ret)
894 continue;
895
896 for (k = 0; k < template[i].ilen;
897 k += crypto_cipher_blocksize(tfm)) {
898 if (enc)
899 crypto_cipher_encrypt_one(tfm, data + k,
900 data + k);
901 else
902 crypto_cipher_decrypt_one(tfm, data + k,
903 data + k);
904 }
905
906 q = data;
907 if (memcmp(q, template[i].result, template[i].rlen)) {
908 printk(KERN_ERR "alg: cipher: Test %d failed "
909 "on %s for %s\n", j, e, algo);
910 hexdump(q, template[i].rlen);
911 ret = -EINVAL;
912 goto out;
913 }
914 }
915
916 ret = 0;
917
918out:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800919 testmgr_free_buf(xbuf);
920out_nobuf:
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000921 return ret;
922}
923
Jussi Kivilinna08d6af82012-09-21 10:26:47 +0300924static int __test_skcipher(struct crypto_ablkcipher *tfm, int enc,
925 struct cipher_testvec *template, unsigned int tcount,
Jussi Kivilinna3a338f22013-06-13 17:37:45 +0300926 const bool diff_dst, const int align_offset)
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000927{
Herbert Xuda7f0332008-07-31 17:08:25 +0800928 const char *algo =
929 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
930 unsigned int i, j, k, n, temp;
Herbert Xuda7f0332008-07-31 17:08:25 +0800931 char *q;
932 struct ablkcipher_request *req;
933 struct scatterlist sg[8];
Jussi Kivilinna08d6af82012-09-21 10:26:47 +0300934 struct scatterlist sgout[8];
935 const char *e, *d;
Herbert Xuda7f0332008-07-31 17:08:25 +0800936 struct tcrypt_result result;
937 void *data;
938 char iv[MAX_IVLEN];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800939 char *xbuf[XBUFSIZE];
Jussi Kivilinna08d6af82012-09-21 10:26:47 +0300940 char *xoutbuf[XBUFSIZE];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800941 int ret = -ENOMEM;
942
943 if (testmgr_alloc_buf(xbuf))
944 goto out_nobuf;
Herbert Xuda7f0332008-07-31 17:08:25 +0800945
Jussi Kivilinna08d6af82012-09-21 10:26:47 +0300946 if (diff_dst && testmgr_alloc_buf(xoutbuf))
947 goto out_nooutbuf;
948
949 if (diff_dst)
950 d = "-ddst";
951 else
952 d = "";
953
Herbert Xuda7f0332008-07-31 17:08:25 +0800954 if (enc == ENCRYPT)
955 e = "encryption";
956 else
957 e = "decryption";
958
959 init_completion(&result.completion);
960
961 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
962 if (!req) {
Jussi Kivilinna08d6af82012-09-21 10:26:47 +0300963 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
964 d, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800965 goto out;
966 }
967
968 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
969 tcrypt_complete, &result);
970
971 j = 0;
972 for (i = 0; i < tcount; i++) {
Cristian Stoicabbb9a7d2014-08-08 14:27:52 +0300973 if (template[i].np && !template[i].also_non_np)
974 continue;
975
Herbert Xuda7f0332008-07-31 17:08:25 +0800976 if (template[i].iv)
977 memcpy(iv, template[i].iv, MAX_IVLEN);
978 else
979 memset(iv, 0, MAX_IVLEN);
980
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +0300981 j++;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +0300982 ret = -EINVAL;
983 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
984 goto out;
985
986 data = xbuf[0];
987 data += align_offset;
988 memcpy(data, template[i].input, template[i].ilen);
989
990 crypto_ablkcipher_clear_flags(tfm, ~0);
991 if (template[i].wk)
992 crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
993
994 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
995 template[i].klen);
996 if (!ret == template[i].fail) {
997 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
998 d, j, algo, crypto_ablkcipher_get_flags(tfm));
999 goto out;
1000 } else if (ret)
1001 continue;
1002
1003 sg_init_one(&sg[0], data, template[i].ilen);
1004 if (diff_dst) {
1005 data = xoutbuf[0];
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001006 data += align_offset;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001007 sg_init_one(&sgout[0], data, template[i].ilen);
1008 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001009
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001010 ablkcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1011 template[i].ilen, iv);
1012 ret = enc ? crypto_ablkcipher_encrypt(req) :
1013 crypto_ablkcipher_decrypt(req);
Herbert Xuda7f0332008-07-31 17:08:25 +08001014
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001015 switch (ret) {
1016 case 0:
1017 break;
1018 case -EINPROGRESS:
1019 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +01001020 wait_for_completion(&result.completion);
1021 reinit_completion(&result.completion);
1022 ret = result.err;
1023 if (!ret)
Herbert Xuda7f0332008-07-31 17:08:25 +08001024 break;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001025 /* fall through */
1026 default:
1027 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1028 d, e, j, algo, -ret);
1029 goto out;
1030 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001031
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001032 q = data;
1033 if (memcmp(q, template[i].result, template[i].rlen)) {
1034 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
1035 d, j, e, algo);
1036 hexdump(q, template[i].rlen);
1037 ret = -EINVAL;
1038 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001039 }
1040 }
1041
1042 j = 0;
1043 for (i = 0; i < tcount; i++) {
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001044 /* alignment tests are only done with continuous buffers */
1045 if (align_offset != 0)
1046 break;
Herbert Xuda7f0332008-07-31 17:08:25 +08001047
Cristian Stoicabbb9a7d2014-08-08 14:27:52 +03001048 if (!template[i].np)
1049 continue;
1050
Herbert Xuda7f0332008-07-31 17:08:25 +08001051 if (template[i].iv)
1052 memcpy(iv, template[i].iv, MAX_IVLEN);
1053 else
1054 memset(iv, 0, MAX_IVLEN);
1055
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001056 j++;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001057 crypto_ablkcipher_clear_flags(tfm, ~0);
1058 if (template[i].wk)
1059 crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1060
1061 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
1062 template[i].klen);
1063 if (!ret == template[i].fail) {
1064 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1065 d, j, algo, crypto_ablkcipher_get_flags(tfm));
1066 goto out;
1067 } else if (ret)
1068 continue;
1069
1070 temp = 0;
1071 ret = -EINVAL;
1072 sg_init_table(sg, template[i].np);
1073 if (diff_dst)
1074 sg_init_table(sgout, template[i].np);
1075 for (k = 0; k < template[i].np; k++) {
1076 if (WARN_ON(offset_in_page(IDX[k]) +
1077 template[i].tap[k] > PAGE_SIZE))
Herbert Xuda7f0332008-07-31 17:08:25 +08001078 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001079
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001080 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1081
1082 memcpy(q, template[i].input + temp, template[i].tap[k]);
1083
1084 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1085 q[template[i].tap[k]] = 0;
1086
1087 sg_set_buf(&sg[k], q, template[i].tap[k]);
1088 if (diff_dst) {
1089 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1090 offset_in_page(IDX[k]);
1091
1092 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1093
1094 memset(q, 0, template[i].tap[k]);
1095 if (offset_in_page(q) +
1096 template[i].tap[k] < PAGE_SIZE)
1097 q[template[i].tap[k]] = 0;
1098 }
1099
1100 temp += template[i].tap[k];
1101 }
1102
1103 ablkcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1104 template[i].ilen, iv);
1105
1106 ret = enc ? crypto_ablkcipher_encrypt(req) :
1107 crypto_ablkcipher_decrypt(req);
1108
1109 switch (ret) {
1110 case 0:
1111 break;
1112 case -EINPROGRESS:
1113 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +01001114 wait_for_completion(&result.completion);
1115 reinit_completion(&result.completion);
1116 ret = result.err;
1117 if (!ret)
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001118 break;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001119 /* fall through */
1120 default:
1121 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1122 d, e, j, algo, -ret);
1123 goto out;
1124 }
1125
1126 temp = 0;
1127 ret = -EINVAL;
1128 for (k = 0; k < template[i].np; k++) {
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001129 if (diff_dst)
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001130 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1131 offset_in_page(IDX[k]);
1132 else
Herbert Xuda7f0332008-07-31 17:08:25 +08001133 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1134 offset_in_page(IDX[k]);
1135
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001136 if (memcmp(q, template[i].result + temp,
1137 template[i].tap[k])) {
1138 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1139 d, j, e, k, algo);
1140 hexdump(q, template[i].tap[k]);
Herbert Xuda7f0332008-07-31 17:08:25 +08001141 goto out;
1142 }
1143
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001144 q += template[i].tap[k];
1145 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1146 ;
1147 if (n) {
1148 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1149 d, j, e, k, algo, n);
1150 hexdump(q, n);
1151 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001152 }
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001153 temp += template[i].tap[k];
Herbert Xuda7f0332008-07-31 17:08:25 +08001154 }
1155 }
1156
1157 ret = 0;
1158
1159out:
1160 ablkcipher_request_free(req);
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001161 if (diff_dst)
1162 testmgr_free_buf(xoutbuf);
1163out_nooutbuf:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001164 testmgr_free_buf(xbuf);
1165out_nobuf:
Herbert Xuda7f0332008-07-31 17:08:25 +08001166 return ret;
1167}
1168
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001169static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
1170 struct cipher_testvec *template, unsigned int tcount)
1171{
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001172 unsigned int alignmask;
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001173 int ret;
1174
1175 /* test 'dst == src' case */
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001176 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001177 if (ret)
1178 return ret;
1179
1180 /* test 'dst != src' case */
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001181 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1182 if (ret)
1183 return ret;
1184
1185 /* test unaligned buffers, check with one byte offset */
1186 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1187 if (ret)
1188 return ret;
1189
1190 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1191 if (alignmask) {
1192 /* Check if alignment mask for tfm is correctly set. */
1193 ret = __test_skcipher(tfm, enc, template, tcount, true,
1194 alignmask + 1);
1195 if (ret)
1196 return ret;
1197 }
1198
1199 return 0;
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001200}
1201
Herbert Xuda7f0332008-07-31 17:08:25 +08001202static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1203 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1204{
1205 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1206 unsigned int i;
1207 char result[COMP_BUF_SIZE];
1208 int ret;
1209
1210 for (i = 0; i < ctcount; i++) {
Geert Uytterhoevenc79cf912009-03-29 15:44:19 +08001211 int ilen;
1212 unsigned int dlen = COMP_BUF_SIZE;
Herbert Xuda7f0332008-07-31 17:08:25 +08001213
1214 memset(result, 0, sizeof (result));
1215
1216 ilen = ctemplate[i].inlen;
1217 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1218 ilen, result, &dlen);
1219 if (ret) {
1220 printk(KERN_ERR "alg: comp: compression failed "
1221 "on test %d for %s: ret=%d\n", i + 1, algo,
1222 -ret);
1223 goto out;
1224 }
1225
Geert Uytterhoevenb812eb02008-11-28 20:51:28 +08001226 if (dlen != ctemplate[i].outlen) {
1227 printk(KERN_ERR "alg: comp: Compression test %d "
1228 "failed for %s: output len = %d\n", i + 1, algo,
1229 dlen);
1230 ret = -EINVAL;
1231 goto out;
1232 }
1233
Herbert Xuda7f0332008-07-31 17:08:25 +08001234 if (memcmp(result, ctemplate[i].output, dlen)) {
1235 printk(KERN_ERR "alg: comp: Compression test %d "
1236 "failed for %s\n", i + 1, algo);
1237 hexdump(result, dlen);
1238 ret = -EINVAL;
1239 goto out;
1240 }
1241 }
1242
1243 for (i = 0; i < dtcount; i++) {
Geert Uytterhoevenc79cf912009-03-29 15:44:19 +08001244 int ilen;
1245 unsigned int dlen = COMP_BUF_SIZE;
Herbert Xuda7f0332008-07-31 17:08:25 +08001246
1247 memset(result, 0, sizeof (result));
1248
1249 ilen = dtemplate[i].inlen;
1250 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1251 ilen, result, &dlen);
1252 if (ret) {
1253 printk(KERN_ERR "alg: comp: decompression failed "
1254 "on test %d for %s: ret=%d\n", i + 1, algo,
1255 -ret);
1256 goto out;
1257 }
1258
Geert Uytterhoevenb812eb02008-11-28 20:51:28 +08001259 if (dlen != dtemplate[i].outlen) {
1260 printk(KERN_ERR "alg: comp: Decompression test %d "
1261 "failed for %s: output len = %d\n", i + 1, algo,
1262 dlen);
1263 ret = -EINVAL;
1264 goto out;
1265 }
1266
Herbert Xuda7f0332008-07-31 17:08:25 +08001267 if (memcmp(result, dtemplate[i].output, dlen)) {
1268 printk(KERN_ERR "alg: comp: Decompression test %d "
1269 "failed for %s\n", i + 1, algo);
1270 hexdump(result, dlen);
1271 ret = -EINVAL;
1272 goto out;
1273 }
1274 }
1275
1276 ret = 0;
1277
1278out:
1279 return ret;
1280}
1281
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001282static int test_pcomp(struct crypto_pcomp *tfm,
1283 struct pcomp_testvec *ctemplate,
1284 struct pcomp_testvec *dtemplate, int ctcount,
1285 int dtcount)
1286{
1287 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1288 unsigned int i;
1289 char result[COMP_BUF_SIZE];
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001290 int res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001291
1292 for (i = 0; i < ctcount; i++) {
1293 struct comp_request req;
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001294 unsigned int produced = 0;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001295
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001296 res = crypto_compress_setup(tfm, ctemplate[i].params,
1297 ctemplate[i].paramsize);
1298 if (res) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001299 pr_err("alg: pcomp: compression setup failed on test "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001300 "%d for %s: error=%d\n", i + 1, algo, res);
1301 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001302 }
1303
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001304 res = crypto_compress_init(tfm);
1305 if (res) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001306 pr_err("alg: pcomp: compression init failed on test "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001307 "%d for %s: error=%d\n", i + 1, algo, res);
1308 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001309 }
1310
1311 memset(result, 0, sizeof(result));
1312
1313 req.next_in = ctemplate[i].input;
1314 req.avail_in = ctemplate[i].inlen / 2;
1315 req.next_out = result;
1316 req.avail_out = ctemplate[i].outlen / 2;
1317
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001318 res = crypto_compress_update(tfm, &req);
1319 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001320 pr_err("alg: pcomp: compression update failed on test "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001321 "%d for %s: error=%d\n", i + 1, algo, res);
1322 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001323 }
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001324 if (res > 0)
1325 produced += res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001326
1327 /* Add remaining input data */
1328 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1329
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001330 res = crypto_compress_update(tfm, &req);
1331 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001332 pr_err("alg: pcomp: compression update failed on test "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001333 "%d for %s: error=%d\n", i + 1, algo, res);
1334 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001335 }
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001336 if (res > 0)
1337 produced += res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001338
1339 /* Provide remaining output space */
1340 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1341
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001342 res = crypto_compress_final(tfm, &req);
1343 if (res < 0) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001344 pr_err("alg: pcomp: compression final failed on test "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001345 "%d for %s: error=%d\n", i + 1, algo, res);
1346 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001347 }
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001348 produced += res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001349
1350 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1351 pr_err("alg: comp: Compression test %d failed for %s: "
1352 "output len = %d (expected %d)\n", i + 1, algo,
1353 COMP_BUF_SIZE - req.avail_out,
1354 ctemplate[i].outlen);
1355 return -EINVAL;
1356 }
1357
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001358 if (produced != ctemplate[i].outlen) {
1359 pr_err("alg: comp: Compression test %d failed for %s: "
1360 "returned len = %u (expected %d)\n", i + 1,
1361 algo, produced, ctemplate[i].outlen);
1362 return -EINVAL;
1363 }
1364
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001365 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1366 pr_err("alg: pcomp: Compression test %d failed for "
1367 "%s\n", i + 1, algo);
1368 hexdump(result, ctemplate[i].outlen);
1369 return -EINVAL;
1370 }
1371 }
1372
1373 for (i = 0; i < dtcount; i++) {
1374 struct comp_request req;
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001375 unsigned int produced = 0;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001376
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001377 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1378 dtemplate[i].paramsize);
1379 if (res) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001380 pr_err("alg: pcomp: decompression setup failed on "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001381 "test %d for %s: error=%d\n", i + 1, algo, res);
1382 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001383 }
1384
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001385 res = crypto_decompress_init(tfm);
1386 if (res) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001387 pr_err("alg: pcomp: decompression init failed on test "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001388 "%d for %s: error=%d\n", i + 1, algo, res);
1389 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001390 }
1391
1392 memset(result, 0, sizeof(result));
1393
1394 req.next_in = dtemplate[i].input;
1395 req.avail_in = dtemplate[i].inlen / 2;
1396 req.next_out = result;
1397 req.avail_out = dtemplate[i].outlen / 2;
1398
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001399 res = crypto_decompress_update(tfm, &req);
1400 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001401 pr_err("alg: pcomp: decompression update failed on "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001402 "test %d for %s: error=%d\n", i + 1, algo, res);
1403 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001404 }
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001405 if (res > 0)
1406 produced += res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001407
1408 /* Add remaining input data */
1409 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1410
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001411 res = crypto_decompress_update(tfm, &req);
1412 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001413 pr_err("alg: pcomp: decompression update failed on "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001414 "test %d for %s: error=%d\n", i + 1, algo, res);
1415 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001416 }
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001417 if (res > 0)
1418 produced += res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001419
1420 /* Provide remaining output space */
1421 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1422
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001423 res = crypto_decompress_final(tfm, &req);
1424 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001425 pr_err("alg: pcomp: decompression final failed on "
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001426 "test %d for %s: error=%d\n", i + 1, algo, res);
1427 return res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001428 }
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001429 if (res > 0)
1430 produced += res;
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001431
1432 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1433 pr_err("alg: comp: Decompression test %d failed for "
1434 "%s: output len = %d (expected %d)\n", i + 1,
1435 algo, COMP_BUF_SIZE - req.avail_out,
1436 dtemplate[i].outlen);
1437 return -EINVAL;
1438 }
1439
Geert Uytterhoeven3ce858c2009-05-27 15:05:02 +10001440 if (produced != dtemplate[i].outlen) {
1441 pr_err("alg: comp: Decompression test %d failed for "
1442 "%s: returned len = %u (expected %d)\n", i + 1,
1443 algo, produced, dtemplate[i].outlen);
1444 return -EINVAL;
1445 }
1446
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001447 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1448 pr_err("alg: pcomp: Decompression test %d failed for "
1449 "%s\n", i + 1, algo);
1450 hexdump(result, dtemplate[i].outlen);
1451 return -EINVAL;
1452 }
1453 }
1454
1455 return 0;
1456}
1457
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001458
1459static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1460 unsigned int tcount)
1461{
1462 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
Felipe Contrerasfa4ef8a2009-10-27 19:04:42 +08001463 int err = 0, i, j, seedsize;
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001464 u8 *seed;
1465 char result[32];
1466
1467 seedsize = crypto_rng_seedsize(tfm);
1468
1469 seed = kmalloc(seedsize, GFP_KERNEL);
1470 if (!seed) {
1471 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1472 "for %s\n", algo);
1473 return -ENOMEM;
1474 }
1475
1476 for (i = 0; i < tcount; i++) {
1477 memset(result, 0, 32);
1478
1479 memcpy(seed, template[i].v, template[i].vlen);
1480 memcpy(seed + template[i].vlen, template[i].key,
1481 template[i].klen);
1482 memcpy(seed + template[i].vlen + template[i].klen,
1483 template[i].dt, template[i].dtlen);
1484
1485 err = crypto_rng_reset(tfm, seed, seedsize);
1486 if (err) {
1487 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1488 "for %s\n", algo);
1489 goto out;
1490 }
1491
1492 for (j = 0; j < template[i].loops; j++) {
1493 err = crypto_rng_get_bytes(tfm, result,
1494 template[i].rlen);
Stephan Mueller19e60e12015-03-10 17:00:36 +01001495 if (err < 0) {
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001496 printk(KERN_ERR "alg: cprng: Failed to obtain "
1497 "the correct amount of random data for "
Stephan Mueller19e60e12015-03-10 17:00:36 +01001498 "%s (requested %d)\n", algo,
1499 template[i].rlen);
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001500 goto out;
1501 }
1502 }
1503
1504 err = memcmp(result, template[i].result,
1505 template[i].rlen);
1506 if (err) {
1507 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1508 i, algo);
1509 hexdump(result, template[i].rlen);
1510 err = -EINVAL;
1511 goto out;
1512 }
1513 }
1514
1515out:
1516 kfree(seed);
1517 return err;
1518}
1519
Herbert Xuda7f0332008-07-31 17:08:25 +08001520static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1521 u32 type, u32 mask)
1522{
1523 struct crypto_aead *tfm;
1524 int err = 0;
1525
Stephan Mueller425a8822015-03-30 21:56:31 +02001526 tfm = crypto_alloc_aead(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001527 if (IS_ERR(tfm)) {
1528 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1529 "%ld\n", driver, PTR_ERR(tfm));
1530 return PTR_ERR(tfm);
1531 }
1532
1533 if (desc->suite.aead.enc.vecs) {
1534 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1535 desc->suite.aead.enc.count);
1536 if (err)
1537 goto out;
1538 }
1539
1540 if (!err && desc->suite.aead.dec.vecs)
1541 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1542 desc->suite.aead.dec.count);
1543
1544out:
1545 crypto_free_aead(tfm);
1546 return err;
1547}
1548
1549static int alg_test_cipher(const struct alg_test_desc *desc,
1550 const char *driver, u32 type, u32 mask)
1551{
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001552 struct crypto_cipher *tfm;
Herbert Xuda7f0332008-07-31 17:08:25 +08001553 int err = 0;
1554
Stephan Mueller425a8822015-03-30 21:56:31 +02001555 tfm = crypto_alloc_cipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001556 if (IS_ERR(tfm)) {
1557 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1558 "%s: %ld\n", driver, PTR_ERR(tfm));
1559 return PTR_ERR(tfm);
1560 }
1561
1562 if (desc->suite.cipher.enc.vecs) {
1563 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1564 desc->suite.cipher.enc.count);
1565 if (err)
1566 goto out;
1567 }
1568
1569 if (desc->suite.cipher.dec.vecs)
1570 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1571 desc->suite.cipher.dec.count);
1572
1573out:
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001574 crypto_free_cipher(tfm);
1575 return err;
1576}
1577
1578static int alg_test_skcipher(const struct alg_test_desc *desc,
1579 const char *driver, u32 type, u32 mask)
1580{
1581 struct crypto_ablkcipher *tfm;
1582 int err = 0;
1583
Stephan Mueller425a8822015-03-30 21:56:31 +02001584 tfm = crypto_alloc_ablkcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001585 if (IS_ERR(tfm)) {
1586 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1587 "%s: %ld\n", driver, PTR_ERR(tfm));
1588 return PTR_ERR(tfm);
1589 }
1590
1591 if (desc->suite.cipher.enc.vecs) {
1592 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1593 desc->suite.cipher.enc.count);
1594 if (err)
1595 goto out;
1596 }
1597
1598 if (desc->suite.cipher.dec.vecs)
1599 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1600 desc->suite.cipher.dec.count);
1601
1602out:
Herbert Xuda7f0332008-07-31 17:08:25 +08001603 crypto_free_ablkcipher(tfm);
1604 return err;
1605}
1606
1607static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1608 u32 type, u32 mask)
1609{
1610 struct crypto_comp *tfm;
1611 int err;
1612
1613 tfm = crypto_alloc_comp(driver, type, mask);
1614 if (IS_ERR(tfm)) {
1615 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1616 "%ld\n", driver, PTR_ERR(tfm));
1617 return PTR_ERR(tfm);
1618 }
1619
1620 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1621 desc->suite.comp.decomp.vecs,
1622 desc->suite.comp.comp.count,
1623 desc->suite.comp.decomp.count);
1624
1625 crypto_free_comp(tfm);
1626 return err;
1627}
1628
Geert Uytterhoeven8064efb2009-03-04 15:08:03 +08001629static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1630 u32 type, u32 mask)
1631{
1632 struct crypto_pcomp *tfm;
1633 int err;
1634
1635 tfm = crypto_alloc_pcomp(driver, type, mask);
1636 if (IS_ERR(tfm)) {
1637 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1638 driver, PTR_ERR(tfm));
1639 return PTR_ERR(tfm);
1640 }
1641
1642 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1643 desc->suite.pcomp.decomp.vecs,
1644 desc->suite.pcomp.comp.count,
1645 desc->suite.pcomp.decomp.count);
1646
1647 crypto_free_pcomp(tfm);
1648 return err;
1649}
1650
Herbert Xuda7f0332008-07-31 17:08:25 +08001651static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1652 u32 type, u32 mask)
1653{
1654 struct crypto_ahash *tfm;
1655 int err;
1656
Stephan Mueller425a8822015-03-30 21:56:31 +02001657 tfm = crypto_alloc_ahash(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001658 if (IS_ERR(tfm)) {
1659 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1660 "%ld\n", driver, PTR_ERR(tfm));
1661 return PTR_ERR(tfm);
1662 }
1663
David S. Millera8f1a052010-05-19 14:12:03 +10001664 err = test_hash(tfm, desc->suite.hash.vecs,
1665 desc->suite.hash.count, true);
1666 if (!err)
1667 err = test_hash(tfm, desc->suite.hash.vecs,
1668 desc->suite.hash.count, false);
Herbert Xuda7f0332008-07-31 17:08:25 +08001669
1670 crypto_free_ahash(tfm);
1671 return err;
1672}
1673
Herbert Xu8e3ee852008-11-07 14:58:52 +08001674static int alg_test_crc32c(const struct alg_test_desc *desc,
1675 const char *driver, u32 type, u32 mask)
1676{
1677 struct crypto_shash *tfm;
1678 u32 val;
1679 int err;
1680
1681 err = alg_test_hash(desc, driver, type, mask);
1682 if (err)
1683 goto out;
1684
Stephan Mueller425a8822015-03-30 21:56:31 +02001685 tfm = crypto_alloc_shash(driver, type | CRYPTO_ALG_INTERNAL, mask);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001686 if (IS_ERR(tfm)) {
1687 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1688 "%ld\n", driver, PTR_ERR(tfm));
1689 err = PTR_ERR(tfm);
1690 goto out;
1691 }
1692
1693 do {
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001694 SHASH_DESC_ON_STACK(shash, tfm);
1695 u32 *ctx = (u32 *)shash_desc_ctx(shash);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001696
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001697 shash->tfm = tfm;
1698 shash->flags = 0;
Herbert Xu8e3ee852008-11-07 14:58:52 +08001699
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001700 *ctx = le32_to_cpu(420553207);
1701 err = crypto_shash_final(shash, (u8 *)&val);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001702 if (err) {
1703 printk(KERN_ERR "alg: crc32c: Operation failed for "
1704 "%s: %d\n", driver, err);
1705 break;
1706 }
1707
1708 if (val != ~420553207) {
1709 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1710 "%d\n", driver, val);
1711 err = -EINVAL;
1712 }
1713 } while (0);
1714
1715 crypto_free_shash(tfm);
1716
1717out:
1718 return err;
1719}
1720
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001721static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1722 u32 type, u32 mask)
1723{
1724 struct crypto_rng *rng;
1725 int err;
1726
Stephan Mueller425a8822015-03-30 21:56:31 +02001727 rng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001728 if (IS_ERR(rng)) {
1729 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1730 "%ld\n", driver, PTR_ERR(rng));
1731 return PTR_ERR(rng);
1732 }
1733
1734 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1735
1736 crypto_free_rng(rng);
1737
1738 return err;
1739}
1740
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001741
1742static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1743 const char *driver, u32 type, u32 mask)
1744{
1745 int ret = -EAGAIN;
1746 struct crypto_rng *drng;
1747 struct drbg_test_data test_data;
1748 struct drbg_string addtl, pers, testentropy;
1749 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1750
1751 if (!buf)
1752 return -ENOMEM;
1753
Stephan Mueller425a8822015-03-30 21:56:31 +02001754 drng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001755 if (IS_ERR(drng)) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001756 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001757 "%s\n", driver);
1758 kzfree(buf);
1759 return -ENOMEM;
1760 }
1761
1762 test_data.testentropy = &testentropy;
1763 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1764 drbg_string_fill(&pers, test->pers, test->perslen);
1765 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1766 if (ret) {
1767 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1768 goto outbuf;
1769 }
1770
1771 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1772 if (pr) {
1773 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1774 ret = crypto_drbg_get_bytes_addtl_test(drng,
1775 buf, test->expectedlen, &addtl, &test_data);
1776 } else {
1777 ret = crypto_drbg_get_bytes_addtl(drng,
1778 buf, test->expectedlen, &addtl);
1779 }
Stephan Mueller19e60e12015-03-10 17:00:36 +01001780 if (ret < 0) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001781 printk(KERN_ERR "alg: drbg: could not obtain random data for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001782 "driver %s\n", driver);
1783 goto outbuf;
1784 }
1785
1786 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1787 if (pr) {
1788 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1789 ret = crypto_drbg_get_bytes_addtl_test(drng,
1790 buf, test->expectedlen, &addtl, &test_data);
1791 } else {
1792 ret = crypto_drbg_get_bytes_addtl(drng,
1793 buf, test->expectedlen, &addtl);
1794 }
Stephan Mueller19e60e12015-03-10 17:00:36 +01001795 if (ret < 0) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001796 printk(KERN_ERR "alg: drbg: could not obtain random data for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001797 "driver %s\n", driver);
1798 goto outbuf;
1799 }
1800
1801 ret = memcmp(test->expected, buf, test->expectedlen);
1802
1803outbuf:
1804 crypto_free_rng(drng);
1805 kzfree(buf);
1806 return ret;
1807}
1808
1809
1810static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1811 u32 type, u32 mask)
1812{
1813 int err = 0;
1814 int pr = 0;
1815 int i = 0;
1816 struct drbg_testvec *template = desc->suite.drbg.vecs;
1817 unsigned int tcount = desc->suite.drbg.count;
1818
1819 if (0 == memcmp(driver, "drbg_pr_", 8))
1820 pr = 1;
1821
1822 for (i = 0; i < tcount; i++) {
1823 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1824 if (err) {
1825 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1826 i, driver);
1827 err = -EINVAL;
1828 break;
1829 }
1830 }
1831 return err;
1832
1833}
1834
Tadeusz Struk946cc462015-06-16 10:31:06 -07001835static int do_test_rsa(struct crypto_akcipher *tfm,
1836 struct akcipher_testvec *vecs)
1837{
1838 struct akcipher_request *req;
1839 void *outbuf_enc = NULL;
1840 void *outbuf_dec = NULL;
1841 struct tcrypt_result result;
1842 unsigned int out_len_max, out_len = 0;
1843 int err = -ENOMEM;
1844
1845 req = akcipher_request_alloc(tfm, GFP_KERNEL);
1846 if (!req)
1847 return err;
1848
1849 init_completion(&result.completion);
1850 err = crypto_akcipher_setkey(tfm, vecs->key, vecs->key_len);
1851 if (err)
1852 goto free_req;
1853
1854 akcipher_request_set_crypt(req, vecs->m, outbuf_enc, vecs->m_size,
1855 out_len);
1856 /* expect this to fail, and update the required buf len */
1857 crypto_akcipher_encrypt(req);
1858 out_len = req->dst_len;
1859 if (!out_len) {
1860 err = -EINVAL;
1861 goto free_req;
1862 }
1863
1864 out_len_max = out_len;
1865 err = -ENOMEM;
1866 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
1867 if (!outbuf_enc)
1868 goto free_req;
1869
1870 akcipher_request_set_crypt(req, vecs->m, outbuf_enc, vecs->m_size,
1871 out_len);
1872 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1873 tcrypt_complete, &result);
1874
1875 /* Run RSA encrypt - c = m^e mod n;*/
1876 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
1877 if (err) {
1878 pr_err("alg: rsa: encrypt test failed. err %d\n", err);
1879 goto free_all;
1880 }
1881 if (out_len != vecs->c_size) {
1882 pr_err("alg: rsa: encrypt test failed. Invalid output len\n");
1883 err = -EINVAL;
1884 goto free_all;
1885 }
1886 /* verify that encrypted message is equal to expected */
1887 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
1888 pr_err("alg: rsa: encrypt test failed. Invalid output\n");
1889 err = -EINVAL;
1890 goto free_all;
1891 }
1892 /* Don't invoke decrypt for vectors with public key */
1893 if (vecs->public_key_vec) {
1894 err = 0;
1895 goto free_all;
1896 }
1897 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
1898 if (!outbuf_dec) {
1899 err = -ENOMEM;
1900 goto free_all;
1901 }
1902 init_completion(&result.completion);
1903 akcipher_request_set_crypt(req, outbuf_enc, outbuf_dec, vecs->c_size,
1904 out_len);
1905
1906 /* Run RSA decrypt - m = c^d mod n;*/
1907 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
1908 if (err) {
1909 pr_err("alg: rsa: decrypt test failed. err %d\n", err);
1910 goto free_all;
1911 }
1912 out_len = req->dst_len;
1913 if (out_len != vecs->m_size) {
1914 pr_err("alg: rsa: decrypt test failed. Invalid output len\n");
1915 err = -EINVAL;
1916 goto free_all;
1917 }
1918 /* verify that decrypted message is equal to the original msg */
1919 if (memcmp(vecs->m, outbuf_dec, vecs->m_size)) {
1920 pr_err("alg: rsa: decrypt test failed. Invalid output\n");
1921 err = -EINVAL;
1922 }
1923free_all:
1924 kfree(outbuf_dec);
1925 kfree(outbuf_enc);
1926free_req:
1927 akcipher_request_free(req);
1928 return err;
1929}
1930
1931static int test_rsa(struct crypto_akcipher *tfm, struct akcipher_testvec *vecs,
1932 unsigned int tcount)
1933{
1934 int ret, i;
1935
1936 for (i = 0; i < tcount; i++) {
1937 ret = do_test_rsa(tfm, vecs++);
1938 if (ret) {
1939 pr_err("alg: rsa: test failed on vector %d, err=%d\n",
1940 i + 1, ret);
1941 return ret;
1942 }
1943 }
1944 return 0;
1945}
1946
1947static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
1948 struct akcipher_testvec *vecs, unsigned int tcount)
1949{
1950 if (strncmp(alg, "rsa", 3) == 0)
1951 return test_rsa(tfm, vecs, tcount);
1952
1953 return 0;
1954}
1955
1956static int alg_test_akcipher(const struct alg_test_desc *desc,
1957 const char *driver, u32 type, u32 mask)
1958{
1959 struct crypto_akcipher *tfm;
1960 int err = 0;
1961
1962 tfm = crypto_alloc_akcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1963 if (IS_ERR(tfm)) {
1964 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
1965 driver, PTR_ERR(tfm));
1966 return PTR_ERR(tfm);
1967 }
1968 if (desc->suite.akcipher.vecs)
1969 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
1970 desc->suite.akcipher.count);
1971
1972 crypto_free_akcipher(tfm);
1973 return err;
1974}
1975
Youquan, Song863b5572009-12-23 19:45:20 +08001976static int alg_test_null(const struct alg_test_desc *desc,
1977 const char *driver, u32 type, u32 mask)
1978{
1979 return 0;
1980}
1981
Herbert Xuda7f0332008-07-31 17:08:25 +08001982/* Please keep this list sorted by algorithm name. */
1983static const struct alg_test_desc alg_test_descs[] = {
1984 {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001985 .alg = "__cbc-cast5-avx",
1986 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02001987 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001988 .alg = "__cbc-cast6-avx",
1989 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02001990 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001991 .alg = "__cbc-serpent-avx",
1992 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08001993 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03001994 .alg = "__cbc-serpent-avx2",
1995 .test = alg_test_null,
1996 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001997 .alg = "__cbc-serpent-sse2",
1998 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02001999 }, {
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002000 .alg = "__cbc-twofish-avx",
2001 .test = alg_test_null,
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002002 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002003 .alg = "__driver-cbc-aes-aesni",
2004 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002005 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002006 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002007 .alg = "__driver-cbc-camellia-aesni",
2008 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002009 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03002010 .alg = "__driver-cbc-camellia-aesni-avx2",
2011 .test = alg_test_null,
2012 }, {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002013 .alg = "__driver-cbc-cast5-avx",
2014 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002015 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002016 .alg = "__driver-cbc-cast6-avx",
2017 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002018 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002019 .alg = "__driver-cbc-serpent-avx",
2020 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002021 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03002022 .alg = "__driver-cbc-serpent-avx2",
2023 .test = alg_test_null,
2024 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002025 .alg = "__driver-cbc-serpent-sse2",
2026 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002027 }, {
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002028 .alg = "__driver-cbc-twofish-avx",
2029 .test = alg_test_null,
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002030 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002031 .alg = "__driver-ecb-aes-aesni",
2032 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002033 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002034 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002035 .alg = "__driver-ecb-camellia-aesni",
2036 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002037 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03002038 .alg = "__driver-ecb-camellia-aesni-avx2",
2039 .test = alg_test_null,
2040 }, {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002041 .alg = "__driver-ecb-cast5-avx",
2042 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002043 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002044 .alg = "__driver-ecb-cast6-avx",
2045 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002046 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002047 .alg = "__driver-ecb-serpent-avx",
2048 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002049 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03002050 .alg = "__driver-ecb-serpent-avx2",
2051 .test = alg_test_null,
2052 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002053 .alg = "__driver-ecb-serpent-sse2",
2054 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002055 }, {
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002056 .alg = "__driver-ecb-twofish-avx",
2057 .test = alg_test_null,
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002058 }, {
Tadeusz Struk9d77b6c2015-06-24 09:01:30 -07002059 .alg = "__driver-gcm-aes-aesni",
2060 .test = alg_test_null,
2061 .fips_allowed = 1,
2062 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002063 .alg = "__ghash-pclmulqdqni",
2064 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002065 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002066 }, {
Jarod Wilsone08ca2d2009-05-04 19:46:29 +08002067 .alg = "ansi_cprng",
2068 .test = alg_test_cprng,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002069 .fips_allowed = 1,
Jarod Wilsone08ca2d2009-05-04 19:46:29 +08002070 .suite = {
2071 .cprng = {
2072 .vecs = ansi_cprng_aes_tv_template,
2073 .count = ANSI_CPRNG_AES_TEST_VECTORS
2074 }
2075 }
2076 }, {
Horia Geantabca4feb2014-03-14 17:46:51 +02002077 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2078 .test = alg_test_aead,
2079 .fips_allowed = 1,
2080 .suite = {
2081 .aead = {
2082 .enc = {
2083 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2084 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2085 },
2086 .dec = {
2087 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2088 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2089 }
2090 }
2091 }
2092 }, {
Horia Geantae46e9a42012-07-03 19:16:54 +03002093 .alg = "authenc(hmac(sha1),cbc(aes))",
2094 .test = alg_test_aead,
2095 .fips_allowed = 1,
2096 .suite = {
2097 .aead = {
2098 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302099 .vecs =
2100 hmac_sha1_aes_cbc_enc_tv_temp,
2101 .count =
2102 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2103 }
2104 }
2105 }
2106 }, {
2107 .alg = "authenc(hmac(sha1),cbc(des))",
2108 .test = alg_test_aead,
2109 .fips_allowed = 1,
2110 .suite = {
2111 .aead = {
2112 .enc = {
2113 .vecs =
2114 hmac_sha1_des_cbc_enc_tv_temp,
2115 .count =
2116 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2117 }
2118 }
2119 }
2120 }, {
2121 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
2122 .test = alg_test_aead,
2123 .fips_allowed = 1,
2124 .suite = {
2125 .aead = {
2126 .enc = {
2127 .vecs =
2128 hmac_sha1_des3_ede_cbc_enc_tv_temp,
2129 .count =
2130 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantae46e9a42012-07-03 19:16:54 +03002131 }
2132 }
2133 }
2134 }, {
Horia Geantabca4feb2014-03-14 17:46:51 +02002135 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2136 .test = alg_test_aead,
2137 .fips_allowed = 1,
2138 .suite = {
2139 .aead = {
2140 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302141 .vecs =
2142 hmac_sha1_ecb_cipher_null_enc_tv_temp,
2143 .count =
2144 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
Horia Geantabca4feb2014-03-14 17:46:51 +02002145 },
2146 .dec = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302147 .vecs =
2148 hmac_sha1_ecb_cipher_null_dec_tv_temp,
2149 .count =
2150 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2151 }
2152 }
2153 }
2154 }, {
2155 .alg = "authenc(hmac(sha224),cbc(des))",
2156 .test = alg_test_aead,
2157 .fips_allowed = 1,
2158 .suite = {
2159 .aead = {
2160 .enc = {
2161 .vecs =
2162 hmac_sha224_des_cbc_enc_tv_temp,
2163 .count =
2164 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2165 }
2166 }
2167 }
2168 }, {
2169 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
2170 .test = alg_test_aead,
2171 .fips_allowed = 1,
2172 .suite = {
2173 .aead = {
2174 .enc = {
2175 .vecs =
2176 hmac_sha224_des3_ede_cbc_enc_tv_temp,
2177 .count =
2178 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantabca4feb2014-03-14 17:46:51 +02002179 }
2180 }
2181 }
2182 }, {
Horia Geantae46e9a42012-07-03 19:16:54 +03002183 .alg = "authenc(hmac(sha256),cbc(aes))",
2184 .test = alg_test_aead,
2185 .fips_allowed = 1,
2186 .suite = {
2187 .aead = {
2188 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302189 .vecs =
2190 hmac_sha256_aes_cbc_enc_tv_temp,
2191 .count =
2192 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2193 }
2194 }
2195 }
2196 }, {
2197 .alg = "authenc(hmac(sha256),cbc(des))",
2198 .test = alg_test_aead,
2199 .fips_allowed = 1,
2200 .suite = {
2201 .aead = {
2202 .enc = {
2203 .vecs =
2204 hmac_sha256_des_cbc_enc_tv_temp,
2205 .count =
2206 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2207 }
2208 }
2209 }
2210 }, {
2211 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
2212 .test = alg_test_aead,
2213 .fips_allowed = 1,
2214 .suite = {
2215 .aead = {
2216 .enc = {
2217 .vecs =
2218 hmac_sha256_des3_ede_cbc_enc_tv_temp,
2219 .count =
2220 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2221 }
2222 }
2223 }
2224 }, {
2225 .alg = "authenc(hmac(sha384),cbc(des))",
2226 .test = alg_test_aead,
2227 .fips_allowed = 1,
2228 .suite = {
2229 .aead = {
2230 .enc = {
2231 .vecs =
2232 hmac_sha384_des_cbc_enc_tv_temp,
2233 .count =
2234 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2235 }
2236 }
2237 }
2238 }, {
2239 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
2240 .test = alg_test_aead,
2241 .fips_allowed = 1,
2242 .suite = {
2243 .aead = {
2244 .enc = {
2245 .vecs =
2246 hmac_sha384_des3_ede_cbc_enc_tv_temp,
2247 .count =
2248 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantae46e9a42012-07-03 19:16:54 +03002249 }
2250 }
2251 }
2252 }, {
2253 .alg = "authenc(hmac(sha512),cbc(aes))",
2254 .test = alg_test_aead,
2255 .fips_allowed = 1,
2256 .suite = {
2257 .aead = {
2258 .enc = {
Nitesh Lal5208ed22014-05-21 17:09:08 +05302259 .vecs =
2260 hmac_sha512_aes_cbc_enc_tv_temp,
2261 .count =
2262 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2263 }
2264 }
2265 }
2266 }, {
2267 .alg = "authenc(hmac(sha512),cbc(des))",
2268 .test = alg_test_aead,
2269 .fips_allowed = 1,
2270 .suite = {
2271 .aead = {
2272 .enc = {
2273 .vecs =
2274 hmac_sha512_des_cbc_enc_tv_temp,
2275 .count =
2276 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2277 }
2278 }
2279 }
2280 }, {
2281 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
2282 .test = alg_test_aead,
2283 .fips_allowed = 1,
2284 .suite = {
2285 .aead = {
2286 .enc = {
2287 .vecs =
2288 hmac_sha512_des3_ede_cbc_enc_tv_temp,
2289 .count =
2290 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
Horia Geantae46e9a42012-07-03 19:16:54 +03002291 }
2292 }
2293 }
2294 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002295 .alg = "cbc(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002296 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002297 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002298 .suite = {
2299 .cipher = {
2300 .enc = {
2301 .vecs = aes_cbc_enc_tv_template,
2302 .count = AES_CBC_ENC_TEST_VECTORS
2303 },
2304 .dec = {
2305 .vecs = aes_cbc_dec_tv_template,
2306 .count = AES_CBC_DEC_TEST_VECTORS
2307 }
2308 }
2309 }
2310 }, {
2311 .alg = "cbc(anubis)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002312 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002313 .suite = {
2314 .cipher = {
2315 .enc = {
2316 .vecs = anubis_cbc_enc_tv_template,
2317 .count = ANUBIS_CBC_ENC_TEST_VECTORS
2318 },
2319 .dec = {
2320 .vecs = anubis_cbc_dec_tv_template,
2321 .count = ANUBIS_CBC_DEC_TEST_VECTORS
2322 }
2323 }
2324 }
2325 }, {
2326 .alg = "cbc(blowfish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002327 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002328 .suite = {
2329 .cipher = {
2330 .enc = {
2331 .vecs = bf_cbc_enc_tv_template,
2332 .count = BF_CBC_ENC_TEST_VECTORS
2333 },
2334 .dec = {
2335 .vecs = bf_cbc_dec_tv_template,
2336 .count = BF_CBC_DEC_TEST_VECTORS
2337 }
2338 }
2339 }
2340 }, {
2341 .alg = "cbc(camellia)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002342 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002343 .suite = {
2344 .cipher = {
2345 .enc = {
2346 .vecs = camellia_cbc_enc_tv_template,
2347 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2348 },
2349 .dec = {
2350 .vecs = camellia_cbc_dec_tv_template,
2351 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2352 }
2353 }
2354 }
2355 }, {
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002356 .alg = "cbc(cast5)",
2357 .test = alg_test_skcipher,
2358 .suite = {
2359 .cipher = {
2360 .enc = {
2361 .vecs = cast5_cbc_enc_tv_template,
2362 .count = CAST5_CBC_ENC_TEST_VECTORS
2363 },
2364 .dec = {
2365 .vecs = cast5_cbc_dec_tv_template,
2366 .count = CAST5_CBC_DEC_TEST_VECTORS
2367 }
2368 }
2369 }
2370 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002371 .alg = "cbc(cast6)",
2372 .test = alg_test_skcipher,
2373 .suite = {
2374 .cipher = {
2375 .enc = {
2376 .vecs = cast6_cbc_enc_tv_template,
2377 .count = CAST6_CBC_ENC_TEST_VECTORS
2378 },
2379 .dec = {
2380 .vecs = cast6_cbc_dec_tv_template,
2381 .count = CAST6_CBC_DEC_TEST_VECTORS
2382 }
2383 }
2384 }
2385 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002386 .alg = "cbc(des)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002387 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002388 .suite = {
2389 .cipher = {
2390 .enc = {
2391 .vecs = des_cbc_enc_tv_template,
2392 .count = DES_CBC_ENC_TEST_VECTORS
2393 },
2394 .dec = {
2395 .vecs = des_cbc_dec_tv_template,
2396 .count = DES_CBC_DEC_TEST_VECTORS
2397 }
2398 }
2399 }
2400 }, {
2401 .alg = "cbc(des3_ede)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002402 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002403 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002404 .suite = {
2405 .cipher = {
2406 .enc = {
2407 .vecs = des3_ede_cbc_enc_tv_template,
2408 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2409 },
2410 .dec = {
2411 .vecs = des3_ede_cbc_dec_tv_template,
2412 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2413 }
2414 }
2415 }
2416 }, {
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002417 .alg = "cbc(serpent)",
2418 .test = alg_test_skcipher,
2419 .suite = {
2420 .cipher = {
2421 .enc = {
2422 .vecs = serpent_cbc_enc_tv_template,
2423 .count = SERPENT_CBC_ENC_TEST_VECTORS
2424 },
2425 .dec = {
2426 .vecs = serpent_cbc_dec_tv_template,
2427 .count = SERPENT_CBC_DEC_TEST_VECTORS
2428 }
2429 }
2430 }
2431 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002432 .alg = "cbc(twofish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002433 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002434 .suite = {
2435 .cipher = {
2436 .enc = {
2437 .vecs = tf_cbc_enc_tv_template,
2438 .count = TF_CBC_ENC_TEST_VECTORS
2439 },
2440 .dec = {
2441 .vecs = tf_cbc_dec_tv_template,
2442 .count = TF_CBC_DEC_TEST_VECTORS
2443 }
2444 }
2445 }
2446 }, {
2447 .alg = "ccm(aes)",
2448 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002449 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002450 .suite = {
2451 .aead = {
2452 .enc = {
2453 .vecs = aes_ccm_enc_tv_template,
2454 .count = AES_CCM_ENC_TEST_VECTORS
2455 },
2456 .dec = {
2457 .vecs = aes_ccm_dec_tv_template,
2458 .count = AES_CCM_DEC_TEST_VECTORS
2459 }
2460 }
2461 }
2462 }, {
Martin Willi3590ebf2015-06-01 13:43:57 +02002463 .alg = "chacha20",
2464 .test = alg_test_skcipher,
2465 .suite = {
2466 .cipher = {
2467 .enc = {
2468 .vecs = chacha20_enc_tv_template,
2469 .count = CHACHA20_ENC_TEST_VECTORS
2470 },
2471 .dec = {
2472 .vecs = chacha20_enc_tv_template,
2473 .count = CHACHA20_ENC_TEST_VECTORS
2474 },
2475 }
2476 }
2477 }, {
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002478 .alg = "cmac(aes)",
2479 .test = alg_test_hash,
2480 .suite = {
2481 .hash = {
2482 .vecs = aes_cmac128_tv_template,
2483 .count = CMAC_AES_TEST_VECTORS
2484 }
2485 }
2486 }, {
2487 .alg = "cmac(des3_ede)",
2488 .test = alg_test_hash,
2489 .suite = {
2490 .hash = {
2491 .vecs = des3_ede_cmac64_tv_template,
2492 .count = CMAC_DES3_EDE_TEST_VECTORS
2493 }
2494 }
2495 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002496 .alg = "compress_null",
2497 .test = alg_test_null,
2498 }, {
Ard Biesheuvelebb34722015-05-04 11:00:17 +02002499 .alg = "crc32",
2500 .test = alg_test_hash,
2501 .suite = {
2502 .hash = {
2503 .vecs = crc32_tv_template,
2504 .count = CRC32_TEST_VECTORS
2505 }
2506 }
2507 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002508 .alg = "crc32c",
Herbert Xu8e3ee852008-11-07 14:58:52 +08002509 .test = alg_test_crc32c,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002510 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002511 .suite = {
2512 .hash = {
2513 .vecs = crc32c_tv_template,
2514 .count = CRC32C_TEST_VECTORS
2515 }
2516 }
2517 }, {
Herbert Xu684115212013-09-07 12:56:26 +10002518 .alg = "crct10dif",
2519 .test = alg_test_hash,
2520 .fips_allowed = 1,
2521 .suite = {
2522 .hash = {
2523 .vecs = crct10dif_tv_template,
2524 .count = CRCT10DIF_TEST_VECTORS
2525 }
2526 }
2527 }, {
Milan Broz6c792942012-06-29 22:08:09 +02002528 .alg = "cryptd(__driver-cbc-aes-aesni)",
2529 .test = alg_test_null,
2530 .fips_allowed = 1,
Milan Broz6c792942012-06-29 22:08:09 +02002531 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002532 .alg = "cryptd(__driver-cbc-camellia-aesni)",
2533 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002534 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03002535 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2536 .test = alg_test_null,
2537 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03002538 .alg = "cryptd(__driver-cbc-serpent-avx2)",
2539 .test = alg_test_null,
2540 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002541 .alg = "cryptd(__driver-ecb-aes-aesni)",
2542 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002543 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002544 }, {
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002545 .alg = "cryptd(__driver-ecb-camellia-aesni)",
2546 .test = alg_test_null,
Jussi Kivilinnad9b1d2e2012-10-26 14:49:01 +03002547 }, {
Jussi Kivilinnaf3f935a2013-04-13 13:47:00 +03002548 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2549 .test = alg_test_null,
2550 }, {
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002551 .alg = "cryptd(__driver-ecb-cast5-avx)",
2552 .test = alg_test_null,
Johannes Goetzfried4d6d6a22012-07-11 19:37:37 +02002553 }, {
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002554 .alg = "cryptd(__driver-ecb-cast6-avx)",
2555 .test = alg_test_null,
Johannes Goetzfried4ea12772012-07-11 19:38:57 +02002556 }, {
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002557 .alg = "cryptd(__driver-ecb-serpent-avx)",
2558 .test = alg_test_null,
Johannes Goetzfried7efe4072012-06-12 16:47:43 +08002559 }, {
Jussi Kivilinna56d76c92013-04-13 13:46:55 +03002560 .alg = "cryptd(__driver-ecb-serpent-avx2)",
2561 .test = alg_test_null,
2562 }, {
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002563 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2564 .test = alg_test_null,
Jussi Kivilinna937c30d2011-11-09 16:26:25 +02002565 }, {
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002566 .alg = "cryptd(__driver-ecb-twofish-avx)",
2567 .test = alg_test_null,
Johannes Goetzfried107778b2012-05-28 15:54:24 +02002568 }, {
Milan Broz6c792942012-06-29 22:08:09 +02002569 .alg = "cryptd(__driver-gcm-aes-aesni)",
2570 .test = alg_test_null,
2571 .fips_allowed = 1,
Milan Broz6c792942012-06-29 22:08:09 +02002572 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002573 .alg = "cryptd(__ghash-pclmulqdqni)",
2574 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002575 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002576 }, {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002577 .alg = "ctr(aes)",
2578 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002579 .fips_allowed = 1,
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002580 .suite = {
2581 .cipher = {
2582 .enc = {
2583 .vecs = aes_ctr_enc_tv_template,
2584 .count = AES_CTR_ENC_TEST_VECTORS
2585 },
2586 .dec = {
2587 .vecs = aes_ctr_dec_tv_template,
2588 .count = AES_CTR_DEC_TEST_VECTORS
2589 }
2590 }
2591 }
2592 }, {
Jussi Kivilinna85b63e32011-10-10 23:03:03 +03002593 .alg = "ctr(blowfish)",
2594 .test = alg_test_skcipher,
2595 .suite = {
2596 .cipher = {
2597 .enc = {
2598 .vecs = bf_ctr_enc_tv_template,
2599 .count = BF_CTR_ENC_TEST_VECTORS
2600 },
2601 .dec = {
2602 .vecs = bf_ctr_dec_tv_template,
2603 .count = BF_CTR_DEC_TEST_VECTORS
2604 }
2605 }
2606 }
2607 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02002608 .alg = "ctr(camellia)",
2609 .test = alg_test_skcipher,
2610 .suite = {
2611 .cipher = {
2612 .enc = {
2613 .vecs = camellia_ctr_enc_tv_template,
2614 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2615 },
2616 .dec = {
2617 .vecs = camellia_ctr_dec_tv_template,
2618 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2619 }
2620 }
2621 }
2622 }, {
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002623 .alg = "ctr(cast5)",
2624 .test = alg_test_skcipher,
2625 .suite = {
2626 .cipher = {
2627 .enc = {
2628 .vecs = cast5_ctr_enc_tv_template,
2629 .count = CAST5_CTR_ENC_TEST_VECTORS
2630 },
2631 .dec = {
2632 .vecs = cast5_ctr_dec_tv_template,
2633 .count = CAST5_CTR_DEC_TEST_VECTORS
2634 }
2635 }
2636 }
2637 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002638 .alg = "ctr(cast6)",
2639 .test = alg_test_skcipher,
2640 .suite = {
2641 .cipher = {
2642 .enc = {
2643 .vecs = cast6_ctr_enc_tv_template,
2644 .count = CAST6_CTR_ENC_TEST_VECTORS
2645 },
2646 .dec = {
2647 .vecs = cast6_ctr_dec_tv_template,
2648 .count = CAST6_CTR_DEC_TEST_VECTORS
2649 }
2650 }
2651 }
2652 }, {
Jussi Kivilinna8163fc32012-10-20 14:53:07 +03002653 .alg = "ctr(des)",
2654 .test = alg_test_skcipher,
2655 .suite = {
2656 .cipher = {
2657 .enc = {
2658 .vecs = des_ctr_enc_tv_template,
2659 .count = DES_CTR_ENC_TEST_VECTORS
2660 },
2661 .dec = {
2662 .vecs = des_ctr_dec_tv_template,
2663 .count = DES_CTR_DEC_TEST_VECTORS
2664 }
2665 }
2666 }
2667 }, {
Jussi Kivilinnae080b172012-10-20 14:53:12 +03002668 .alg = "ctr(des3_ede)",
2669 .test = alg_test_skcipher,
2670 .suite = {
2671 .cipher = {
2672 .enc = {
2673 .vecs = des3_ede_ctr_enc_tv_template,
2674 .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2675 },
2676 .dec = {
2677 .vecs = des3_ede_ctr_dec_tv_template,
2678 .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2679 }
2680 }
2681 }
2682 }, {
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002683 .alg = "ctr(serpent)",
2684 .test = alg_test_skcipher,
2685 .suite = {
2686 .cipher = {
2687 .enc = {
2688 .vecs = serpent_ctr_enc_tv_template,
2689 .count = SERPENT_CTR_ENC_TEST_VECTORS
2690 },
2691 .dec = {
2692 .vecs = serpent_ctr_dec_tv_template,
2693 .count = SERPENT_CTR_DEC_TEST_VECTORS
2694 }
2695 }
2696 }
2697 }, {
Jussi Kivilinna573da622011-10-10 23:03:12 +03002698 .alg = "ctr(twofish)",
2699 .test = alg_test_skcipher,
2700 .suite = {
2701 .cipher = {
2702 .enc = {
2703 .vecs = tf_ctr_enc_tv_template,
2704 .count = TF_CTR_ENC_TEST_VECTORS
2705 },
2706 .dec = {
2707 .vecs = tf_ctr_dec_tv_template,
2708 .count = TF_CTR_DEC_TEST_VECTORS
2709 }
2710 }
2711 }
2712 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002713 .alg = "cts(cbc(aes))",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002714 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002715 .suite = {
2716 .cipher = {
2717 .enc = {
2718 .vecs = cts_mode_enc_tv_template,
2719 .count = CTS_MODE_ENC_TEST_VECTORS
2720 },
2721 .dec = {
2722 .vecs = cts_mode_dec_tv_template,
2723 .count = CTS_MODE_DEC_TEST_VECTORS
2724 }
2725 }
2726 }
2727 }, {
2728 .alg = "deflate",
2729 .test = alg_test_comp,
Milan Broz08189042012-12-06 17:16:28 +08002730 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002731 .suite = {
2732 .comp = {
2733 .comp = {
2734 .vecs = deflate_comp_tv_template,
2735 .count = DEFLATE_COMP_TEST_VECTORS
2736 },
2737 .decomp = {
2738 .vecs = deflate_decomp_tv_template,
2739 .count = DEFLATE_DECOMP_TEST_VECTORS
2740 }
2741 }
2742 }
2743 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002744 .alg = "digest_null",
2745 .test = alg_test_null,
2746 }, {
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002747 .alg = "drbg_nopr_ctr_aes128",
2748 .test = alg_test_drbg,
2749 .fips_allowed = 1,
2750 .suite = {
2751 .drbg = {
2752 .vecs = drbg_nopr_ctr_aes128_tv_template,
2753 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2754 }
2755 }
2756 }, {
2757 .alg = "drbg_nopr_ctr_aes192",
2758 .test = alg_test_drbg,
2759 .fips_allowed = 1,
2760 .suite = {
2761 .drbg = {
2762 .vecs = drbg_nopr_ctr_aes192_tv_template,
2763 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2764 }
2765 }
2766 }, {
2767 .alg = "drbg_nopr_ctr_aes256",
2768 .test = alg_test_drbg,
2769 .fips_allowed = 1,
2770 .suite = {
2771 .drbg = {
2772 .vecs = drbg_nopr_ctr_aes256_tv_template,
2773 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2774 }
2775 }
2776 }, {
2777 /*
2778 * There is no need to specifically test the DRBG with every
2779 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2780 */
2781 .alg = "drbg_nopr_hmac_sha1",
2782 .fips_allowed = 1,
2783 .test = alg_test_null,
2784 }, {
2785 .alg = "drbg_nopr_hmac_sha256",
2786 .test = alg_test_drbg,
2787 .fips_allowed = 1,
2788 .suite = {
2789 .drbg = {
2790 .vecs = drbg_nopr_hmac_sha256_tv_template,
2791 .count =
2792 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2793 }
2794 }
2795 }, {
2796 /* covered by drbg_nopr_hmac_sha256 test */
2797 .alg = "drbg_nopr_hmac_sha384",
2798 .fips_allowed = 1,
2799 .test = alg_test_null,
2800 }, {
2801 .alg = "drbg_nopr_hmac_sha512",
2802 .test = alg_test_null,
2803 .fips_allowed = 1,
2804 }, {
2805 .alg = "drbg_nopr_sha1",
2806 .fips_allowed = 1,
2807 .test = alg_test_null,
2808 }, {
2809 .alg = "drbg_nopr_sha256",
2810 .test = alg_test_drbg,
2811 .fips_allowed = 1,
2812 .suite = {
2813 .drbg = {
2814 .vecs = drbg_nopr_sha256_tv_template,
2815 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2816 }
2817 }
2818 }, {
2819 /* covered by drbg_nopr_sha256 test */
2820 .alg = "drbg_nopr_sha384",
2821 .fips_allowed = 1,
2822 .test = alg_test_null,
2823 }, {
2824 .alg = "drbg_nopr_sha512",
2825 .fips_allowed = 1,
2826 .test = alg_test_null,
2827 }, {
2828 .alg = "drbg_pr_ctr_aes128",
2829 .test = alg_test_drbg,
2830 .fips_allowed = 1,
2831 .suite = {
2832 .drbg = {
2833 .vecs = drbg_pr_ctr_aes128_tv_template,
2834 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
2835 }
2836 }
2837 }, {
2838 /* covered by drbg_pr_ctr_aes128 test */
2839 .alg = "drbg_pr_ctr_aes192",
2840 .fips_allowed = 1,
2841 .test = alg_test_null,
2842 }, {
2843 .alg = "drbg_pr_ctr_aes256",
2844 .fips_allowed = 1,
2845 .test = alg_test_null,
2846 }, {
2847 .alg = "drbg_pr_hmac_sha1",
2848 .fips_allowed = 1,
2849 .test = alg_test_null,
2850 }, {
2851 .alg = "drbg_pr_hmac_sha256",
2852 .test = alg_test_drbg,
2853 .fips_allowed = 1,
2854 .suite = {
2855 .drbg = {
2856 .vecs = drbg_pr_hmac_sha256_tv_template,
2857 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
2858 }
2859 }
2860 }, {
2861 /* covered by drbg_pr_hmac_sha256 test */
2862 .alg = "drbg_pr_hmac_sha384",
2863 .fips_allowed = 1,
2864 .test = alg_test_null,
2865 }, {
2866 .alg = "drbg_pr_hmac_sha512",
2867 .test = alg_test_null,
2868 .fips_allowed = 1,
2869 }, {
2870 .alg = "drbg_pr_sha1",
2871 .fips_allowed = 1,
2872 .test = alg_test_null,
2873 }, {
2874 .alg = "drbg_pr_sha256",
2875 .test = alg_test_drbg,
2876 .fips_allowed = 1,
2877 .suite = {
2878 .drbg = {
2879 .vecs = drbg_pr_sha256_tv_template,
2880 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
2881 }
2882 }
2883 }, {
2884 /* covered by drbg_pr_sha256 test */
2885 .alg = "drbg_pr_sha384",
2886 .fips_allowed = 1,
2887 .test = alg_test_null,
2888 }, {
2889 .alg = "drbg_pr_sha512",
2890 .fips_allowed = 1,
2891 .test = alg_test_null,
2892 }, {
Youquan, Song863b5572009-12-23 19:45:20 +08002893 .alg = "ecb(__aes-aesni)",
2894 .test = alg_test_null,
Milan Broz6c792942012-06-29 22:08:09 +02002895 .fips_allowed = 1,
Youquan, Song863b5572009-12-23 19:45:20 +08002896 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002897 .alg = "ecb(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002898 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002899 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002900 .suite = {
2901 .cipher = {
2902 .enc = {
2903 .vecs = aes_enc_tv_template,
2904 .count = AES_ENC_TEST_VECTORS
2905 },
2906 .dec = {
2907 .vecs = aes_dec_tv_template,
2908 .count = AES_DEC_TEST_VECTORS
2909 }
2910 }
2911 }
2912 }, {
2913 .alg = "ecb(anubis)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002914 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002915 .suite = {
2916 .cipher = {
2917 .enc = {
2918 .vecs = anubis_enc_tv_template,
2919 .count = ANUBIS_ENC_TEST_VECTORS
2920 },
2921 .dec = {
2922 .vecs = anubis_dec_tv_template,
2923 .count = ANUBIS_DEC_TEST_VECTORS
2924 }
2925 }
2926 }
2927 }, {
2928 .alg = "ecb(arc4)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002929 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002930 .suite = {
2931 .cipher = {
2932 .enc = {
2933 .vecs = arc4_enc_tv_template,
2934 .count = ARC4_ENC_TEST_VECTORS
2935 },
2936 .dec = {
2937 .vecs = arc4_dec_tv_template,
2938 .count = ARC4_DEC_TEST_VECTORS
2939 }
2940 }
2941 }
2942 }, {
2943 .alg = "ecb(blowfish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002944 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002945 .suite = {
2946 .cipher = {
2947 .enc = {
2948 .vecs = bf_enc_tv_template,
2949 .count = BF_ENC_TEST_VECTORS
2950 },
2951 .dec = {
2952 .vecs = bf_dec_tv_template,
2953 .count = BF_DEC_TEST_VECTORS
2954 }
2955 }
2956 }
2957 }, {
2958 .alg = "ecb(camellia)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002959 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002960 .suite = {
2961 .cipher = {
2962 .enc = {
2963 .vecs = camellia_enc_tv_template,
2964 .count = CAMELLIA_ENC_TEST_VECTORS
2965 },
2966 .dec = {
2967 .vecs = camellia_dec_tv_template,
2968 .count = CAMELLIA_DEC_TEST_VECTORS
2969 }
2970 }
2971 }
2972 }, {
2973 .alg = "ecb(cast5)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002974 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002975 .suite = {
2976 .cipher = {
2977 .enc = {
2978 .vecs = cast5_enc_tv_template,
2979 .count = CAST5_ENC_TEST_VECTORS
2980 },
2981 .dec = {
2982 .vecs = cast5_dec_tv_template,
2983 .count = CAST5_DEC_TEST_VECTORS
2984 }
2985 }
2986 }
2987 }, {
2988 .alg = "ecb(cast6)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002989 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002990 .suite = {
2991 .cipher = {
2992 .enc = {
2993 .vecs = cast6_enc_tv_template,
2994 .count = CAST6_ENC_TEST_VECTORS
2995 },
2996 .dec = {
2997 .vecs = cast6_dec_tv_template,
2998 .count = CAST6_DEC_TEST_VECTORS
2999 }
3000 }
3001 }
3002 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03003003 .alg = "ecb(cipher_null)",
3004 .test = alg_test_null,
3005 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003006 .alg = "ecb(des)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003007 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003008 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003009 .suite = {
3010 .cipher = {
3011 .enc = {
3012 .vecs = des_enc_tv_template,
3013 .count = DES_ENC_TEST_VECTORS
3014 },
3015 .dec = {
3016 .vecs = des_dec_tv_template,
3017 .count = DES_DEC_TEST_VECTORS
3018 }
3019 }
3020 }
3021 }, {
3022 .alg = "ecb(des3_ede)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003023 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003024 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003025 .suite = {
3026 .cipher = {
3027 .enc = {
3028 .vecs = des3_ede_enc_tv_template,
3029 .count = DES3_EDE_ENC_TEST_VECTORS
3030 },
3031 .dec = {
3032 .vecs = des3_ede_dec_tv_template,
3033 .count = DES3_EDE_DEC_TEST_VECTORS
3034 }
3035 }
3036 }
3037 }, {
Jussi Kivilinna66e5bd02013-01-19 13:31:36 +02003038 .alg = "ecb(fcrypt)",
3039 .test = alg_test_skcipher,
3040 .suite = {
3041 .cipher = {
3042 .enc = {
3043 .vecs = fcrypt_pcbc_enc_tv_template,
3044 .count = 1
3045 },
3046 .dec = {
3047 .vecs = fcrypt_pcbc_dec_tv_template,
3048 .count = 1
3049 }
3050 }
3051 }
3052 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003053 .alg = "ecb(khazad)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003054 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003055 .suite = {
3056 .cipher = {
3057 .enc = {
3058 .vecs = khazad_enc_tv_template,
3059 .count = KHAZAD_ENC_TEST_VECTORS
3060 },
3061 .dec = {
3062 .vecs = khazad_dec_tv_template,
3063 .count = KHAZAD_DEC_TEST_VECTORS
3064 }
3065 }
3066 }
3067 }, {
3068 .alg = "ecb(seed)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003069 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003070 .suite = {
3071 .cipher = {
3072 .enc = {
3073 .vecs = seed_enc_tv_template,
3074 .count = SEED_ENC_TEST_VECTORS
3075 },
3076 .dec = {
3077 .vecs = seed_dec_tv_template,
3078 .count = SEED_DEC_TEST_VECTORS
3079 }
3080 }
3081 }
3082 }, {
3083 .alg = "ecb(serpent)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003084 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003085 .suite = {
3086 .cipher = {
3087 .enc = {
3088 .vecs = serpent_enc_tv_template,
3089 .count = SERPENT_ENC_TEST_VECTORS
3090 },
3091 .dec = {
3092 .vecs = serpent_dec_tv_template,
3093 .count = SERPENT_DEC_TEST_VECTORS
3094 }
3095 }
3096 }
3097 }, {
3098 .alg = "ecb(tea)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003099 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003100 .suite = {
3101 .cipher = {
3102 .enc = {
3103 .vecs = tea_enc_tv_template,
3104 .count = TEA_ENC_TEST_VECTORS
3105 },
3106 .dec = {
3107 .vecs = tea_dec_tv_template,
3108 .count = TEA_DEC_TEST_VECTORS
3109 }
3110 }
3111 }
3112 }, {
3113 .alg = "ecb(tnepres)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003114 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003115 .suite = {
3116 .cipher = {
3117 .enc = {
3118 .vecs = tnepres_enc_tv_template,
3119 .count = TNEPRES_ENC_TEST_VECTORS
3120 },
3121 .dec = {
3122 .vecs = tnepres_dec_tv_template,
3123 .count = TNEPRES_DEC_TEST_VECTORS
3124 }
3125 }
3126 }
3127 }, {
3128 .alg = "ecb(twofish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003129 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003130 .suite = {
3131 .cipher = {
3132 .enc = {
3133 .vecs = tf_enc_tv_template,
3134 .count = TF_ENC_TEST_VECTORS
3135 },
3136 .dec = {
3137 .vecs = tf_dec_tv_template,
3138 .count = TF_DEC_TEST_VECTORS
3139 }
3140 }
3141 }
3142 }, {
3143 .alg = "ecb(xeta)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003144 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003145 .suite = {
3146 .cipher = {
3147 .enc = {
3148 .vecs = xeta_enc_tv_template,
3149 .count = XETA_ENC_TEST_VECTORS
3150 },
3151 .dec = {
3152 .vecs = xeta_dec_tv_template,
3153 .count = XETA_DEC_TEST_VECTORS
3154 }
3155 }
3156 }
3157 }, {
3158 .alg = "ecb(xtea)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003159 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003160 .suite = {
3161 .cipher = {
3162 .enc = {
3163 .vecs = xtea_enc_tv_template,
3164 .count = XTEA_ENC_TEST_VECTORS
3165 },
3166 .dec = {
3167 .vecs = xtea_dec_tv_template,
3168 .count = XTEA_DEC_TEST_VECTORS
3169 }
3170 }
3171 }
3172 }, {
3173 .alg = "gcm(aes)",
3174 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003175 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003176 .suite = {
3177 .aead = {
3178 .enc = {
3179 .vecs = aes_gcm_enc_tv_template,
3180 .count = AES_GCM_ENC_TEST_VECTORS
3181 },
3182 .dec = {
3183 .vecs = aes_gcm_dec_tv_template,
3184 .count = AES_GCM_DEC_TEST_VECTORS
3185 }
3186 }
3187 }
3188 }, {
Youquan, Song507069c2009-11-23 20:23:04 +08003189 .alg = "ghash",
3190 .test = alg_test_hash,
Jarod Wilson18c0ebd2011-01-29 15:14:35 +11003191 .fips_allowed = 1,
Youquan, Song507069c2009-11-23 20:23:04 +08003192 .suite = {
3193 .hash = {
3194 .vecs = ghash_tv_template,
3195 .count = GHASH_TEST_VECTORS
3196 }
3197 }
3198 }, {
Sonic Zhanga482b082012-05-25 17:54:13 +08003199 .alg = "hmac(crc32)",
3200 .test = alg_test_hash,
3201 .suite = {
3202 .hash = {
3203 .vecs = bfin_crc_tv_template,
3204 .count = BFIN_CRC_TEST_VECTORS
3205 }
3206 }
3207 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003208 .alg = "hmac(md5)",
3209 .test = alg_test_hash,
3210 .suite = {
3211 .hash = {
3212 .vecs = hmac_md5_tv_template,
3213 .count = HMAC_MD5_TEST_VECTORS
3214 }
3215 }
3216 }, {
3217 .alg = "hmac(rmd128)",
3218 .test = alg_test_hash,
3219 .suite = {
3220 .hash = {
3221 .vecs = hmac_rmd128_tv_template,
3222 .count = HMAC_RMD128_TEST_VECTORS
3223 }
3224 }
3225 }, {
3226 .alg = "hmac(rmd160)",
3227 .test = alg_test_hash,
3228 .suite = {
3229 .hash = {
3230 .vecs = hmac_rmd160_tv_template,
3231 .count = HMAC_RMD160_TEST_VECTORS
3232 }
3233 }
3234 }, {
3235 .alg = "hmac(sha1)",
3236 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003237 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003238 .suite = {
3239 .hash = {
3240 .vecs = hmac_sha1_tv_template,
3241 .count = HMAC_SHA1_TEST_VECTORS
3242 }
3243 }
3244 }, {
3245 .alg = "hmac(sha224)",
3246 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003247 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003248 .suite = {
3249 .hash = {
3250 .vecs = hmac_sha224_tv_template,
3251 .count = HMAC_SHA224_TEST_VECTORS
3252 }
3253 }
3254 }, {
3255 .alg = "hmac(sha256)",
3256 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003257 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003258 .suite = {
3259 .hash = {
3260 .vecs = hmac_sha256_tv_template,
3261 .count = HMAC_SHA256_TEST_VECTORS
3262 }
3263 }
3264 }, {
3265 .alg = "hmac(sha384)",
3266 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003267 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003268 .suite = {
3269 .hash = {
3270 .vecs = hmac_sha384_tv_template,
3271 .count = HMAC_SHA384_TEST_VECTORS
3272 }
3273 }
3274 }, {
3275 .alg = "hmac(sha512)",
3276 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003277 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003278 .suite = {
3279 .hash = {
3280 .vecs = hmac_sha512_tv_template,
3281 .count = HMAC_SHA512_TEST_VECTORS
3282 }
3283 }
3284 }, {
Stephan Muellerbb5530e2015-05-25 15:10:20 +02003285 .alg = "jitterentropy_rng",
3286 .fips_allowed = 1,
3287 .test = alg_test_null,
3288 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003289 .alg = "lrw(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003290 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003291 .suite = {
3292 .cipher = {
3293 .enc = {
3294 .vecs = aes_lrw_enc_tv_template,
3295 .count = AES_LRW_ENC_TEST_VECTORS
3296 },
3297 .dec = {
3298 .vecs = aes_lrw_dec_tv_template,
3299 .count = AES_LRW_DEC_TEST_VECTORS
3300 }
3301 }
3302 }
3303 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02003304 .alg = "lrw(camellia)",
3305 .test = alg_test_skcipher,
3306 .suite = {
3307 .cipher = {
3308 .enc = {
3309 .vecs = camellia_lrw_enc_tv_template,
3310 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
3311 },
3312 .dec = {
3313 .vecs = camellia_lrw_dec_tv_template,
3314 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
3315 }
3316 }
3317 }
3318 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003319 .alg = "lrw(cast6)",
3320 .test = alg_test_skcipher,
3321 .suite = {
3322 .cipher = {
3323 .enc = {
3324 .vecs = cast6_lrw_enc_tv_template,
3325 .count = CAST6_LRW_ENC_TEST_VECTORS
3326 },
3327 .dec = {
3328 .vecs = cast6_lrw_dec_tv_template,
3329 .count = CAST6_LRW_DEC_TEST_VECTORS
3330 }
3331 }
3332 }
3333 }, {
Jussi Kivilinnad7bfc0f2011-10-18 13:32:34 +03003334 .alg = "lrw(serpent)",
3335 .test = alg_test_skcipher,
3336 .suite = {
3337 .cipher = {
3338 .enc = {
3339 .vecs = serpent_lrw_enc_tv_template,
3340 .count = SERPENT_LRW_ENC_TEST_VECTORS
3341 },
3342 .dec = {
3343 .vecs = serpent_lrw_dec_tv_template,
3344 .count = SERPENT_LRW_DEC_TEST_VECTORS
3345 }
3346 }
3347 }
3348 }, {
Jussi Kivilinna0b2a1552011-10-18 13:32:50 +03003349 .alg = "lrw(twofish)",
3350 .test = alg_test_skcipher,
3351 .suite = {
3352 .cipher = {
3353 .enc = {
3354 .vecs = tf_lrw_enc_tv_template,
3355 .count = TF_LRW_ENC_TEST_VECTORS
3356 },
3357 .dec = {
3358 .vecs = tf_lrw_dec_tv_template,
3359 .count = TF_LRW_DEC_TEST_VECTORS
3360 }
3361 }
3362 }
3363 }, {
KOVACS Krisztian1443cc92014-08-22 10:44:36 +02003364 .alg = "lz4",
3365 .test = alg_test_comp,
3366 .fips_allowed = 1,
3367 .suite = {
3368 .comp = {
3369 .comp = {
3370 .vecs = lz4_comp_tv_template,
3371 .count = LZ4_COMP_TEST_VECTORS
3372 },
3373 .decomp = {
3374 .vecs = lz4_decomp_tv_template,
3375 .count = LZ4_DECOMP_TEST_VECTORS
3376 }
3377 }
3378 }
3379 }, {
3380 .alg = "lz4hc",
3381 .test = alg_test_comp,
3382 .fips_allowed = 1,
3383 .suite = {
3384 .comp = {
3385 .comp = {
3386 .vecs = lz4hc_comp_tv_template,
3387 .count = LZ4HC_COMP_TEST_VECTORS
3388 },
3389 .decomp = {
3390 .vecs = lz4hc_decomp_tv_template,
3391 .count = LZ4HC_DECOMP_TEST_VECTORS
3392 }
3393 }
3394 }
3395 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003396 .alg = "lzo",
3397 .test = alg_test_comp,
Milan Broz08189042012-12-06 17:16:28 +08003398 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003399 .suite = {
3400 .comp = {
3401 .comp = {
3402 .vecs = lzo_comp_tv_template,
3403 .count = LZO_COMP_TEST_VECTORS
3404 },
3405 .decomp = {
3406 .vecs = lzo_decomp_tv_template,
3407 .count = LZO_DECOMP_TEST_VECTORS
3408 }
3409 }
3410 }
3411 }, {
3412 .alg = "md4",
3413 .test = alg_test_hash,
3414 .suite = {
3415 .hash = {
3416 .vecs = md4_tv_template,
3417 .count = MD4_TEST_VECTORS
3418 }
3419 }
3420 }, {
3421 .alg = "md5",
3422 .test = alg_test_hash,
3423 .suite = {
3424 .hash = {
3425 .vecs = md5_tv_template,
3426 .count = MD5_TEST_VECTORS
3427 }
3428 }
3429 }, {
3430 .alg = "michael_mic",
3431 .test = alg_test_hash,
3432 .suite = {
3433 .hash = {
3434 .vecs = michael_mic_tv_template,
3435 .count = MICHAEL_MIC_TEST_VECTORS
3436 }
3437 }
3438 }, {
Puneet Saxenaba0e14a2011-05-04 15:04:10 +10003439 .alg = "ofb(aes)",
3440 .test = alg_test_skcipher,
3441 .fips_allowed = 1,
3442 .suite = {
3443 .cipher = {
3444 .enc = {
3445 .vecs = aes_ofb_enc_tv_template,
3446 .count = AES_OFB_ENC_TEST_VECTORS
3447 },
3448 .dec = {
3449 .vecs = aes_ofb_dec_tv_template,
3450 .count = AES_OFB_DEC_TEST_VECTORS
3451 }
3452 }
3453 }
3454 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003455 .alg = "pcbc(fcrypt)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003456 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003457 .suite = {
3458 .cipher = {
3459 .enc = {
3460 .vecs = fcrypt_pcbc_enc_tv_template,
3461 .count = FCRYPT_ENC_TEST_VECTORS
3462 },
3463 .dec = {
3464 .vecs = fcrypt_pcbc_dec_tv_template,
3465 .count = FCRYPT_DEC_TEST_VECTORS
3466 }
3467 }
3468 }
3469 }, {
Martin Willieee9dc62015-06-01 13:43:59 +02003470 .alg = "poly1305",
3471 .test = alg_test_hash,
3472 .suite = {
3473 .hash = {
3474 .vecs = poly1305_tv_template,
3475 .count = POLY1305_TEST_VECTORS
3476 }
3477 }
3478 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003479 .alg = "rfc3686(ctr(aes))",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003480 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003481 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003482 .suite = {
3483 .cipher = {
3484 .enc = {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08003485 .vecs = aes_ctr_rfc3686_enc_tv_template,
3486 .count = AES_CTR_3686_ENC_TEST_VECTORS
Herbert Xuda7f0332008-07-31 17:08:25 +08003487 },
3488 .dec = {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08003489 .vecs = aes_ctr_rfc3686_dec_tv_template,
3490 .count = AES_CTR_3686_DEC_TEST_VECTORS
Herbert Xuda7f0332008-07-31 17:08:25 +08003491 }
3492 }
3493 }
3494 }, {
Adrian Hoban69435b92010-11-04 15:02:04 -04003495 .alg = "rfc4106(gcm(aes))",
3496 .test = alg_test_aead,
Jarod Wilsondb71f292015-01-23 12:42:15 -05003497 .fips_allowed = 1,
Adrian Hoban69435b92010-11-04 15:02:04 -04003498 .suite = {
3499 .aead = {
3500 .enc = {
3501 .vecs = aes_gcm_rfc4106_enc_tv_template,
3502 .count = AES_GCM_4106_ENC_TEST_VECTORS
3503 },
3504 .dec = {
3505 .vecs = aes_gcm_rfc4106_dec_tv_template,
3506 .count = AES_GCM_4106_DEC_TEST_VECTORS
3507 }
3508 }
3509 }
3510 }, {
Jarod Wilson5d667322009-05-04 19:23:40 +08003511 .alg = "rfc4309(ccm(aes))",
3512 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003513 .fips_allowed = 1,
Jarod Wilson5d667322009-05-04 19:23:40 +08003514 .suite = {
3515 .aead = {
3516 .enc = {
3517 .vecs = aes_ccm_rfc4309_enc_tv_template,
3518 .count = AES_CCM_4309_ENC_TEST_VECTORS
3519 },
3520 .dec = {
3521 .vecs = aes_ccm_rfc4309_dec_tv_template,
3522 .count = AES_CCM_4309_DEC_TEST_VECTORS
3523 }
3524 }
3525 }
3526 }, {
Herbert Xubb687452015-06-16 13:54:24 +08003527 .alg = "rfc4543(gcm(aes))",
Jussi Kivilinnae9b74412013-04-07 16:43:51 +03003528 .test = alg_test_aead,
3529 .suite = {
3530 .aead = {
3531 .enc = {
3532 .vecs = aes_gcm_rfc4543_enc_tv_template,
3533 .count = AES_GCM_4543_ENC_TEST_VECTORS
3534 },
3535 .dec = {
3536 .vecs = aes_gcm_rfc4543_dec_tv_template,
3537 .count = AES_GCM_4543_DEC_TEST_VECTORS
3538 },
3539 }
3540 }
3541 }, {
Martin Williaf2b76b2015-06-01 13:44:01 +02003542 .alg = "rfc7539(chacha20,poly1305)",
3543 .test = alg_test_aead,
3544 .suite = {
3545 .aead = {
3546 .enc = {
3547 .vecs = rfc7539_enc_tv_template,
3548 .count = RFC7539_ENC_TEST_VECTORS
3549 },
3550 .dec = {
3551 .vecs = rfc7539_dec_tv_template,
3552 .count = RFC7539_DEC_TEST_VECTORS
3553 },
3554 }
3555 }
3556 }, {
Martin Willi59007582015-06-01 13:44:03 +02003557 .alg = "rfc7539esp(chacha20,poly1305)",
3558 .test = alg_test_aead,
3559 .suite = {
3560 .aead = {
3561 .enc = {
3562 .vecs = rfc7539esp_enc_tv_template,
3563 .count = RFC7539ESP_ENC_TEST_VECTORS
3564 },
3565 .dec = {
3566 .vecs = rfc7539esp_dec_tv_template,
3567 .count = RFC7539ESP_DEC_TEST_VECTORS
3568 },
3569 }
3570 }
3571 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003572 .alg = "rmd128",
3573 .test = alg_test_hash,
3574 .suite = {
3575 .hash = {
3576 .vecs = rmd128_tv_template,
3577 .count = RMD128_TEST_VECTORS
3578 }
3579 }
3580 }, {
3581 .alg = "rmd160",
3582 .test = alg_test_hash,
3583 .suite = {
3584 .hash = {
3585 .vecs = rmd160_tv_template,
3586 .count = RMD160_TEST_VECTORS
3587 }
3588 }
3589 }, {
3590 .alg = "rmd256",
3591 .test = alg_test_hash,
3592 .suite = {
3593 .hash = {
3594 .vecs = rmd256_tv_template,
3595 .count = RMD256_TEST_VECTORS
3596 }
3597 }
3598 }, {
3599 .alg = "rmd320",
3600 .test = alg_test_hash,
3601 .suite = {
3602 .hash = {
3603 .vecs = rmd320_tv_template,
3604 .count = RMD320_TEST_VECTORS
3605 }
3606 }
3607 }, {
Tadeusz Struk946cc462015-06-16 10:31:06 -07003608 .alg = "rsa",
3609 .test = alg_test_akcipher,
3610 .fips_allowed = 1,
3611 .suite = {
3612 .akcipher = {
3613 .vecs = rsa_tv_template,
3614 .count = RSA_TEST_VECTORS
3615 }
3616 }
3617 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003618 .alg = "salsa20",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003619 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003620 .suite = {
3621 .cipher = {
3622 .enc = {
3623 .vecs = salsa20_stream_enc_tv_template,
3624 .count = SALSA20_STREAM_ENC_TEST_VECTORS
3625 }
3626 }
3627 }
3628 }, {
3629 .alg = "sha1",
3630 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003631 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003632 .suite = {
3633 .hash = {
3634 .vecs = sha1_tv_template,
3635 .count = SHA1_TEST_VECTORS
3636 }
3637 }
3638 }, {
3639 .alg = "sha224",
3640 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003641 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003642 .suite = {
3643 .hash = {
3644 .vecs = sha224_tv_template,
3645 .count = SHA224_TEST_VECTORS
3646 }
3647 }
3648 }, {
3649 .alg = "sha256",
3650 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003651 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003652 .suite = {
3653 .hash = {
3654 .vecs = sha256_tv_template,
3655 .count = SHA256_TEST_VECTORS
3656 }
3657 }
3658 }, {
3659 .alg = "sha384",
3660 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003661 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003662 .suite = {
3663 .hash = {
3664 .vecs = sha384_tv_template,
3665 .count = SHA384_TEST_VECTORS
3666 }
3667 }
3668 }, {
3669 .alg = "sha512",
3670 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003671 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003672 .suite = {
3673 .hash = {
3674 .vecs = sha512_tv_template,
3675 .count = SHA512_TEST_VECTORS
3676 }
3677 }
3678 }, {
3679 .alg = "tgr128",
3680 .test = alg_test_hash,
3681 .suite = {
3682 .hash = {
3683 .vecs = tgr128_tv_template,
3684 .count = TGR128_TEST_VECTORS
3685 }
3686 }
3687 }, {
3688 .alg = "tgr160",
3689 .test = alg_test_hash,
3690 .suite = {
3691 .hash = {
3692 .vecs = tgr160_tv_template,
3693 .count = TGR160_TEST_VECTORS
3694 }
3695 }
3696 }, {
3697 .alg = "tgr192",
3698 .test = alg_test_hash,
3699 .suite = {
3700 .hash = {
3701 .vecs = tgr192_tv_template,
3702 .count = TGR192_TEST_VECTORS
3703 }
3704 }
3705 }, {
Shane Wangf1939f72009-09-02 20:05:22 +10003706 .alg = "vmac(aes)",
3707 .test = alg_test_hash,
3708 .suite = {
3709 .hash = {
3710 .vecs = aes_vmac128_tv_template,
3711 .count = VMAC_AES_TEST_VECTORS
3712 }
3713 }
3714 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003715 .alg = "wp256",
3716 .test = alg_test_hash,
3717 .suite = {
3718 .hash = {
3719 .vecs = wp256_tv_template,
3720 .count = WP256_TEST_VECTORS
3721 }
3722 }
3723 }, {
3724 .alg = "wp384",
3725 .test = alg_test_hash,
3726 .suite = {
3727 .hash = {
3728 .vecs = wp384_tv_template,
3729 .count = WP384_TEST_VECTORS
3730 }
3731 }
3732 }, {
3733 .alg = "wp512",
3734 .test = alg_test_hash,
3735 .suite = {
3736 .hash = {
3737 .vecs = wp512_tv_template,
3738 .count = WP512_TEST_VECTORS
3739 }
3740 }
3741 }, {
3742 .alg = "xcbc(aes)",
3743 .test = alg_test_hash,
3744 .suite = {
3745 .hash = {
3746 .vecs = aes_xcbc128_tv_template,
3747 .count = XCBC_AES_TEST_VECTORS
3748 }
3749 }
3750 }, {
3751 .alg = "xts(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003752 .test = alg_test_skcipher,
Jarod Wilson2918aa82011-01-29 15:14:01 +11003753 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003754 .suite = {
3755 .cipher = {
3756 .enc = {
3757 .vecs = aes_xts_enc_tv_template,
3758 .count = AES_XTS_ENC_TEST_VECTORS
3759 },
3760 .dec = {
3761 .vecs = aes_xts_dec_tv_template,
3762 .count = AES_XTS_DEC_TEST_VECTORS
3763 }
3764 }
3765 }
Geert Uytterhoeven0c01aed2009-03-04 15:42:15 +08003766 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02003767 .alg = "xts(camellia)",
3768 .test = alg_test_skcipher,
3769 .suite = {
3770 .cipher = {
3771 .enc = {
3772 .vecs = camellia_xts_enc_tv_template,
3773 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
3774 },
3775 .dec = {
3776 .vecs = camellia_xts_dec_tv_template,
3777 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
3778 }
3779 }
3780 }
3781 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003782 .alg = "xts(cast6)",
3783 .test = alg_test_skcipher,
3784 .suite = {
3785 .cipher = {
3786 .enc = {
3787 .vecs = cast6_xts_enc_tv_template,
3788 .count = CAST6_XTS_ENC_TEST_VECTORS
3789 },
3790 .dec = {
3791 .vecs = cast6_xts_dec_tv_template,
3792 .count = CAST6_XTS_DEC_TEST_VECTORS
3793 }
3794 }
3795 }
3796 }, {
Jussi Kivilinna18be20b2011-10-18 13:33:17 +03003797 .alg = "xts(serpent)",
3798 .test = alg_test_skcipher,
3799 .suite = {
3800 .cipher = {
3801 .enc = {
3802 .vecs = serpent_xts_enc_tv_template,
3803 .count = SERPENT_XTS_ENC_TEST_VECTORS
3804 },
3805 .dec = {
3806 .vecs = serpent_xts_dec_tv_template,
3807 .count = SERPENT_XTS_DEC_TEST_VECTORS
3808 }
3809 }
3810 }
3811 }, {
Jussi Kivilinnaaed265b2011-10-18 13:33:33 +03003812 .alg = "xts(twofish)",
3813 .test = alg_test_skcipher,
3814 .suite = {
3815 .cipher = {
3816 .enc = {
3817 .vecs = tf_xts_enc_tv_template,
3818 .count = TF_XTS_ENC_TEST_VECTORS
3819 },
3820 .dec = {
3821 .vecs = tf_xts_dec_tv_template,
3822 .count = TF_XTS_DEC_TEST_VECTORS
3823 }
3824 }
3825 }
3826 }, {
Geert Uytterhoeven0c01aed2009-03-04 15:42:15 +08003827 .alg = "zlib",
3828 .test = alg_test_pcomp,
Milan Broz08189042012-12-06 17:16:28 +08003829 .fips_allowed = 1,
Geert Uytterhoeven0c01aed2009-03-04 15:42:15 +08003830 .suite = {
3831 .pcomp = {
3832 .comp = {
3833 .vecs = zlib_comp_tv_template,
3834 .count = ZLIB_COMP_TEST_VECTORS
3835 },
3836 .decomp = {
3837 .vecs = zlib_decomp_tv_template,
3838 .count = ZLIB_DECOMP_TEST_VECTORS
3839 }
3840 }
3841 }
Herbert Xuda7f0332008-07-31 17:08:25 +08003842 }
3843};
3844
Jussi Kivilinna57147582013-06-13 17:37:40 +03003845static bool alg_test_descs_checked;
3846
3847static void alg_test_descs_check_order(void)
3848{
3849 int i;
3850
3851 /* only check once */
3852 if (alg_test_descs_checked)
3853 return;
3854
3855 alg_test_descs_checked = true;
3856
3857 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3858 int diff = strcmp(alg_test_descs[i - 1].alg,
3859 alg_test_descs[i].alg);
3860
3861 if (WARN_ON(diff > 0)) {
3862 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3863 alg_test_descs[i - 1].alg,
3864 alg_test_descs[i].alg);
3865 }
3866
3867 if (WARN_ON(diff == 0)) {
3868 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3869 alg_test_descs[i].alg);
3870 }
3871 }
3872}
3873
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003874static int alg_find_test(const char *alg)
Herbert Xuda7f0332008-07-31 17:08:25 +08003875{
3876 int start = 0;
3877 int end = ARRAY_SIZE(alg_test_descs);
3878
3879 while (start < end) {
3880 int i = (start + end) / 2;
3881 int diff = strcmp(alg_test_descs[i].alg, alg);
3882
3883 if (diff > 0) {
3884 end = i;
3885 continue;
3886 }
3887
3888 if (diff < 0) {
3889 start = i + 1;
3890 continue;
3891 }
3892
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003893 return i;
Herbert Xuda7f0332008-07-31 17:08:25 +08003894 }
3895
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003896 return -1;
3897}
3898
3899int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3900{
3901 int i;
Herbert Xua68f6612009-07-02 16:32:12 +08003902 int j;
Neil Hormand12d6b62008-10-12 20:36:51 +08003903 int rc;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003904
Jussi Kivilinna57147582013-06-13 17:37:40 +03003905 alg_test_descs_check_order();
3906
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003907 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3908 char nalg[CRYPTO_MAX_ALG_NAME];
3909
3910 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3911 sizeof(nalg))
3912 return -ENAMETOOLONG;
3913
3914 i = alg_find_test(nalg);
3915 if (i < 0)
3916 goto notest;
3917
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003918 if (fips_enabled && !alg_test_descs[i].fips_allowed)
3919 goto non_fips_alg;
3920
Jarod Wilson941fb322009-05-04 19:49:23 +08003921 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3922 goto test_done;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003923 }
3924
3925 i = alg_find_test(alg);
Herbert Xua68f6612009-07-02 16:32:12 +08003926 j = alg_find_test(driver);
3927 if (i < 0 && j < 0)
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003928 goto notest;
3929
Herbert Xua68f6612009-07-02 16:32:12 +08003930 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3931 (j >= 0 && !alg_test_descs[j].fips_allowed)))
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003932 goto non_fips_alg;
3933
Herbert Xua68f6612009-07-02 16:32:12 +08003934 rc = 0;
3935 if (i >= 0)
3936 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3937 type, mask);
Cristian Stoica032c8ca2013-07-18 18:57:07 +03003938 if (j >= 0 && j != i)
Herbert Xua68f6612009-07-02 16:32:12 +08003939 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3940 type, mask);
3941
Jarod Wilson941fb322009-05-04 19:49:23 +08003942test_done:
Neil Hormand12d6b62008-10-12 20:36:51 +08003943 if (fips_enabled && rc)
3944 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3945
Jarod Wilson29ecd4a2009-05-04 19:51:17 +08003946 if (fips_enabled && !rc)
Masanari Iida3e8cffd2014-10-07 00:37:54 +09003947 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
Jarod Wilson29ecd4a2009-05-04 19:51:17 +08003948
Neil Hormand12d6b62008-10-12 20:36:51 +08003949 return rc;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003950
3951notest:
Herbert Xuda7f0332008-07-31 17:08:25 +08003952 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3953 return 0;
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003954non_fips_alg:
3955 return -EINVAL;
Herbert Xuda7f0332008-07-31 17:08:25 +08003956}
Alexander Shishkin0b767f92010-06-03 20:53:43 +10003957
Herbert Xu326a6342010-08-06 09:40:28 +08003958#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
Alexander Shishkin0b767f92010-06-03 20:53:43 +10003959
Herbert Xuda7f0332008-07-31 17:08:25 +08003960EXPORT_SYMBOL_GPL(alg_test);