crypto: user - fix use_after_free of struct xxx_request

All crypto_stats functions use the struct xxx_request for feeding stats,
but in some case this structure could already be freed.

For fixing this, the needed parameters (len and alg) will be stored
before the request being executed.
Fixes: cac5818c25d0 ("crypto: user - Implement a generic crypto statistics")
Reported-by: syzbot <syzbot+6939a606a5305e9e9799@syzkaller.appspotmail.com>
Signed-off-by: Corentin Labbe <clabbe@baylibre.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/ahash.c b/crypto/ahash.c
index 3a348fbcf8f91899924ac139d9d087837258467b..5d320a811f75023271b1cbf8525f086c0f1df687 100644 (file)
--- a/crypto/ahash.c
+++ b/crypto/ahash.c
@@ -364,20 +364,28 @@ static int crypto_ahash_op(struct ahash_request *req,
 
 int crypto_ahash_final(struct ahash_request *req)
 {
+       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int nbytes = req->nbytes;
        int ret;
 
+       crypto_stats_get(alg);
        ret = crypto_ahash_op(req, crypto_ahash_reqtfm(req)->final);
-       crypto_stat_ahash_final(req, ret);
+       crypto_stats_ahash_final(nbytes, ret, alg);
        return ret;
 }
 EXPORT_SYMBOL_GPL(crypto_ahash_final);
 
 int crypto_ahash_finup(struct ahash_request *req)
 {
+       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int nbytes = req->nbytes;
        int ret;
 
+       crypto_stats_get(alg);
        ret = crypto_ahash_op(req, crypto_ahash_reqtfm(req)->finup);
-       crypto_stat_ahash_final(req, ret);
+       crypto_stats_ahash_final(nbytes, ret, alg);
        return ret;
 }
 EXPORT_SYMBOL_GPL(crypto_ahash_finup);
@@ -385,13 +393,16 @@ EXPORT_SYMBOL_GPL(crypto_ahash_finup);
 int crypto_ahash_digest(struct ahash_request *req)
 {
        struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int nbytes = req->nbytes;
        int ret;
 
+       crypto_stats_get(alg);
        if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
                ret = -ENOKEY;
        else
                ret = crypto_ahash_op(req, tfm->digest);
-       crypto_stat_ahash_final(req, ret);
+       crypto_stats_ahash_final(nbytes, ret, alg);
        return ret;
 }
 EXPORT_SYMBOL_GPL(crypto_ahash_digest);

diff --git a/crypto/algapi.c b/crypto/algapi.c
index 42fe316f80eeade100ea8080c4076e71dfc11995..4c1e6079d2714e168e3aa2ecf14d0bb6dd6d9f2d 100644 (file)
--- a/crypto/algapi.c
+++ b/crypto/algapi.c
@@ -1078,6 +1078,239 @@ int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,
 }
 EXPORT_SYMBOL_GPL(crypto_type_has_alg);
 
