1/*
   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 *
   9 * 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 *
  16 * This program is free software; you can redistribute it and/or modify it
  17 * under the terms of the GNU General Public License as published by the Free
  18 * Software Foundation; either version 2 of the License, or (at your option)
  19 * any later version.
  20 *
  21 */
  22
 
  23#include <crypto/hash.h>
 
  24#include <linux/err.h>
 
  25#include <linux/module.h>
  26#include <linux/scatterlist.h>
  27#include <linux/slab.h>
  28#include <linux/string.h>
  29#include <crypto/rng.h>
 
 
 
 
  30
  31#include "internal.h"
  32
 
 
 
 
  33#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
  34
  35/* a perfect nop */
  36int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
  37{
  38	return 0;
  39}
  40
  41#else
  42
  43#include "testmgr.h"
  44
  45/*
  46 * Need slab memory for testing (size in number of pages).
  47 */
  48#define XBUFSIZE	8
  49
  50/*
  51 * Indexes into the xbuf to simulate cross-page access.
  52 */
  53#define IDX1		32
  54#define IDX2		32400
  55#define IDX3		1
  56#define IDX4		8193
  57#define IDX5		22222
  58#define IDX6		17101
  59#define IDX7		27333
  60#define IDX8		3000
  61
  62/*
  63* Used by test_cipher()
  64*/
  65#define ENCRYPT 1
  66#define DECRYPT 0
  67
  68struct tcrypt_result {
  69	struct completion completion;
  70	int err;
  71};
  72
  73struct aead_test_suite {
  74	struct {
  75		struct aead_testvec *vecs;
  76		unsigned int count;
  77	} enc, dec;
  78};
  79
  80struct cipher_test_suite {
  81	struct {
  82		struct cipher_testvec *vecs;
  83		unsigned int count;
  84	} enc, dec;
  85};
  86
  87struct comp_test_suite {
  88	struct {
  89		struct comp_testvec *vecs;
  90		unsigned int count;
  91	} comp, decomp;
  92};
  93
  94struct pcomp_test_suite {
  95	struct {
  96		struct pcomp_testvec *vecs;
  97		unsigned int count;
  98	} comp, decomp;
  99};
 100
 101struct hash_test_suite {
 102	struct hash_testvec *vecs;
 103	unsigned int count;
 104};
 105
 106struct cprng_test_suite {
 107	struct cprng_testvec *vecs;
 108	unsigned int count;
 109};
 110
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 111struct alg_test_desc {
 112	const char *alg;
 113	int (*test)(const struct alg_test_desc *desc, const char *driver,
 114		    u32 type, u32 mask);
 115	int fips_allowed;	/* set if alg is allowed in fips mode */
 116
 117	union {
 118		struct aead_test_suite aead;
 119		struct cipher_test_suite cipher;
 120		struct comp_test_suite comp;
 121		struct pcomp_test_suite pcomp;
 122		struct hash_test_suite hash;
 123		struct cprng_test_suite cprng;
 
 
 
 124	} suite;
 125};
 126
 127static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
 128
 129static void hexdump(unsigned char *buf, unsigned int len)
 130{
 131	print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
 132			16, 1,
 133			buf, len, false);
 134}
 135
 136static void tcrypt_complete(struct crypto_async_request *req, int err)
 137{
 138	struct tcrypt_result *res = req->data;
 139
 140	if (err == -EINPROGRESS)
 141		return;
 142
 143	res->err = err;
 144	complete(&res->completion);
 145}
 146
 147static int testmgr_alloc_buf(char *buf[XBUFSIZE])
 148{
 149	int i;
 150
 151	for (i = 0; i < XBUFSIZE; i++) {
 152		buf[i] = (void *)__get_free_page(GFP_KERNEL);
 153		if (!buf[i])
 154			goto err_free_buf;
 155	}
 156
 157	return 0;
 158
 159err_free_buf:
 160	while (i-- > 0)
 161		free_page((unsigned long)buf[i]);
 162
 163	return -ENOMEM;
 164}
 165
 166static void testmgr_free_buf(char *buf[XBUFSIZE])
 167{
 168	int i;
 169
 170	for (i = 0; i < XBUFSIZE; i++)
 171		free_page((unsigned long)buf[i]);
 172}
 173
 174static int do_one_async_hash_op(struct ahash_request *req,
 175				struct tcrypt_result *tr,
 176				int ret)
 177{
 178	if (ret == -EINPROGRESS || ret == -EBUSY) {
 179		ret = wait_for_completion_interruptible(&tr->completion);
 180		if (!ret)
 181			ret = tr->err;
 182		reinit_completion(&tr->completion);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 183	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 184	return ret;
 185}
 186
 187static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
 188		       unsigned int tcount, bool use_digest,
 189		       const int align_offset)
 190{
 191	const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
 192	unsigned int i, j, k, temp;
 193	struct scatterlist sg[8];
 194	char result[64];
 
 195	struct ahash_request *req;
 196	struct tcrypt_result tresult;
 197	void *hash_buff;
 198	char *xbuf[XBUFSIZE];
 199	int ret = -ENOMEM;
 200
 
 
 
 
 
 
 201	if (testmgr_alloc_buf(xbuf))
 202		goto out_nobuf;
 203
 204	init_completion(&tresult.completion);
 205
 206	req = ahash_request_alloc(tfm, GFP_KERNEL);
 207	if (!req) {
 208		printk(KERN_ERR "alg: hash: Failed to allocate request for "
 209		       "%s\n", algo);
 210		goto out_noreq;
 211	}
 212	ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 213				   tcrypt_complete, &tresult);
 214
 215	j = 0;
 216	for (i = 0; i < tcount; i++) {
 217		if (template[i].np)
 218			continue;
 219
 220		ret = -EINVAL;
 221		if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
 222			goto out;
 223
 224		j++;
 225		memset(result, 0, 64);
 226
 227		hash_buff = xbuf[0];
 228		hash_buff += align_offset;
 229
 230		memcpy(hash_buff, template[i].plaintext, template[i].psize);
 231		sg_init_one(&sg[0], hash_buff, template[i].psize);
 232
 233		if (template[i].ksize) {
 234			crypto_ahash_clear_flags(tfm, ~0);
 235			ret = crypto_ahash_setkey(tfm, template[i].key,
 236						  template[i].ksize);
 
 
 
 
 
 
 237			if (ret) {
 238				printk(KERN_ERR "alg: hash: setkey failed on "
 239				       "test %d for %s: ret=%d\n", j, algo,
 240				       -ret);
 241				goto out;
 242			}
 243		}
 244
 245		ahash_request_set_crypt(req, sg, result, template[i].psize);
 246		if (use_digest) {
 247			ret = do_one_async_hash_op(req, &tresult,
 248						   crypto_ahash_digest(req));
 249			if (ret) {
 250				pr_err("alg: hash: digest failed on test %d "
 251				       "for %s: ret=%d\n", j, algo, -ret);
 252				goto out;
 253			}
 254		} else {
 255			ret = do_one_async_hash_op(req, &tresult,
 256						   crypto_ahash_init(req));
 257			if (ret) {
 258				pr_err("alt: hash: init failed on test %d "
 259				       "for %s: ret=%d\n", j, algo, -ret);
 260				goto out;
 261			}
 262			ret = do_one_async_hash_op(req, &tresult,
 263						   crypto_ahash_update(req));
 264			if (ret) {
 265				pr_err("alt: hash: update failed on test %d "
 266				       "for %s: ret=%d\n", j, algo, -ret);
 267				goto out;
 268			}
 269			ret = do_one_async_hash_op(req, &tresult,
 270						   crypto_ahash_final(req));
 271			if (ret) {
 272				pr_err("alt: hash: final failed on test %d "
 273				       "for %s: ret=%d\n", j, algo, -ret);
 274				goto out;
 275			}
 276		}
 277
 278		if (memcmp(result, template[i].digest,
 279			   crypto_ahash_digestsize(tfm))) {
 280			printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
 281			       j, algo);
 282			hexdump(result, crypto_ahash_digestsize(tfm));
 283			ret = -EINVAL;
 284			goto out;
 285		}
 286	}
 287
 288	j = 0;
 289	for (i = 0; i < tcount; i++) {
 290		/* alignment tests are only done with continuous buffers */
 291		if (align_offset != 0)
 292			break;
 293
 294		if (template[i].np) {
 295			j++;
 296			memset(result, 0, 64);
 
 
 297
 298			temp = 0;
 299			sg_init_table(sg, template[i].np);
 300			ret = -EINVAL;
 301			for (k = 0; k < template[i].np; k++) {
 302				if (WARN_ON(offset_in_page(IDX[k]) +
 303					    template[i].tap[k] > PAGE_SIZE))
 304					goto out;
 305				sg_set_buf(&sg[k],
 306					   memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
 307						  offset_in_page(IDX[k]),
 308						  template[i].plaintext + temp,
 309						  template[i].tap[k]),
 310					   template[i].tap[k]);
 311				temp += template[i].tap[k];
 312			}
 313
 314			if (template[i].ksize) {
 315				crypto_ahash_clear_flags(tfm, ~0);
 316				ret = crypto_ahash_setkey(tfm, template[i].key,
 317							  template[i].ksize);
 318
 319				if (ret) {
 320					printk(KERN_ERR "alg: hash: setkey "
 321					       "failed on chunking test %d "
 322					       "for %s: ret=%d\n", j, algo,
 323					       -ret);
 324					goto out;
 325				}
 326			}
 
 
 
 327
 328			ahash_request_set_crypt(req, sg, result,
 329						template[i].psize);
 330			ret = crypto_ahash_digest(req);
 331			switch (ret) {
 332			case 0:
 333				break;
 334			case -EINPROGRESS:
 335			case -EBUSY:
 336				ret = wait_for_completion_interruptible(
 337					&tresult.completion);
 338				if (!ret && !(ret = tresult.err)) {
 339					reinit_completion(&tresult.completion);
 340					break;
 341				}
 342				/* fall through */
 343			default:
 344				printk(KERN_ERR "alg: hash: digest failed "
 345				       "on chunking test %d for %s: "
 346				       "ret=%d\n", j, algo, -ret);
 347				goto out;
 348			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 349
 350			if (memcmp(result, template[i].digest,
 351				   crypto_ahash_digestsize(tfm))) {
 352				printk(KERN_ERR "alg: hash: Chunking test %d "
 353				       "failed for %s\n", j, algo);
 354				hexdump(result, crypto_ahash_digestsize(tfm));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 355				ret = -EINVAL;
 356				goto out;
 357			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 358		}
 359	}
 360
 361	ret = 0;
 362
 363out:
 364	ahash_request_free(req);
 365out_noreq:
 366	testmgr_free_buf(xbuf);
 367out_nobuf:
 
 
 368	return ret;
 369}
 370
 371static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
 372		     unsigned int tcount, bool use_digest)
 373{
 374	unsigned int alignmask;
 375	int ret;
 376
 377	ret = __test_hash(tfm, template, tcount, use_digest, 0);
 378	if (ret)
 379		return ret;
 380
 381	/* test unaligned buffers, check with one byte offset */
 382	ret = __test_hash(tfm, template, tcount, use_digest, 1);
 383	if (ret)
 384		return ret;
 385
 386	alignmask = crypto_tfm_alg_alignmask(&tfm->base);
 387	if (alignmask) {
 388		/* Check if alignment mask for tfm is correctly set. */
 389		ret = __test_hash(tfm, template, tcount, use_digest,
 390				  alignmask + 1);
 391		if (ret)
 392			return ret;
 393	}
 394
 395	return 0;
 396}
 397
 398static int __test_aead(struct crypto_aead *tfm, int enc,
 399		       struct aead_testvec *template, unsigned int tcount,
 400		       const bool diff_dst, const int align_offset)
 401{
 402	const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
 403	unsigned int i, j, k, n, temp;
 404	int ret = -ENOMEM;
 405	char *q;
 406	char *key;
 407	struct aead_request *req;
 408	struct scatterlist *sg;
 409	struct scatterlist *asg;
 410	struct scatterlist *sgout;
 411	const char *e, *d;
 412	struct tcrypt_result result;
 413	unsigned int authsize;
 414	void *input;
 415	void *output;
 416	void *assoc;
 417	char iv[MAX_IVLEN];
 418	char *xbuf[XBUFSIZE];
 419	char *xoutbuf[XBUFSIZE];
 420	char *axbuf[XBUFSIZE];
 421
 
 
 
 
 
 
 422	if (testmgr_alloc_buf(xbuf))
 423		goto out_noxbuf;
 424	if (testmgr_alloc_buf(axbuf))
 425		goto out_noaxbuf;
 426
 427	if (diff_dst && testmgr_alloc_buf(xoutbuf))
 428		goto out_nooutbuf;
 429
 430	/* avoid "the frame size is larger than 1024 bytes" compiler warning */
 431	sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 3 : 2), GFP_KERNEL);
 432	if (!sg)
 433		goto out_nosg;
 434	asg = &sg[8];
 435	sgout = &asg[8];
 436
 437	if (diff_dst)
 438		d = "-ddst";
 439	else
 440		d = "";
 441
 442	if (enc == ENCRYPT)
 443		e = "encryption";
 444	else
 445		e = "decryption";
 446
 447	init_completion(&result.completion);
 448
 449	req = aead_request_alloc(tfm, GFP_KERNEL);
 450	if (!req) {
 451		pr_err("alg: aead%s: Failed to allocate request for %s\n",
 452		       d, algo);
 453		goto out;
 454	}
 455
 456	aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 457				  tcrypt_complete, &result);
 458
 
 
 459	for (i = 0, j = 0; i < tcount; i++) {
 460		if (!template[i].np) {
 461			j++;
 
 
 462
 463			/* some templates have no input data but they will
 464			 * touch input
 465			 */
 466			input = xbuf[0];
 467			input += align_offset;
 468			assoc = axbuf[0];
 469
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 470			ret = -EINVAL;
 471			if (WARN_ON(align_offset + template[i].ilen >
 472				    PAGE_SIZE || template[i].alen > PAGE_SIZE))
 473				goto out;
 474
 475			memcpy(input, template[i].input, template[i].ilen);
 476			memcpy(assoc, template[i].assoc, template[i].alen);
 477			if (template[i].iv)
 478				memcpy(iv, template[i].iv, MAX_IVLEN);
 479			else
 480				memset(iv, 0, MAX_IVLEN);
 
 481
 482			crypto_aead_clear_flags(tfm, ~0);
 483			if (template[i].wk)
 484				crypto_aead_set_flags(
 485					tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 486
 487			key = template[i].key;
 488
 489			ret = crypto_aead_setkey(tfm, key,
 490						 template[i].klen);
 491			if (!ret == template[i].fail) {
 492				pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
 493				       d, j, algo, crypto_aead_get_flags(tfm));
 494				goto out;
 495			} else if (ret)
 496				continue;
 497
 498			authsize = abs(template[i].rlen - template[i].ilen);
 499			ret = crypto_aead_setauthsize(tfm, authsize);
 500			if (ret) {
 501				pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
 502				       d, authsize, j, algo);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 503				goto out;
 504			}
 505
 506			if (diff_dst) {
 507				output = xoutbuf[0];
 508				output += align_offset;
 509				sg_init_one(&sg[0], input, template[i].ilen);
 510				sg_init_one(&sgout[0], output,
 511					    template[i].rlen);
 512			} else {
 513				sg_init_one(&sg[0], input,
 514					    template[i].ilen +
 515						(enc ? authsize : 0));
 516				output = input;
 517			}
 518
 519			sg_init_one(&asg[0], assoc, template[i].alen);
 520
 521			aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
 522					       template[i].ilen, iv);
 523
 524			aead_request_set_assoc(req, asg, template[i].alen);
 525
 526			ret = enc ?
 527				crypto_aead_encrypt(req) :
 528				crypto_aead_decrypt(req);
 529
 530			switch (ret) {
 531			case 0:
 532				if (template[i].novrfy) {
 533					/* verification was supposed to fail */
 534					pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
 535					       d, e, j, algo);
 536					/* so really, we got a bad message */
 537					ret = -EBADMSG;
 538					goto out;
 539				}
 540				break;
 541			case -EINPROGRESS:
 542			case -EBUSY:
 543				ret = wait_for_completion_interruptible(
 544					&result.completion);
 545				if (!ret && !(ret = result.err)) {
 546					reinit_completion(&result.completion);
 547					break;
 548				}
 549			case -EBADMSG:
 550				if (template[i].novrfy)
 551					/* verification failure was expected */
 552					continue;
 553				/* fall through */
 554			default:
 555				pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
 556				       d, e, j, algo, -ret);
 557				goto out;
 558			}
 559
 560			q = output;
 561			if (memcmp(q, template[i].result, template[i].rlen)) {
 562				pr_err("alg: aead%s: Test %d failed on %s for %s\n",
 563				       d, j, e, algo);
 564				hexdump(q, template[i].rlen);
 565				ret = -EINVAL;
 566				goto out;
 567			}
 568		}
 569	}
 570
 571	for (i = 0, j = 0; i < tcount; i++) {
 572		/* alignment tests are only done with continuous buffers */
 573		if (align_offset != 0)
 574			break;
 575
 576		if (template[i].np) {
 577			j++;
 578
 579			if (template[i].iv)
 580				memcpy(iv, template[i].iv, MAX_IVLEN);
 581			else
 582				memset(iv, 0, MAX_IVLEN);
 583
 584			crypto_aead_clear_flags(tfm, ~0);
 585			if (template[i].wk)
 586				crypto_aead_set_flags(
 587					tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 588			key = template[i].key;
 589
 590			ret = crypto_aead_setkey(tfm, key, template[i].klen);
 591			if (!ret == template[i].fail) {
 592				pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
 593				       d, j, algo, crypto_aead_get_flags(tfm));
 594				goto out;
 595			} else if (ret)
 596				continue;
 597
 598			authsize = abs(template[i].rlen - template[i].ilen);
 
 
 
 599
 
 
 
 
 
 
 600			ret = -EINVAL;
 601			sg_init_table(sg, template[i].np);
 602			if (diff_dst)
 603				sg_init_table(sgout, template[i].np);
 604			for (k = 0, temp = 0; k < template[i].np; k++) {
 605				if (WARN_ON(offset_in_page(IDX[k]) +
 606					    template[i].tap[k] > PAGE_SIZE))
 607					goto out;
 608
 609				q = xbuf[IDX[k] >> PAGE_SHIFT] +
 610				    offset_in_page(IDX[k]);
 
 
 
 
 
 611
 612				memcpy(q, template[i].input + temp,
 613				       template[i].tap[k]);
 614
 615				sg_set_buf(&sg[k], q, template[i].tap[k]);
 
 
 
 616
 617				if (diff_dst) {
 618					q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
 619					    offset_in_page(IDX[k]);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 620
 621					memset(q, 0, template[i].tap[k]);
 
 
 
 622
 623					sg_set_buf(&sgout[k], q,
 624						   template[i].tap[k]);
 625				}
 
 626
 627				n = template[i].tap[k];
 628				if (k == template[i].np - 1 && enc)
 629					n += authsize;
 630				if (offset_in_page(q) + n < PAGE_SIZE)
 631					q[n] = 0;
 632
 633				temp += template[i].tap[k];
 634			}
 635
 636			ret = crypto_aead_setauthsize(tfm, authsize);
 637			if (ret) {
 638				pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
 639				       d, authsize, j, algo);
 640				goto out;
 641			}
 642
 643			if (enc) {
 644				if (WARN_ON(sg[k - 1].offset +
 645					    sg[k - 1].length + authsize >
 646					    PAGE_SIZE)) {
 647					ret = -EINVAL;
 648					goto out;
 649				}
 650
 651				if (diff_dst)
 652					sgout[k - 1].length += authsize;
 653				else
 654					sg[k - 1].length += authsize;
 655			}
 656
 657			sg_init_table(asg, template[i].anp);
 658			ret = -EINVAL;
 659			for (k = 0, temp = 0; k < template[i].anp; k++) {
 660				if (WARN_ON(offset_in_page(IDX[k]) +
 661					    template[i].atap[k] > PAGE_SIZE))
 662					goto out;
 663				sg_set_buf(&asg[k],
 664					   memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
 665						  offset_in_page(IDX[k]),
 666						  template[i].assoc + temp,
 667						  template[i].atap[k]),
 668					   template[i].atap[k]);
 669				temp += template[i].atap[k];
 670			}
 671
 672			aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
 673					       template[i].ilen,
 674					       iv);
 675
 676			aead_request_set_assoc(req, asg, template[i].alen);
 677
 678			ret = enc ?
 679				crypto_aead_encrypt(req) :
 680				crypto_aead_decrypt(req);
 681
 682			switch (ret) {
 683			case 0:
 684				if (template[i].novrfy) {
 685					/* verification was supposed to fail */
 686					pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
 687					       d, e, j, algo);
 688					/* so really, we got a bad message */
 689					ret = -EBADMSG;
 690					goto out;
 691				}
 692				break;
 693			case -EINPROGRESS:
 694			case -EBUSY:
 695				ret = wait_for_completion_interruptible(
 696					&result.completion);
 697				if (!ret && !(ret = result.err)) {
 698					reinit_completion(&result.completion);
 699					break;
 700				}
 701			case -EBADMSG:
 702				if (template[i].novrfy)
 703					/* verification failure was expected */
 704					continue;
 705				/* fall through */
 706			default:
 707				pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
 708				       d, e, j, algo, -ret);
 709				goto out;
 710			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 711
 712			ret = -EINVAL;
 713			for (k = 0, temp = 0; k < template[i].np; k++) {
 714				if (diff_dst)
 715					q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
 716					    offset_in_page(IDX[k]);
 717				else
 718					q = xbuf[IDX[k] >> PAGE_SHIFT] +
 719					    offset_in_page(IDX[k]);
 720
 721				n = template[i].tap[k];
 722				if (k == template[i].np - 1)
 723					n += enc ? authsize : -authsize;
 724
 725				if (memcmp(q, template[i].result + temp, n)) {
 726					pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
 727					       d, j, e, k, algo);
 728					hexdump(q, n);
 729					goto out;
 730				}
 731
 732				q += n;
 733				if (k == template[i].np - 1 && !enc) {
 734					if (!diff_dst &&
 735						memcmp(q, template[i].input +
 736						      temp + n, authsize))
 737						n = authsize;
 738					else
 739						n = 0;
 740				} else {
 741					for (n = 0; offset_in_page(q + n) &&
 742						    q[n]; n++)
 743						;
 744				}
 745				if (n) {
 746					pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
 747					       d, j, e, k, algo, n);
 748					hexdump(q, n);
 749					goto out;
 750				}
 751
 752				temp += template[i].tap[k];
 
 
 
 
 
 
 
 
 
 
 753			}
 
 
 
 
 
 
 
 
 754		}
 755	}
 756
 757	ret = 0;
 758
 759out:
 760	aead_request_free(req);
 761	kfree(sg);
 762out_nosg:
 763	if (diff_dst)
 764		testmgr_free_buf(xoutbuf);
 765out_nooutbuf:
 766	testmgr_free_buf(axbuf);
 767out_noaxbuf:
 768	testmgr_free_buf(xbuf);
 769out_noxbuf:
 
 
 770	return ret;
 771}
 772
 773static int test_aead(struct crypto_aead *tfm, int enc,
 774		     struct aead_testvec *template, unsigned int tcount)
 775{
 776	unsigned int alignmask;
 777	int ret;
 778
 779	/* test 'dst == src' case */
 780	ret = __test_aead(tfm, enc, template, tcount, false, 0);
 781	if (ret)
 782		return ret;
 783
 784	/* test 'dst != src' case */
 785	ret = __test_aead(tfm, enc, template, tcount, true, 0);
 786	if (ret)
 787		return ret;
 788
 789	/* test unaligned buffers, check with one byte offset */
 790	ret = __test_aead(tfm, enc, template, tcount, true, 1);
 791	if (ret)
 792		return ret;
 793
 794	alignmask = crypto_tfm_alg_alignmask(&tfm->base);
 795	if (alignmask) {
 796		/* Check if alignment mask for tfm is correctly set. */
 797		ret = __test_aead(tfm, enc, template, tcount, true,
 798				  alignmask + 1);
 799		if (ret)
 800			return ret;
 801	}
 802
 803	return 0;
 804}
 805
 806static int test_cipher(struct crypto_cipher *tfm, int enc,
 807		       struct cipher_testvec *template, unsigned int tcount)
 808{
 809	const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
 810	unsigned int i, j, k;
 811	char *q;
 812	const char *e;
 813	void *data;
 814	char *xbuf[XBUFSIZE];
 815	int ret = -ENOMEM;
 816
 817	if (testmgr_alloc_buf(xbuf))
 818		goto out_nobuf;
 819
 820	if (enc == ENCRYPT)
 821	        e = "encryption";
 822	else
 823		e = "decryption";
 824
 825	j = 0;
 826	for (i = 0; i < tcount; i++) {
 827		if (template[i].np)
 828			continue;
 829
 
 
 
 830		j++;
 831
 832		ret = -EINVAL;
 833		if (WARN_ON(template[i].ilen > PAGE_SIZE))
 834			goto out;
 835
 836		data = xbuf[0];
 837		memcpy(data, template[i].input, template[i].ilen);
 838
 839		crypto_cipher_clear_flags(tfm, ~0);
 840		if (template[i].wk)
 841			crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 842
 843		ret = crypto_cipher_setkey(tfm, template[i].key,
 844					   template[i].klen);
 845		if (!ret == template[i].fail) {
 846			printk(KERN_ERR "alg: cipher: setkey failed "
 847			       "on test %d for %s: flags=%x\n", j,
 848			       algo, crypto_cipher_get_flags(tfm));
 849			goto out;
 850		} else if (ret)
 851			continue;
 852
 853		for (k = 0; k < template[i].ilen;
 854		     k += crypto_cipher_blocksize(tfm)) {
 855			if (enc)
 856				crypto_cipher_encrypt_one(tfm, data + k,
 857							  data + k);
 858			else
 859				crypto_cipher_decrypt_one(tfm, data + k,
 860							  data + k);
 861		}
 862
 863		q = data;
 864		if (memcmp(q, template[i].result, template[i].rlen)) {
 865			printk(KERN_ERR "alg: cipher: Test %d failed "
 866			       "on %s for %s\n", j, e, algo);
 867			hexdump(q, template[i].rlen);
 868			ret = -EINVAL;
 869			goto out;
 870		}
 871	}
 872
 873	ret = 0;
 874
 875out:
 876	testmgr_free_buf(xbuf);
 877out_nobuf:
 878	return ret;
 879}
 880
 881static int __test_skcipher(struct crypto_ablkcipher *tfm, int enc,
 882			   struct cipher_testvec *template, unsigned int tcount,
 883			   const bool diff_dst, const int align_offset)
 884{
 885	const char *algo =
 886		crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
 887	unsigned int i, j, k, n, temp;
 888	char *q;
 889	struct ablkcipher_request *req;
 890	struct scatterlist sg[8];
 891	struct scatterlist sgout[8];
 892	const char *e, *d;
 893	struct tcrypt_result result;
 894	void *data;
 895	char iv[MAX_IVLEN];
 896	char *xbuf[XBUFSIZE];
 897	char *xoutbuf[XBUFSIZE];
 898	int ret = -ENOMEM;
 
 899
 900	if (testmgr_alloc_buf(xbuf))
 901		goto out_nobuf;
 902
 903	if (diff_dst && testmgr_alloc_buf(xoutbuf))
 904		goto out_nooutbuf;
 905
 906	if (diff_dst)
 907		d = "-ddst";
 908	else
 909		d = "";
 910
 911	if (enc == ENCRYPT)
 912	        e = "encryption";
 913	else
 914		e = "decryption";
 915
 916	init_completion(&result.completion);
 917
 918	req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
 919	if (!req) {
 920		pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
 921		       d, algo);
 922		goto out;
 923	}
 924
 925	ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 926					tcrypt_complete, &result);
 927
 928	j = 0;
 929	for (i = 0; i < tcount; i++) {
 
 
 
 
 
 
 930		if (template[i].iv)
 931			memcpy(iv, template[i].iv, MAX_IVLEN);
 932		else
 933			memset(iv, 0, MAX_IVLEN);
 934
 935		if (!(template[i].np) || (template[i].also_non_np)) {
 936			j++;
 
 
 937
 938			ret = -EINVAL;
 939			if (WARN_ON(align_offset + template[i].ilen >
 940				    PAGE_SIZE))
 941				goto out;
 942
 943			data = xbuf[0];
 944			data += align_offset;
 945			memcpy(data, template[i].input, template[i].ilen);
 
 946
 947			crypto_ablkcipher_clear_flags(tfm, ~0);
 948			if (template[i].wk)
 949				crypto_ablkcipher_set_flags(
 950					tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 951
 952			ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 953						       template[i].klen);
 954			if (!ret == template[i].fail) {
 955				pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
 956				       d, j, algo,
 957				       crypto_ablkcipher_get_flags(tfm));
 958				goto out;
 959			} else if (ret)
 960				continue;
 961
 962			sg_init_one(&sg[0], data, template[i].ilen);
 963			if (diff_dst) {
 964				data = xoutbuf[0];
 965				data += align_offset;
 966				sg_init_one(&sgout[0], data, template[i].ilen);
 967			}
 968
 969			ablkcipher_request_set_crypt(req, sg,
 970						     (diff_dst) ? sgout : sg,
 971						     template[i].ilen, iv);
 972			ret = enc ?
 973				crypto_ablkcipher_encrypt(req) :
 974				crypto_ablkcipher_decrypt(req);
 975
 976			switch (ret) {
 977			case 0:
 
 
 
 
 
 
 
 978				break;
 979			case -EINPROGRESS:
 980			case -EBUSY:
 981				ret = wait_for_completion_interruptible(
 982					&result.completion);
 983				if (!ret && !((ret = result.err))) {
 984					reinit_completion(&result.completion);
 985					break;
 986				}
 987				/* fall through */
 988			default:
 989				pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
 990				       d, e, j, algo, -ret);
 991				goto out;
 992			}
 993
 994			q = data;
 995			if (memcmp(q, template[i].result, template[i].rlen)) {
 996				pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
 997				       d, j, e, algo);
 998				hexdump(q, template[i].rlen);
 999				ret = -EINVAL;
