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