+#ifdef CONFIG_CRYPTO_STATS
+void crypto_stats_get(struct crypto_alg *alg)
+{
+       crypto_alg_get(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_get);
+
+void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret,
+                                    struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->cipher_err_cnt);
+       } else {
+               atomic64_inc(&alg->encrypt_cnt);
+               atomic64_add(nbytes, &alg->encrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_ablkcipher_encrypt);
+
+void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret,
+                                    struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->cipher_err_cnt);
+       } else {
+               atomic64_inc(&alg->decrypt_cnt);
+               atomic64_add(nbytes, &alg->decrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_ablkcipher_decrypt);
+
+void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg,
+                              int ret)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->aead_err_cnt);
+       } else {
+               atomic64_inc(&alg->encrypt_cnt);
+               atomic64_add(cryptlen, &alg->encrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_aead_encrypt);
+
+void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg,
+                              int ret)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->aead_err_cnt);
+       } else {
+               atomic64_inc(&alg->decrypt_cnt);
+               atomic64_add(cryptlen, &alg->decrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_aead_decrypt);
+
+void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret,
+                                  struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->akcipher_err_cnt);
+       } else {
+               atomic64_inc(&alg->encrypt_cnt);
+               atomic64_add(src_len, &alg->encrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_akcipher_encrypt);
+
+void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret,
+                                  struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->akcipher_err_cnt);
+       } else {
+               atomic64_inc(&alg->decrypt_cnt);
+               atomic64_add(src_len, &alg->decrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_akcipher_decrypt);
+
+void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
+               atomic64_inc(&alg->akcipher_err_cnt);
+       else
+               atomic64_inc(&alg->sign_cnt);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_akcipher_sign);
+
+void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
+               atomic64_inc(&alg->akcipher_err_cnt);
+       else
+               atomic64_inc(&alg->verify_cnt);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_akcipher_verify);
+
+void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->compress_err_cnt);
+       } else {
+               atomic64_inc(&alg->compress_cnt);
+               atomic64_add(slen, &alg->compress_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_compress);
+
+void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->compress_err_cnt);
+       } else {
+               atomic64_inc(&alg->decompress_cnt);
+               atomic64_add(slen, &alg->decompress_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_decompress);
+
+void crypto_stats_ahash_update(unsigned int nbytes, int ret,
+                              struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
+               atomic64_inc(&alg->hash_err_cnt);
+       else
+               atomic64_add(nbytes, &alg->hash_tlen);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_ahash_update);
+
+void crypto_stats_ahash_final(unsigned int nbytes, int ret,
+                             struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->hash_err_cnt);
+       } else {
+               atomic64_inc(&alg->hash_cnt);
+               atomic64_add(nbytes, &alg->hash_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_ahash_final);
+
+void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret)
+{
+       if (ret)
+               atomic64_inc(&alg->kpp_err_cnt);
+       else
+               atomic64_inc(&alg->setsecret_cnt);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_kpp_set_secret);
+
+void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret)
+{
+       if (ret)
+               atomic64_inc(&alg->kpp_err_cnt);
+       else
+               atomic64_inc(&alg->generate_public_key_cnt);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_kpp_generate_public_key);
+
+void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret)
+{
+       if (ret)
+               atomic64_inc(&alg->kpp_err_cnt);
+       else
+               atomic64_inc(&alg->compute_shared_secret_cnt);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_kpp_compute_shared_secret);
+
+void crypto_stats_rng_seed(struct crypto_alg *alg, int ret)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
+               atomic64_inc(&alg->rng_err_cnt);
+       else
+               atomic64_inc(&alg->seed_cnt);
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_rng_seed);
+
+void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen,
+                              int ret)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->rng_err_cnt);
+       } else {
+               atomic64_inc(&alg->generate_cnt);
+               atomic64_add(dlen, &alg->generate_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_rng_generate);
+
+void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret,
+                                  struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->cipher_err_cnt);
+       } else {
+               atomic64_inc(&alg->encrypt_cnt);
+               atomic64_add(cryptlen, &alg->encrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_skcipher_encrypt);
+
+void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret,
+                                  struct crypto_alg *alg)
+{
+       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+               atomic64_inc(&alg->cipher_err_cnt);
+       } else {
+               atomic64_inc(&alg->decrypt_cnt);
+               atomic64_add(cryptlen, &alg->decrypt_tlen);
+       }
+       crypto_alg_put(alg);
+}
+EXPORT_SYMBOL_GPL(crypto_stats_skcipher_decrypt);
+#endif
+
 static int __init crypto_algapi_init(void)
 {
        crypto_init_proc();

diff --git a/crypto/rng.c b/crypto/rng.c
index 2406501b90b7036540bbfca51e08b302d3f66857..33c38a72bff59fea8ff1c762957408e2d1f29434 100644 (file)
--- a/crypto/rng.c
+++ b/crypto/rng.c
@@ -35,9 +35,11 @@ static int crypto_default_rng_refcnt;
 
 int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed, unsigned int slen)
 {
+       struct crypto_alg *alg = tfm->base.__crt_alg;
        u8 *buf = NULL;
        int err;
 
+       crypto_stats_get(alg);
        if (!seed && slen) {
                buf = kmalloc(slen, GFP_KERNEL);
                if (!buf)
@@ -50,7 +52,7 @@ int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed, unsigned int slen)
        }
 
        err = crypto_rng_alg(tfm)->seed(tfm, seed, slen);
