crypto: testmgr - Use ahash for generic tfm

As shash is being phased out, use ahash for the generic tfm.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/testmgr.c b/crypto/testmgr.c
index ee682ad50e3478d6579f0e0a544981da60503a91..72005074a5c26ae8edaa94507ad2c86f3a03b4da 100644 (file)
--- a/crypto/testmgr.c
+++ b/crypto/testmgr.c
@@ -1699,7 +1699,7 @@ static int test_hash_vec(const struct hash_testvec *vec, unsigned int vec_num,
  * Assumes the buffers in 'vec' were already allocated.
  */
 static void generate_random_hash_testvec(struct rnd_state *rng,
-                                        struct shash_desc *desc,
+                                        struct ahash_request *req,
                                         struct hash_testvec *vec,
                                         unsigned int maxkeysize,
                                         unsigned int maxdatasize,
@@ -1721,16 +1721,17 @@ static void generate_random_hash_testvec(struct rnd_state *rng,
                        vec->ksize = prandom_u32_inclusive(rng, 1, maxkeysize);
                generate_random_bytes(rng, (u8 *)vec->key, vec->ksize);
 
-               vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
-                                                       vec->ksize);
+               vec->setkey_error = crypto_ahash_setkey(
+                       crypto_ahash_reqtfm(req), vec->key, vec->ksize);
                /* If the key couldn't be set, no need to continue to digest. */
                if (vec->setkey_error)
                        goto done;
        }
 
        /* Digest */
-       vec->digest_error = crypto_shash_digest(desc, vec->plaintext,
-                                               vec->psize, (u8 *)vec->digest);
+       vec->digest_error = crypto_hash_digest(
+               crypto_ahash_reqtfm(req), vec->plaintext,
+               vec->psize, (u8 *)vec->digest);
 done:
        snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"",
                 vec->psize, vec->ksize);
@@ -1755,8 +1756,8 @@ static int test_hash_vs_generic_impl(const char *generic_driver,
        const char *driver = crypto_ahash_driver_name(tfm);
        struct rnd_state rng;
        char _generic_driver[CRYPTO_MAX_ALG_NAME];
-       struct crypto_shash *generic_tfm = NULL;
-       struct shash_desc *generic_desc = NULL;
+       struct ahash_request *generic_req = NULL;
+       struct crypto_ahash *generic_tfm = NULL;
        unsigned int i;
        struct hash_testvec vec = { 0 };
        char vec_name[64];
@@ -1779,7 +1780,7 @@ static int test_hash_vs_generic_impl(const char *generic_driver,
        if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */
                return 0;
 
-       generic_tfm = crypto_alloc_shash(generic_driver, 0, 0);
+       generic_tfm = crypto_alloc_ahash(generic_driver, 0, 0);
        if (IS_ERR(generic_tfm)) {
                err = PTR_ERR(generic_tfm);
                if (err == -ENOENT) {
@@ -1798,27 +1799,25 @@ static int test_hash_vs_generic_impl(const char *generic_driver,
                goto out;
        }
 
-       generic_desc = kzalloc(sizeof(*desc) +
-                              crypto_shash_descsize(generic_tfm), GFP_KERNEL);
-       if (!generic_desc) {
+       generic_req = ahash_request_alloc(generic_tfm, GFP_KERNEL);
+       if (!generic_req) {
                err = -ENOMEM;
                goto out;
        }
-       generic_desc->tfm = generic_tfm;
 
        /* Check the algorithm properties for consistency. */
 
-       if (digestsize != crypto_shash_digestsize(generic_tfm)) {
+       if (digestsize != crypto_ahash_digestsize(generic_tfm)) {
                pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n",
                       driver, digestsize,
-                      crypto_shash_digestsize(generic_tfm));
+                      crypto_ahash_digestsize(generic_tfm));
                err = -EINVAL;
                goto out;
        }
 
-       if (blocksize != crypto_shash_blocksize(generic_tfm)) {
+       if (blocksize != crypto_ahash_blocksize(generic_tfm)) {
                pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n",
-                      driver, blocksize, crypto_shash_blocksize(generic_tfm));
+                      driver, blocksize, crypto_ahash_blocksize(generic_tfm));
                err = -EINVAL;
                goto out;
        }
@@ -1837,7 +1836,7 @@ static int test_hash_vs_generic_impl(const char *generic_driver,
        }
 
        for (i = 0; i < fuzz_iterations * 8; i++) {
-               generate_random_hash_testvec(&rng, generic_desc, &vec,
+               generate_random_hash_testvec(&rng, generic_req, &vec,
                                             maxkeysize, maxdatasize,
                                             vec_name, sizeof(vec_name));
                generate_random_testvec_config(&rng, cfg, cfgname,
@@ -1855,8 +1854,8 @@ out:
        kfree(vec.key);
        kfree(vec.plaintext);
        kfree(vec.digest);
-       crypto_free_shash(generic_tfm);
-       kfree_sensitive(generic_desc);
+       ahash_request_free(generic_req);
+       crypto_free_ahash(generic_tfm);
        return err;
 }