[v4,06/11] crypto: crypto_user_stat: fix use_after_free of struct xxx_request

Message ID	1542974541-23024-7-git-send-email-clabbe@baylibre.com (mailing list archive)
State	Changes Requested
Delegated to:	Herbert Xu
Headers	show Return-Path: <linux-crypto-owner@kernel.org> From: Corentin Labbe <clabbe@baylibre.com> To: davem@davemloft.net, ebiggers@kernel.org, herbert@gondor.apana.org.au, nhorman@tuxdriver.com Cc: linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, Corentin Labbe <clabbe@baylibre.com> Subject: [PATCH v4 06/11] crypto: crypto_user_stat: fix use_after_free of struct xxx_request Date: Fri, 23 Nov 2018 12:02:16 +0000 Message-Id: <1542974541-23024-7-git-send-email-clabbe@baylibre.com> In-Reply-To: <1542974541-23024-1-git-send-email-clabbe@baylibre.com> References: <1542974541-23024-1-git-send-email-clabbe@baylibre.com> Sender: linux-crypto-owner@vger.kernel.org Precedence: bulk
Series	crypto: crypto_user_stat: misc enhancement \| expand [v4,00/11] crypto: crypto_user_stat: misc enhancement [v4,01/11] crypto: crypto_user_stat: made crypto_user_stat optional [v4,02/11] crypto: CRYPTO_STATS should depend on CRYPTO_USER [v4,03/11] crypto: crypto_user_stat: convert all stats from u32 to u64 [v4,04/11] crypto: crypto_user_stat: split user space crypto stat structures [v4,05/11] crypto: tool: getstat: convert user space example to the new crypto_user_stat uapi [v4,06/11] crypto: crypto_user_stat: fix use_after_free of struct xxx_request [v4,07/11] crypto: crypto_user_stat: Fix invalid stat reporting [v4,08/11] crypto: crypto_user_stat: remove intermediate variable [v4,09/11] crypto: crypto_user_stat: Split stats in multiple structures [v4,10/11] crypto: crypto_user_stat: rename err_cnt parameter [v4,11/11] crypto: crypto_user_stat: Add crypto_stats_init

Hi Corentin, On Fri, Nov 23, 2018 at 12:02:16PM +0000, Corentin Labbe wrote: > 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> > --- > crypto/ahash.c | 17 ++- > crypto/algapi.c | 285 +++++++++++++++++++++++++++++++++++++ > crypto/rng.c | 4 +- > include/crypto/acompress.h | 38 ++--- > include/crypto/aead.h | 38 ++--- > include/crypto/akcipher.h | 74 ++-------- > include/crypto/hash.h | 32 +---- > include/crypto/kpp.h | 48 ++----- > include/crypto/rng.h | 27 +--- > include/crypto/skcipher.h | 36 ++--- > include/linux/crypto.h | 63 ++++---- > 11 files changed, 386 insertions(+), 276 deletions(-) > > diff --git a/crypto/ahash.c b/crypto/ahash.c > index 3a348fbcf8f9..5d320a811f75 100644 > --- 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 42fe316f80ee..aae302d92c2a 100644 > --- a/crypto/algapi.c > +++ b/crypto/algapi.c > @@ -1078,6 +1078,291 @@ 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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > + > +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); > +} > +#else > +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) > +{} > +#endif The stubs need to be static inline in the .h file so that they are optimized out when !CONFIG_CRYPTO_STATS. Otherwise there is a massive bloat. See the dissassembly of a call to crypto_skcipher_encrypt() in each case: With inline stubs (same as original, before the crypto stats feature): ffffffff812f6e80 <encrypt>: ffffffff812f6e80: 48 8b 47 40 mov 0x40(%rdi),%rax ffffffff812f6e84: f6 00 01 testb $0x1,(%rax) ffffffff812f6e87: 75 03 jne ffffffff812f6e8c <encrypt+0xc> ffffffff812f6e89: ff 60 e0 jmpq *-0x20(%rax) ffffffff812f6e8c: b8 82 ff ff ff mov $0xffffff82,%eax ffffffff812f6e91: c3 retq With non-inline stubs (even when !CONFIG_CRYPTO_STATS): ffffffff812f75e0 <encrypt>: ffffffff812f75e0: 41 55 push %r13 ffffffff812f75e2: 41 54 push %r12 ffffffff812f75e4: 55 push %rbp ffffffff812f75e5: 48 89 fd mov %rdi,%rbp ffffffff812f75e8: 53 push %rbx ffffffff812f75e9: 48 8b 5f 40 mov 0x40(%rdi),%rbx ffffffff812f75ed: 44 8b 2f mov (%rdi),%r13d ffffffff812f75f0: 4c 8b 63 38 mov 0x38(%rbx),%r12 ffffffff812f75f4: 4c 89 e7 mov %r12,%rdi ffffffff812f75f7: e8 14 df fd ff callq ffffffff812d5510 <crypto_stats_get> ffffffff812f75fc: f6 03 01 testb $0x1,(%rbx) ffffffff812f75ff: 75 1e jne ffffffff812f761f <encrypt+0x3f> ffffffff812f7601: 48 89 ef mov %rbp,%rdi ffffffff812f7604: ff 53 e0 callq *-0x20(%rbx) ffffffff812f7607: 89 c3 mov %eax,%ebx ffffffff812f7609: 4c 89 e2 mov %r12,%rdx ffffffff812f760c: 89 de mov %ebx,%esi ffffffff812f760e: 44 89 ef mov %r13d,%edi ffffffff812f7611: e8 3a de fd ff callq ffffffff812d5450 <crypto_stats_skcipher_encrypt> ffffffff812f7616: 89 d8 mov %ebx,%eax ffffffff812f7618: 5b pop %rbx ffffffff812f7619: 5d pop %rbp ffffffff812f761a: 41 5c pop %r12 ffffffff812f761c: 41 5d pop %r13 ffffffff812f761e: c3 retq ffffffff812f761f: bb 82 ff ff ff mov $0xffffff82,%ebx ffffffff812f7624: eb e3 jmp ffffffff812f7609 <encrypt+0x29> - Eric