-       crypto_stat_rng_seed(tfm, err);
+       crypto_stats_rng_seed(alg, err);
 out:
        kzfree(buf);
        return err;

diff --git a/include/crypto/acompress.h b/include/crypto/acompress.h
index f799181968119d6cea241e9c0ce115148680308b..a3e766dff917f0055a275b4f8e961a67da84a2a3 100644 (file)
--- a/include/crypto/acompress.h
+++ b/include/crypto/acompress.h
@@ -234,34 +234,6 @@ static inline void acomp_request_set_params(struct acomp_req *req,
                req->flags |= CRYPTO_ACOMP_ALLOC_OUTPUT;
 }
 
-static inline void crypto_stat_compress(struct acomp_req *req, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->compress_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->compress_cnt);
-               atomic64_add(req->slen, &tfm->base.__crt_alg->compress_tlen);
-       }
-#endif
-}
-
-static inline void crypto_stat_decompress(struct acomp_req *req, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->compress_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->decompress_cnt);
-               atomic64_add(req->slen, &tfm->base.__crt_alg->decompress_tlen);
-       }
-#endif
-}
-
 /**
  * crypto_acomp_compress() -- Invoke asynchronous compress operation
  *
@@ -274,10 +246,13 @@ static inline void crypto_stat_decompress(struct acomp_req *req, int ret)
 static inline int crypto_acomp_compress(struct acomp_req *req)
 {
        struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int slen = req->slen;
        int ret;
 
+       crypto_stats_get(alg);
        ret = tfm->compress(req);
-       crypto_stat_compress(req, ret);
+       crypto_stats_compress(slen, ret, alg);
        return ret;
 }
 
@@ -293,10 +268,13 @@ static inline int crypto_acomp_compress(struct acomp_req *req)
 static inline int crypto_acomp_decompress(struct acomp_req *req)
 {
        struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int slen = req->slen;
        int ret;
 
+       crypto_stats_get(alg);
        ret = tfm->decompress(req);
-       crypto_stat_decompress(req, ret);
+       crypto_stats_decompress(slen, ret, alg);
        return ret;
 }
 

diff --git a/include/crypto/aead.h b/include/crypto/aead.h
index 99afd78c665d8f3920b465c2029da91a8b57d557..b7b8d24cf765f08fd4fe5c665fa220fa0bc51f74 100644 (file)
--- a/include/crypto/aead.h
+++ b/include/crypto/aead.h
@@ -306,34 +306,6 @@ static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
        return __crypto_aead_cast(req->base.tfm);
 }
 
-static inline void crypto_stat_aead_encrypt(struct aead_request *req, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_aead *tfm = crypto_aead_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->aead_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->encrypt_cnt);
-               atomic64_add(req->cryptlen, &tfm->base.__crt_alg->encrypt_tlen);
-       }
-#endif
-}
-
-static inline void crypto_stat_aead_decrypt(struct aead_request *req, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_aead *tfm = crypto_aead_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->aead_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->decrypt_cnt);
-               atomic64_add(req->cryptlen, &tfm->base.__crt_alg->decrypt_tlen);
-       }
-#endif
-}
-
 /**
  * crypto_aead_encrypt() - encrypt plaintext
  * @req: reference to the aead_request handle that holds all information
@@ -356,13 +328,16 @@ static inline void crypto_stat_aead_decrypt(struct aead_request *req, int ret)
 static inline int crypto_aead_encrypt(struct aead_request *req)
 {
        struct crypto_aead *aead = crypto_aead_reqtfm(req);
+       struct crypto_alg *alg = aead->base.__crt_alg;
+       unsigned int cryptlen = req->cryptlen;
        int ret;
 
+       crypto_stats_get(alg);
        if (crypto_aead_get_flags(aead) & CRYPTO_TFM_NEED_KEY)
                ret = -ENOKEY;
        else
                ret = crypto_aead_alg(aead)->encrypt(req);
-       crypto_stat_aead_encrypt(req, ret);
+       crypto_stats_aead_encrypt(cryptlen, alg, ret);
        return ret;
 }
 
@@ -391,15 +366,18 @@ static inline int crypto_aead_encrypt(struct aead_request *req)
 static inline int crypto_aead_decrypt(struct aead_request *req)
 {
        struct crypto_aead *aead = crypto_aead_reqtfm(req);
+       struct crypto_alg *alg = aead->base.__crt_alg;
+       unsigned int cryptlen = req->cryptlen;
        int ret;
 
+       crypto_stats_get(alg);
        if (crypto_aead_get_flags(aead) & CRYPTO_TFM_NEED_KEY)
                ret = -ENOKEY;
        else if (req->cryptlen < crypto_aead_authsize(aead))
                ret = -EINVAL;
        else
                ret = crypto_aead_alg(aead)->decrypt(req);
-       crypto_stat_aead_decrypt(req, ret);
+       crypto_stats_aead_decrypt(cryptlen, alg, ret);
        return ret;
 }
 

diff --git a/include/crypto/akcipher.h b/include/crypto/akcipher.h
index 3dc05cf7e0a952cb3c362b70d46f8e6a28a0c814..2d690494568cf8b4e70fcc93a5d324d286cf6616 100644 (file)
--- a/include/crypto/akcipher.h
+++ b/include/crypto/akcipher.h
@@ -271,62 +271,6 @@ static inline unsigned int crypto_akcipher_maxsize(struct crypto_akcipher *tfm)
        return alg->max_size(tfm);
 }
 
-static inline void crypto_stat_akcipher_encrypt(struct akcipher_request *req,
-                                               int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->akcipher_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->encrypt_cnt);
-               atomic64_add(req->src_len, &tfm->base.__crt_alg->encrypt_tlen);
-       }
-#endif
-}
-
-static inline void crypto_stat_akcipher_decrypt(struct akcipher_request *req,
-                                               int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->akcipher_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->decrypt_cnt);
-               atomic64_add(req->src_len, &tfm->base.__crt_alg->decrypt_tlen);
-       }
-#endif
-}
-
-static inline void crypto_stat_akcipher_sign(struct akcipher_request *req,
-                                            int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
-               atomic64_inc(&tfm->base.__crt_alg->akcipher_err_cnt);
-       else
-               atomic64_inc(&tfm->base.__crt_alg->sign_cnt);
-#endif
-}
-
-static inline void crypto_stat_akcipher_verify(struct akcipher_request *req,
-                                              int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
-               atomic64_inc(&tfm->base.__crt_alg->akcipher_err_cnt);
-       else
-               atomic64_inc(&tfm->base.__crt_alg->verify_cnt);
-#endif
-}
-
 /**
  * crypto_akcipher_encrypt() - Invoke public key encrypt operation
  *
@@ -341,10 +285,13 @@ static inline int crypto_akcipher_encrypt(struct akcipher_request *req)
 {
        struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
        struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
+       unsigned int src_len = req->src_len;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->encrypt(req);
-       crypto_stat_akcipher_encrypt(req, ret);
+       crypto_stats_akcipher_encrypt(src_len, ret, calg);
        return ret;
 }
 
@@ -362,10 +309,13 @@ static inline int crypto_akcipher_decrypt(struct akcipher_request *req)
 {
        struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
        struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
+       unsigned int src_len = req->src_len;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->decrypt(req);
-       crypto_stat_akcipher_decrypt(req, ret);
+       crypto_stats_akcipher_decrypt(src_len, ret, calg);
        return ret;
 }
 
@@ -383,10 +333,12 @@ static inline int crypto_akcipher_sign(struct akcipher_request *req)
 {
        struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
        struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->sign(req);
-       crypto_stat_akcipher_sign(req, ret);
+       crypto_stats_akcipher_sign(ret, calg);
        return ret;
 }
 
@@ -404,10 +356,12 @@ static inline int crypto_akcipher_verify(struct akcipher_request *req)
 {
        struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
        struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->verify(req);
-       crypto_stat_akcipher_verify(req, ret);
+       crypto_stats_akcipher_verify(ret, calg);
        return ret;
 }
 

diff --git a/include/crypto/hash.h b/include/crypto/hash.h
index 52920bed05bad6ddac512e6824094571e6171713..3b31c1b349ae60158f96d4605f0dc2952cb089a6 100644 (file)
--- a/include/crypto/hash.h
+++ b/include/crypto/hash.h
@@ -412,32 +412,6 @@ static inline void *ahash_request_ctx(struct ahash_request *req)
 int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
                        unsigned int keylen);
 
-static inline void crypto_stat_ahash_update(struct ahash_request *req, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
-               atomic64_inc(&tfm->base.__crt_alg->hash_err_cnt);
-       else
-               atomic64_add(req->nbytes, &tfm->base.__crt_alg->hash_tlen);
-#endif
-}
-
-static inline void crypto_stat_ahash_final(struct ahash_request *req, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->hash_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->hash_cnt);
-               atomic64_add(req->nbytes, &tfm->base.__crt_alg->hash_tlen);
-       }
-#endif
-}
-
 /**
  * crypto_ahash_finup() - update and finalize message digest
  * @req: reference to the ahash_request handle that holds all information
@@ -552,10 +526,14 @@ static inline int crypto_ahash_init(struct ahash_request *req)
  */
 static inline int crypto_ahash_update(struct ahash_request *req)
 {
+       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int nbytes = req->nbytes;
        int ret;
 
+       crypto_stats_get(alg);
        ret = crypto_ahash_reqtfm(req)->update(req);
-       crypto_stat_ahash_update(req, ret);
+       crypto_stats_ahash_update(nbytes, ret, alg);
        return ret;
 }
 

