12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2004a403cSLoc Ho /*
3004a403cSLoc Ho * Asynchronous Cryptographic Hash operations.
4004a403cSLoc Ho *
5004a403cSLoc Ho * This is the asynchronous version of hash.c with notification of
6004a403cSLoc Ho * completion via a callback.
7004a403cSLoc Ho *
8004a403cSLoc Ho * Copyright (c) 2008 Loc Ho <lho@amcc.com>
9004a403cSLoc Ho */
10004a403cSLoc Ho
1120036252SHerbert Xu #include <crypto/scatterwalk.h>
1242808e5dSHerbert Xu #include <linux/cryptouser.h>
13004a403cSLoc Ho #include <linux/err.h>
14004a403cSLoc Ho #include <linux/kernel.h>
15004a403cSLoc Ho #include <linux/module.h>
16004a403cSLoc Ho #include <linux/sched.h>
17004a403cSLoc Ho #include <linux/slab.h>
18004a403cSLoc Ho #include <linux/seq_file.h>
1942808e5dSHerbert Xu #include <linux/string.h>
206238cbaeSSteffen Klassert #include <net/netlink.h>
21004a403cSLoc Ho
2242808e5dSHerbert Xu #include "hash.h"
23004a403cSLoc Ho
246d1b41fcSEric Biggers static const struct crypto_type crypto_ahash_type;
256d1b41fcSEric Biggers
2666f6ce5eSHerbert Xu struct ahash_request_priv {
2766f6ce5eSHerbert Xu crypto_completion_t complete;
2866f6ce5eSHerbert Xu void *data;
2966f6ce5eSHerbert Xu u8 *result;
30ef0579b6SHerbert Xu u32 flags;
3166f6ce5eSHerbert Xu void *ubuf[] CRYPTO_MINALIGN_ATTR;
3266f6ce5eSHerbert Xu };
3366f6ce5eSHerbert Xu
hash_walk_next(struct crypto_hash_walk * walk)3420036252SHerbert Xu static int hash_walk_next(struct crypto_hash_walk *walk)
3520036252SHerbert Xu {
3620036252SHerbert Xu unsigned int alignmask = walk->alignmask;
3720036252SHerbert Xu unsigned int offset = walk->offset;
3820036252SHerbert Xu unsigned int nbytes = min(walk->entrylen,
3920036252SHerbert Xu ((unsigned int)(PAGE_SIZE)) - offset);
4020036252SHerbert Xu
41aa969515SArd Biesheuvel walk->data = kmap_local_page(walk->pg);
4220036252SHerbert Xu walk->data += offset;
4320036252SHerbert Xu
4423a75eeeSSzilveszter Ördög if (offset & alignmask) {
4523a75eeeSSzilveszter Ördög unsigned int unaligned = alignmask + 1 - (offset & alignmask);
46b516d514SJoshua I. James
4723a75eeeSSzilveszter Ördög if (nbytes > unaligned)
4823a75eeeSSzilveszter Ördög nbytes = unaligned;
4923a75eeeSSzilveszter Ördög }
5020036252SHerbert Xu
5120036252SHerbert Xu walk->entrylen -= nbytes;
5220036252SHerbert Xu return nbytes;
5320036252SHerbert Xu }
5420036252SHerbert Xu
hash_walk_new_entry(struct crypto_hash_walk * walk)5520036252SHerbert Xu static int hash_walk_new_entry(struct crypto_hash_walk *walk)
5620036252SHerbert Xu {
5720036252SHerbert Xu struct scatterlist *sg;
5820036252SHerbert Xu
5920036252SHerbert Xu sg = walk->sg;
6020036252SHerbert Xu walk->offset = sg->offset;
6113f4bb78SHerbert Xu walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
6213f4bb78SHerbert Xu walk->offset = offset_in_page(walk->offset);
6320036252SHerbert Xu walk->entrylen = sg->length;
6420036252SHerbert Xu
6520036252SHerbert Xu if (walk->entrylen > walk->total)
6620036252SHerbert Xu walk->entrylen = walk->total;
6720036252SHerbert Xu walk->total -= walk->entrylen;
6820036252SHerbert Xu
6920036252SHerbert Xu return hash_walk_next(walk);
7020036252SHerbert Xu }
7120036252SHerbert Xu
crypto_hash_walk_done(struct crypto_hash_walk * walk,int err)7220036252SHerbert Xu int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
7320036252SHerbert Xu {
7420036252SHerbert Xu unsigned int alignmask = walk->alignmask;
7520036252SHerbert Xu
7620036252SHerbert Xu walk->data -= walk->offset;
7720036252SHerbert Xu
7877568e53SEric Biggers if (walk->entrylen && (walk->offset & alignmask) && !err) {
7977568e53SEric Biggers unsigned int nbytes;
8020036252SHerbert Xu
8177568e53SEric Biggers walk->offset = ALIGN(walk->offset, alignmask + 1);
8277568e53SEric Biggers nbytes = min(walk->entrylen,
8377568e53SEric Biggers (unsigned int)(PAGE_SIZE - walk->offset));
84900a081fSHerbert Xu if (nbytes) {
8577568e53SEric Biggers walk->entrylen -= nbytes;
86900a081fSHerbert Xu walk->data += walk->offset;
8720036252SHerbert Xu return nbytes;
8820036252SHerbert Xu }
89900a081fSHerbert Xu }
9020036252SHerbert Xu
91aa969515SArd Biesheuvel kunmap_local(walk->data);
9220036252SHerbert Xu crypto_yield(walk->flags);
9320036252SHerbert Xu
9420036252SHerbert Xu if (err)
9520036252SHerbert Xu return err;
9620036252SHerbert Xu
9777568e53SEric Biggers if (walk->entrylen) {
9820036252SHerbert Xu walk->offset = 0;
99d315a0e0SHerbert Xu walk->pg++;
10020036252SHerbert Xu return hash_walk_next(walk);
101d315a0e0SHerbert Xu }
10220036252SHerbert Xu
10320036252SHerbert Xu if (!walk->total)
10420036252SHerbert Xu return 0;
10520036252SHerbert Xu
1065be4d4c9SCristian Stoica walk->sg = sg_next(walk->sg);
10720036252SHerbert Xu
10820036252SHerbert Xu return hash_walk_new_entry(walk);
10920036252SHerbert Xu }
11020036252SHerbert Xu EXPORT_SYMBOL_GPL(crypto_hash_walk_done);
11120036252SHerbert Xu
crypto_hash_walk_first(struct ahash_request * req,struct crypto_hash_walk * walk)11220036252SHerbert Xu int crypto_hash_walk_first(struct ahash_request *req,
11320036252SHerbert Xu struct crypto_hash_walk *walk)
11420036252SHerbert Xu {
11520036252SHerbert Xu walk->total = req->nbytes;
11620036252SHerbert Xu
1176d9529c5STim Chen if (!walk->total) {
1186d9529c5STim Chen walk->entrylen = 0;
11920036252SHerbert Xu return 0;
1206d9529c5STim Chen }
12120036252SHerbert Xu
12220036252SHerbert Xu walk->alignmask = crypto_ahash_alignmask(crypto_ahash_reqtfm(req));
12320036252SHerbert Xu walk->sg = req->src;
1248afa25aaSIra Weiny walk->flags = req->base.flags;
12520036252SHerbert Xu
12620036252SHerbert Xu return hash_walk_new_entry(walk);
12720036252SHerbert Xu }
12820036252SHerbert Xu EXPORT_SYMBOL_GPL(crypto_hash_walk_first);
12920036252SHerbert Xu
ahash_setkey_unaligned(struct crypto_ahash * tfm,const u8 * key,unsigned int keylen)130004a403cSLoc Ho static int ahash_setkey_unaligned(struct crypto_ahash *tfm, const u8 *key,
131004a403cSLoc Ho unsigned int keylen)
132004a403cSLoc Ho {
133004a403cSLoc Ho unsigned long alignmask = crypto_ahash_alignmask(tfm);
134004a403cSLoc Ho int ret;
135004a403cSLoc Ho u8 *buffer, *alignbuffer;
136004a403cSLoc Ho unsigned long absize;
137004a403cSLoc Ho
138004a403cSLoc Ho absize = keylen + alignmask;
139093900c2SHerbert Xu buffer = kmalloc(absize, GFP_KERNEL);
140004a403cSLoc Ho if (!buffer)
141004a403cSLoc Ho return -ENOMEM;
142004a403cSLoc Ho
143004a403cSLoc Ho alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
144004a403cSLoc Ho memcpy(alignbuffer, key, keylen);
145a70c5225SHerbert Xu ret = tfm->setkey(tfm, alignbuffer, keylen);
146453431a5SWaiman Long kfree_sensitive(buffer);
147004a403cSLoc Ho return ret;
148004a403cSLoc Ho }
149004a403cSLoc Ho
ahash_nosetkey(struct crypto_ahash * tfm,const u8 * key,unsigned int keylen)150ba7d7433SEric Biggers static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
151ba7d7433SEric Biggers unsigned int keylen)
152ba7d7433SEric Biggers {
153ba7d7433SEric Biggers return -ENOSYS;
154ba7d7433SEric Biggers }
155ba7d7433SEric Biggers
ahash_set_needkey(struct crypto_ahash * tfm)156ba7d7433SEric Biggers static void ahash_set_needkey(struct crypto_ahash *tfm)
157ba7d7433SEric Biggers {
158ba7d7433SEric Biggers const struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
159ba7d7433SEric Biggers
160ba7d7433SEric Biggers if (tfm->setkey != ahash_nosetkey &&
161ba7d7433SEric Biggers !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
162ba7d7433SEric Biggers crypto_ahash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
163ba7d7433SEric Biggers }
164ba7d7433SEric Biggers
crypto_ahash_setkey(struct crypto_ahash * tfm,const u8 * key,unsigned int keylen)16566f6ce5eSHerbert Xu int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
166004a403cSLoc Ho unsigned int keylen)
167004a403cSLoc Ho {
168004a403cSLoc Ho unsigned long alignmask = crypto_ahash_alignmask(tfm);
1699fa68f62SEric Biggers int err;
170004a403cSLoc Ho
171004a403cSLoc Ho if ((unsigned long)key & alignmask)
1729fa68f62SEric Biggers err = ahash_setkey_unaligned(tfm, key, keylen);
1739fa68f62SEric Biggers else
1749fa68f62SEric Biggers err = tfm->setkey(tfm, key, keylen);
175004a403cSLoc Ho
176ba7d7433SEric Biggers if (unlikely(err)) {
177ba7d7433SEric Biggers ahash_set_needkey(tfm);
1789fa68f62SEric Biggers return err;
179ba7d7433SEric Biggers }
1809fa68f62SEric Biggers
1819fa68f62SEric Biggers crypto_ahash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
1829fa68f62SEric Biggers return 0;
183004a403cSLoc Ho }
18466f6ce5eSHerbert Xu EXPORT_SYMBOL_GPL(crypto_ahash_setkey);
185004a403cSLoc Ho
ahash_save_req(struct ahash_request * req,crypto_completion_t cplt,bool has_state)186d9588045SHerbert Xu static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt,
187d9588045SHerbert Xu bool has_state)
18866f6ce5eSHerbert Xu {
18966f6ce5eSHerbert Xu struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
19066f6ce5eSHerbert Xu unsigned long alignmask = crypto_ahash_alignmask(tfm);
19166f6ce5eSHerbert Xu unsigned int ds = crypto_ahash_digestsize(tfm);
192d9588045SHerbert Xu struct ahash_request *subreq;
193d9588045SHerbert Xu unsigned int subreq_size;
194d9588045SHerbert Xu unsigned int reqsize;
195d9588045SHerbert Xu u8 *result;
196d9588045SHerbert Xu gfp_t gfp;
197d9588045SHerbert Xu u32 flags;
19866f6ce5eSHerbert Xu
199d9588045SHerbert Xu subreq_size = sizeof(*subreq);
200d9588045SHerbert Xu reqsize = crypto_ahash_reqsize(tfm);
201d9588045SHerbert Xu reqsize = ALIGN(reqsize, crypto_tfm_ctx_alignment());
202d9588045SHerbert Xu subreq_size += reqsize;
203d9588045SHerbert Xu subreq_size += ds;
204d9588045SHerbert Xu subreq_size += alignmask & ~(crypto_tfm_ctx_alignment() - 1);
205d9588045SHerbert Xu
206d9588045SHerbert Xu flags = ahash_request_flags(req);
207d9588045SHerbert Xu gfp = (flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL : GFP_ATOMIC;
208d9588045SHerbert Xu subreq = kmalloc(subreq_size, gfp);
209d9588045SHerbert Xu if (!subreq)
21066f6ce5eSHerbert Xu return -ENOMEM;
21166f6ce5eSHerbert Xu
212d9588045SHerbert Xu ahash_request_set_tfm(subreq, tfm);
213d9588045SHerbert Xu ahash_request_set_callback(subreq, flags, cplt, req);
214ab6bf4e5SMarek Vasut
215d9588045SHerbert Xu result = (u8 *)(subreq + 1) + reqsize;
216d9588045SHerbert Xu result = PTR_ALIGN(result, alignmask + 1);
217ef0579b6SHerbert Xu
218d9588045SHerbert Xu ahash_request_set_crypt(subreq, req->src, result, req->nbytes);
21966f6ce5eSHerbert Xu
220d9588045SHerbert Xu if (has_state) {
221d9588045SHerbert Xu void *state;
222d9588045SHerbert Xu
223d9588045SHerbert Xu state = kmalloc(crypto_ahash_statesize(tfm), gfp);
224d9588045SHerbert Xu if (!state) {
225d9588045SHerbert Xu kfree(subreq);
226d9588045SHerbert Xu return -ENOMEM;
227d9588045SHerbert Xu }
228d9588045SHerbert Xu
229d9588045SHerbert Xu crypto_ahash_export(req, state);
230d9588045SHerbert Xu crypto_ahash_import(subreq, state);
231d9588045SHerbert Xu kfree_sensitive(state);
232d9588045SHerbert Xu }
233d9588045SHerbert Xu
234d9588045SHerbert Xu req->priv = subreq;
23566f6ce5eSHerbert Xu
2361ffc9fbdSMarek Vasut return 0;
2371ffc9fbdSMarek Vasut }
2381ffc9fbdSMarek Vasut
ahash_restore_req(struct ahash_request * req,int err)239ef0579b6SHerbert Xu static void ahash_restore_req(struct ahash_request *req, int err)
2401ffc9fbdSMarek Vasut {
241d9588045SHerbert Xu struct ahash_request *subreq = req->priv;
2421ffc9fbdSMarek Vasut
243ef0579b6SHerbert Xu if (!err)
244d9588045SHerbert Xu memcpy(req->result, subreq->result,
245ef0579b6SHerbert Xu crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
246ef0579b6SHerbert Xu
2471ffc9fbdSMarek Vasut req->priv = NULL;
2481ffc9fbdSMarek Vasut
249d9588045SHerbert Xu kfree_sensitive(subreq);
2501ffc9fbdSMarek Vasut }
2511ffc9fbdSMarek Vasut
ahash_op_unaligned_done(void * data,int err)252255e48ebSHerbert Xu static void ahash_op_unaligned_done(void *data, int err)
2531ffc9fbdSMarek Vasut {
254255e48ebSHerbert Xu struct ahash_request *areq = data;
2551ffc9fbdSMarek Vasut
256d9588045SHerbert Xu if (err == -EINPROGRESS)
257d9588045SHerbert Xu goto out;
2581ffc9fbdSMarek Vasut
2591ffc9fbdSMarek Vasut /* First copy req->result into req->priv.result */
260ef0579b6SHerbert Xu ahash_restore_req(areq, err);
2611ffc9fbdSMarek Vasut
262d9588045SHerbert Xu out:
2631ffc9fbdSMarek Vasut /* Complete the ORIGINAL request. */
264d9588045SHerbert Xu ahash_request_complete(areq, err);
2651ffc9fbdSMarek Vasut }
2661ffc9fbdSMarek Vasut
ahash_op_unaligned(struct ahash_request * req,int (* op)(struct ahash_request *),bool has_state)2671ffc9fbdSMarek Vasut static int ahash_op_unaligned(struct ahash_request *req,
268d9588045SHerbert Xu int (*op)(struct ahash_request *),
269d9588045SHerbert Xu bool has_state)
2701ffc9fbdSMarek Vasut {
2711ffc9fbdSMarek Vasut int err;
2721ffc9fbdSMarek Vasut
273d9588045SHerbert Xu err = ahash_save_req(req, ahash_op_unaligned_done, has_state);
2741ffc9fbdSMarek Vasut if (err)
2751ffc9fbdSMarek Vasut return err;
2761ffc9fbdSMarek Vasut
277d9588045SHerbert Xu err = op(req->priv);
2784e5b0ad5SGilad Ben-Yossef if (err == -EINPROGRESS || err == -EBUSY)
279ef0579b6SHerbert Xu return err;
280ef0579b6SHerbert Xu
281ef0579b6SHerbert Xu ahash_restore_req(req, err);
28266f6ce5eSHerbert Xu
28366f6ce5eSHerbert Xu return err;
28466f6ce5eSHerbert Xu }
28566f6ce5eSHerbert Xu
crypto_ahash_op(struct ahash_request * req,int (* op)(struct ahash_request *),bool has_state)28666f6ce5eSHerbert Xu static int crypto_ahash_op(struct ahash_request *req,
287d9588045SHerbert Xu int (*op)(struct ahash_request *),
288d9588045SHerbert Xu bool has_state)
28966f6ce5eSHerbert Xu {
29066f6ce5eSHerbert Xu struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
29166f6ce5eSHerbert Xu unsigned long alignmask = crypto_ahash_alignmask(tfm);
29242808e5dSHerbert Xu int err;
29366f6ce5eSHerbert Xu
29466f6ce5eSHerbert Xu if ((unsigned long)req->result & alignmask)
29542808e5dSHerbert Xu err = ahash_op_unaligned(req, op, has_state);
29642808e5dSHerbert Xu else
29742808e5dSHerbert Xu err = op(req);
29866f6ce5eSHerbert Xu
29942808e5dSHerbert Xu return crypto_hash_errstat(crypto_hash_alg_common(tfm), err);
30066f6ce5eSHerbert Xu }
30166f6ce5eSHerbert Xu
crypto_ahash_final(struct ahash_request * req)30266f6ce5eSHerbert Xu int crypto_ahash_final(struct ahash_request *req)
30366f6ce5eSHerbert Xu {
304f7d76e05SCorentin Labbe struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
30542808e5dSHerbert Xu struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
306cac5818cSCorentin Labbe
30742808e5dSHerbert Xu if (IS_ENABLED(CONFIG_CRYPTO_STATS))
30842808e5dSHerbert Xu atomic64_inc(&hash_get_stat(alg)->hash_cnt);
30942808e5dSHerbert Xu
31042808e5dSHerbert Xu return crypto_ahash_op(req, tfm->final, true);
31166f6ce5eSHerbert Xu }
31266f6ce5eSHerbert Xu EXPORT_SYMBOL_GPL(crypto_ahash_final);
31366f6ce5eSHerbert Xu
crypto_ahash_finup(struct ahash_request * req)31466f6ce5eSHerbert Xu int crypto_ahash_finup(struct ahash_request *req)
31566f6ce5eSHerbert Xu {
316f7d76e05SCorentin Labbe struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
31742808e5dSHerbert Xu struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
318cac5818cSCorentin Labbe
31942808e5dSHerbert Xu if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
32042808e5dSHerbert Xu struct crypto_istat_hash *istat = hash_get_stat(alg);
32142808e5dSHerbert Xu
32242808e5dSHerbert Xu atomic64_inc(&istat->hash_cnt);
32342808e5dSHerbert Xu atomic64_add(req->nbytes, &istat->hash_tlen);
32442808e5dSHerbert Xu }
32542808e5dSHerbert Xu
32642808e5dSHerbert Xu return crypto_ahash_op(req, tfm->finup, true);
32766f6ce5eSHerbert Xu }
32866f6ce5eSHerbert Xu EXPORT_SYMBOL_GPL(crypto_ahash_finup);
32966f6ce5eSHerbert Xu
crypto_ahash_digest(struct ahash_request * req)33066f6ce5eSHerbert Xu int crypto_ahash_digest(struct ahash_request *req)
33166f6ce5eSHerbert Xu {
3329fa68f62SEric Biggers struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
33342808e5dSHerbert Xu struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
3349fa68f62SEric Biggers
33542808e5dSHerbert Xu if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
33642808e5dSHerbert Xu struct crypto_istat_hash *istat = hash_get_stat(alg);
33742808e5dSHerbert Xu
33842808e5dSHerbert Xu atomic64_inc(&istat->hash_cnt);
33942808e5dSHerbert Xu atomic64_add(req->nbytes, &istat->hash_tlen);
34042808e5dSHerbert Xu }
34142808e5dSHerbert Xu
3429fa68f62SEric Biggers if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
34342808e5dSHerbert Xu return crypto_hash_errstat(alg, -ENOKEY);
34442808e5dSHerbert Xu
34542808e5dSHerbert Xu return crypto_ahash_op(req, tfm->digest, false);
34666f6ce5eSHerbert Xu }
34766f6ce5eSHerbert Xu EXPORT_SYMBOL_GPL(crypto_ahash_digest);
34866f6ce5eSHerbert Xu
ahash_def_finup_done2(void * data,int err)349255e48ebSHerbert Xu static void ahash_def_finup_done2(void *data, int err)
35066f6ce5eSHerbert Xu {
351255e48ebSHerbert Xu struct ahash_request *areq = data;
35266f6ce5eSHerbert Xu
353ef0579b6SHerbert Xu if (err == -EINPROGRESS)
354ef0579b6SHerbert Xu return;
355ef0579b6SHerbert Xu
356ef0579b6SHerbert Xu ahash_restore_req(areq, err);
35766f6ce5eSHerbert Xu
358d9588045SHerbert Xu ahash_request_complete(areq, err);
35966f6ce5eSHerbert Xu }
36066f6ce5eSHerbert Xu
ahash_def_finup_finish1(struct ahash_request * req,int err)36166f6ce5eSHerbert Xu static int ahash_def_finup_finish1(struct ahash_request *req, int err)
36266f6ce5eSHerbert Xu {
363d9588045SHerbert Xu struct ahash_request *subreq = req->priv;
364d9588045SHerbert Xu
36566f6ce5eSHerbert Xu if (err)
36666f6ce5eSHerbert Xu goto out;
36766f6ce5eSHerbert Xu
368d9588045SHerbert Xu subreq->base.complete = ahash_def_finup_done2;
369ef0579b6SHerbert Xu
370d9588045SHerbert Xu err = crypto_ahash_reqtfm(req)->final(subreq);
3714e5b0ad5SGilad Ben-Yossef if (err == -EINPROGRESS || err == -EBUSY)
372ef0579b6SHerbert Xu return err;
37366f6ce5eSHerbert Xu
37466f6ce5eSHerbert Xu out:
375ef0579b6SHerbert Xu ahash_restore_req(req, err);
37666f6ce5eSHerbert Xu return err;
37766f6ce5eSHerbert Xu }
37866f6ce5eSHerbert Xu
ahash_def_finup_done1(void * data,int err)379255e48ebSHerbert Xu static void ahash_def_finup_done1(void *data, int err)
38066f6ce5eSHerbert Xu {
381255e48ebSHerbert Xu struct ahash_request *areq = data;
382d9588045SHerbert Xu struct ahash_request *subreq;
38366f6ce5eSHerbert Xu
384d9588045SHerbert Xu if (err == -EINPROGRESS)
385d9588045SHerbert Xu goto out;
386ef0579b6SHerbert Xu
387d9588045SHerbert Xu subreq = areq->priv;
388d9588045SHerbert Xu subreq->base.flags &= CRYPTO_TFM_REQ_MAY_BACKLOG;
389ef0579b6SHerbert Xu
39066f6ce5eSHerbert Xu err = ahash_def_finup_finish1(areq, err);
391d9588045SHerbert Xu if (err == -EINPROGRESS || err == -EBUSY)
392ef0579b6SHerbert Xu return;
39366f6ce5eSHerbert Xu
394d9588045SHerbert Xu out:
395d9588045SHerbert Xu ahash_request_complete(areq, err);
39666f6ce5eSHerbert Xu }
39766f6ce5eSHerbert Xu
ahash_def_finup(struct ahash_request * req)39866f6ce5eSHerbert Xu static int ahash_def_finup(struct ahash_request *req)
39966f6ce5eSHerbert Xu {
40066f6ce5eSHerbert Xu struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
401d4a7a0fbSMarek Vasut int err;
40266f6ce5eSHerbert Xu
403d9588045SHerbert Xu err = ahash_save_req(req, ahash_def_finup_done1, true);
404d4a7a0fbSMarek Vasut if (err)
405d4a7a0fbSMarek Vasut return err;
40666f6ce5eSHerbert Xu
407d9588045SHerbert Xu err = tfm->update(req->priv);
4084e5b0ad5SGilad Ben-Yossef if (err == -EINPROGRESS || err == -EBUSY)
409ef0579b6SHerbert Xu return err;
410ef0579b6SHerbert Xu
411d4a7a0fbSMarek Vasut return ahash_def_finup_finish1(req, err);
41266f6ce5eSHerbert Xu }
41366f6ce5eSHerbert Xu
crypto_ahash_exit_tfm(struct crypto_tfm * tfm)414e73d340dSHerbert Xu static void crypto_ahash_exit_tfm(struct crypto_tfm *tfm)
415e73d340dSHerbert Xu {
416e73d340dSHerbert Xu struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
417e73d340dSHerbert Xu struct ahash_alg *alg = crypto_ahash_alg(hash);
418e73d340dSHerbert Xu
419e73d340dSHerbert Xu alg->exit_tfm(hash);
420e73d340dSHerbert Xu }
421e73d340dSHerbert Xu
crypto_ahash_init_tfm(struct crypto_tfm * tfm)42288056ec3SHerbert Xu static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
42388056ec3SHerbert Xu {
42488056ec3SHerbert Xu struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
42588056ec3SHerbert Xu struct ahash_alg *alg = crypto_ahash_alg(hash);
42688056ec3SHerbert Xu
42766f6ce5eSHerbert Xu hash->setkey = ahash_nosetkey;
42866f6ce5eSHerbert Xu
429*c7535fb2SHerbert Xu crypto_ahash_set_statesize(hash, alg->halg.statesize);
430*c7535fb2SHerbert Xu
43188056ec3SHerbert Xu if (tfm->__crt_alg->cra_type != &crypto_ahash_type)
43288056ec3SHerbert Xu return crypto_init_shash_ops_async(tfm);
43388056ec3SHerbert Xu
43488056ec3SHerbert Xu hash->init = alg->init;
43588056ec3SHerbert Xu hash->update = alg->update;
43688056ec3SHerbert Xu hash->final = alg->final;
43766f6ce5eSHerbert Xu hash->finup = alg->finup ?: ahash_def_finup;
43888056ec3SHerbert Xu hash->digest = alg->digest;
4396f221f7eSKamil Konieczny hash->export = alg->export;
4406f221f7eSKamil Konieczny hash->import = alg->import;
44166f6ce5eSHerbert Xu
442a5596d63SHerbert Xu if (alg->setkey) {
44366f6ce5eSHerbert Xu hash->setkey = alg->setkey;
444ba7d7433SEric Biggers ahash_set_needkey(hash);
445a5596d63SHerbert Xu }
44688056ec3SHerbert Xu
447e73d340dSHerbert Xu if (alg->exit_tfm)
448e73d340dSHerbert Xu tfm->exit = crypto_ahash_exit_tfm;
449e73d340dSHerbert Xu
450e73d340dSHerbert Xu return alg->init_tfm ? alg->init_tfm(hash) : 0;
45188056ec3SHerbert Xu }
45288056ec3SHerbert Xu
crypto_ahash_extsize(struct crypto_alg * alg)45388056ec3SHerbert Xu static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
45488056ec3SHerbert Xu {
4552495cf25SHerbert Xu if (alg->cra_type != &crypto_ahash_type)
45688056ec3SHerbert Xu return sizeof(struct crypto_shash *);
4572495cf25SHerbert Xu
4582495cf25SHerbert Xu return crypto_alg_extsize(alg);
45988056ec3SHerbert Xu }
46088056ec3SHerbert Xu
crypto_ahash_free_instance(struct crypto_instance * inst)46148fb3e57SEric Biggers static void crypto_ahash_free_instance(struct crypto_instance *inst)
46248fb3e57SEric Biggers {
46348fb3e57SEric Biggers struct ahash_instance *ahash = ahash_instance(inst);
46448fb3e57SEric Biggers
46548fb3e57SEric Biggers ahash->free(ahash);
46648fb3e57SEric Biggers }
46748fb3e57SEric Biggers
crypto_ahash_report(struct sk_buff * skb,struct crypto_alg * alg)468c0f9e01dSHerbert Xu static int __maybe_unused crypto_ahash_report(
469c0f9e01dSHerbert Xu struct sk_buff *skb, struct crypto_alg *alg)
4706238cbaeSSteffen Klassert {
4716238cbaeSSteffen Klassert struct crypto_report_hash rhash;
4726238cbaeSSteffen Klassert
47337db69e0SEric Biggers memset(&rhash, 0, sizeof(rhash));
47437db69e0SEric Biggers
47537db69e0SEric Biggers strscpy(rhash.type, "ahash", sizeof(rhash.type));
4766238cbaeSSteffen Klassert
4776238cbaeSSteffen Klassert rhash.blocksize = alg->cra_blocksize;
4786238cbaeSSteffen Klassert rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize;
4796238cbaeSSteffen Klassert
48037db69e0SEric Biggers return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
4816238cbaeSSteffen Klassert }
4826238cbaeSSteffen Klassert
483004a403cSLoc Ho static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
484d8c34b94SGideon Israel Dsouza __maybe_unused;
crypto_ahash_show(struct seq_file * m,struct crypto_alg * alg)485004a403cSLoc Ho static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
486004a403cSLoc Ho {
487004a403cSLoc Ho seq_printf(m, "type : ahash\n");
488004a403cSLoc Ho seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
489004a403cSLoc Ho "yes" : "no");
490004a403cSLoc Ho seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
49188056ec3SHerbert Xu seq_printf(m, "digestsize : %u\n",
49288056ec3SHerbert Xu __crypto_hash_alg_common(alg)->digestsize);
493004a403cSLoc Ho }
494004a403cSLoc Ho
crypto_ahash_report_stat(struct sk_buff * skb,struct crypto_alg * alg)49542808e5dSHerbert Xu static int __maybe_unused crypto_ahash_report_stat(
49642808e5dSHerbert Xu struct sk_buff *skb, struct crypto_alg *alg)
49742808e5dSHerbert Xu {
49842808e5dSHerbert Xu return crypto_hash_report_stat(skb, alg, "ahash");
49942808e5dSHerbert Xu }
50042808e5dSHerbert Xu
5016d1b41fcSEric Biggers static const struct crypto_type crypto_ahash_type = {
50288056ec3SHerbert Xu .extsize = crypto_ahash_extsize,
50388056ec3SHerbert Xu .init_tfm = crypto_ahash_init_tfm,
50448fb3e57SEric Biggers .free = crypto_ahash_free_instance,
505004a403cSLoc Ho #ifdef CONFIG_PROC_FS
506004a403cSLoc Ho .show = crypto_ahash_show,
507004a403cSLoc Ho #endif
508b8969a1bSOndrej Mosnacek #if IS_ENABLED(CONFIG_CRYPTO_USER)
5096238cbaeSSteffen Klassert .report = crypto_ahash_report,
510c0f9e01dSHerbert Xu #endif
51142808e5dSHerbert Xu #ifdef CONFIG_CRYPTO_STATS
51242808e5dSHerbert Xu .report_stat = crypto_ahash_report_stat,
51342808e5dSHerbert Xu #endif
51488056ec3SHerbert Xu .maskclear = ~CRYPTO_ALG_TYPE_MASK,
51588056ec3SHerbert Xu .maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
51688056ec3SHerbert Xu .type = CRYPTO_ALG_TYPE_AHASH,
51788056ec3SHerbert Xu .tfmsize = offsetof(struct crypto_ahash, base),
518004a403cSLoc Ho };
519004a403cSLoc Ho
crypto_grab_ahash(struct crypto_ahash_spawn * spawn,struct crypto_instance * inst,const char * name,u32 type,u32 mask)52084a9c938SEric Biggers int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
52184a9c938SEric Biggers struct crypto_instance *inst,
52284a9c938SEric Biggers const char *name, u32 type, u32 mask)
52384a9c938SEric Biggers {
52484a9c938SEric Biggers spawn->base.frontend = &crypto_ahash_type;
52584a9c938SEric Biggers return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
52684a9c938SEric Biggers }
52784a9c938SEric Biggers EXPORT_SYMBOL_GPL(crypto_grab_ahash);
52884a9c938SEric Biggers
crypto_alloc_ahash(const char * alg_name,u32 type,u32 mask)52988056ec3SHerbert Xu struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
53088056ec3SHerbert Xu u32 mask)
53188056ec3SHerbert Xu {
53288056ec3SHerbert Xu return crypto_alloc_tfm(alg_name, &crypto_ahash_type, type, mask);
53388056ec3SHerbert Xu }
53488056ec3SHerbert Xu EXPORT_SYMBOL_GPL(crypto_alloc_ahash);
53588056ec3SHerbert Xu
crypto_has_ahash(const char * alg_name,u32 type,u32 mask)5368d18e34cSHerbert Xu int crypto_has_ahash(const char *alg_name, u32 type, u32 mask)
5378d18e34cSHerbert Xu {
5388d18e34cSHerbert Xu return crypto_type_has_alg(alg_name, &crypto_ahash_type, type, mask);
5398d18e34cSHerbert Xu }
5408d18e34cSHerbert Xu EXPORT_SYMBOL_GPL(crypto_has_ahash);
5418d18e34cSHerbert Xu
crypto_clone_ahash(struct crypto_ahash * hash)542ed3630b8SHerbert Xu struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *hash)
543ed3630b8SHerbert Xu {
544ed3630b8SHerbert Xu struct hash_alg_common *halg = crypto_hash_alg_common(hash);
545ed3630b8SHerbert Xu struct crypto_tfm *tfm = crypto_ahash_tfm(hash);
546ed3630b8SHerbert Xu struct crypto_ahash *nhash;
547ed3630b8SHerbert Xu struct ahash_alg *alg;
548ed3630b8SHerbert Xu int err;
549ed3630b8SHerbert Xu
550ed3630b8SHerbert Xu if (!crypto_hash_alg_has_setkey(halg)) {
551ed3630b8SHerbert Xu tfm = crypto_tfm_get(tfm);
552ed3630b8SHerbert Xu if (IS_ERR(tfm))
553ed3630b8SHerbert Xu return ERR_CAST(tfm);
554ed3630b8SHerbert Xu
555ed3630b8SHerbert Xu return hash;
556ed3630b8SHerbert Xu }
557ed3630b8SHerbert Xu
558ed3630b8SHerbert Xu nhash = crypto_clone_tfm(&crypto_ahash_type, tfm);
559ed3630b8SHerbert Xu
560ed3630b8SHerbert Xu if (IS_ERR(nhash))
561ed3630b8SHerbert Xu return nhash;
562ed3630b8SHerbert Xu
563ed3630b8SHerbert Xu nhash->init = hash->init;
564ed3630b8SHerbert Xu nhash->update = hash->update;
565ed3630b8SHerbert Xu nhash->final = hash->final;
566ed3630b8SHerbert Xu nhash->finup = hash->finup;
567ed3630b8SHerbert Xu nhash->digest = hash->digest;
568ed3630b8SHerbert Xu nhash->export = hash->export;
569ed3630b8SHerbert Xu nhash->import = hash->import;
570ed3630b8SHerbert Xu nhash->setkey = hash->setkey;
571ed3630b8SHerbert Xu nhash->reqsize = hash->reqsize;
572*c7535fb2SHerbert Xu nhash->statesize = hash->statesize;
573ed3630b8SHerbert Xu
574ed3630b8SHerbert Xu if (tfm->__crt_alg->cra_type != &crypto_ahash_type)
575ed3630b8SHerbert Xu return crypto_clone_shash_ops_async(nhash, hash);
576ed3630b8SHerbert Xu
577ed3630b8SHerbert Xu err = -ENOSYS;
578ed3630b8SHerbert Xu alg = crypto_ahash_alg(hash);
579ed3630b8SHerbert Xu if (!alg->clone_tfm)
580ed3630b8SHerbert Xu goto out_free_nhash;
581ed3630b8SHerbert Xu
582ed3630b8SHerbert Xu err = alg->clone_tfm(nhash, hash);
583ed3630b8SHerbert Xu if (err)
584ed3630b8SHerbert Xu goto out_free_nhash;
585ed3630b8SHerbert Xu
586ed3630b8SHerbert Xu return nhash;
587ed3630b8SHerbert Xu
588ed3630b8SHerbert Xu out_free_nhash:
589ed3630b8SHerbert Xu crypto_free_ahash(nhash);
590ed3630b8SHerbert Xu return ERR_PTR(err);
591ed3630b8SHerbert Xu }
592ed3630b8SHerbert Xu EXPORT_SYMBOL_GPL(crypto_clone_ahash);
593ed3630b8SHerbert Xu
ahash_prepare_alg(struct ahash_alg * alg)59401c2deceSHerbert Xu static int ahash_prepare_alg(struct ahash_alg *alg)
59501c2deceSHerbert Xu {
59601c2deceSHerbert Xu struct crypto_alg *base = &alg->halg.base;
59742808e5dSHerbert Xu int err;
59801c2deceSHerbert Xu
59942808e5dSHerbert Xu if (alg->halg.statesize == 0)
60001c2deceSHerbert Xu return -EINVAL;
60101c2deceSHerbert Xu
60242808e5dSHerbert Xu err = hash_prepare_alg(&alg->halg);
60342808e5dSHerbert Xu if (err)
60442808e5dSHerbert Xu return err;
60542808e5dSHerbert Xu
60601c2deceSHerbert Xu base->cra_type = &crypto_ahash_type;
60701c2deceSHerbert Xu base->cra_flags |= CRYPTO_ALG_TYPE_AHASH;
60801c2deceSHerbert Xu
60901c2deceSHerbert Xu return 0;
61001c2deceSHerbert Xu }
61101c2deceSHerbert Xu
crypto_register_ahash(struct ahash_alg * alg)61201c2deceSHerbert Xu int crypto_register_ahash(struct ahash_alg *alg)
61301c2deceSHerbert Xu {
61401c2deceSHerbert Xu struct crypto_alg *base = &alg->halg.base;
61501c2deceSHerbert Xu int err;
61601c2deceSHerbert Xu
61701c2deceSHerbert Xu err = ahash_prepare_alg(alg);
61801c2deceSHerbert Xu if (err)
61901c2deceSHerbert Xu return err;
62001c2deceSHerbert Xu
62101c2deceSHerbert Xu return crypto_register_alg(base);
62201c2deceSHerbert Xu }
62301c2deceSHerbert Xu EXPORT_SYMBOL_GPL(crypto_register_ahash);
62401c2deceSHerbert Xu
crypto_unregister_ahash(struct ahash_alg * alg)625c6d633a9SEric Biggers void crypto_unregister_ahash(struct ahash_alg *alg)
62601c2deceSHerbert Xu {
627c6d633a9SEric Biggers crypto_unregister_alg(&alg->halg.base);
62801c2deceSHerbert Xu }
62901c2deceSHerbert Xu EXPORT_SYMBOL_GPL(crypto_unregister_ahash);
63001c2deceSHerbert Xu
crypto_register_ahashes(struct ahash_alg * algs,int count)6316f7473c5SRabin Vincent int crypto_register_ahashes(struct ahash_alg *algs, int count)
6326f7473c5SRabin Vincent {
6336f7473c5SRabin Vincent int i, ret;
6346f7473c5SRabin Vincent
6356f7473c5SRabin Vincent for (i = 0; i < count; i++) {
6366f7473c5SRabin Vincent ret = crypto_register_ahash(&algs[i]);
6376f7473c5SRabin Vincent if (ret)
6386f7473c5SRabin Vincent goto err;
6396f7473c5SRabin Vincent }
6406f7473c5SRabin Vincent
6416f7473c5SRabin Vincent return 0;
6426f7473c5SRabin Vincent
6436f7473c5SRabin Vincent err:
6446f7473c5SRabin Vincent for (--i; i >= 0; --i)
6456f7473c5SRabin Vincent crypto_unregister_ahash(&algs[i]);
6466f7473c5SRabin Vincent
6476f7473c5SRabin Vincent return ret;
6486f7473c5SRabin Vincent }
6496f7473c5SRabin Vincent EXPORT_SYMBOL_GPL(crypto_register_ahashes);
6506f7473c5SRabin Vincent
crypto_unregister_ahashes(struct ahash_alg * algs,int count)6516f7473c5SRabin Vincent void crypto_unregister_ahashes(struct ahash_alg *algs, int count)
6526f7473c5SRabin Vincent {
6536f7473c5SRabin Vincent int i;
6546f7473c5SRabin Vincent
6556f7473c5SRabin Vincent for (i = count - 1; i >= 0; --i)
6566f7473c5SRabin Vincent crypto_unregister_ahash(&algs[i]);
6576f7473c5SRabin Vincent }
6586f7473c5SRabin Vincent EXPORT_SYMBOL_GPL(crypto_unregister_ahashes);
6596f7473c5SRabin Vincent
ahash_register_instance(struct crypto_template * tmpl,struct ahash_instance * inst)66001c2deceSHerbert Xu int ahash_register_instance(struct crypto_template *tmpl,
66101c2deceSHerbert Xu struct ahash_instance *inst)
66201c2deceSHerbert Xu {
66301c2deceSHerbert Xu int err;
66401c2deceSHerbert Xu
665d4fdc2dfSEric Biggers if (WARN_ON(!inst->free))
666d4fdc2dfSEric Biggers return -EINVAL;
667d4fdc2dfSEric Biggers
66801c2deceSHerbert Xu err = ahash_prepare_alg(&inst->alg);
66901c2deceSHerbert Xu if (err)
67001c2deceSHerbert Xu return err;
67101c2deceSHerbert Xu
67201c2deceSHerbert Xu return crypto_register_instance(tmpl, ahash_crypto_instance(inst));
67301c2deceSHerbert Xu }
67401c2deceSHerbert Xu EXPORT_SYMBOL_GPL(ahash_register_instance);
67501c2deceSHerbert Xu
crypto_hash_alg_has_setkey(struct hash_alg_common * halg)676cd6ed77aSEric Biggers bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)
677cd6ed77aSEric Biggers {
678cd6ed77aSEric Biggers struct crypto_alg *alg = &halg->base;
679cd6ed77aSEric Biggers
680cd6ed77aSEric Biggers if (alg->cra_type != &crypto_ahash_type)
681cd6ed77aSEric Biggers return crypto_shash_alg_has_setkey(__crypto_shash_alg(alg));
682cd6ed77aSEric Biggers
683cd6ed77aSEric Biggers return __crypto_ahash_alg(alg)->setkey != NULL;
684cd6ed77aSEric Biggers }
685cd6ed77aSEric Biggers EXPORT_SYMBOL_GPL(crypto_hash_alg_has_setkey);
686cd6ed77aSEric Biggers
687004a403cSLoc Ho MODULE_LICENSE("GPL");
688004a403cSLoc Ho MODULE_DESCRIPTION("Asynchronous cryptographic hash type");
689