diff --git a/crypto/ahash.c b/crypto/ahash.c index 3a348fbcf8f9..5d320a811f75 100644 --- 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 42fe316f80ee..aae302d92c2a 100644 --- a/crypto/algapi.c +++ b/crypto/algapi.c @@ -1078,6 +1078,291 @@ 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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} +#else +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) +{} +#endif +EXPORT_SYMBOL_GPL(crypto_stats_get); +EXPORT_SYMBOL_GPL(crypto_stats_ablkcipher_encrypt); +EXPORT_SYMBOL_GPL(crypto_stats_ablkcipher_decrypt); +EXPORT_SYMBOL_GPL(crypto_stats_aead_encrypt); +EXPORT_SYMBOL_GPL(crypto_stats_aead_decrypt); +EXPORT_SYMBOL_GPL(crypto_stats_ahash_update); +EXPORT_SYMBOL_GPL(crypto_stats_ahash_final); +EXPORT_SYMBOL_GPL(crypto_stats_akcipher_encrypt); +EXPORT_SYMBOL_GPL(crypto_stats_akcipher_decrypt); +EXPORT_SYMBOL_GPL(crypto_stats_akcipher_sign); +EXPORT_SYMBOL_GPL(crypto_stats_akcipher_verify); +EXPORT_SYMBOL_GPL(crypto_stats_compress); +EXPORT_SYMBOL_GPL(crypto_stats_decompress); +EXPORT_SYMBOL_GPL(crypto_stats_kpp_set_secret); +EXPORT_SYMBOL_GPL(crypto_stats_kpp_generate_public_key); +EXPORT_SYMBOL_GPL(crypto_stats_kpp_compute_shared_secret); +EXPORT_SYMBOL_GPL(crypto_stats_rng_generate); +EXPORT_SYMBOL_GPL(crypto_stats_rng_seed); +EXPORT_SYMBOL_GPL(crypto_stats_skcipher_encrypt); +EXPORT_SYMBOL_GPL(crypto_stats_skcipher_decrypt); + static int __init crypto_algapi_init(void) { crypto_init_proc(); diff --git a/crypto/rng.c b/crypto/rng.c index 2406501b90b7..33c38a72bff5 100644 --- 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 f79918196811..a3e766dff917 100644 --- 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 99afd78c665d..b7b8d24cf765 100644 --- 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 97056fd5e718..d564e701654f 100644 --- 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 52920bed05ba..3b31c1b349ae 100644 --- 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 bd5103a80919..1a97e1601422 100644 --- 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 bdcaac34e9d7..e7c97b946fee 100644 --- 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 dff54731ddf4..480f8301a47d 100644 --- 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 b109b50906e7..7af63cb9c815 100644 --- a/include/linux/crypto.h +++ b/include/linux/crypto.h @@ -557,6 +557,27 @@ struct crypto_alg { } CRYPTO_MINALIGN_ATTR; +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); + /* * A helper struct for waiting for completion of async crypto ops */ @@ -975,38 +996,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 +1011,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 +1036,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; }

[v4,06/11] crypto: crypto_user_stat: fix use_after_free of struct xxx_request

Commit Message

Comments

Patch