diff --git a/include/crypto/kpp.h b/include/crypto/kpp.h
index bd5103a80919817bc74d5fa6d01f9399803766f5..1a97e160142228913241e43f6da77938d5cfd636 100644 (file)
--- a/include/crypto/kpp.h
+++ b/include/crypto/kpp.h
@@ -268,42 +268,6 @@ struct kpp_secret {
        unsigned short len;
 };
 
-static inline void crypto_stat_kpp_set_secret(struct crypto_kpp *tfm, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       if (ret)
-               atomic64_inc(&tfm->base.__crt_alg->kpp_err_cnt);
-       else
-               atomic64_inc(&tfm->base.__crt_alg->setsecret_cnt);
-#endif
-}
-
-static inline void crypto_stat_kpp_generate_public_key(struct kpp_request *req,
-                                                      int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
-
-       if (ret)
-               atomic64_inc(&tfm->base.__crt_alg->kpp_err_cnt);
-       else
-               atomic64_inc(&tfm->base.__crt_alg->generate_public_key_cnt);
-#endif
-}
-
-static inline void crypto_stat_kpp_compute_shared_secret(struct kpp_request *req,
-                                                        int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
-
-       if (ret)
-               atomic64_inc(&tfm->base.__crt_alg->kpp_err_cnt);
-       else
-               atomic64_inc(&tfm->base.__crt_alg->compute_shared_secret_cnt);
-#endif
-}
-
 /**
  * crypto_kpp_set_secret() - Invoke kpp operation
  *
@@ -323,10 +287,12 @@ static inline int crypto_kpp_set_secret(struct crypto_kpp *tfm,
                                        const void *buffer, unsigned int len)
 {
        struct kpp_alg *alg = crypto_kpp_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->set_secret(tfm, buffer, len);
-       crypto_stat_kpp_set_secret(tfm, ret);
+       crypto_stats_kpp_set_secret(calg, ret);
        return ret;
 }
 
@@ -347,10 +313,12 @@ static inline int crypto_kpp_generate_public_key(struct kpp_request *req)
 {
        struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
        struct kpp_alg *alg = crypto_kpp_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->generate_public_key(req);
-       crypto_stat_kpp_generate_public_key(req, ret);
+       crypto_stats_kpp_generate_public_key(calg, ret);
        return ret;
 }
 
@@ -368,10 +336,12 @@ static inline int crypto_kpp_compute_shared_secret(struct kpp_request *req)
 {
        struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
        struct kpp_alg *alg = crypto_kpp_alg(tfm);
+       struct crypto_alg *calg = tfm->base.__crt_alg;
        int ret;
 
+       crypto_stats_get(calg);
        ret = alg->compute_shared_secret(req);
-       crypto_stat_kpp_compute_shared_secret(req, ret);
+       crypto_stats_kpp_compute_shared_secret(calg, ret);
        return ret;
 }
 

diff --git a/include/crypto/rng.h b/include/crypto/rng.h
index 966615bba45e557ca67283403d70194058c77fc6..022a1b896b475c2430558345c033d18d2d191c32 100644 (file)
--- a/include/crypto/rng.h
+++ b/include/crypto/rng.h
@@ -122,29 +122,6 @@ static inline void crypto_free_rng(struct crypto_rng *tfm)
        crypto_destroy_tfm(tfm, crypto_rng_tfm(tfm));
 }
 
-static inline void crypto_stat_rng_seed(struct crypto_rng *tfm, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY)
-               atomic64_inc(&tfm->base.__crt_alg->rng_err_cnt);
-       else
-               atomic64_inc(&tfm->base.__crt_alg->seed_cnt);
-#endif
-}
-
-static inline void crypto_stat_rng_generate(struct crypto_rng *tfm,
-                                           unsigned int dlen, int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&tfm->base.__crt_alg->rng_err_cnt);
-       } else {
-               atomic64_inc(&tfm->base.__crt_alg->generate_cnt);
-               atomic64_add(dlen, &tfm->base.__crt_alg->generate_tlen);
-       }
-#endif
-}
-
 /**
  * crypto_rng_generate() - get random number
  * @tfm: cipher handle
@@ -163,10 +140,12 @@ static inline int crypto_rng_generate(struct crypto_rng *tfm,
                                      const u8 *src, unsigned int slen,
                                      u8 *dst, unsigned int dlen)
 {
+       struct crypto_alg *alg = tfm->base.__crt_alg;
        int ret;
 
+       crypto_stats_get(alg);
        ret = crypto_rng_alg(tfm)->generate(tfm, src, slen, dst, dlen);
-       crypto_stat_rng_generate(tfm, dlen, ret);
+       crypto_stats_rng_generate(alg, dlen, ret);
        return ret;
 }
 

diff --git a/include/crypto/skcipher.h b/include/crypto/skcipher.h
index dff54731ddf4ff16ae79f0fd81a49c7d730bb56b..480f8301a47db2022c7e5a77633d2352825bdb94 100644 (file)
--- a/include/crypto/skcipher.h
+++ b/include/crypto/skcipher.h
@@ -486,32 +486,6 @@ static inline struct crypto_sync_skcipher *crypto_sync_skcipher_reqtfm(
        return container_of(tfm, struct crypto_sync_skcipher, base);
 }
 
-static inline void crypto_stat_skcipher_encrypt(struct skcipher_request *req,
-                                               int ret, struct crypto_alg *alg)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&alg->cipher_err_cnt);
-       } else {
-               atomic64_inc(&alg->encrypt_cnt);
-               atomic64_add(req->cryptlen, &alg->encrypt_tlen);
-       }
-#endif
-}
-
-static inline void crypto_stat_skcipher_decrypt(struct skcipher_request *req,
-                                               int ret, struct crypto_alg *alg)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&alg->cipher_err_cnt);
-       } else {
-               atomic64_inc(&alg->decrypt_cnt);
-               atomic64_add(req->cryptlen, &alg->decrypt_tlen);
-       }
-#endif
-}
-
 /**
  * crypto_skcipher_encrypt() - encrypt plaintext
  * @req: reference to the skcipher_request handle that holds all information
@@ -526,13 +500,16 @@ static inline void crypto_stat_skcipher_decrypt(struct skcipher_request *req,
 static inline int crypto_skcipher_encrypt(struct skcipher_request *req)
 {
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int cryptlen = req->cryptlen;
        int ret;
 
+       crypto_stats_get(alg);
        if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
                ret = -ENOKEY;
        else
                ret = tfm->encrypt(req);
-       crypto_stat_skcipher_encrypt(req, ret, tfm->base.__crt_alg);
+       crypto_stats_skcipher_encrypt(cryptlen, ret, alg);
        return ret;
 }
 
@@ -550,13 +527,16 @@ static inline int crypto_skcipher_encrypt(struct skcipher_request *req)
 static inline int crypto_skcipher_decrypt(struct skcipher_request *req)
 {
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct crypto_alg *alg = tfm->base.__crt_alg;
+       unsigned int cryptlen = req->cryptlen;
        int ret;
 
+       crypto_stats_get(alg);
        if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
                ret = -ENOKEY;
        else
                ret = tfm->decrypt(req);
-       crypto_stat_skcipher_decrypt(req, ret, tfm->base.__crt_alg);
+       crypto_stats_skcipher_decrypt(cryptlen, ret, alg);
        return ret;
 }
 

diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index b109b50906e74f4b548cc1000f425245c4cc6bb5..e2fd24714e001140d60e48ad362a0091eee96de7 100644 (file)
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -557,6 +557,69 @@ struct crypto_alg {
 
 } CRYPTO_MINALIGN_ATTR;
 
+#ifdef CONFIG_CRYPTO_STATS
+void crypto_stats_get(struct crypto_alg *alg);
+void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg);
+void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg);
+void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
+void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
+void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg);
+void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg);
+void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg);
+void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg);
+void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg);
+void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg);
+void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg);
+void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg);
+void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret);
+void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret);
+void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret);
+void crypto_stats_rng_seed(struct crypto_alg *alg, int ret);
+void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret);
+void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg);
+void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg);
+#else
+static inline void crypto_stats_get(struct crypto_alg *alg)
+{}
+static inline void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
+{}
+static inline void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
+{}
+static inline void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret)
+{}
+static inline void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret)
+{}
+static inline void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret)
+{}
+static inline void crypto_stats_rng_seed(struct crypto_alg *alg, int ret)
+{}
+static inline void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret)
+{}
+static inline void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg)
+{}
+static inline void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg)
+{}
+#endif
 /*
  * A helper struct for waiting for completion of async crypto ops
  */