1000				goto out;
1001			}
 
 
 
 
 
 
 
 
 
1002		}
1003	}
1004
1005	j = 0;
1006	for (i = 0; i < tcount; i++) {
1007		/* alignment tests are only done with continuous buffers */
1008		if (align_offset != 0)
1009			break;
1010
 
 
 
 
 
 
1011		if (template[i].iv)
1012			memcpy(iv, template[i].iv, MAX_IVLEN);
1013		else
1014			memset(iv, 0, MAX_IVLEN);
1015
1016		if (template[i].np) {
1017			j++;
 
 
 
1018
1019			crypto_ablkcipher_clear_flags(tfm, ~0);
1020			if (template[i].wk)
1021				crypto_ablkcipher_set_flags(
1022					tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1023
1024			ret = crypto_ablkcipher_setkey(tfm, template[i].key,
1025						       template[i].klen);
1026			if (!ret == template[i].fail) {
1027				pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1028				       d, j, algo,
1029				       crypto_ablkcipher_get_flags(tfm));
 
 
 
 
 
 
1030				goto out;
1031			} else if (ret)
1032				continue;
1033
1034			temp = 0;
1035			ret = -EINVAL;
1036			sg_init_table(sg, template[i].np);
1037			if (diff_dst)
1038				sg_init_table(sgout, template[i].np);
1039			for (k = 0; k < template[i].np; k++) {
1040				if (WARN_ON(offset_in_page(IDX[k]) +
1041					    template[i].tap[k] > PAGE_SIZE))
1042					goto out;
1043
1044				q = xbuf[IDX[k] >> PAGE_SHIFT] +
 
 
 
 
 
 
 
1045				    offset_in_page(IDX[k]);
1046
1047				memcpy(q, template[i].input + temp,
1048				       template[i].tap[k]);
1049
1050				if (offset_in_page(q) + template[i].tap[k] <
1051				    PAGE_SIZE)
 
1052					q[template[i].tap[k]] = 0;
 
1053
1054				sg_set_buf(&sg[k], q, template[i].tap[k]);
1055				if (diff_dst) {
1056					q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1057					    offset_in_page(IDX[k]);
1058
1059					sg_set_buf(&sgout[k], q,
1060						   template[i].tap[k]);
1061
1062					memset(q, 0, template[i].tap[k]);
1063					if (offset_in_page(q) +
1064					    template[i].tap[k] < PAGE_SIZE)
1065						q[template[i].tap[k]] = 0;
1066				}
1067
1068				temp += template[i].tap[k];
1069			}
1070
1071			ablkcipher_request_set_crypt(req, sg,
1072					(diff_dst) ? sgout : sg,
1073					template[i].ilen, iv);
 
 
 
 
 
 
 
 
 
 
 
 
 
1074
1075			ret = enc ?
1076				crypto_ablkcipher_encrypt(req) :
1077				crypto_ablkcipher_decrypt(req);
 
 
 
 
 
 
1078
1079			switch (ret) {
1080			case 0:
1081				break;
1082			case -EINPROGRESS:
1083			case -EBUSY:
1084				ret = wait_for_completion_interruptible(
1085					&result.completion);
1086				if (!ret && !((ret = result.err))) {
1087					reinit_completion(&result.completion);
1088					break;
1089				}
1090				/* fall through */
1091			default:
1092				pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1093				       d, e, j, algo, -ret);
1094				goto out;
1095			}
1096
1097			temp = 0;
1098			ret = -EINVAL;
1099			for (k = 0; k < template[i].np; k++) {
1100				if (diff_dst)
1101					q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1102					    offset_in_page(IDX[k]);
1103				else
1104					q = xbuf[IDX[k] >> PAGE_SHIFT] +
1105					    offset_in_page(IDX[k]);
1106
1107				if (memcmp(q, template[i].result + temp,
1108					   template[i].tap[k])) {
1109					pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1110					       d, j, e, k, algo);
1111					hexdump(q, template[i].tap[k]);
1112					goto out;
1113				}
1114
1115				q += template[i].tap[k];
1116				for (n = 0; offset_in_page(q + n) && q[n]; n++)
1117					;
1118				if (n) {
1119					pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1120					       d, j, e, k, algo, n);
1121					hexdump(q, n);
1122					goto out;
1123				}
1124				temp += template[i].tap[k];
1125			}
 
