crypto: skcipher - pass instance to crypto_grab_skcipher()

Initializing a crypto_skcipher_spawn currently requires:

1. Set spawn->base.inst to point to the instance.
2. Call crypto_grab_skcipher().

But there's no reason for these steps to be separate, and in fact this
unneeded complication has caused at least one bug, the one fixed by
commit 6db43410179b ("crypto: adiantum - initialize crypto_spawn::inst")

So just make crypto_grab_skcipher() take the instance as an argument.

To keep the function calls from getting too unwieldy due to this extra
argument, also introduce a 'mask' variable into the affected places
which weren't already using one.

Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/adiantum.c b/crypto/adiantum.c
index 30cffb45b88f83c1bb8c74d48c0a49ebcd8c1f8b..567071464fabe772f9435e3a4dd0fa1fc72268ca 100644 (file)
--- a/crypto/adiantum.c
+++ b/crypto/adiantum.c
@@ -493,6 +493,7 @@ static bool adiantum_supported_algorithms(struct skcipher_alg *streamcipher_alg,
 static int adiantum_create(struct crypto_template *tmpl, struct rtattr **tb)
 {
        struct crypto_attr_type *algt;
+       u32 mask;
        const char *streamcipher_name;
        const char *blockcipher_name;
        const char *nhpoly1305_name;
@@ -511,6 +512,8 @@ static int adiantum_create(struct crypto_template *tmpl, struct rtattr **tb)
        if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        streamcipher_name = crypto_attr_alg_name(tb[1]);
        if (IS_ERR(streamcipher_name))
                return PTR_ERR(streamcipher_name);
@@ -531,11 +534,9 @@ static int adiantum_create(struct crypto_template *tmpl, struct rtattr **tb)
        ictx = skcipher_instance_ctx(inst);
 
        /* Stream cipher, e.g. "xchacha12" */
-       crypto_set_skcipher_spawn(&ictx->streamcipher_spawn,
-                                 skcipher_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ictx->streamcipher_spawn, streamcipher_name,
-                                  0, crypto_requires_sync(algt->type,
-                                                          algt->mask));
+       err = crypto_grab_skcipher(&ictx->streamcipher_spawn,
+                                  skcipher_crypto_instance(inst),
+                                  streamcipher_name, 0, mask);
        if (err)
                goto out_free_inst;
        streamcipher_alg = crypto_spawn_skcipher_alg(&ictx->streamcipher_spawn);

diff --git a/crypto/authenc.c b/crypto/authenc.c
index 15aaddd34171f40f663888ac23add9e1e214ccf4..e31bcec58564b489db89204ef01ddb301839c343 100644 (file)
--- a/crypto/authenc.c
+++ b/crypto/authenc.c
@@ -373,6 +373,7 @@ static int crypto_authenc_create(struct crypto_template *tmpl,
                                 struct rtattr **tb)
 {
        struct crypto_attr_type *algt;
+       u32 mask;
        struct aead_instance *inst;
        struct hash_alg_common *auth;
        struct crypto_alg *auth_base;
@@ -388,9 +389,10 @@ static int crypto_authenc_create(struct crypto_template *tmpl,
        if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        auth = ahash_attr_alg(tb[1], CRYPTO_ALG_TYPE_HASH,
-                             CRYPTO_ALG_TYPE_AHASH_MASK |
-                             crypto_requires_sync(algt->type, algt->mask));
+                             CRYPTO_ALG_TYPE_AHASH_MASK | mask);
        if (IS_ERR(auth))
                return PTR_ERR(auth);
 
@@ -413,10 +415,8 @@ static int crypto_authenc_create(struct crypto_template *tmpl,
        if (err)
                goto err_free_inst;
 
-       crypto_set_skcipher_spawn(&ctx->enc, aead_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ctx->enc, enc_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(&ctx->enc, aead_crypto_instance(inst),
+                                  enc_name, 0, mask);
        if (err)
                goto err_drop_auth;
 

diff --git a/crypto/authencesn.c b/crypto/authencesn.c
index fc81324ce881e2000af81db8632776414da864b5..83bda7f905bba94fb8ff0e8ac967ef2d8008e09c 100644 (file)
--- a/crypto/authencesn.c
+++ b/crypto/authencesn.c
@@ -391,6 +391,7 @@ static int crypto_authenc_esn_create(struct crypto_template *tmpl,
                                     struct rtattr **tb)
 {
        struct crypto_attr_type *algt;
+       u32 mask;
        struct aead_instance *inst;
        struct hash_alg_common *auth;
        struct crypto_alg *auth_base;
@@ -406,9 +407,10 @@ static int crypto_authenc_esn_create(struct crypto_template *tmpl,
        if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        auth = ahash_attr_alg(tb[1], CRYPTO_ALG_TYPE_HASH,
-                             CRYPTO_ALG_TYPE_AHASH_MASK |
-                             crypto_requires_sync(algt->type, algt->mask));
+                             CRYPTO_ALG_TYPE_AHASH_MASK | mask);
        if (IS_ERR(auth))
                return PTR_ERR(auth);
 
@@ -431,10 +433,8 @@ static int crypto_authenc_esn_create(struct crypto_template *tmpl,
        if (err)
                goto err_free_inst;
 
-       crypto_set_skcipher_spawn(&ctx->enc, aead_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ctx->enc, enc_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(&ctx->enc, aead_crypto_instance(inst),
+                                  enc_name, 0, mask);
        if (err)
                goto err_drop_auth;
 

diff --git a/crypto/ccm.c b/crypto/ccm.c
index 44104524e95a8816d044a4d3c9d91550a2acacda..4414f0ddfe5a2229a2a12786a6c4f641e170ad4a 100644 (file)
--- a/crypto/ccm.c
+++ b/crypto/ccm.c
@@ -450,6 +450,7 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl,
                                    const char *mac_name)
 {
        struct crypto_attr_type *algt;
+       u32 mask;
        struct aead_instance *inst;
        struct skcipher_alg *ctr;
        struct crypto_alg *mac_alg;
@@ -464,6 +465,8 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl,
        if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        mac_alg = crypto_find_alg(mac_name, &crypto_ahash_type,
                                  CRYPTO_ALG_TYPE_HASH,
                                  CRYPTO_ALG_TYPE_AHASH_MASK |
@@ -488,10 +491,8 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl,
        if (err)
                goto err_free_inst;
 
-       crypto_set_skcipher_spawn(&ictx->ctr, aead_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ictx->ctr, ctr_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(&ictx->ctr, aead_crypto_instance(inst),
+                                  ctr_name, 0, mask);
        if (err)
                goto err_drop_mac;
 

diff --git a/crypto/chacha20poly1305.c b/crypto/chacha20poly1305.c
index 88cbdaba43b8881045677e8dd5580613d901aac1..09d5a34ab339974239c5c90d5cb62ad0b5f158c9 100644 (file)
--- a/crypto/chacha20poly1305.c
+++ b/crypto/chacha20poly1305.c
@@ -558,6 +558,7 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
                             const char *name, unsigned int ivsize)
 {
        struct crypto_attr_type *algt;
+       u32 mask;
        struct aead_instance *inst;
        struct skcipher_alg *chacha;
        struct crypto_alg *poly;
@@ -576,6 +577,8 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
        if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        chacha_name = crypto_attr_alg_name(tb[1]);
        if (IS_ERR(chacha_name))
                return PTR_ERR(chacha_name);
@@ -585,9 +588,7 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
 
        poly = crypto_find_alg(poly_name, &crypto_ahash_type,
                               CRYPTO_ALG_TYPE_HASH,
-                              CRYPTO_ALG_TYPE_AHASH_MASK |
-                              crypto_requires_sync(algt->type,
-                                                   algt->mask));
+                              CRYPTO_ALG_TYPE_AHASH_MASK | mask);
        if (IS_ERR(poly))
                return PTR_ERR(poly);
        poly_hash = __crypto_hash_alg_common(poly);
@@ -608,10 +609,8 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
        if (err)
                goto err_free_inst;
 
-       crypto_set_skcipher_spawn(&ctx->chacha, aead_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ctx->chacha, chacha_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(&ctx->chacha, aead_crypto_instance(inst),
+                                  chacha_name, 0, mask);
        if (err)
                goto err_drop_poly;
 

diff --git a/crypto/cryptd.c b/crypto/cryptd.c
index cd94243a1605863b304c74a803cd005b9c689ff9..a0fe10624cfd564f71f9a43655f42350f86b7722 100644 (file)
--- a/crypto/cryptd.c
+++ b/crypto/cryptd.c
@@ -416,8 +416,8 @@ static int cryptd_create_skcipher(struct crypto_template *tmpl,
        ctx = skcipher_instance_ctx(inst);
        ctx->queue = queue;
 
-       crypto_set_skcipher_spawn(&ctx->spawn, skcipher_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ctx->spawn, name, type, mask);
+       err = crypto_grab_skcipher(&ctx->spawn, skcipher_crypto_instance(inst),
+                                  name, type, mask);
        if (err)
                goto out_free_inst;
 

diff --git a/crypto/ctr.c b/crypto/ctr.c
index b63b19de68a96160a870d49fd79273cc9c0a790d..a8feab621c6c10aa532e3d8fe933341126673b8d 100644 (file)
--- a/crypto/ctr.c
+++ b/crypto/ctr.c
@@ -286,8 +286,8 @@ static int crypto_rfc3686_create(struct crypto_template *tmpl,
 
        spawn = skcipher_instance_ctx(inst);
 
-       crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
-       err = crypto_grab_skcipher(spawn, cipher_name, 0, mask);
+       err = crypto_grab_skcipher(spawn, skcipher_crypto_instance(inst),
+                                  cipher_name, 0, mask);
        if (err)
                goto err_free_inst;
 

diff --git a/crypto/cts.c b/crypto/cts.c
index a0bb994f8b1174d3391d9022aa6e5532a0331a6a..48188adc8e91c3407cda1b7549ecf9f96eaf8ac3 100644 (file)
--- a/crypto/cts.c
+++ b/crypto/cts.c
@@ -328,6 +328,7 @@ static int crypto_cts_create(struct crypto_template *tmpl, struct rtattr **tb)
        struct crypto_attr_type *algt;
        struct skcipher_alg *alg;
        const char *cipher_name;
+       u32 mask;
        int err;
 
        algt = crypto_get_attr_type(tb);
@@ -337,6 +338,8 @@ static int crypto_cts_create(struct crypto_template *tmpl, struct rtattr **tb)
        if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        cipher_name = crypto_attr_alg_name(tb[1]);
        if (IS_ERR(cipher_name))
                return PTR_ERR(cipher_name);
@@ -347,10 +350,8 @@ static int crypto_cts_create(struct crypto_template *tmpl, struct rtattr **tb)
 
        spawn = skcipher_instance_ctx(inst);
 
-       crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
-       err = crypto_grab_skcipher(spawn, cipher_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(spawn, skcipher_crypto_instance(inst),
+                                  cipher_name, 0, mask);
        if (err)
                goto err_free_inst;
 

diff --git a/crypto/essiv.c b/crypto/essiv.c
index 61d9000ae4ad00eb2e595d66e7d609ffa9eac74e..0e45f5b4f67f54689dfc02c73bbc688ea4135a92 100644 (file)
--- a/crypto/essiv.c
+++ b/crypto/essiv.c
@@ -452,6 +452,7 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb)
        struct shash_alg *hash_alg;
        int ivsize;
        u32 type;
+       u32 mask;
        int err;
 
        algt = crypto_get_attr_type(tb);
@@ -467,6 +468,7 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb)
                return PTR_ERR(shash_name);
 
        type = algt->type & algt->mask;
+       mask = crypto_requires_sync(algt->type, algt->mask);
 
        switch (type) {
        case CRYPTO_ALG_TYPE_SKCIPHER:
@@ -479,11 +481,8 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb)
                ictx = crypto_instance_ctx(inst);
 
                /* Symmetric cipher, e.g., "cbc(aes)" */
-               crypto_set_skcipher_spawn(&ictx->u.skcipher_spawn, inst);
-               err = crypto_grab_skcipher(&ictx->u.skcipher_spawn,
-                                          inner_cipher_name, 0,
-                                          crypto_requires_sync(algt->type,
-                                                               algt->mask));
+               err = crypto_grab_skcipher(&ictx->u.skcipher_spawn, inst,
+                                          inner_cipher_name, 0, mask);
                if (err)
                        goto out_free_inst;
                skcipher_alg = crypto_spawn_skcipher_alg(&ictx->u.skcipher_spawn);
@@ -503,9 +502,7 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb)
                /* AEAD cipher, e.g., "authenc(hmac(sha256),cbc(aes))" */
                crypto_set_aead_spawn(&ictx->u.aead_spawn, inst);
                err = crypto_grab_aead(&ictx->u.aead_spawn,
-                                      inner_cipher_name, 0,
-                                      crypto_requires_sync(algt->type,
-                                                           algt->mask));
+                                      inner_cipher_name, 0, mask);
                if (err)
                        goto out_free_inst;
                aead_alg = crypto_spawn_aead_alg(&ictx->u.aead_spawn);

diff --git a/crypto/gcm.c b/crypto/gcm.c
index 7041cb1b6fd56deba2d827d4fb40071516b4dedb..887f472734b66c2d26b1de2002244fbee40a5d27 100644 (file)
--- a/crypto/gcm.c
+++ b/crypto/gcm.c
@@ -580,6 +580,7 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,
                                    const char *ghash_name)
 {
        struct crypto_attr_type *algt;
+       u32 mask;
        struct aead_instance *inst;
        struct skcipher_alg *ctr;
        struct crypto_alg *ghash_alg;
@@ -594,11 +595,11 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,
        if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        ghash_alg = crypto_find_alg(ghash_name, &crypto_ahash_type,
                                    CRYPTO_ALG_TYPE_HASH,
-                                   CRYPTO_ALG_TYPE_AHASH_MASK |
-                                   crypto_requires_sync(algt->type,
-                                                        algt->mask));
+                                   CRYPTO_ALG_TYPE_AHASH_MASK | mask);
        if (IS_ERR(ghash_alg))
                return PTR_ERR(ghash_alg);
 
@@ -620,10 +621,8 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,
            ghash->digestsize != 16)
                goto err_drop_ghash;
 
-       crypto_set_skcipher_spawn(&ctx->ctr, aead_crypto_instance(inst));
-       err = crypto_grab_skcipher(&ctx->ctr, ctr_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(&ctx->ctr, aead_crypto_instance(inst),
+                                  ctr_name, 0, mask);
        if (err)
                goto err_drop_ghash;
 

diff --git a/crypto/lrw.c b/crypto/lrw.c
index 8ebd79276c78c0c07297ce69d710fff9d57b8ec0..63c485c0d8a668a11dc430ce7f93c43568bbd858 100644 (file)
--- a/crypto/lrw.c
+++ b/crypto/lrw.c
@@ -301,6 +301,7 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb)
        struct skcipher_alg *alg;
        const char *cipher_name;
        char ecb_name[CRYPTO_MAX_ALG_NAME];
+       u32 mask;
        int err;
 
        algt = crypto_get_attr_type(tb);
@@ -310,6 +311,8 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb)
        if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
                return -EINVAL;
 
+       mask = crypto_requires_sync(algt->type, algt->mask);
+
        cipher_name = crypto_attr_alg_name(tb[1]);
        if (IS_ERR(cipher_name))
                return PTR_ERR(cipher_name);
@@ -320,19 +323,17 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb)
 
        spawn = skcipher_instance_ctx(inst);
 
-       crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
-       err = crypto_grab_skcipher(spawn, cipher_name, 0,
-                                  crypto_requires_sync(algt->type,
-                                                       algt->mask));
+       err = crypto_grab_skcipher(spawn, skcipher_crypto_instance(inst),
+                                  cipher_name, 0, mask);
        if (err == -ENOENT) {
                err = -ENAMETOOLONG;
                if (snprintf(ecb_name, CRYPTO_MAX_ALG_NAME, "ecb(%s)",
                             cipher_name) >= CRYPTO_MAX_ALG_NAME)
                        goto err_free_inst;
 
-               err = crypto_grab_skcipher(spawn, ecb_name, 0,
-                                          crypto_requires_sync(algt->type,
-                                                               algt->mask));
+               err = crypto_grab_skcipher(spawn,
+                                          skcipher_crypto_instance(inst),
+                                          ecb_name, 0, mask);
        }
 
        if (err)

diff --git a/crypto/skcipher.c b/crypto/skcipher.c
index 89137a197fc8f5c68eb7b31c1d2c5e8c953e5b00..8759d473a154e40df180489602fd92551a94a34d 100644 (file)
--- a/crypto/skcipher.c
+++ b/crypto/skcipher.c
@@ -747,8 +747,10 @@ static const struct crypto_type crypto_skcipher_type = {
 };
 
 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
-                         const char *name, u32 type, u32 mask)
+                        struct crypto_instance *inst,
+                        const char *name, u32 type, u32 mask)
 {
+       spawn->base.inst = inst;
        spawn->base.frontend = &crypto_skcipher_type;
        return crypto_grab_spawn(&spawn->base, name, type, mask);
 }

diff --git a/crypto/xts.c b/crypto/xts.c
index 19d55489e78b5d02f0bd79c871d3dd5c14821d3b..29efa15f149548b0e757f477b0af6544ce6bc330 100644 (file)
--- a/crypto/xts.c
+++ b/crypto/xts.c
@@ -355,20 +355,21 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb)
 
        ctx = skcipher_instance_ctx(inst);
 
-       crypto_set_skcipher_spawn(&ctx->spawn, skcipher_crypto_instance(inst));
-
        mask = crypto_requires_off(algt->type, algt->mask,
                                   CRYPTO_ALG_NEED_FALLBACK |
                                   CRYPTO_ALG_ASYNC);
 
-       err = crypto_grab_skcipher(&ctx->spawn, cipher_name, 0, mask);
+       err = crypto_grab_skcipher(&ctx->spawn, skcipher_crypto_instance(inst),
+                                  cipher_name, 0, mask);
        if (err == -ENOENT) {
                err = -ENAMETOOLONG;
                if (snprintf(ctx->name, CRYPTO_MAX_ALG_NAME, "ecb(%s)",
                             cipher_name) >= CRYPTO_MAX_ALG_NAME)
                        goto err_free_inst;
 
-               err = crypto_grab_skcipher(&ctx->spawn, ctx->name, 0, mask);
+               err = crypto_grab_skcipher(&ctx->spawn,
+                                          skcipher_crypto_instance(inst),
+                                          ctx->name, 0, mask);
        }
 
        if (err)

diff --git a/include/crypto/internal/skcipher.h b/include/crypto/internal/skcipher.h
index df4fdeaa13f3aeda90762fc28216ac1fcf03b72d..e387424f62475282cb15884918dfa7b4b139fe23 100644 (file)
--- a/include/crypto/internal/skcipher.h
+++ b/include/crypto/internal/skcipher.h
@@ -88,14 +88,9 @@ static inline void skcipher_request_complete(struct skcipher_request *req, int e
        req->base.complete(&req->base, err);
 }
 
-static inline void crypto_set_skcipher_spawn(
-       struct crypto_skcipher_spawn *spawn, struct crypto_instance *inst)
-{
-       crypto_set_spawn(&spawn->base, inst);
-}
-
-int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
-                        u32 type, u32 mask);
+int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
+                        struct crypto_instance *inst,
+                        const char *name, u32 type, u32 mask);
 
 static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
 {