Lines Matching defs:tfm
846 /* Like setkey_f(tfm, key, ksize), but sometimes misalign the key */
847 #define do_setkey(setkey_f, tfm, key, ksize, cfg, alignmask) \
855 err = setkey_f((tfm), keyptr, (ksize)); \
1277 struct crypto_shash *tfm = desc->tfm;
1278 const unsigned int alignmask = crypto_shash_alignmask(tfm);
1279 const unsigned int digestsize = crypto_shash_digestsize(tfm);
1280 const unsigned int statesize = crypto_shash_statesize(tfm);
1281 const char *driver = crypto_shash_driver_name(tfm);
1289 err = do_setkey(crypto_shash_setkey, tfm, vec->key, vec->ksize,
1296 crypto_shash_get_flags(tfm));
1316 testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm));
1396 testmgr_poison(desc->__ctx, crypto_shash_descsize(tfm));
1461 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1462 const unsigned int alignmask = crypto_ahash_alignmask(tfm);
1463 const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1464 const unsigned int statesize = crypto_ahash_statesize(tfm);
1465 const char *driver = crypto_ahash_driver_name(tfm);
1477 err = do_setkey(crypto_ahash_setkey, tfm, vec->key, vec->ksize,
1484 crypto_ahash_get_flags(tfm));
1504 testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1577 testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1714 vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
1740 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1741 const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1742 const unsigned int blocksize = crypto_ahash_blocksize(tfm);
1744 const char *algname = crypto_hash_alg_common(tfm)->base.cra_name;
1745 const char *driver = crypto_ahash_driver_name(tfm);
1797 generic_desc->tfm = generic_tfm;
1868 struct crypto_shash *tfm;
1871 tfm = crypto_alloc_shash(driver, type, mask);
1872 if (IS_ERR(tfm)) {
1873 if (PTR_ERR(tfm) == -ENOENT) {
1881 driver, PTR_ERR(tfm));
1882 return PTR_ERR(tfm);
1885 desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);
1887 crypto_free_shash(tfm);
1890 desc->tfm = tfm;
1892 *tfm_ret = tfm;
1997 * first, before setting a key on the tfm. To make this easier, we
2035 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2036 const unsigned int alignmask = crypto_aead_alignmask(tfm);
2037 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2039 const char *driver = crypto_aead_driver_name(tfm);
2052 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2054 crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2056 err = do_setkey(crypto_aead_setkey, tfm, vec->key, vec->klen,
2061 crypto_aead_get_flags(tfm));
2071 err = crypto_aead_setauthsize(tfm, authsize);
2112 testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm));
2130 crypto_aead_reqtfm(req) != tfm ||
2146 if (crypto_aead_reqtfm(req) != tfm)
2147 pr_err("alg: aead: changed 'req->base.tfm'\n");
2261 struct crypto_aead *tfm;
2314 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2315 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2384 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2385 const unsigned int ivsize = crypto_aead_ivsize(tfm);
2386 const unsigned int maxauthsize = crypto_aead_maxauthsize(tfm);
2395 vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
2409 vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize);
2490 struct crypto_aead *tfm = ctx->tfm;
2491 const char *algname = crypto_aead_alg(tfm)->base.cra_name;
2492 const char *driver = crypto_aead_driver_name(tfm);
2531 if (crypto_aead_maxauthsize(tfm) !=
2534 driver, crypto_aead_maxauthsize(tfm),
2540 if (crypto_aead_ivsize(tfm) != crypto_aead_ivsize(generic_tfm)) {
2542 driver, crypto_aead_ivsize(tfm),
2548 if (crypto_aead_blocksize(tfm) != crypto_aead_blocksize(generic_tfm)) {
2550 driver, crypto_aead_blocksize(tfm),
2608 ctx->tfm = crypto_aead_reqtfm(req);
2618 ctx->vec.iv = kmalloc(crypto_aead_ivsize(ctx->tfm), GFP_KERNEL);
2671 struct crypto_aead *tfm;
2681 tfm = crypto_alloc_aead(driver, type, mask);
2682 if (IS_ERR(tfm)) {
2684 driver, PTR_ERR(tfm));
2685 return PTR_ERR(tfm);
2687 driver = crypto_aead_driver_name(tfm);
2689 req = aead_request_alloc(tfm, GFP_KERNEL);
2717 crypto_free_aead(tfm);
2721 static int test_cipher(struct crypto_cipher *tfm, int enc,
2725 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
2759 crypto_cipher_clear_flags(tfm, ~0);
2761 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2763 ret = crypto_cipher_setkey(tfm, template[i].key,
2770 crypto_cipher_get_flags(tfm));
2781 k += crypto_cipher_blocksize(tfm)) {
2783 crypto_cipher_encrypt_one(tfm, data + k,
2786 crypto_cipher_decrypt_one(tfm, data + k,
2814 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2815 const unsigned int alignmask = crypto_skcipher_alignmask(tfm);
2816 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2817 const char *driver = crypto_skcipher_driver_name(tfm);
2830 crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2832 crypto_skcipher_clear_flags(tfm,
2834 err = do_setkey(crypto_skcipher_setkey, tfm, vec->key, vec->klen,
2841 crypto_skcipher_get_flags(tfm));
2881 testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm));
2897 crypto_skcipher_reqtfm(req) != tfm ||
2911 if (crypto_skcipher_reqtfm(req) != tfm)
2912 pr_err("alg: skcipher: changed 'req->base.tfm'\n");
3027 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
3028 const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
3029 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
3039 vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
3081 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
3082 const unsigned int maxkeysize = crypto_skcipher_max_keysize(tfm);
3083 const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
3084 const unsigned int blocksize = crypto_skcipher_blocksize(tfm);
3086 const char *algname = crypto_skcipher_alg(tfm)->base.cra_name;
3087 const char *driver = crypto_skcipher_driver_name(tfm);
3145 if (crypto_skcipher_min_keysize(tfm) !=
3148 driver, crypto_skcipher_min_keysize(tfm),
3248 struct crypto_skcipher *tfm;
3258 tfm = crypto_alloc_skcipher(driver, type, mask);
3259 if (IS_ERR(tfm)) {
3261 driver, PTR_ERR(tfm));
3262 return PTR_ERR(tfm);
3264 driver = crypto_skcipher_driver_name(tfm);
3266 req = skcipher_request_alloc(tfm, GFP_KERNEL);
3294 crypto_free_skcipher(tfm);
3298 static int test_comp(struct crypto_comp *tfm,
3303 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
3326 ret = crypto_comp_compress(tfm, ctemplate[i].input,
3337 ret = crypto_comp_decompress(tfm, output,
3370 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
3404 static int test_acomp(struct crypto_acomp *tfm,
3409 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
3443 req = acomp_request_alloc(tfm);
3535 req = acomp_request_alloc(tfm);
3602 static int test_cprng(struct crypto_rng *tfm,
3606 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
3611 seedsize = crypto_rng_seedsize(tfm);
3629 err = crypto_rng_reset(tfm, seed, seedsize);
3637 err = crypto_rng_get_bytes(tfm, result,
3668 struct crypto_cipher *tfm;
3671 tfm = crypto_alloc_cipher(driver, type, mask);
3672 if (IS_ERR(tfm)) {
3674 "%s: %ld\n", driver, PTR_ERR(tfm));
3675 return PTR_ERR(tfm);
3678 err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count);
3680 err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count);
3682 crypto_free_cipher(tfm);
3727 struct crypto_shash *tfm;
3735 tfm = crypto_alloc_shash(driver, type, mask);
3736 if (IS_ERR(tfm)) {
3737 if (PTR_ERR(tfm) == -ENOENT) {
3746 "%ld\n", driver, PTR_ERR(tfm));
3747 return PTR_ERR(tfm);
3749 driver = crypto_shash_driver_name(tfm);
3752 SHASH_DESC_ON_STACK(shash, tfm);
3755 shash->tfm = tfm;
3772 crypto_free_shash(tfm);
3891 static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
3905 req = kpp_request_alloc(tfm, GFP_KERNEL);
3911 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
3915 out_len_max = crypto_kpp_maxsize(tfm);
3987 err = crypto_kpp_set_secret(tfm, vec->b_secret,
4033 static int test_kpp(struct crypto_kpp *tfm, const char *alg,
4039 ret = do_test_kpp(tfm, vecs++, alg);
4052 struct crypto_kpp *tfm;
4055 tfm = crypto_alloc_kpp(driver, type, mask);
4056 if (IS_ERR(tfm)) {
4057 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
4058 driver, PTR_ERR(tfm));
4059 return PTR_ERR(tfm);
4062 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
4065 crypto_free_kpp(tfm);
4075 static int test_akcipher_one(struct crypto_akcipher *tfm,
4094 req = akcipher_request_alloc(tfm, GFP_KERNEL);
4111 err = crypto_akcipher_set_pub_key(tfm, key, vecs->key_len);
4113 err = crypto_akcipher_set_priv_key(tfm, key, vecs->key_len);
4122 out_len_max = crypto_akcipher_maxsize(tfm);
4257 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
4262 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
4266 ret = test_akcipher_one(tfm, vecs++);
4280 struct crypto_akcipher *tfm;
4283 tfm = crypto_alloc_akcipher(driver, type, mask);
4284 if (IS_ERR(tfm)) {
4285 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
4286 driver, PTR_ERR(tfm));
4287 return PTR_ERR(tfm);
4290 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
4293 crypto_free_akcipher(tfm);