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