Lines Matching defs:tfm
844 /* Like setkey_f(tfm, key, ksize), but sometimes misalign the key */
845 #define do_setkey(setkey_f, tfm, key, ksize, cfg, alignmask) \
853 err = setkey_f((tfm), keyptr, (ksize)); \
1275 struct crypto_shash *tfm = desc->tfm;
1276 const unsigned int digestsize = crypto_shash_digestsize(tfm);
1277 const unsigned int statesize = crypto_shash_statesize(tfm);
1278 const char *driver = crypto_shash_driver_name(tfm);
1286 err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize,
1293 crypto_shash_get_flags(tfm));
1313 testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm));
1393 testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm));
1458 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1459 const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1460 const unsigned int statesize = crypto_ahash_statesize(tfm);
1461 const char *driver = crypto_ahash_driver_name(tfm);
1473 err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize,
1480 crypto_ahash_get_flags(tfm));
1500 testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1573 testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1710 vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
1736 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1737 const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1738 const unsigned int blocksize = crypto_ahash_blocksize(tfm);
1740 const char *algname = crypto_hash_alg_common(tfm)->base.cra_name;
1741 const char *driver = crypto_ahash_driver_name(tfm);
1793 generic_desc->tfm = generic_tfm;
1864 struct crypto_shash *tfm;
1867 tfm = crypto_alloc_shash(driver, type, mask);
1868 if (IS_ERR(tfm)) {
1869 if (PTR_ERR(tfm) == -ENOENT) {
1877 driver, PTR_ERR(tfm));
1878 return PTR_ERR(tfm);
1881 desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);
1883 crypto_free_shash(tfm);
1886 desc->tfm = tfm;
1888 *tfm_ret = tfm;
1993 * first, before setting a key on the tfm. To make this easier, we
2031 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2032 const unsigned int alignmask = crypto_aead_alignmask(tfm);
2033 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2035 const char *driver = crypto_aead_driver_name(tfm);
2048 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2050 crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2052 err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen,
2057 crypto_aead_get_flags(tfm));
2067 err = crypto_aead_setauthsize(tfm, authsize);
2108 testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm));
2126 crypto_aead_reqtfm(req) != tfm ||
2142 if (crypto_aead_reqtfm(req) != tfm)
2143 pr_err("alg: aead: changed 'req->base.tfm'\n");
2257 struct crypto_aead *tfm;
2310 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2311 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2380 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2381 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2382 const unsigned int maxauthsize = crypto_aead_maxauthsize(tfm);
2391 vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
2405 vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize);
2486 struct crypto_aead *tfm = ctx->tfm;
2487 const char *algname = crypto_aead_alg(tfm)->base.cra_name;
2488 const char *driver = crypto_aead_driver_name(tfm);
2527 if (crypto_aead_maxauthsize(tfm) !=
2530 driver, crypto_aead_maxauthsize(tfm),
2536 if (crypto_aead_ivsize(tfm) != crypto_aead_ivsize(generic_tfm)) {
2538 driver, crypto_aead_ivsize(tfm),
2544 if (crypto_aead_blocksize(tfm) != crypto_aead_blocksize(generic_tfm)) {
2546 driver, crypto_aead_blocksize(tfm),
2604 ctx->tfm = crypto_aead_reqtfm(req);
2614 ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL);
2667 struct crypto_aead *tfm;
2677 tfm = crypto_alloc_aead(driver, type, mask);
2678 if (IS_ERR(tfm)) {
2680 driver, PTR_ERR(tfm));
2681 return PTR_ERR(tfm);
2683 driver = crypto_aead_driver_name(tfm);
2685 req = aead_request_alloc(tfm, GFP_KERNEL);
2713 crypto_free_aead(tfm);
2717 static int test_cipher(struct crypto_cipher *tfm, int enc,
2721 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
2755 crypto_cipher_clear_flags(tfm, ~0);
2757 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2759 ret = crypto_cipher_setkey(tfm, template[i].key,
2766 crypto_cipher_get_flags(tfm));
2777 k += crypto_cipher_blocksize(tfm)) {
2779 crypto_cipher_encrypt_one(tfm, data + k,
2782 crypto_cipher_decrypt_one(tfm, data + k,
2810 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2811 const unsigned int alignmask = crypto_skcipher_alignmask(tfm);
2812 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2813 const char *driver = crypto_skcipher_driver_name(tfm);
2826 crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2828 crypto_skcipher_clear_flags(tfm,
2830 err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen,
2837 crypto_skcipher_get_flags(tfm));
2877 testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm));
2893 crypto_skcipher_reqtfm(req) != tfm ||
2907 if (crypto_skcipher_reqtfm(req) != tfm)
2908 pr_err("alg: skcipher: changed 'req->base.tfm'\n");
3023 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
3024 const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
3025 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
3035 vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
3077 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
3078 const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
3079 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
3080 const unsigned int blocksize = crypto_skcipher_blocksize(tfm);
3082 const char *algname = crypto_skcipher_alg(tfm)->base.cra_name;
3083 const char *driver = crypto_skcipher_driver_name(tfm);
3141 if (crypto_skcipher_min_keysize(tfm) !=
3144 driver, crypto_skcipher_min_keysize(tfm),
3244 struct crypto_skcipher *tfm;
3254 tfm = crypto_alloc_skcipher(driver, type, mask);
3255 if (IS_ERR(tfm)) {
3257 driver, PTR_ERR(tfm));
3258 return PTR_ERR(tfm);
3260 driver = crypto_skcipher_driver_name(tfm);
3262 req = skcipher_request_alloc(tfm, GFP_KERNEL);
3290 crypto_free_skcipher(tfm);
3294 static int test_comp(struct crypto_comp *tfm,
3299 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
3322 ret = crypto_comp_compress(tfm, ctemplate[i].input,
3333 ret = crypto_comp_decompress(tfm, output,
3366 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
3400 static int test_acomp(struct crypto_acomp *tfm,
3405 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
3439 req = acomp_request_alloc(tfm);
3531 req = acomp_request_alloc(tfm);
3598 static int test_cprng(struct crypto_rng *tfm,
3602 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
3607 seedsize = crypto_rng_seedsize(tfm);
3625 err = crypto_rng_reset(tfm, seed, seedsize);
3633 err = crypto_rng_get_bytes(tfm, result,
3664 struct crypto_cipher *tfm;
3667 tfm = crypto_alloc_cipher(driver, type, mask);
3668 if (IS_ERR(tfm)) {
3670 "%s: %ld\n", driver, PTR_ERR(tfm));
3671 return PTR_ERR(tfm);
3674 err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count);
3676 err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count);
3678 crypto_free_cipher(tfm);
3723 struct crypto_shash *tfm;
3731 tfm = crypto_alloc_shash(driver, type, mask);
3732 if (IS_ERR(tfm)) {
3733 if (PTR_ERR(tfm) == -ENOENT) {
3742 "%ld\n", driver, PTR_ERR(tfm));
3743 return PTR_ERR(tfm);
3745 driver = crypto_shash_driver_name(tfm);
3748 SHASH_DESC_ON_STACK(shash, tfm);
3751 shash->tfm = tfm;
3768 crypto_free_shash(tfm);
3887 static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
3901 req = kpp_request_alloc(tfm, GFP_KERNEL);
3907 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
3911 out_len_max = crypto_kpp_maxsize(tfm);
3983 err = crypto_kpp_set_secret(tfm, vec->b_secret,
4029 static int test_kpp(struct crypto_kpp *tfm, const char *alg,
4035 ret = do_test_kpp(tfm, vecs++, alg);
4048 struct crypto_kpp *tfm;
4051 tfm = crypto_alloc_kpp(driver, type, mask);
4052 if (IS_ERR(tfm)) {
4053 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
4054 driver, PTR_ERR(tfm));
4055 return PTR_ERR(tfm);
4058 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
4061 crypto_free_kpp(tfm);
4071 static int test_akcipher_one(struct crypto_akcipher *tfm,
4090 req = akcipher_request_alloc(tfm, GFP_KERNEL);
4107 err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len);
4109 err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len);
4118 out_len_max = crypto_akcipher_maxsize(tfm);
4253 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
4258 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
4262 ret = test_akcipher_one(tfm, vecs++);
4276 struct crypto_akcipher *tfm;
4279 tfm = crypto_alloc_akcipher(driver, type, mask);
4280 if (IS_ERR(tfm)) {
4281 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
4282 driver, PTR_ERR(tfm));
4283 return PTR_ERR(tfm);
4286 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
4289 crypto_free_akcipher(tfm);