1126		}
1127	}
1128
1129	ret = 0;
1130
1131out:
1132	ablkcipher_request_free(req);
1133	if (diff_dst)
1134		testmgr_free_buf(xoutbuf);
1135out_nooutbuf:
1136	testmgr_free_buf(xbuf);
1137out_nobuf:
1138	return ret;
1139}
1140
1141static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
1142			 struct cipher_testvec *template, unsigned int tcount)
1143{
1144	unsigned int alignmask;
1145	int ret;
1146
1147	/* test 'dst == src' case */
1148	ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
1149	if (ret)
1150		return ret;
1151
1152	/* test 'dst != src' case */
1153	ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1154	if (ret)
1155		return ret;
1156
1157	/* test unaligned buffers, check with one byte offset */
1158	ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1159	if (ret)
1160		return ret;
1161
1162	alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1163	if (alignmask) {
1164		/* Check if alignment mask for tfm is correctly set. */
1165		ret = __test_skcipher(tfm, enc, template, tcount, true,
1166				      alignmask + 1);
1167		if (ret)
1168			return ret;
1169	}
1170
1171	return 0;
1172}
1173
1174static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1175		     struct comp_testvec *dtemplate, int ctcount, int dtcount)
1176{
1177	const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1178	unsigned int i;
1179	char result[COMP_BUF_SIZE];
1180	int ret;
1181
1182	for (i = 0; i < ctcount; i++) {
1183		int ilen;
1184		unsigned int dlen = COMP_BUF_SIZE;
1185
1186		memset(result, 0, sizeof (result));
1187
1188		ilen = ctemplate[i].inlen;
1189		ret = crypto_comp_compress(tfm, ctemplate[i].input,
1190		                           ilen, result, &dlen);
1191		if (ret) {
1192			printk(KERN_ERR "alg: comp: compression failed "
1193			       "on test %d for %s: ret=%d\n", i + 1, algo,
1194			       -ret);
1195			goto out;
1196		}
1197
1198		if (dlen != ctemplate[i].outlen) {
1199			printk(KERN_ERR "alg: comp: Compression test %d "
1200			       "failed for %s: output len = %d\n", i + 1, algo,
1201			       dlen);
1202			ret = -EINVAL;
1203			goto out;
1204		}
1205
1206		if (memcmp(result, ctemplate[i].output, dlen)) {
1207			printk(KERN_ERR "alg: comp: Compression test %d "
1208			       "failed for %s\n", i + 1, algo);
1209			hexdump(result, dlen);
1210			ret = -EINVAL;
1211			goto out;
1212		}
1213	}
1214
1215	for (i = 0; i < dtcount; i++) {
1216		int ilen;
1217		unsigned int dlen = COMP_BUF_SIZE;
1218
1219		memset(result, 0, sizeof (result));
1220
1221		ilen = dtemplate[i].inlen;
1222		ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1223		                             ilen, result, &dlen);
1224		if (ret) {
1225			printk(KERN_ERR "alg: comp: decompression failed "
1226			       "on test %d for %s: ret=%d\n", i + 1, algo,
1227			       -ret);
1228			goto out;
1229		}
1230
1231		if (dlen != dtemplate[i].outlen) {
1232			printk(KERN_ERR "alg: comp: Decompression test %d "
1233			       "failed for %s: output len = %d\n", i + 1, algo,
1234			       dlen);
1235			ret = -EINVAL;
1236			goto out;
1237		}
1238
1239		if (memcmp(result, dtemplate[i].output, dlen)) {
1240			printk(KERN_ERR "alg: comp: Decompression test %d "
1241			       "failed for %s\n", i + 1, algo);
1242			hexdump(result, dlen);
1243			ret = -EINVAL;
1244			goto out;
1245		}
1246	}
1247
1248	ret = 0;
1249
1250out:
1251	return ret;
1252}
1253
1254static int test_pcomp(struct crypto_pcomp *tfm,
1255		      struct pcomp_testvec *ctemplate,
1256		      struct pcomp_testvec *dtemplate, int ctcount,
1257		      int dtcount)
1258{
1259	const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1260	unsigned int i;
1261	char result[COMP_BUF_SIZE];
1262	int res;
 
 
 
 
 
 
 
1263
1264	for (i = 0; i < ctcount; i++) {
1265		struct comp_request req;
1266		unsigned int produced = 0;
 
1267
1268		res = crypto_compress_setup(tfm, ctemplate[i].params,
1269					    ctemplate[i].paramsize);
1270		if (res) {
1271			pr_err("alg: pcomp: compression setup failed on test "
1272			       "%d for %s: error=%d\n", i + 1, algo, res);
1273			return res;
1274		}
1275
1276		res = crypto_compress_init(tfm);
1277		if (res) {
1278			pr_err("alg: pcomp: compression init failed on test "
1279			       "%d for %s: error=%d\n", i + 1, algo, res);
1280			return res;
1281		}
1282
1283		memset(result, 0, sizeof(result));
1284
1285		req.next_in = ctemplate[i].input;
1286		req.avail_in = ctemplate[i].inlen / 2;
1287		req.next_out = result;
1288		req.avail_out = ctemplate[i].outlen / 2;
1289
1290		res = crypto_compress_update(tfm, &req);
1291		if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1292			pr_err("alg: pcomp: compression update failed on test "
1293			       "%d for %s: error=%d\n", i + 1, algo, res);
1294			return res;
1295		}
1296		if (res > 0)
1297			produced += res;
1298
1299		/* Add remaining input data */
1300		req.avail_in += (ctemplate[i].inlen + 1) / 2;
1301
1302		res = crypto_compress_update(tfm, &req);
1303		if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1304			pr_err("alg: pcomp: compression update failed on test "
1305			       "%d for %s: error=%d\n", i + 1, algo, res);
1306			return res;
1307		}
1308		if (res > 0)
1309			produced += res;
1310
1311		/* Provide remaining output space */
1312		req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1313
1314		res = crypto_compress_final(tfm, &req);
1315		if (res < 0) {
1316			pr_err("alg: pcomp: compression final failed on test "
1317			       "%d for %s: error=%d\n", i + 1, algo, res);
1318			return res;
1319		}
1320		produced += res;
1321
1322		if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1323			pr_err("alg: comp: Compression test %d failed for %s: "
1324			       "output len = %d (expected %d)\n", i + 1, algo,
1325			       COMP_BUF_SIZE - req.avail_out,
1326			       ctemplate[i].outlen);
1327			return -EINVAL;
1328		}
1329
1330		if (produced != ctemplate[i].outlen) {
1331			pr_err("alg: comp: Compression test %d failed for %s: "
1332			       "returned len = %u (expected %d)\n", i + 1,
1333			       algo, produced, ctemplate[i].outlen);
1334			return -EINVAL;
1335		}
1336
1337		if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1338			pr_err("alg: pcomp: Compression test %d failed for "
1339			       "%s\n", i + 1, algo);
1340			hexdump(result, ctemplate[i].outlen);
1341			return -EINVAL;
1342		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1343	}
1344
1345	for (i = 0; i < dtcount; i++) {
1346		struct comp_request req;
1347		unsigned int produced = 0;
 
1348
1349		res = crypto_decompress_setup(tfm, dtemplate[i].params,
1350					      dtemplate[i].paramsize);
1351		if (res) {
1352			pr_err("alg: pcomp: decompression setup failed on "
1353			       "test %d for %s: error=%d\n", i + 1, algo, res);
1354			return res;
1355		}
1356
1357		res = crypto_decompress_init(tfm);
1358		if (res) {
1359			pr_err("alg: pcomp: decompression init failed on test "
1360			       "%d for %s: error=%d\n", i + 1, algo, res);
1361			return res;
1362		}
1363
1364		memset(result, 0, sizeof(result));
1365
1366		req.next_in = dtemplate[i].input;
1367		req.avail_in = dtemplate[i].inlen / 2;
1368		req.next_out = result;
1369		req.avail_out = dtemplate[i].outlen / 2;
1370
1371		res = crypto_decompress_update(tfm, &req);
1372		if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1373			pr_err("alg: pcomp: decompression update failed on "
1374			       "test %d for %s: error=%d\n", i + 1, algo, res);
1375			return res;
1376		}
1377		if (res > 0)
1378			produced += res;
1379
1380		/* Add remaining input data */
1381		req.avail_in += (dtemplate[i].inlen + 1) / 2;
1382
1383		res = crypto_decompress_update(tfm, &req);
1384		if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1385			pr_err("alg: pcomp: decompression update failed on "
1386			       "test %d for %s: error=%d\n", i + 1, algo, res);
1387			return res;
1388		}
1389		if (res > 0)
1390			produced += res;
1391
1392		/* Provide remaining output space */
1393		req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1394
1395		res = crypto_decompress_final(tfm, &req);
1396		if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1397			pr_err("alg: pcomp: decompression final failed on "
1398			       "test %d for %s: error=%d\n", i + 1, algo, res);
1399			return res;
1400		}
1401		if (res > 0)
1402			produced += res;
1403
1404		if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1405			pr_err("alg: comp: Decompression test %d failed for "
1406			       "%s: output len = %d (expected %d)\n", i + 1,
1407			       algo, COMP_BUF_SIZE - req.avail_out,
1408			       dtemplate[i].outlen);
1409			return -EINVAL;
1410		}
1411
1412		if (produced != dtemplate[i].outlen) {
1413			pr_err("alg: comp: Decompression test %d failed for "
1414			       "%s: returned len = %u (expected %d)\n", i + 1,
1415			       algo, produced, dtemplate[i].outlen);
1416			return -EINVAL;
1417		}
1418
1419		if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1420			pr_err("alg: pcomp: Decompression test %d failed for "
1421			       "%s\n", i + 1, algo);
1422			hexdump(result, dtemplate[i].outlen);
1423			return -EINVAL;
1424		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1425	}
1426
1427	return 0;
1428}
1429
 
 
 
 
1430
1431static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1432		      unsigned int tcount)
1433{
1434	const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1435	int err = 0, i, j, seedsize;
1436	u8 *seed;
1437	char result[32];
1438
1439	seedsize = crypto_rng_seedsize(tfm);
1440
1441	seed = kmalloc(seedsize, GFP_KERNEL);
1442	if (!seed) {
1443		printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1444		       "for %s\n", algo);
1445		return -ENOMEM;
1446	}
1447
1448	for (i = 0; i < tcount; i++) {
1449		memset(result, 0, 32);
1450
1451		memcpy(seed, template[i].v, template[i].vlen);
1452		memcpy(seed + template[i].vlen, template[i].key,
1453		       template[i].klen);
1454		memcpy(seed + template[i].vlen + template[i].klen,
1455		       template[i].dt, template[i].dtlen);
1456
1457		err = crypto_rng_reset(tfm, seed, seedsize);
1458		if (err) {
1459			printk(KERN_ERR "alg: cprng: Failed to reset rng "
1460			       "for %s\n", algo);
1461			goto out;
1462		}
1463
1464		for (j = 0; j < template[i].loops; j++) {
1465			err = crypto_rng_get_bytes(tfm, result,
1466						   template[i].rlen);
1467			if (err != template[i].rlen) {
1468				printk(KERN_ERR "alg: cprng: Failed to obtain "
1469				       "the correct amount of random data for "
1470				       "%s (requested %d, got %d)\n", algo,
1471				       template[i].rlen, err);
1472				goto out;
1473			}
1474		}
1475
1476		err = memcmp(result, template[i].result,
1477			     template[i].rlen);
1478		if (err) {
1479			printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1480			       i, algo);
1481			hexdump(result, template[i].rlen);
1482			err = -EINVAL;
1483			goto out;
1484		}
1485	}
1486
1487out:
1488	kfree(seed);
1489	return err;
1490}
1491
1492static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1493			 u32 type, u32 mask)
1494{
1495	struct crypto_aead *tfm;
1496	int err = 0;
1497
1498	tfm = crypto_alloc_aead(driver, type, mask);
1499	if (IS_ERR(tfm)) {
1500		printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1501		       "%ld\n", driver, PTR_ERR(tfm));
1502		return PTR_ERR(tfm);
1503	}
1504
1505	if (desc->suite.aead.enc.vecs) {
1506		err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1507				desc->suite.aead.enc.count);
1508		if (err)
1509			goto out;
1510	}
1511
1512	if (!err && desc->suite.aead.dec.vecs)
1513		err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1514				desc->suite.aead.dec.count);
1515
1516out:
1517	crypto_free_aead(tfm);
1518	return err;
1519}
1520
1521static int alg_test_cipher(const struct alg_test_desc *desc,
1522			   const char *driver, u32 type, u32 mask)
1523{
1524	struct crypto_cipher *tfm;
1525	int err = 0;
1526
1527	tfm = crypto_alloc_cipher(driver, type, mask);
1528	if (IS_ERR(tfm)) {
1529		printk(KERN_ERR "alg: cipher: Failed to load transform for "
1530		       "%s: %ld\n", driver, PTR_ERR(tfm));
1531		return PTR_ERR(tfm);
1532	}
1533
1534	if (desc->suite.cipher.enc.vecs) {
1535		err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1536				  desc->suite.cipher.enc.count);
1537		if (err)
1538			goto out;
1539	}
1540
1541	if (desc->suite.cipher.dec.vecs)
1542		err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1543				  desc->suite.cipher.dec.count);
1544
1545out:
1546	crypto_free_cipher(tfm);
1547	return err;
1548}
1549
1550static int alg_test_skcipher(const struct alg_test_desc *desc,
1551			     const char *driver, u32 type, u32 mask)
1552{
1553	struct crypto_ablkcipher *tfm;
1554	int err = 0;
1555
1556	tfm = crypto_alloc_ablkcipher(driver, type, mask);
1557	if (IS_ERR(tfm)) {
1558		printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1559		       "%s: %ld\n", driver, PTR_ERR(tfm));
1560		return PTR_ERR(tfm);
1561	}
1562
1563	if (desc->suite.cipher.enc.vecs) {
1564		err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1565				    desc->suite.cipher.enc.count);
1566		if (err)
1567			goto out;
1568	}
1569
1570	if (desc->suite.cipher.dec.vecs)
1571		err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1572				    desc->suite.cipher.dec.count);
1573
1574out:
1575	crypto_free_ablkcipher(tfm);
1576	return err;
1577}
1578
1579static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1580			 u32 type, u32 mask)
1581{
1582	struct crypto_comp *tfm;
 
1583	int err;
 
1584
1585	tfm = crypto_alloc_comp(driver, type, mask);
1586	if (IS_ERR(tfm)) {
1587		printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1588		       "%ld\n", driver, PTR_ERR(tfm));
1589		return PTR_ERR(tfm);
1590	}
1591
1592	err = test_comp(tfm, desc->suite.comp.comp.vecs,
1593			desc->suite.comp.decomp.vecs,
1594			desc->suite.comp.comp.count,
1595			desc->suite.comp.decomp.count);
1596
1597	crypto_free_comp(tfm);
1598	return err;
1599}
1600
1601static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1602			  u32 type, u32 mask)
1603{
1604	struct crypto_pcomp *tfm;
1605	int err;
 
 
 
1606
1607	tfm = crypto_alloc_pcomp(driver, type, mask);
1608	if (IS_ERR(tfm)) {
1609		pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1610		       driver, PTR_ERR(tfm));
1611		return PTR_ERR(tfm);
1612	}
1613
1614	err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1615			 desc->suite.pcomp.decomp.vecs,
1616			 desc->suite.pcomp.comp.count,
1617			 desc->suite.pcomp.decomp.count);
1618
1619	crypto_free_pcomp(tfm);
1620	return err;
1621}
1622
1623static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1624			 u32 type, u32 mask)
1625{
1626	struct crypto_ahash *tfm;
1627	int err;
1628
1629	tfm = crypto_alloc_ahash(driver, type, mask);
1630	if (IS_ERR(tfm)) {
1631		printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1632		       "%ld\n", driver, PTR_ERR(tfm));
1633		return PTR_ERR(tfm);
1634	}
1635
1636	err = test_hash(tfm, desc->suite.hash.vecs,
1637			desc->suite.hash.count, true);
1638	if (!err)
1639		err = test_hash(tfm, desc->suite.hash.vecs,
1640				desc->suite.hash.count, false);
1641
1642	crypto_free_ahash(tfm);
1643	return err;
1644}
1645
1646static int alg_test_crc32c(const struct alg_test_desc *desc,
1647			   const char *driver, u32 type, u32 mask)
1648{
1649	struct crypto_shash *tfm;
1650	u32 val;
1651	int err;
1652
1653	err = alg_test_hash(desc, driver, type, mask);
1654	if (err)
1655		goto out;
1656
1657	tfm = crypto_alloc_shash(driver, type, mask);
1658	if (IS_ERR(tfm)) {
1659		printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1660		       "%ld\n", driver, PTR_ERR(tfm));
1661		err = PTR_ERR(tfm);
1662		goto out;
1663	}
1664
1665	do {
1666		struct {
1667			struct shash_desc shash;
1668			char ctx[crypto_shash_descsize(tfm)];
1669		} sdesc;
1670
1671		sdesc.shash.tfm = tfm;
1672		sdesc.shash.flags = 0;
1673
1674		*(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1675		err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1676		if (err) {
1677			printk(KERN_ERR "alg: crc32c: Operation failed for "
1678			       "%s: %d\n", driver, err);
1679			break;
1680		}
1681
1682		if (val != ~420553207) {
1683			printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1684			       "%d\n", driver, val);
1685			err = -EINVAL;
1686		}
1687	} while (0);
1688
1689	crypto_free_shash(tfm);
1690
1691out:
1692	return err;
1693}
1694
1695static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1696			  u32 type, u32 mask)
1697{
1698	struct crypto_rng *rng;
1699	int err;
1700
1701	rng = crypto_alloc_rng(driver, type, mask);
1702	if (IS_ERR(rng)) {
1703		printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1704		       "%ld\n", driver, PTR_ERR(rng));
1705		return PTR_ERR(rng);
1706	}
1707
1708	err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1709
1710	crypto_free_rng(rng);
1711
1712	return err;
1713}
1714
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1715static int alg_test_null(const struct alg_test_desc *desc,
1716			     const char *driver, u32 type, u32 mask)
1717{
1718	return 0;
1719}
1720
1721/* Please keep this list sorted by algorithm name. */
1722static const struct alg_test_desc alg_test_descs[] = {
1723	{
1724		.alg = "__cbc-cast5-avx",
1725		.test = alg_test_null,
1726	}, {
1727		.alg = "__cbc-cast6-avx",
1728		.test = alg_test_null,
1729	}, {
1730		.alg = "__cbc-serpent-avx",
1731		.test = alg_test_null,
1732	}, {
1733		.alg = "__cbc-serpent-avx2",
1734		.test = alg_test_null,
1735	}, {
1736		.alg = "__cbc-serpent-sse2",
1737		.test = alg_test_null,
1738	}, {
1739		.alg = "__cbc-twofish-avx",
1740		.test = alg_test_null,
1741	}, {
1742		.alg = "__driver-cbc-aes-aesni",
1743		.test = alg_test_null,
1744		.fips_allowed = 1,
1745	}, {
1746		.alg = "__driver-cbc-camellia-aesni",
1747		.test = alg_test_null,
1748	}, {
1749		.alg = "__driver-cbc-camellia-aesni-avx2",
1750		.test = alg_test_null,
1751	}, {
1752		.alg = "__driver-cbc-cast5-avx",
1753		.test = alg_test_null,
1754	}, {
1755		.alg = "__driver-cbc-cast6-avx",
1756		.test = alg_test_null,
1757	}, {
1758		.alg = "__driver-cbc-serpent-avx",
1759		.test = alg_test_null,
1760	}, {
1761		.alg = "__driver-cbc-serpent-avx2",
1762		.test = alg_test_null,
1763	}, {
1764		.alg = "__driver-cbc-serpent-sse2",
1765		.test = alg_test_null,
1766	}, {
1767		.alg = "__driver-cbc-twofish-avx",
1768		.test = alg_test_null,
1769	}, {
1770		.alg = "__driver-ecb-aes-aesni",
1771		.test = alg_test_null,
1772		.fips_allowed = 1,
1773	}, {
1774		.alg = "__driver-ecb-camellia-aesni",
1775		.test = alg_test_null,
1776	}, {
1777		.alg = "__driver-ecb-camellia-aesni-avx2",
1778		.test = alg_test_null,
1779	}, {
1780		.alg = "__driver-ecb-cast5-avx",
1781		.test = alg_test_null,
1782	}, {
1783		.alg = "__driver-ecb-cast6-avx",
1784		.test = alg_test_null,
1785	}, {
1786		.alg = "__driver-ecb-serpent-avx",
1787		.test = alg_test_null,
1788	}, {
1789		.alg = "__driver-ecb-serpent-avx2",
1790		.test = alg_test_null,
1791	}, {
1792		.alg = "__driver-ecb-serpent-sse2",
1793		.test = alg_test_null,
1794	}, {
1795		.alg = "__driver-ecb-twofish-avx",
1796		.test = alg_test_null,
1797	}, {
1798		.alg = "__ghash-pclmulqdqni",
1799		.test = alg_test_null,
1800		.fips_allowed = 1,
1801	}, {
1802		.alg = "ansi_cprng",
1803		.test = alg_test_cprng,
1804		.fips_allowed = 1,
1805		.suite = {
1806			.cprng = {
1807				.vecs = ansi_cprng_aes_tv_template,
1808				.count = ANSI_CPRNG_AES_TEST_VECTORS
1809			}
1810		}
1811	}, {
1812		.alg = "authenc(hmac(md5),ecb(cipher_null))",
1813		.test = alg_test_aead,
1814		.fips_allowed = 1,
1815		.suite = {
1816			.aead = {
1817				.enc = {
1818					.vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
1819					.count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
1820				},
1821				.dec = {
1822					.vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
1823					.count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
1824				}
1825			}
1826		}
1827	}, {
1828		.alg = "authenc(hmac(sha1),cbc(aes))",
1829		.test = alg_test_aead,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1830		.fips_allowed = 1,
1831		.suite = {
1832			.aead = {
1833				.enc = {
1834					.vecs = hmac_sha1_aes_cbc_enc_tv_template,
1835					.count = HMAC_SHA1_AES_CBC_ENC_TEST_VECTORS
 
 
1836				}
1837			}
1838		}
1839	}, {
 
 
 
 
1840		.alg = "authenc(hmac(sha1),ecb(cipher_null))",
1841		.test = alg_test_aead,
1842		.fips_allowed = 1,
1843		.suite = {
1844			.aead = {
1845				.enc = {
1846					.vecs = hmac_sha1_ecb_cipher_null_enc_tv_template,
1847					.count = HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VECTORS
 
 
1848				},
1849				.dec = {
1850					.vecs = hmac_sha1_ecb_cipher_null_dec_tv_template,
1851					.count = HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VECTORS
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1852				}
1853			}
1854		}
1855	}, {
1856		.alg = "authenc(hmac(sha256),cbc(aes))",
1857		.test = alg_test_aead,
1858		.fips_allowed = 1,
1859		.suite = {
1860			.aead = {
1861				.enc = {
1862					.vecs = hmac_sha256_aes_cbc_enc_tv_template,
1863					.count = HMAC_SHA256_AES_CBC_ENC_TEST_VECTORS
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1864				}
1865			}
1866		}
1867	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1868		.alg = "authenc(hmac(sha512),cbc(aes))",
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1869		.test = alg_test_aead,
1870		.fips_allowed = 1,
1871		.suite = {
1872			.aead = {
1873				.enc = {
1874					.vecs = hmac_sha512_aes_cbc_enc_tv_template,
1875					.count = HMAC_SHA512_AES_CBC_ENC_TEST_VECTORS
 
 
1876				}
1877			}
1878		}
1879	}, {
 
 
 
 
 
 
 
 
1880		.alg = "cbc(aes)",
1881		.test = alg_test_skcipher,
1882		.fips_allowed = 1,
1883		.suite = {
1884			.cipher = {
1885				.enc = {
1886					.vecs = aes_cbc_enc_tv_template,
1887					.count = AES_CBC_ENC_TEST_VECTORS
1888				},
1889				.dec = {
1890					.vecs = aes_cbc_dec_tv_template,
1891					.count = AES_CBC_DEC_TEST_VECTORS
1892				}
1893			}
1894		}
1895	}, {
1896		.alg = "cbc(anubis)",
1897		.test = alg_test_skcipher,
1898		.suite = {
1899			.cipher = {
1900				.enc = {
1901					.vecs = anubis_cbc_enc_tv_template,
1902					.count = ANUBIS_CBC_ENC_TEST_VECTORS
1903				},
1904				.dec = {
1905					.vecs = anubis_cbc_dec_tv_template,
1906					.count = ANUBIS_CBC_DEC_TEST_VECTORS
1907				}
1908			}
1909		}
1910	}, {
1911		.alg = "cbc(blowfish)",
1912		.test = alg_test_skcipher,
1913		.suite = {
1914			.cipher = {
1915				.enc = {
1916					.vecs = bf_cbc_enc_tv_template,
1917					.count = BF_CBC_ENC_TEST_VECTORS
1918				},
1919				.dec = {
1920					.vecs = bf_cbc_dec_tv_template,
1921					.count = BF_CBC_DEC_TEST_VECTORS
1922				}
1923			}
1924		}
1925	}, {
1926		.alg = "cbc(camellia)",
1927		.test = alg_test_skcipher,
1928		.suite = {
1929			.cipher = {
1930				.enc = {
1931					.vecs = camellia_cbc_enc_tv_template,
1932					.count = CAMELLIA_CBC_ENC_TEST_VECTORS
1933				},
1934				.dec = {
1935					.vecs = camellia_cbc_dec_tv_template,
1936					.count = CAMELLIA_CBC_DEC_TEST_VECTORS
1937				}
1938			}
1939		}
1940	}, {
1941		.alg = "cbc(cast5)",
1942		.test = alg_test_skcipher,
1943		.suite = {
1944			.cipher = {
1945				.enc = {
1946					.vecs = cast5_cbc_enc_tv_template,
1947					.count = CAST5_CBC_ENC_TEST_VECTORS
1948				},
1949				.dec = {
1950					.vecs = cast5_cbc_dec_tv_template,
1951					.count = CAST5_CBC_DEC_TEST_VECTORS
1952				}
1953			}
1954		}
1955	}, {
1956		.alg = "cbc(cast6)",
1957		.test = alg_test_skcipher,
1958		.suite = {
1959			.cipher = {
1960				.enc = {
1961					.vecs = cast6_cbc_enc_tv_template,
1962					.count = CAST6_CBC_ENC_TEST_VECTORS
1963				},
1964				.dec = {
1965					.vecs = cast6_cbc_dec_tv_template,
1966					.count = CAST6_CBC_DEC_TEST_VECTORS
1967				}
1968			}
1969		}
1970	}, {
1971		.alg = "cbc(des)",
1972		.test = alg_test_skcipher,
1973		.suite = {
1974			.cipher = {
1975				.enc = {
1976					.vecs = des_cbc_enc_tv_template,
1977					.count = DES_CBC_ENC_TEST_VECTORS
1978				},
1979				.dec = {
1980					.vecs = des_cbc_dec_tv_template,
1981					.count = DES_CBC_DEC_TEST_VECTORS
1982				}
1983			}
1984		}
1985	}, {
1986		.alg = "cbc(des3_ede)",
1987		.test = alg_test_skcipher,
1988		.fips_allowed = 1,
1989		.suite = {
1990			.cipher = {
1991				.enc = {
1992					.vecs = des3_ede_cbc_enc_tv_template,
1993					.count = DES3_EDE_CBC_ENC_TEST_VECTORS
1994				},
1995				.dec = {
1996					.vecs = des3_ede_cbc_dec_tv_template,
1997					.count = DES3_EDE_CBC_DEC_TEST_VECTORS
1998				}
1999			}
2000		}
2001	}, {
2002		.alg = "cbc(serpent)",
2003		.test = alg_test_skcipher,
2004		.suite = {
2005			.cipher = {
2006				.enc = {
2007					.vecs = serpent_cbc_enc_tv_template,
2008					.count = SERPENT_CBC_ENC_TEST_VECTORS
2009				},
2010				.dec = {
2011					.vecs = serpent_cbc_dec_tv_template,
2012					.count = SERPENT_CBC_DEC_TEST_VECTORS
2013				}
2014			}
2015		}
2016	}, {
2017		.alg = "cbc(twofish)",
2018		.test = alg_test_skcipher,
2019		.suite = {
2020			.cipher = {
2021				.enc = {
2022					.vecs = tf_cbc_enc_tv_template,
2023					.count = TF_CBC_ENC_TEST_VECTORS
2024				},
2025				.dec = {
2026					.vecs = tf_cbc_dec_tv_template,
2027					.count = TF_CBC_DEC_TEST_VECTORS
2028				}
2029			}
2030		}
2031	}, {
2032		.alg = "ccm(aes)",
2033		.test = alg_test_aead,
2034		.fips_allowed = 1,
2035		.suite = {
2036			.aead = {
2037				.enc = {
2038					.vecs = aes_ccm_enc_tv_template,
2039					.count = AES_CCM_ENC_TEST_VECTORS
2040				},
2041				.dec = {
2042					.vecs = aes_ccm_dec_tv_template,
2043					.count = AES_CCM_DEC_TEST_VECTORS
2044				}
2045			}
2046		}
2047	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2048		.alg = "cmac(aes)",
 
2049		.test = alg_test_hash,
2050		.suite = {
2051			.hash = {
2052				.vecs = aes_cmac128_tv_template,
2053				.count = CMAC_AES_TEST_VECTORS
2054			}
2055		}
2056	}, {
2057		.alg = "cmac(des3_ede)",
 
2058		.test = alg_test_hash,
2059		.suite = {
2060			.hash = {
2061				.vecs = des3_ede_cmac64_tv_template,
2062				.count = CMAC_DES3_EDE_TEST_VECTORS
2063			}
2064		}
2065	}, {
2066		.alg = "compress_null",
2067		.test = alg_test_null,
2068	}, {
 
 
 
 
 
 
 
 
 
2069		.alg = "crc32c",
2070		.test = alg_test_crc32c,
2071		.fips_allowed = 1,
2072		.suite = {
2073			.hash = {
2074				.vecs = crc32c_tv_template,
2075				.count = CRC32C_TEST_VECTORS
2076			}
2077		}
2078	}, {
2079		.alg = "crct10dif",
2080		.test = alg_test_hash,
2081		.fips_allowed = 1,
2082		.suite = {
2083			.hash = {
2084				.vecs = crct10dif_tv_template,
2085				.count = CRCT10DIF_TEST_VECTORS
2086			}
2087		}
2088	}, {
2089		.alg = "cryptd(__driver-cbc-aes-aesni)",
2090		.test = alg_test_null,
2091		.fips_allowed = 1,
2092	}, {
2093		.alg = "cryptd(__driver-cbc-camellia-aesni)",
2094		.test = alg_test_null,
2095	}, {
2096		.alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2097		.test = alg_test_null,
2098	}, {
2099		.alg = "cryptd(__driver-cbc-serpent-avx2)",
2100		.test = alg_test_null,
2101	}, {
2102		.alg = "cryptd(__driver-ecb-aes-aesni)",
2103		.test = alg_test_null,
2104		.fips_allowed = 1,
2105	}, {
2106		.alg = "cryptd(__driver-ecb-camellia-aesni)",
2107		.test = alg_test_null,
2108	}, {
2109		.alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2110		.test = alg_test_null,
2111	}, {
2112		.alg = "cryptd(__driver-ecb-cast5-avx)",
2113		.test = alg_test_null,
2114	}, {
2115		.alg = "cryptd(__driver-ecb-cast6-avx)",
2116		.test = alg_test_null,
2117	}, {
2118		.alg = "cryptd(__driver-ecb-serpent-avx)",
2119		.test = alg_test_null,
2120	}, {
2121		.alg = "cryptd(__driver-ecb-serpent-avx2)",
2122		.test = alg_test_null,
2123	}, {
2124		.alg = "cryptd(__driver-ecb-serpent-sse2)",
2125		.test = alg_test_null,
2126	}, {
2127		.alg = "cryptd(__driver-ecb-twofish-avx)",
2128		.test = alg_test_null,
2129	}, {
2130		.alg = "cryptd(__driver-gcm-aes-aesni)",
2131		.test = alg_test_null,
2132		.fips_allowed = 1,
2133	}, {
2134		.alg = "cryptd(__ghash-pclmulqdqni)",
2135		.test = alg_test_null,
2136		.fips_allowed = 1,
2137	}, {
2138		.alg = "ctr(aes)",
2139		.test = alg_test_skcipher,
2140		.fips_allowed = 1,
2141		.suite = {
2142			.cipher = {
2143				.enc = {
2144					.vecs = aes_ctr_enc_tv_template,
2145					.count = AES_CTR_ENC_TEST_VECTORS
2146				},
2147				.dec = {
2148					.vecs = aes_ctr_dec_tv_template,
2149					.count = AES_CTR_DEC_TEST_VECTORS
2150				}
2151			}
2152		}
2153	}, {
2154		.alg = "ctr(blowfish)",
2155		.test = alg_test_skcipher,
2156		.suite = {
2157			.cipher = {
2158				.enc = {
2159					.vecs = bf_ctr_enc_tv_template,
2160					.count = BF_CTR_ENC_TEST_VECTORS
2161				},
2162				.dec = {
2163					.vecs = bf_ctr_dec_tv_template,
2164					.count = BF_CTR_DEC_TEST_VECTORS
2165				}
2166			}
2167		}
2168	}, {
2169		.alg = "ctr(camellia)",
2170		.test = alg_test_skcipher,
2171		.suite = {
2172			.cipher = {
2173				.enc = {
2174					.vecs = camellia_ctr_enc_tv_template,
2175					.count = CAMELLIA_CTR_ENC_TEST_VECTORS
2176				},
2177				.dec = {
2178					.vecs = camellia_ctr_dec_tv_template,
2179					.count = CAMELLIA_CTR_DEC_TEST_VECTORS
2180				}
2181			}
2182		}
2183	}, {
2184		.alg = "ctr(cast5)",
2185		.test = alg_test_skcipher,
2186		.suite = {
2187			.cipher = {
2188				.enc = {
2189					.vecs = cast5_ctr_enc_tv_template,
2190					.count = CAST5_CTR_ENC_TEST_VECTORS
2191				},
2192				.dec = {
2193					.vecs = cast5_ctr_dec_tv_template,
2194					.count = CAST5_CTR_DEC_TEST_VECTORS
2195				}
2196			}
2197		}
2198	}, {
2199		.alg = "ctr(cast6)",
2200		.test = alg_test_skcipher,
2201		.suite = {
2202			.cipher = {
2203				.enc = {
2204					.vecs = cast6_ctr_enc_tv_template,
2205					.count = CAST6_CTR_ENC_TEST_VECTORS
2206				},
2207				.dec = {
2208					.vecs = cast6_ctr_dec_tv_template,
2209					.count = CAST6_CTR_DEC_TEST_VECTORS
2210				}
2211			}
2212		}
2213	}, {
2214		.alg = "ctr(des)",
2215		.test = alg_test_skcipher,
2216		.suite = {
2217			.cipher = {
2218				.enc = {
2219					.vecs = des_ctr_enc_tv_template,
2220					.count = DES_CTR_ENC_TEST_VECTORS
2221				},
2222				.dec = {
2223					.vecs = des_ctr_dec_tv_template,
2224					.count = DES_CTR_DEC_TEST_VECTORS
2225				}
2226			}
2227		}
2228	}, {
2229		.alg = "ctr(des3_ede)",
2230		.test = alg_test_skcipher,
2231		.suite = {
2232			.cipher = {
2233				.enc = {
2234					.vecs = des3_ede_ctr_enc_tv_template,
2235					.count = DES3_EDE_CTR_ENC_TEST_VECTORS
2236				},
2237				.dec = {
2238					.vecs = des3_ede_ctr_dec_tv_template,
2239					.count = DES3_EDE_CTR_DEC_TEST_VECTORS
2240				}
2241			}
2242		}
2243	}, {
2244		.alg = "ctr(serpent)",
2245		.test = alg_test_skcipher,
2246		.suite = {
2247			.cipher = {
2248				.enc = {
2249					.vecs = serpent_ctr_enc_tv_template,
2250					.count = SERPENT_CTR_ENC_TEST_VECTORS
2251				},
2252				.dec = {
2253					.vecs = serpent_ctr_dec_tv_template,
2254					.count = SERPENT_CTR_DEC_TEST_VECTORS
2255				}
2256			}
2257		}
2258	}, {
2259		.alg = "ctr(twofish)",
2260		.test = alg_test_skcipher,
2261		.suite = {
2262			.cipher = {
2263				.enc = {
2264					.vecs = tf_ctr_enc_tv_template,
2265					.count = TF_CTR_ENC_TEST_VECTORS
2266				},
2267				.dec = {
2268					.vecs = tf_ctr_dec_tv_template,
2269					.count = TF_CTR_DEC_TEST_VECTORS
2270				}
2271			}
2272		}
2273	}, {
2274		.alg = "cts(cbc(aes))",
2275		.test = alg_test_skcipher,
2276		.suite = {
2277			.cipher = {
2278				.enc = {
2279					.vecs = cts_mode_enc_tv_template,
2280					.count = CTS_MODE_ENC_TEST_VECTORS
2281				},
2282				.dec = {
2283					.vecs = cts_mode_dec_tv_template,
2284					.count = CTS_MODE_DEC_TEST_VECTORS
2285				}
2286			}
2287		}
2288	}, {
2289		.alg = "deflate",
2290		.test = alg_test_comp,
2291		.fips_allowed = 1,
2292		.suite = {
2293			.comp = {
2294				.comp = {
2295					.vecs = deflate_comp_tv_template,
2296					.count = DEFLATE_COMP_TEST_VECTORS
2297				},
2298				.decomp = {
2299					.vecs = deflate_decomp_tv_template,
2300					.count = DEFLATE_DECOMP_TEST_VECTORS
2301				}
2302			}
2303		}
2304	}, {
 
 
 
 
 
 
 
 
 
 
2305		.alg = "digest_null",
2306		.test = alg_test_null,
2307	}, {
2308		.alg = "ecb(__aes-aesni)",
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2309		.test = alg_test_null,
 
 
 
2310		.fips_allowed = 1,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2311	}, {
2312		.alg = "ecb(aes)",
2313		.test = alg_test_skcipher,
2314		.fips_allowed = 1,
2315		.suite = {
2316			.cipher = {
2317				.enc = {
2318					.vecs = aes_enc_tv_template,
2319					.count = AES_ENC_TEST_VECTORS
2320				},
2321				.dec = {
2322					.vecs = aes_dec_tv_template,
2323					.count = AES_DEC_TEST_VECTORS
2324				}
2325			}
2326		}
2327	}, {
2328		.alg = "ecb(anubis)",
2329		.test = alg_test_skcipher,
2330		.suite = {
2331			.cipher = {
2332				.enc = {
2333					.vecs = anubis_enc_tv_template,
2334					.count = ANUBIS_ENC_TEST_VECTORS
2335				},
2336				.dec = {
2337					.vecs = anubis_dec_tv_template,
2338					.count = ANUBIS_DEC_TEST_VECTORS
2339				}
2340			}
2341		}
2342	}, {
2343		.alg = "ecb(arc4)",
2344		.test = alg_test_skcipher,
2345		.suite = {
2346			.cipher = {
2347				.enc = {
2348					.vecs = arc4_enc_tv_template,
2349					.count = ARC4_ENC_TEST_VECTORS
2350				},
2351				.dec = {
2352					.vecs = arc4_dec_tv_template,
2353					.count = ARC4_DEC_TEST_VECTORS
2354				}
2355			}
2356		}
2357	}, {
2358		.alg = "ecb(blowfish)",
2359		.test = alg_test_skcipher,
2360		.suite = {
2361			.cipher = {
2362				.enc = {
2363					.vecs = bf_enc_tv_template,
2364					.count = BF_ENC_TEST_VECTORS
2365				},
2366				.dec = {
2367					.vecs = bf_dec_tv_template,
2368					.count = BF_DEC_TEST_VECTORS
2369				}
2370			}
2371		}
2372	}, {
2373		.alg = "ecb(camellia)",
2374		.test = alg_test_skcipher,
2375		.suite = {
2376			.cipher = {
2377				.enc = {
2378					.vecs = camellia_enc_tv_template,
2379					.count = CAMELLIA_ENC_TEST_VECTORS
2380				},
2381				.dec = {
2382					.vecs = camellia_dec_tv_template,
2383					.count = CAMELLIA_DEC_TEST_VECTORS
2384				}
2385			}
2386		}
2387	}, {
2388		.alg = "ecb(cast5)",
2389		.test = alg_test_skcipher,
2390		.suite = {
2391			.cipher = {
2392				.enc = {
2393					.vecs = cast5_enc_tv_template,
2394					.count = CAST5_ENC_TEST_VECTORS
2395				},
2396				.dec = {
2397					.vecs = cast5_dec_tv_template,
2398					.count = CAST5_DEC_TEST_VECTORS
2399				}
2400			}
2401		}
2402	}, {
2403		.alg = "ecb(cast6)",
2404		.test = alg_test_skcipher,
2405		.suite = {
2406			.cipher = {
2407				.enc = {
2408					.vecs = cast6_enc_tv_template,
2409					.count = CAST6_ENC_TEST_VECTORS
2410				},
2411				.dec = {
2412					.vecs = cast6_dec_tv_template,
2413					.count = CAST6_DEC_TEST_VECTORS
2414				}
2415			}
2416		}
2417	}, {
2418		.alg = "ecb(cipher_null)",
2419		.test = alg_test_null,
2420	}, {
2421		.alg = "ecb(des)",
2422		.test = alg_test_skcipher,
2423		.fips_allowed = 1,
2424		.suite = {
2425			.cipher = {
2426				.enc = {
2427					.vecs = des_enc_tv_template,
2428					.count = DES_ENC_TEST_VECTORS
2429				},
2430				.dec = {
2431					.vecs = des_dec_tv_template,
2432					.count = DES_DEC_TEST_VECTORS
2433				}
2434			}
2435		}
2436	}, {
2437		.alg = "ecb(des3_ede)",
2438		.test = alg_test_skcipher,
2439		.fips_allowed = 1,
2440		.suite = {
2441			.cipher = {
2442				.enc = {
2443					.vecs = des3_ede_enc_tv_template,
2444					.count = DES3_EDE_ENC_TEST_VECTORS
2445				},
2446				.dec = {
2447					.vecs = des3_ede_dec_tv_template,
2448					.count = DES3_EDE_DEC_TEST_VECTORS
2449				}
2450			}
2451		}
2452	}, {
2453		.alg = "ecb(fcrypt)",
2454		.test = alg_test_skcipher,
2455		.suite = {
2456			.cipher = {
2457				.enc = {
2458					.vecs = fcrypt_pcbc_enc_tv_template,
2459					.count = 1
2460				},
2461				.dec = {
2462					.vecs = fcrypt_pcbc_dec_tv_template,
2463					.count = 1
2464				}
2465			}
2466		}
2467	}, {
2468		.alg = "ecb(khazad)",
2469		.test = alg_test_skcipher,
2470		.suite = {
2471			.cipher = {
2472				.enc = {
2473					.vecs = khazad_enc_tv_template,
2474					.count = KHAZAD_ENC_TEST_VECTORS
2475				},
2476				.dec = {
2477					.vecs = khazad_dec_tv_template,
2478					.count = KHAZAD_DEC_TEST_VECTORS
2479				}
2480			}
2481		}
2482	}, {
2483		.alg = "ecb(seed)",
2484		.test = alg_test_skcipher,
2485		.suite = {
2486			.cipher = {
2487				.enc = {
2488					.vecs = seed_enc_tv_template,
2489					.count = SEED_ENC_TEST_VECTORS
2490				},
2491				.dec = {
2492					.vecs = seed_dec_tv_template,
2493					.count = SEED_DEC_TEST_VECTORS
2494				}
2495			}
2496		}
2497	}, {
2498		.alg = "ecb(serpent)",
2499		.test = alg_test_skcipher,
2500		.suite = {
2501			.cipher = {
2502				.enc = {
2503					.vecs = serpent_enc_tv_template,
2504					.count = SERPENT_ENC_TEST_VECTORS
2505				},
2506				.dec = {
2507					.vecs = serpent_dec_tv_template,
2508					.count = SERPENT_DEC_TEST_VECTORS
2509				}
2510			}
2511		}
2512	}, {
2513		.alg = "ecb(tea)",
2514		.test = alg_test_skcipher,
2515		.suite = {
2516			.cipher = {
2517				.enc = {
2518					.vecs = tea_enc_tv_template,
2519					.count = TEA_ENC_TEST_VECTORS
2520				},
2521				.dec = {
2522					.vecs = tea_dec_tv_template,
2523					.count = TEA_DEC_TEST_VECTORS
2524				}
2525			}
2526		}
2527	}, {
2528		.alg = "ecb(tnepres)",
2529		.test = alg_test_skcipher,
2530		.suite = {
2531			.cipher = {
2532				.enc = {
2533					.vecs = tnepres_enc_tv_template,
2534					.count = TNEPRES_ENC_TEST_VECTORS
2535				},
2536				.dec = {
2537					.vecs = tnepres_dec_tv_template,
2538					.count = TNEPRES_DEC_TEST_VECTORS
2539				}
2540			}
2541		}
2542	}, {
2543		.alg = "ecb(twofish)",
2544		.test = alg_test_skcipher,
2545		.suite = {
2546			.cipher = {
2547				.enc = {
2548					.vecs = tf_enc_tv_template,
2549					.count = TF_ENC_TEST_VECTORS
2550				},
2551				.dec = {
2552					.vecs = tf_dec_tv_template,
2553					.count = TF_DEC_TEST_VECTORS
2554				}
2555			}
2556		}
2557	}, {
2558		.alg = "ecb(xeta)",
2559		.test = alg_test_skcipher,
2560		.suite = {
2561			.cipher = {
2562				.enc = {
2563					.vecs = xeta_enc_tv_template,
2564					.count = XETA_ENC_TEST_VECTORS
2565				},
2566				.dec = {
2567					.vecs = xeta_dec_tv_template,
2568					.count = XETA_DEC_TEST_VECTORS
2569				}
2570			}
2571		}
2572	}, {
2573		.alg = "ecb(xtea)",
2574		.test = alg_test_skcipher,
2575		.suite = {
2576			.cipher = {
2577				.enc = {
2578					.vecs = xtea_enc_tv_template,
2579					.count = XTEA_ENC_TEST_VECTORS
2580				},
2581				.dec = {
2582					.vecs = xtea_dec_tv_template,
2583					.count = XTEA_DEC_TEST_VECTORS
2584				}
2585			}
2586		}
2587	}, {
 
 
 
 
 
 
 
 
 
 
2588		.alg = "gcm(aes)",
2589		.test = alg_test_aead,
2590		.fips_allowed = 1,
2591		.suite = {
2592			.aead = {
2593				.enc = {
2594					.vecs = aes_gcm_enc_tv_template,
2595					.count = AES_GCM_ENC_TEST_VECTORS
2596				},
2597				.dec = {
2598					.vecs = aes_gcm_dec_tv_template,
2599					.count = AES_GCM_DEC_TEST_VECTORS
2600				}
2601			}
2602		}
2603	}, {
2604		.alg = "ghash",
2605		.test = alg_test_hash,
2606		.fips_allowed = 1,
2607		.suite = {
2608			.hash = {
2609				.vecs = ghash_tv_template,
2610				.count = GHASH_TEST_VECTORS
2611			}
2612		}
2613	}, {
2614		.alg = "hmac(crc32)",
2615		.test = alg_test_hash,
2616		.suite = {
2617			.hash = {
2618				.vecs = bfin_crc_tv_template,
2619				.count = BFIN_CRC_TEST_VECTORS
2620			}
2621		}
2622	}, {
2623		.alg = "hmac(md5)",
2624		.test = alg_test_hash,
2625		.suite = {
2626			.hash = {
2627				.vecs = hmac_md5_tv_template,
2628				.count = HMAC_MD5_TEST_VECTORS
2629			}
2630		}
2631	}, {
2632		.alg = "hmac(rmd128)",
2633		.test = alg_test_hash,
2634		.suite = {
2635			.hash = {
2636				.vecs = hmac_rmd128_tv_template,
2637				.count = HMAC_RMD128_TEST_VECTORS
2638			}
2639		}
2640	}, {
2641		.alg = "hmac(rmd160)",
2642		.test = alg_test_hash,
2643		.suite = {
2644			.hash = {
2645				.vecs = hmac_rmd160_tv_template,
2646				.count = HMAC_RMD160_TEST_VECTORS
2647			}
2648		}
2649	}, {
2650		.alg = "hmac(sha1)",
2651		.test = alg_test_hash,
2652		.fips_allowed = 1,
2653		.suite = {
2654			.hash = {
2655				.vecs = hmac_sha1_tv_template,
2656				.count = HMAC_SHA1_TEST_VECTORS
2657			}
2658		}
2659	}, {
2660		.alg = "hmac(sha224)",
2661		.test = alg_test_hash,
2662		.fips_allowed = 1,
2663		.suite = {
2664			.hash = {
2665				.vecs = hmac_sha224_tv_template,
2666				.count = HMAC_SHA224_TEST_VECTORS
2667			}
2668		}
2669	}, {
2670		.alg = "hmac(sha256)",
2671		.test = alg_test_hash,
2672		.fips_allowed = 1,
2673		.suite = {
2674			.hash = {
2675				.vecs = hmac_sha256_tv_template,
2676				.count = HMAC_SHA256_TEST_VECTORS
2677			}
2678		}
2679	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2680		.alg = "hmac(sha384)",
2681		.test = alg_test_hash,
2682		.fips_allowed = 1,
2683		.suite = {
2684			.hash = {
2685				.vecs = hmac_sha384_tv_template,
2686				.count = HMAC_SHA384_TEST_VECTORS
2687			}
2688		}
2689	}, {
2690		.alg = "hmac(sha512)",
2691		.test = alg_test_hash,
2692		.fips_allowed = 1,
2693		.suite = {
2694			.hash = {
2695				.vecs = hmac_sha512_tv_template,
2696				.count = HMAC_SHA512_TEST_VECTORS
2697			}
2698		}
2699	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2700		.alg = "lrw(aes)",
2701		.test = alg_test_skcipher,
2702		.suite = {
2703			.cipher = {
2704				.enc = {
2705					.vecs = aes_lrw_enc_tv_template,
2706					.count = AES_LRW_ENC_TEST_VECTORS
2707				},
2708				.dec = {
2709					.vecs = aes_lrw_dec_tv_template,
2710					.count = AES_LRW_DEC_TEST_VECTORS
2711				}
2712			}
2713		}
2714	}, {
2715		.alg = "lrw(camellia)",
2716		.test = alg_test_skcipher,
2717		.suite = {
2718			.cipher = {
2719				.enc = {
2720					.vecs = camellia_lrw_enc_tv_template,
2721					.count = CAMELLIA_LRW_ENC_TEST_VECTORS
2722				},
2723				.dec = {
2724					.vecs = camellia_lrw_dec_tv_template,
2725					.count = CAMELLIA_LRW_DEC_TEST_VECTORS
2726				}
2727			}
2728		}
2729	}, {
2730		.alg = "lrw(cast6)",
2731		.test = alg_test_skcipher,
2732		.suite = {
2733			.cipher = {
2734				.enc = {
2735					.vecs = cast6_lrw_enc_tv_template,
2736					.count = CAST6_LRW_ENC_TEST_VECTORS
2737				},
2738				.dec = {
2739					.vecs = cast6_lrw_dec_tv_template,
2740					.count = CAST6_LRW_DEC_TEST_VECTORS
2741				}
2742			}
2743		}
2744	}, {
2745		.alg = "lrw(serpent)",
2746		.test = alg_test_skcipher,
2747		.suite = {
2748			.cipher = {
2749				.enc = {
2750					.vecs = serpent_lrw_enc_tv_template,
2751					.count = SERPENT_LRW_ENC_TEST_VECTORS
2752				},
2753				.dec = {
2754					.vecs = serpent_lrw_dec_tv_template,
2755					.count = SERPENT_LRW_DEC_TEST_VECTORS
2756				}
2757			}
2758		}
2759	}, {
2760		.alg = "lrw(twofish)",
2761		.test = alg_test_skcipher,
2762		.suite = {
2763			.cipher = {
2764				.enc = {
2765					.vecs = tf_lrw_enc_tv_template,
2766					.count = TF_LRW_ENC_TEST_VECTORS
2767				},
2768				.dec = {
2769					.vecs = tf_lrw_dec_tv_template,
2770					.count = TF_LRW_DEC_TEST_VECTORS
2771				}
2772			}
2773		}
2774	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2775		.alg = "lzo",
2776		.test = alg_test_comp,
2777		.fips_allowed = 1,
2778		.suite = {
2779			.comp = {
2780				.comp = {
2781					.vecs = lzo_comp_tv_template,
2782					.count = LZO_COMP_TEST_VECTORS
2783				},
2784				.decomp = {
2785					.vecs = lzo_decomp_tv_template,
2786					.count = LZO_DECOMP_TEST_VECTORS
2787				}
2788			}
2789		}
2790	}, {
2791		.alg = "md4",
2792		.test = alg_test_hash,
2793		.suite = {
2794			.hash = {
2795				.vecs = md4_tv_template,
2796				.count = MD4_TEST_VECTORS
2797			}
2798		}
2799	}, {
2800		.alg = "md5",
2801		.test = alg_test_hash,
2802		.suite = {
2803			.hash = {
2804				.vecs = md5_tv_template,
2805				.count = MD5_TEST_VECTORS
2806			}
2807		}
2808	}, {
2809		.alg = "michael_mic",
2810		.test = alg_test_hash,
2811		.suite = {
2812			.hash = {
2813				.vecs = michael_mic_tv_template,
2814				.count = MICHAEL_MIC_TEST_VECTORS
2815			}
2816		}
2817	}, {
2818		.alg = "ofb(aes)",
2819		.test = alg_test_skcipher,
2820		.fips_allowed = 1,
2821		.suite = {
2822			.cipher = {
2823				.enc = {
2824					.vecs = aes_ofb_enc_tv_template,
2825					.count = AES_OFB_ENC_TEST_VECTORS
2826				},
2827				.dec = {
2828					.vecs = aes_ofb_dec_tv_template,
2829					.count = AES_OFB_DEC_TEST_VECTORS
2830				}
2831			}
2832		}
2833	}, {
2834		.alg = "pcbc(fcrypt)",
2835		.test = alg_test_skcipher,
2836		.suite = {
2837			.cipher = {
2838				.enc = {
2839					.vecs = fcrypt_pcbc_enc_tv_template,
2840					.count = FCRYPT_ENC_TEST_VECTORS
2841				},
2842				.dec = {
2843					.vecs = fcrypt_pcbc_dec_tv_template,
2844					.count = FCRYPT_DEC_TEST_VECTORS
2845				}
2846			}
2847		}
2848	}, {
 
 
 
 
 
 
 
 
 
2849		.alg = "rfc3686(ctr(aes))",
2850		.test = alg_test_skcipher,
2851		.fips_allowed = 1,
2852		.suite = {
2853			.cipher = {
2854				.enc = {
2855					.vecs = aes_ctr_rfc3686_enc_tv_template,
2856					.count = AES_CTR_3686_ENC_TEST_VECTORS
2857				},
2858				.dec = {
2859					.vecs = aes_ctr_rfc3686_dec_tv_template,
2860					.count = AES_CTR_3686_DEC_TEST_VECTORS
2861				}
2862			}
2863		}
2864	}, {
2865		.alg = "rfc4106(gcm(aes))",
2866		.test = alg_test_aead,
 
2867		.suite = {
2868			.aead = {
2869				.enc = {
2870					.vecs = aes_gcm_rfc4106_enc_tv_template,
2871					.count = AES_GCM_4106_ENC_TEST_VECTORS
2872				},
2873				.dec = {
2874					.vecs = aes_gcm_rfc4106_dec_tv_template,
2875					.count = AES_GCM_4106_DEC_TEST_VECTORS
2876				}
2877			}
2878		}
2879	}, {
2880		.alg = "rfc4309(ccm(aes))",
2881		.test = alg_test_aead,
2882		.fips_allowed = 1,
2883		.suite = {
2884			.aead = {
2885				.enc = {
2886					.vecs = aes_ccm_rfc4309_enc_tv_template,
2887					.count = AES_CCM_4309_ENC_TEST_VECTORS
2888				},
2889				.dec = {
2890					.vecs = aes_ccm_rfc4309_dec_tv_template,
2891					.count = AES_CCM_4309_DEC_TEST_VECTORS
2892				}
2893			}
2894		}
2895	}, {
2896		.alg = "rfc4543(gcm(aes))",
2897		.test = alg_test_aead,
2898		.suite = {
2899			.aead = {
2900				.enc = {
2901					.vecs = aes_gcm_rfc4543_enc_tv_template,
2902					.count = AES_GCM_4543_ENC_TEST_VECTORS
2903				},
2904				.dec = {
2905					.vecs = aes_gcm_rfc4543_dec_tv_template,
2906					.count = AES_GCM_4543_DEC_TEST_VECTORS
2907				},
2908			}
2909		}
2910	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2911		.alg = "rmd128",
2912		.test = alg_test_hash,
2913		.suite = {
2914			.hash = {
2915				.vecs = rmd128_tv_template,
2916				.count = RMD128_TEST_VECTORS
2917			}
2918		}
2919	}, {
2920		.alg = "rmd160",
2921		.test = alg_test_hash,
2922		.suite = {
2923			.hash = {
2924				.vecs = rmd160_tv_template,
2925				.count = RMD160_TEST_VECTORS
2926			}
2927		}
2928	}, {
2929		.alg = "rmd256",
2930		.test = alg_test_hash,
2931		.suite = {
2932			.hash = {
2933				.vecs = rmd256_tv_template,
2934				.count = RMD256_TEST_VECTORS
2935			}
2936		}
2937	}, {
2938		.alg = "rmd320",
2939		.test = alg_test_hash,
2940		.suite = {
2941			.hash = {
2942				.vecs = rmd320_tv_template,
2943				.count = RMD320_TEST_VECTORS
2944			}
2945		}
2946	}, {
 
 
 
 
 
 
 
 
 
 
2947		.alg = "salsa20",
2948		.test = alg_test_skcipher,
2949		.suite = {
2950			.cipher = {
2951				.enc = {
2952					.vecs = salsa20_stream_enc_tv_template,
2953					.count = SALSA20_STREAM_ENC_TEST_VECTORS
2954				}
2955			}
2956		}
2957	}, {
2958		.alg = "sha1",
2959		.test = alg_test_hash,
2960		.fips_allowed = 1,
2961		.suite = {
2962			.hash = {
2963				.vecs = sha1_tv_template,
2964				.count = SHA1_TEST_VECTORS
2965			}
2966		}
2967	}, {
2968		.alg = "sha224",
2969		.test = alg_test_hash,
2970		.fips_allowed = 1,
2971		.suite = {
2972			.hash = {
2973				.vecs = sha224_tv_template,
2974				.count = SHA224_TEST_VECTORS
2975			}
2976		}
2977	}, {
2978		.alg = "sha256",
2979		.test = alg_test_hash,
2980		.fips_allowed = 1,
2981		.suite = {
2982			.hash = {
2983				.vecs = sha256_tv_template,
2984				.count = SHA256_TEST_VECTORS
2985			}
2986		}
2987	}, {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2988		.alg = "sha384",
2989		.test = alg_test_hash,
2990		.fips_allowed = 1,
2991		.suite = {
2992			.hash = {
2993				.vecs = sha384_tv_template,
2994				.count = SHA384_TEST_VECTORS
2995			}
2996		}
2997	}, {
2998		.alg = "sha512",
2999		.test = alg_test_hash,
3000		.fips_allowed = 1,
3001		.suite = {
3002			.hash = {
3003				.vecs = sha512_tv_template,
3004				.count = SHA512_TEST_VECTORS
3005			}
3006		}
3007	}, {
3008		.alg = "tgr128",
3009		.test = alg_test_hash,
3010		.suite = {
3011			.hash = {
3012				.vecs = tgr128_tv_template,
3013				.count = TGR128_TEST_VECTORS
3014			}
3015		}
3016	}, {
3017		.alg = "tgr160",
3018		.test = alg_test_hash,
3019		.suite = {
3020			.hash = {
3021				.vecs = tgr160_tv_template,
3022				.count = TGR160_TEST_VECTORS
3023			}
3024		}
3025	}, {
3026		.alg = "tgr192",
3027		.test = alg_test_hash,
3028		.suite = {
3029			.hash = {
3030				.vecs = tgr192_tv_template,
3031				.count = TGR192_TEST_VECTORS
3032			}
3033		}
3034	}, {
3035		.alg = "vmac(aes)",
3036		.test = alg_test_hash,
3037		.suite = {
3038			.hash = {
3039				.vecs = aes_vmac128_tv_template,
3040				.count = VMAC_AES_TEST_VECTORS
3041			}
3042		}
3043	}, {
3044		.alg = "wp256",
3045		.test = alg_test_hash,
3046		.suite = {
3047			.hash = {
3048				.vecs = wp256_tv_template,
3049				.count = WP256_TEST_VECTORS
3050			}
3051		}
3052	}, {
3053		.alg = "wp384",
3054		.test = alg_test_hash,
3055		.suite = {
3056			.hash = {
3057				.vecs = wp384_tv_template,
3058				.count = WP384_TEST_VECTORS
3059			}
3060		}
3061	}, {
3062		.alg = "wp512",
3063		.test = alg_test_hash,
3064		.suite = {
3065			.hash = {
3066				.vecs = wp512_tv_template,
3067				.count = WP512_TEST_VECTORS
3068			}
3069		}
3070	}, {
3071		.alg = "xcbc(aes)",
3072		.test = alg_test_hash,
3073		.suite = {
3074			.hash = {
3075				.vecs = aes_xcbc128_tv_template,
3076				.count = XCBC_AES_TEST_VECTORS
3077			}
3078		}
3079	}, {
3080		.alg = "xts(aes)",
3081		.test = alg_test_skcipher,
3082		.fips_allowed = 1,
3083		.suite = {
3084			.cipher = {
3085				.enc = {
3086					.vecs = aes_xts_enc_tv_template,
3087					.count = AES_XTS_ENC_TEST_VECTORS
3088				},
3089				.dec = {
3090					.vecs = aes_xts_dec_tv_template,
3091					.count = AES_XTS_DEC_TEST_VECTORS
3092				}
3093			}
3094		}
3095	}, {
3096		.alg = "xts(camellia)",
3097		.test = alg_test_skcipher,
3098		.suite = {
3099			.cipher = {
3100				.enc = {
3101					.vecs = camellia_xts_enc_tv_template,
3102					.count = CAMELLIA_XTS_ENC_TEST_VECTORS
3103				},
3104				.dec = {
3105					.vecs = camellia_xts_dec_tv_template,
3106					.count = CAMELLIA_XTS_DEC_TEST_VECTORS
3107				}
3108			}
3109		}
3110	}, {
3111		.alg = "xts(cast6)",
3112		.test = alg_test_skcipher,
3113		.suite = {
3114			.cipher = {
3115				.enc = {
3116					.vecs = cast6_xts_enc_tv_template,
3117					.count = CAST6_XTS_ENC_TEST_VECTORS
3118				},
3119				.dec = {
3120					.vecs = cast6_xts_dec_tv_template,
3121					.count = CAST6_XTS_DEC_TEST_VECTORS
3122				}
3123			}
3124		}
3125	}, {
3126		.alg = "xts(serpent)",
3127		.test = alg_test_skcipher,
3128		.suite = {
3129			.cipher = {
3130				.enc = {
3131					.vecs = serpent_xts_enc_tv_template,
3132					.count = SERPENT_XTS_ENC_TEST_VECTORS
3133				},
3134				.dec = {
3135					.vecs = serpent_xts_dec_tv_template,
3136					.count = SERPENT_XTS_DEC_TEST_VECTORS
3137				}
3138			}
3139		}
3140	}, {
3141		.alg = "xts(twofish)",
3142		.test = alg_test_skcipher,
3143		.suite = {
3144			.cipher = {
3145				.enc = {
3146					.vecs = tf_xts_enc_tv_template,
3147					.count = TF_XTS_ENC_TEST_VECTORS
3148				},
3149				.dec = {
3150					.vecs = tf_xts_dec_tv_template,
3151					.count = TF_XTS_DEC_TEST_VECTORS
3152				}
3153			}
3154		}
3155	}, {
3156		.alg = "zlib",
3157		.test = alg_test_pcomp,
3158		.fips_allowed = 1,
3159		.suite = {
3160			.pcomp = {
3161				.comp = {
3162					.vecs = zlib_comp_tv_template,
3163					.count = ZLIB_COMP_TEST_VECTORS
3164				},
3165				.decomp = {
3166					.vecs = zlib_decomp_tv_template,
3167					.count = ZLIB_DECOMP_TEST_VECTORS
3168				}
3169			}
3170		}
3171	}
3172};
3173
3174static bool alg_test_descs_checked;
3175
3176static void alg_test_descs_check_order(void)
3177{
3178	int i;
3179
3180	/* only check once */
3181	if (alg_test_descs_checked)
3182		return;
3183
3184	alg_test_descs_checked = true;
3185
3186	for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3187		int diff = strcmp(alg_test_descs[i - 1].alg,
3188				  alg_test_descs[i].alg);
3189
3190		if (WARN_ON(diff > 0)) {
3191			pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3192				alg_test_descs[i - 1].alg,
3193				alg_test_descs[i].alg);
3194		}
3195
3196		if (WARN_ON(diff == 0)) {
3197			pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3198				alg_test_descs[i].alg);
3199		}
3200	}
3201}
3202
3203static int alg_find_test(const char *alg)
3204{
3205	int start = 0;
3206	int end = ARRAY_SIZE(alg_test_descs);
3207
3208	while (start < end) {
3209		int i = (start + end) / 2;
3210		int diff = strcmp(alg_test_descs[i].alg, alg);
3211
3212		if (diff > 0) {
3213			end = i;
3214			continue;
3215		}
3216
3217		if (diff < 0) {
3218			start = i + 1;
3219			continue;
3220		}
3221
3222		return i;
3223	}
3224
3225	return -1;
3226}
3227
3228int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3229{
3230	int i;
3231	int j;
3232	int rc;
3233
 
 
 
 
 
3234	alg_test_descs_check_order();
3235
3236	if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3237		char nalg[CRYPTO_MAX_ALG_NAME];
3238
3239		if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3240		    sizeof(nalg))
3241			return -ENAMETOOLONG;
3242
3243		i = alg_find_test(nalg);
3244		if (i < 0)
3245			goto notest;
3246
3247		if (fips_enabled && !alg_test_descs[i].fips_allowed)
3248			goto non_fips_alg;
3249
3250		rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3251		goto test_done;
3252	}
3253
3254	i = alg_find_test(alg);
3255	j = alg_find_test(driver);
3256	if (i < 0 && j < 0)
3257		goto notest;
3258
3259	if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3260			     (j >= 0 && !alg_test_descs[j].fips_allowed)))
3261		goto non_fips_alg;
3262
3263	rc = 0;
3264	if (i >= 0)
3265		rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3266					     type, mask);
3267	if (j >= 0 && j != i)
3268		rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3269					     type, mask);
3270
3271test_done:
3272	if (fips_enabled && rc)
3273		panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3274
3275	if (fips_enabled && !rc)
3276		printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
3277		       driver, alg);
3278
3279	return rc;
3280
3281notest:
3282	printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3283	return 0;
3284non_fips_alg:
3285	return -EINVAL;
3286}
3287
3288#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3289
3290EXPORT_SYMBOL_GPL(alg_test);