@@ -975,38 +1038,6 @@ static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
        return __crypto_ablkcipher_cast(req->base.tfm);
 }
 
-static inline void crypto_stat_ablkcipher_encrypt(struct ablkcipher_request *req,
-                                                 int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct ablkcipher_tfm *crt =
-               crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&crt->base->base.__crt_alg->cipher_err_cnt);
-       } else {
-               atomic64_inc(&crt->base->base.__crt_alg->encrypt_cnt);
-               atomic64_add(req->nbytes, &crt->base->base.__crt_alg->encrypt_tlen);
-       }
-#endif
-}
-
-static inline void crypto_stat_ablkcipher_decrypt(struct ablkcipher_request *req,
-                                                 int ret)
-{
-#ifdef CONFIG_CRYPTO_STATS
-       struct ablkcipher_tfm *crt =
-               crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
-
-       if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
-               atomic64_inc(&crt->base->base.__crt_alg->cipher_err_cnt);
-       } else {
-               atomic64_inc(&crt->base->base.__crt_alg->decrypt_cnt);
-               atomic64_add(req->nbytes, &crt->base->base.__crt_alg->decrypt_tlen);
-       }
-#endif
-}
-
 /**
  * crypto_ablkcipher_encrypt() - encrypt plaintext
  * @req: reference to the ablkcipher_request handle that holds all information
@@ -1022,10 +1053,13 @@ static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
 {
        struct ablkcipher_tfm *crt =
                crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
+       struct crypto_alg *alg = crt->base->base.__crt_alg;
+       unsigned int nbytes = req->nbytes;
        int ret;
 
+       crypto_stats_get(alg);
        ret = crt->encrypt(req);
-       crypto_stat_ablkcipher_encrypt(req, ret);
+       crypto_stats_ablkcipher_encrypt(nbytes, ret, alg);
        return ret;
 }
 
@@ -1044,10 +1078,13 @@ static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
 {
        struct ablkcipher_tfm *crt =
                crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
+       struct crypto_alg *alg = crt->base->base.__crt_alg;
+       unsigned int nbytes = req->nbytes;
        int ret;
 
+       crypto_stats_get(alg);
        ret = crt->decrypt(req);
-       crypto_stat_ablkcipher_decrypt(req, ret);
+       crypto_stats_ablkcipher_decrypt(nbytes, ret, alg);
        return ret;
 }