Lines Matching defs:tfm
798 /* Like setkey_f(tfm, key, ksize), but sometimes misalign the key */
799 #define do_setkey(setkey_f, tfm, key, ksize, cfg, alignmask) \
807 err = setkey_f((tfm), keyptr, (ksize)); \
1182 struct crypto_shash *tfm = desc->tfm;
1183 const unsigned int alignmask = crypto_shash_alignmask(tfm);
1184 const unsigned int digestsize = crypto_shash_digestsize(tfm);
1185 const unsigned int statesize = crypto_shash_statesize(tfm);
1193 err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize,
1200 crypto_shash_get_flags(tfm));
1220 testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm));
1300 testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm));
1366 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1367 const unsigned int alignmask = crypto_ahash_alignmask(tfm);
1368 const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1369 const unsigned int statesize = crypto_ahash_statesize(tfm);
1381 err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize,
1388 crypto_ahash_get_flags(tfm));
1408 testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1481 testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1617 vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
1644 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1645 const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1646 const unsigned int blocksize = crypto_ahash_blocksize(tfm);
1648 const char *algname = crypto_hash_alg_common(tfm)->base.cra_name;
1697 generic_desc->tfm = generic_tfm;
1768 struct crypto_shash *tfm;
1771 tfm = crypto_alloc_shash(driver, type, mask);
1772 if (IS_ERR(tfm)) {
1773 if (PTR_ERR(tfm) == -ENOENT) {
1781 driver, PTR_ERR(tfm));
1782 return PTR_ERR(tfm);
1785 desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);
1787 crypto_free_shash(tfm);
1790 desc->tfm = tfm;
1792 *tfm_ret = tfm;
1894 * first, before setting a key on the tfm. To make this easier, we
1933 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1934 const unsigned int alignmask = crypto_aead_alignmask(tfm);
1935 const unsigned int ivsize = crypto_aead_ivsize(tfm);
1949 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
1951 crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
1953 err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen,
1958 crypto_aead_get_flags(tfm));
1968 err = crypto_aead_setauthsize(tfm, authsize);
2009 testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm));
2027 crypto_aead_reqtfm(req) != tfm ||
2043 if (crypto_aead_reqtfm(req) != tfm)
2044 pr_err("alg: aead: changed 'req->base.tfm'\n");
2154 struct crypto_aead *tfm;
2205 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2206 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2273 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2274 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2275 const unsigned int maxauthsize = crypto_aead_maxauthsize(tfm);
2284 vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
2298 vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize);
2378 struct crypto_aead *tfm = ctx->tfm;
2379 const char *algname = crypto_aead_alg(tfm)->base.cra_name;
2419 if (crypto_aead_maxauthsize(tfm) !=
2422 driver, crypto_aead_maxauthsize(tfm),
2428 if (crypto_aead_ivsize(tfm) != crypto_aead_ivsize(generic_tfm)) {
2430 driver, crypto_aead_ivsize(tfm),
2436 if (crypto_aead_blocksize(tfm) != crypto_aead_blocksize(generic_tfm)) {
2438 driver, crypto_aead_blocksize(tfm),
2495 ctx->tfm = crypto_aead_reqtfm(req);
2506 ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL);
2562 struct crypto_aead *tfm;
2572 tfm = crypto_alloc_aead(driver, type, mask);
2573 if (IS_ERR(tfm)) {
2575 driver, PTR_ERR(tfm));
2576 return PTR_ERR(tfm);
2579 req = aead_request_alloc(tfm, GFP_KERNEL);
2607 crypto_free_aead(tfm);
2611 static int test_cipher(struct crypto_cipher *tfm, int enc,
2615 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
2649 crypto_cipher_clear_flags(tfm, ~0);
2651 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2653 ret = crypto_cipher_setkey(tfm, template[i].key,
2660 crypto_cipher_get_flags(tfm));
2671 k += crypto_cipher_blocksize(tfm)) {
2673 crypto_cipher_encrypt_one(tfm, data + k,
2676 crypto_cipher_decrypt_one(tfm, data + k,
2705 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2706 const unsigned int alignmask = crypto_skcipher_alignmask(tfm);
2707 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2720 crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2722 crypto_skcipher_clear_flags(tfm,
2724 err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen,
2731 crypto_skcipher_get_flags(tfm));
2771 testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm));
2787 crypto_skcipher_reqtfm(req) != tfm ||
2801 if (crypto_skcipher_reqtfm(req) != tfm)
2802 pr_err("alg: skcipher: changed 'req->base.tfm'\n");
2914 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2915 const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
2916 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2926 vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
2969 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2970 const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
2971 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2972 const unsigned int blocksize = crypto_skcipher_blocksize(tfm);
2974 const char *algname = crypto_skcipher_alg(tfm)->base.cra_name;
3029 if (crypto_skcipher_min_keysize(tfm) !=
3032 driver, crypto_skcipher_min_keysize(tfm),
3133 struct crypto_skcipher *tfm;
3143 tfm = crypto_alloc_skcipher(driver, type, mask);
3144 if (IS_ERR(tfm)) {
3146 driver, PTR_ERR(tfm));
3147 return PTR_ERR(tfm);
3150 req = skcipher_request_alloc(tfm, GFP_KERNEL);
3179 crypto_free_skcipher(tfm);
3183 static int test_comp(struct crypto_comp *tfm,
3188 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
3211 ret = crypto_comp_compress(tfm, ctemplate[i].input,
3222 ret = crypto_comp_decompress(tfm, output,
3255 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
3289 static int test_acomp(struct crypto_acomp *tfm,
3294 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
3328 req = acomp_request_alloc(tfm);
3405 req = acomp_request_alloc(tfm);
3458 static int test_cprng(struct crypto_rng *tfm,
3462 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
3467 seedsize = crypto_rng_seedsize(tfm);
3485 err = crypto_rng_reset(tfm, seed, seedsize);
3493 err = crypto_rng_get_bytes(tfm, result,
3524 struct crypto_cipher *tfm;
3527 tfm = crypto_alloc_cipher(driver, type, mask);
3528 if (IS_ERR(tfm)) {
3530 "%s: %ld\n", driver, PTR_ERR(tfm));
3531 return PTR_ERR(tfm);
3534 err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count);
3536 err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count);
3538 crypto_free_cipher(tfm);
3583 struct crypto_shash *tfm;
3591 tfm = crypto_alloc_shash(driver, type, mask);
3592 if (IS_ERR(tfm)) {
3593 if (PTR_ERR(tfm) == -ENOENT) {
3602 "%ld\n", driver, PTR_ERR(tfm));
3603 return PTR_ERR(tfm);
3607 SHASH_DESC_ON_STACK(shash, tfm);
3610 shash->tfm = tfm;
3627 crypto_free_shash(tfm);
3746 static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
3760 req = kpp_request_alloc(tfm, GFP_KERNEL);
3766 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
3770 out_len_max = crypto_kpp_maxsize(tfm);
3842 err = crypto_kpp_set_secret(tfm, vec->b_secret,
3888 static int test_kpp(struct crypto_kpp *tfm, const char *alg,
3894 ret = do_test_kpp(tfm, vecs++, alg);
3907 struct crypto_kpp *tfm;
3910 tfm = crypto_alloc_kpp(driver, type, mask);
3911 if (IS_ERR(tfm)) {
3912 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
3913 driver, PTR_ERR(tfm));
3914 return PTR_ERR(tfm);
3917 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
3920 crypto_free_kpp(tfm);
3930 static int test_akcipher_one(struct crypto_akcipher *tfm,
3949 req = akcipher_request_alloc(tfm, GFP_KERNEL);
3966 err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len);
3968 err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len);
3977 out_len_max = crypto_akcipher_maxsize(tfm);
4112 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
4117 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
4121 ret = test_akcipher_one(tfm, vecs++);
4135 struct crypto_akcipher *tfm;
4138 tfm = crypto_alloc_akcipher(driver, type, mask);
4139 if (IS_ERR(tfm)) {
4140 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
4141 driver, PTR_ERR(tfm));
4142 return PTR_ERR(tfm);
4145 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
4148 crypto_free_akcipher(tfm);