blob: 80c3e5354711e1fcaf2e7d487ac742bdc0e2cf77 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Loc Ho004a4032008-05-14 20:41:47 +08002/*
3 * Asynchronous Cryptographic Hash operations.
4 *
Eric Biggers4d707a42023-10-22 01:10:55 -07005 * This is the implementation of the ahash (asynchronous hash) API. It differs
6 * from shash (synchronous hash) in that ahash supports asynchronous operations,
7 * and it hashes data from scatterlists instead of virtually addressed buffers.
8 *
9 * The ahash API provides access to both ahash and shash algorithms. The shash
10 * API only provides access to shash algorithms.
Loc Ho004a4032008-05-14 20:41:47 +080011 *
12 * Copyright (c) 2008 Loc Ho <lho@amcc.com>
Loc Ho004a4032008-05-14 20:41:47 +080013 */
14
Herbert Xu20036252008-07-07 22:19:53 +080015#include <crypto/scatterwalk.h>
Herbert Xu42808e52023-02-16 18:35:15 +080016#include <linux/cryptouser.h>
Loc Ho004a4032008-05-14 20:41:47 +080017#include <linux/err.h>
18#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/sched.h>
21#include <linux/slab.h>
22#include <linux/seq_file.h>
Herbert Xu42808e52023-02-16 18:35:15 +080023#include <linux/string.h>
Steffen Klassert6238cba2011-09-27 07:41:07 +020024#include <net/netlink.h>
Loc Ho004a4032008-05-14 20:41:47 +080025
Herbert Xu42808e52023-02-16 18:35:15 +080026#include "hash.h"
Loc Ho004a4032008-05-14 20:41:47 +080027
Herbert Xub64d1432023-09-14 16:28:23 +080028#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
29
Eric Biggers2f1f34c2023-10-22 01:11:00 -070030static inline struct crypto_istat_hash *ahash_get_stat(struct ahash_alg *alg)
Eric Biggersecf889b2023-10-22 01:10:58 -070031{
Eric Biggers2f1f34c2023-10-22 01:11:00 -070032 return hash_get_stat(&alg->halg);
Eric Biggersecf889b2023-10-22 01:10:58 -070033}
34
Eric Biggers2f1f34c2023-10-22 01:11:00 -070035static inline int crypto_ahash_errstat(struct ahash_alg *alg, int err)
Eric Biggersecf889b2023-10-22 01:10:58 -070036{
Eric Biggers2f1f34c2023-10-22 01:11:00 -070037 if (!IS_ENABLED(CONFIG_CRYPTO_STATS))
38 return err;
39
40 if (err && err != -EINPROGRESS && err != -EBUSY)
41 atomic64_inc(&ahash_get_stat(alg)->err_cnt);
42
43 return err;
44}
45
46/*
47 * For an ahash tfm that is using an shash algorithm (instead of an ahash
48 * algorithm), this returns the underlying shash tfm.
49 */
50static inline struct crypto_shash *ahash_to_shash(struct crypto_ahash *tfm)
51{
52 return *(struct crypto_shash **)crypto_ahash_ctx(tfm);
53}
54
55static inline struct shash_desc *prepare_shash_desc(struct ahash_request *req,
56 struct crypto_ahash *tfm)
57{
Eric Biggersecf889b2023-10-22 01:10:58 -070058 struct shash_desc *desc = ahash_request_ctx(req);
59
Eric Biggers2f1f34c2023-10-22 01:11:00 -070060 desc->tfm = ahash_to_shash(tfm);
61 return desc;
Eric Biggersecf889b2023-10-22 01:10:58 -070062}
63
64int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
65{
66 struct crypto_hash_walk walk;
67 int nbytes;
68
69 for (nbytes = crypto_hash_walk_first(req, &walk); nbytes > 0;
70 nbytes = crypto_hash_walk_done(&walk, nbytes))
71 nbytes = crypto_shash_update(desc, walk.data, nbytes);
72
73 return nbytes;
74}
75EXPORT_SYMBOL_GPL(shash_ahash_update);
76
Eric Biggersecf889b2023-10-22 01:10:58 -070077int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
78{
79 struct crypto_hash_walk walk;
80 int nbytes;
81
82 nbytes = crypto_hash_walk_first(req, &walk);
83 if (!nbytes)
84 return crypto_shash_final(desc, req->result);
85
86 do {
87 nbytes = crypto_hash_walk_last(&walk) ?
88 crypto_shash_finup(desc, walk.data, nbytes,
89 req->result) :
90 crypto_shash_update(desc, walk.data, nbytes);
91 nbytes = crypto_hash_walk_done(&walk, nbytes);
92 } while (nbytes > 0);
93
94 return nbytes;
95}
96EXPORT_SYMBOL_GPL(shash_ahash_finup);
97
Eric Biggersecf889b2023-10-22 01:10:58 -070098int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
99{
100 unsigned int nbytes = req->nbytes;
101 struct scatterlist *sg;
102 unsigned int offset;
103 int err;
104
105 if (nbytes &&
106 (sg = req->src, offset = sg->offset,
107 nbytes <= min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
108 void *data;
109
110 data = kmap_local_page(sg_page(sg));
111 err = crypto_shash_digest(desc, data + offset, nbytes,
112 req->result);
113 kunmap_local(data);
114 } else
115 err = crypto_shash_init(desc) ?:
116 shash_ahash_finup(req, desc);
117
118 return err;
119}
120EXPORT_SYMBOL_GPL(shash_ahash_digest);
121
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700122static void crypto_exit_ahash_using_shash(struct crypto_tfm *tfm)
Eric Biggersecf889b2023-10-22 01:10:58 -0700123{
124 struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
125
126 crypto_free_shash(*ctx);
127}
128
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700129static int crypto_init_ahash_using_shash(struct crypto_tfm *tfm)
Eric Biggersecf889b2023-10-22 01:10:58 -0700130{
131 struct crypto_alg *calg = tfm->__crt_alg;
Eric Biggersecf889b2023-10-22 01:10:58 -0700132 struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
133 struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
134 struct crypto_shash *shash;
135
136 if (!crypto_mod_get(calg))
137 return -EAGAIN;
138
139 shash = crypto_create_tfm(calg, &crypto_shash_type);
140 if (IS_ERR(shash)) {
141 crypto_mod_put(calg);
142 return PTR_ERR(shash);
143 }
144
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700145 crt->using_shash = true;
Eric Biggersecf889b2023-10-22 01:10:58 -0700146 *ctx = shash;
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700147 tfm->exit = crypto_exit_ahash_using_shash;
Eric Biggersecf889b2023-10-22 01:10:58 -0700148
149 crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
150 CRYPTO_TFM_NEED_KEY);
Eric Biggersecf889b2023-10-22 01:10:58 -0700151 crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
152
153 return 0;
154}
155
Herbert Xu20036252008-07-07 22:19:53 +0800156static int hash_walk_next(struct crypto_hash_walk *walk)
157{
Herbert Xu20036252008-07-07 22:19:53 +0800158 unsigned int offset = walk->offset;
159 unsigned int nbytes = min(walk->entrylen,
160 ((unsigned int)(PAGE_SIZE)) - offset);
161
Ard Biesheuvelaa969512022-12-13 17:13:10 +0100162 walk->data = kmap_local_page(walk->pg);
Herbert Xu20036252008-07-07 22:19:53 +0800163 walk->data += offset;
Herbert Xu20036252008-07-07 22:19:53 +0800164 walk->entrylen -= nbytes;
165 return nbytes;
166}
167
168static int hash_walk_new_entry(struct crypto_hash_walk *walk)
169{
170 struct scatterlist *sg;
171
172 sg = walk->sg;
Herbert Xu20036252008-07-07 22:19:53 +0800173 walk->offset = sg->offset;
Herbert Xu13f4bb72016-05-04 17:52:56 +0800174 walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
175 walk->offset = offset_in_page(walk->offset);
Herbert Xu20036252008-07-07 22:19:53 +0800176 walk->entrylen = sg->length;
177
178 if (walk->entrylen > walk->total)
179 walk->entrylen = walk->total;
180 walk->total -= walk->entrylen;
181
182 return hash_walk_next(walk);
183}
184
185int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
186{
Herbert Xu20036252008-07-07 22:19:53 +0800187 walk->data -= walk->offset;
188
Ard Biesheuvelaa969512022-12-13 17:13:10 +0100189 kunmap_local(walk->data);
Ira Weiny8afa25a2020-08-10 17:40:15 -0700190 crypto_yield(walk->flags);
Herbert Xu20036252008-07-07 22:19:53 +0800191
192 if (err)
193 return err;
194
Eric Biggers77568e52019-01-31 23:51:41 -0800195 if (walk->entrylen) {
Herbert Xud315a0e2009-05-31 23:09:22 +1000196 walk->offset = 0;
197 walk->pg++;
Herbert Xu20036252008-07-07 22:19:53 +0800198 return hash_walk_next(walk);
Herbert Xud315a0e2009-05-31 23:09:22 +1000199 }
Herbert Xu20036252008-07-07 22:19:53 +0800200
201 if (!walk->total)
202 return 0;
203
Cristian Stoica5be4d4c2015-01-20 10:06:16 +0200204 walk->sg = sg_next(walk->sg);
Herbert Xu20036252008-07-07 22:19:53 +0800205
206 return hash_walk_new_entry(walk);
207}
208EXPORT_SYMBOL_GPL(crypto_hash_walk_done);
209
210int crypto_hash_walk_first(struct ahash_request *req,
211 struct crypto_hash_walk *walk)
212{
213 walk->total = req->nbytes;
214
Tim Chen6d9529c2014-07-10 16:18:08 -0700215 if (!walk->total) {
216 walk->entrylen = 0;
Herbert Xu20036252008-07-07 22:19:53 +0800217 return 0;
Tim Chen6d9529c2014-07-10 16:18:08 -0700218 }
Herbert Xu20036252008-07-07 22:19:53 +0800219
Herbert Xu20036252008-07-07 22:19:53 +0800220 walk->sg = req->src;
Ira Weiny8afa25a2020-08-10 17:40:15 -0700221 walk->flags = req->base.flags;
Herbert Xu20036252008-07-07 22:19:53 +0800222
223 return hash_walk_new_entry(walk);
224}
225EXPORT_SYMBOL_GPL(crypto_hash_walk_first);
226
Eric Biggersba7d7432019-01-06 18:47:42 -0800227static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
228 unsigned int keylen)
229{
230 return -ENOSYS;
231}
232
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700233static void ahash_set_needkey(struct crypto_ahash *tfm, struct ahash_alg *alg)
Eric Biggersba7d7432019-01-06 18:47:42 -0800234{
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700235 if (alg->setkey != ahash_nosetkey &&
236 !(alg->halg.base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
Eric Biggersba7d7432019-01-06 18:47:42 -0800237 crypto_ahash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
238}
239
Herbert Xu66f6ce52009-07-15 12:40:40 +0800240int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
Loc Ho004a4032008-05-14 20:41:47 +0800241 unsigned int keylen)
242{
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700243 if (likely(tfm->using_shash)) {
244 struct crypto_shash *shash = ahash_to_shash(tfm);
245 int err;
Loc Ho004a4032008-05-14 20:41:47 +0800246
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700247 err = crypto_shash_setkey(shash, key, keylen);
248 if (unlikely(err)) {
249 crypto_ahash_set_flags(tfm,
250 crypto_shash_get_flags(shash) &
251 CRYPTO_TFM_NEED_KEY);
252 return err;
253 }
254 } else {
255 struct ahash_alg *alg = crypto_ahash_alg(tfm);
256 int err;
257
258 err = alg->setkey(tfm, key, keylen);
259 if (unlikely(err)) {
260 ahash_set_needkey(tfm, alg);
261 return err;
262 }
Eric Biggersba7d7432019-01-06 18:47:42 -0800263 }
Eric Biggers9fa68f62018-01-03 11:16:27 -0800264 crypto_ahash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
265 return 0;
Loc Ho004a4032008-05-14 20:41:47 +0800266}
Herbert Xu66f6ce52009-07-15 12:40:40 +0800267EXPORT_SYMBOL_GPL(crypto_ahash_setkey);
Loc Ho004a4032008-05-14 20:41:47 +0800268
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700269int crypto_ahash_init(struct ahash_request *req)
270{
271 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
272
273 if (likely(tfm->using_shash))
274 return crypto_shash_init(prepare_shash_desc(req, tfm));
275 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
276 return -ENOKEY;
277 return crypto_ahash_alg(tfm)->init(req);
278}
279EXPORT_SYMBOL_GPL(crypto_ahash_init);
280
Herbert Xud9588042023-02-10 20:20:20 +0800281static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt,
282 bool has_state)
Herbert Xu66f6ce52009-07-15 12:40:40 +0800283{
284 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800285 unsigned int ds = crypto_ahash_digestsize(tfm);
Herbert Xud9588042023-02-10 20:20:20 +0800286 struct ahash_request *subreq;
287 unsigned int subreq_size;
288 unsigned int reqsize;
289 u8 *result;
290 gfp_t gfp;
291 u32 flags;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800292
Herbert Xud9588042023-02-10 20:20:20 +0800293 subreq_size = sizeof(*subreq);
294 reqsize = crypto_ahash_reqsize(tfm);
295 reqsize = ALIGN(reqsize, crypto_tfm_ctx_alignment());
296 subreq_size += reqsize;
297 subreq_size += ds;
Herbert Xud9588042023-02-10 20:20:20 +0800298
299 flags = ahash_request_flags(req);
300 gfp = (flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL : GFP_ATOMIC;
301 subreq = kmalloc(subreq_size, gfp);
302 if (!subreq)
Herbert Xu66f6ce52009-07-15 12:40:40 +0800303 return -ENOMEM;
304
Herbert Xud9588042023-02-10 20:20:20 +0800305 ahash_request_set_tfm(subreq, tfm);
306 ahash_request_set_callback(subreq, flags, cplt, req);
Marek Vasutab6bf4e2014-03-14 02:37:04 +0100307
Herbert Xud9588042023-02-10 20:20:20 +0800308 result = (u8 *)(subreq + 1) + reqsize;
Herbert Xuef0579b2017-04-10 17:27:57 +0800309
Herbert Xud9588042023-02-10 20:20:20 +0800310 ahash_request_set_crypt(subreq, req->src, result, req->nbytes);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800311
Herbert Xud9588042023-02-10 20:20:20 +0800312 if (has_state) {
313 void *state;
314
315 state = kmalloc(crypto_ahash_statesize(tfm), gfp);
316 if (!state) {
317 kfree(subreq);
318 return -ENOMEM;
319 }
320
321 crypto_ahash_export(req, state);
322 crypto_ahash_import(subreq, state);
323 kfree_sensitive(state);
324 }
325
326 req->priv = subreq;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800327
Marek Vasut1ffc9fb2014-03-14 02:37:05 +0100328 return 0;
329}
330
Herbert Xuef0579b2017-04-10 17:27:57 +0800331static void ahash_restore_req(struct ahash_request *req, int err)
Marek Vasut1ffc9fb2014-03-14 02:37:05 +0100332{
Herbert Xud9588042023-02-10 20:20:20 +0800333 struct ahash_request *subreq = req->priv;
Marek Vasut1ffc9fb2014-03-14 02:37:05 +0100334
Herbert Xuef0579b2017-04-10 17:27:57 +0800335 if (!err)
Herbert Xud9588042023-02-10 20:20:20 +0800336 memcpy(req->result, subreq->result,
Herbert Xuef0579b2017-04-10 17:27:57 +0800337 crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
338
Marek Vasut1ffc9fb2014-03-14 02:37:05 +0100339 req->priv = NULL;
340
Herbert Xud9588042023-02-10 20:20:20 +0800341 kfree_sensitive(subreq);
Marek Vasut1ffc9fb2014-03-14 02:37:05 +0100342}
343
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700344int crypto_ahash_update(struct ahash_request *req)
345{
346 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
347 struct ahash_alg *alg;
348
349 if (likely(tfm->using_shash))
350 return shash_ahash_update(req, ahash_request_ctx(req));
351
352 alg = crypto_ahash_alg(tfm);
353 if (IS_ENABLED(CONFIG_CRYPTO_STATS))
354 atomic64_add(req->nbytes, &ahash_get_stat(alg)->hash_tlen);
355 return crypto_ahash_errstat(alg, alg->update(req));
356}
357EXPORT_SYMBOL_GPL(crypto_ahash_update);
358
Herbert Xu66f6ce52009-07-15 12:40:40 +0800359int crypto_ahash_final(struct ahash_request *req)
360{
Corentin Labbef7d76e02018-11-29 14:42:21 +0000361 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700362 struct ahash_alg *alg;
Corentin Labbecac58182018-09-19 10:10:54 +0000363
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700364 if (likely(tfm->using_shash))
365 return crypto_shash_final(ahash_request_ctx(req), req->result);
366
367 alg = crypto_ahash_alg(tfm);
Herbert Xu42808e52023-02-16 18:35:15 +0800368 if (IS_ENABLED(CONFIG_CRYPTO_STATS))
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700369 atomic64_inc(&ahash_get_stat(alg)->hash_cnt);
370 return crypto_ahash_errstat(alg, alg->final(req));
Herbert Xu66f6ce52009-07-15 12:40:40 +0800371}
372EXPORT_SYMBOL_GPL(crypto_ahash_final);
373
374int crypto_ahash_finup(struct ahash_request *req)
375{
Corentin Labbef7d76e02018-11-29 14:42:21 +0000376 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700377 struct ahash_alg *alg;
Corentin Labbecac58182018-09-19 10:10:54 +0000378
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700379 if (likely(tfm->using_shash))
380 return shash_ahash_finup(req, ahash_request_ctx(req));
381
382 alg = crypto_ahash_alg(tfm);
Herbert Xu42808e52023-02-16 18:35:15 +0800383 if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700384 struct crypto_istat_hash *istat = ahash_get_stat(alg);
Herbert Xu42808e52023-02-16 18:35:15 +0800385
386 atomic64_inc(&istat->hash_cnt);
387 atomic64_add(req->nbytes, &istat->hash_tlen);
388 }
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700389 return crypto_ahash_errstat(alg, alg->finup(req));
Herbert Xu66f6ce52009-07-15 12:40:40 +0800390}
391EXPORT_SYMBOL_GPL(crypto_ahash_finup);
392
393int crypto_ahash_digest(struct ahash_request *req)
394{
Eric Biggers9fa68f62018-01-03 11:16:27 -0800395 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700396 struct ahash_alg *alg;
Eric Biggersc6269102023-10-22 01:10:44 -0700397 int err;
Eric Biggers9fa68f62018-01-03 11:16:27 -0800398
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700399 if (likely(tfm->using_shash))
400 return shash_ahash_digest(req, prepare_shash_desc(req, tfm));
401
402 alg = crypto_ahash_alg(tfm);
Herbert Xu42808e52023-02-16 18:35:15 +0800403 if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700404 struct crypto_istat_hash *istat = ahash_get_stat(alg);
Herbert Xu42808e52023-02-16 18:35:15 +0800405
406 atomic64_inc(&istat->hash_cnt);
407 atomic64_add(req->nbytes, &istat->hash_tlen);
408 }
409
Eric Biggers9fa68f62018-01-03 11:16:27 -0800410 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
Eric Biggersc6269102023-10-22 01:10:44 -0700411 err = -ENOKEY;
412 else
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700413 err = alg->digest(req);
Herbert Xu42808e52023-02-16 18:35:15 +0800414
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700415 return crypto_ahash_errstat(alg, err);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800416}
417EXPORT_SYMBOL_GPL(crypto_ahash_digest);
418
Herbert Xu255e48e2023-02-08 13:58:44 +0800419static void ahash_def_finup_done2(void *data, int err)
Herbert Xu66f6ce52009-07-15 12:40:40 +0800420{
Herbert Xu255e48e2023-02-08 13:58:44 +0800421 struct ahash_request *areq = data;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800422
Herbert Xuef0579b2017-04-10 17:27:57 +0800423 if (err == -EINPROGRESS)
424 return;
425
426 ahash_restore_req(areq, err);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800427
Herbert Xud9588042023-02-10 20:20:20 +0800428 ahash_request_complete(areq, err);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800429}
430
431static int ahash_def_finup_finish1(struct ahash_request *req, int err)
432{
Herbert Xud9588042023-02-10 20:20:20 +0800433 struct ahash_request *subreq = req->priv;
434
Herbert Xu66f6ce52009-07-15 12:40:40 +0800435 if (err)
436 goto out;
437
Herbert Xud9588042023-02-10 20:20:20 +0800438 subreq->base.complete = ahash_def_finup_done2;
Herbert Xuef0579b2017-04-10 17:27:57 +0800439
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700440 err = crypto_ahash_alg(crypto_ahash_reqtfm(req))->final(subreq);
Gilad Ben-Yossef4e5b0ad2017-10-18 08:00:36 +0100441 if (err == -EINPROGRESS || err == -EBUSY)
Herbert Xuef0579b2017-04-10 17:27:57 +0800442 return err;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800443
444out:
Herbert Xuef0579b2017-04-10 17:27:57 +0800445 ahash_restore_req(req, err);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800446 return err;
447}
448
Herbert Xu255e48e2023-02-08 13:58:44 +0800449static void ahash_def_finup_done1(void *data, int err)
Herbert Xu66f6ce52009-07-15 12:40:40 +0800450{
Herbert Xu255e48e2023-02-08 13:58:44 +0800451 struct ahash_request *areq = data;
Herbert Xud9588042023-02-10 20:20:20 +0800452 struct ahash_request *subreq;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800453
Herbert Xud9588042023-02-10 20:20:20 +0800454 if (err == -EINPROGRESS)
455 goto out;
Herbert Xuef0579b2017-04-10 17:27:57 +0800456
Herbert Xud9588042023-02-10 20:20:20 +0800457 subreq = areq->priv;
458 subreq->base.flags &= CRYPTO_TFM_REQ_MAY_BACKLOG;
Herbert Xuef0579b2017-04-10 17:27:57 +0800459
Herbert Xu66f6ce52009-07-15 12:40:40 +0800460 err = ahash_def_finup_finish1(areq, err);
Herbert Xud9588042023-02-10 20:20:20 +0800461 if (err == -EINPROGRESS || err == -EBUSY)
Herbert Xuef0579b2017-04-10 17:27:57 +0800462 return;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800463
Herbert Xud9588042023-02-10 20:20:20 +0800464out:
465 ahash_request_complete(areq, err);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800466}
467
468static int ahash_def_finup(struct ahash_request *req)
469{
470 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
Marek Vasutd4a7a0f2014-03-14 02:37:06 +0100471 int err;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800472
Herbert Xud9588042023-02-10 20:20:20 +0800473 err = ahash_save_req(req, ahash_def_finup_done1, true);
Marek Vasutd4a7a0f2014-03-14 02:37:06 +0100474 if (err)
475 return err;
Herbert Xu66f6ce52009-07-15 12:40:40 +0800476
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700477 err = crypto_ahash_alg(tfm)->update(req->priv);
Gilad Ben-Yossef4e5b0ad2017-10-18 08:00:36 +0100478 if (err == -EINPROGRESS || err == -EBUSY)
Herbert Xuef0579b2017-04-10 17:27:57 +0800479 return err;
480
Marek Vasutd4a7a0f2014-03-14 02:37:06 +0100481 return ahash_def_finup_finish1(req, err);
Herbert Xu66f6ce52009-07-15 12:40:40 +0800482}
483
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700484int crypto_ahash_export(struct ahash_request *req, void *out)
485{
486 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
487
488 if (likely(tfm->using_shash))
489 return crypto_shash_export(ahash_request_ctx(req), out);
490 return crypto_ahash_alg(tfm)->export(req, out);
491}
492EXPORT_SYMBOL_GPL(crypto_ahash_export);
493
494int crypto_ahash_import(struct ahash_request *req, const void *in)
495{
496 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
497
498 if (likely(tfm->using_shash))
499 return crypto_shash_import(prepare_shash_desc(req, tfm), in);
500 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
501 return -ENOKEY;
502 return crypto_ahash_alg(tfm)->import(req, in);
503}
504EXPORT_SYMBOL_GPL(crypto_ahash_import);
505
Herbert Xue73d3402020-08-18 18:25:34 +1000506static void crypto_ahash_exit_tfm(struct crypto_tfm *tfm)
507{
508 struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
509 struct ahash_alg *alg = crypto_ahash_alg(hash);
510
511 alg->exit_tfm(hash);
512}
513
Herbert Xu88056ec2009-07-14 12:28:26 +0800514static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
515{
516 struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
517 struct ahash_alg *alg = crypto_ahash_alg(hash);
Herbert Xu88056ec2009-07-14 12:28:26 +0800518
Herbert Xuc7535fb2023-04-20 18:05:16 +0800519 crypto_ahash_set_statesize(hash, alg->halg.statesize);
520
Eric Biggers85b843272023-10-22 01:10:59 -0700521 if (tfm->__crt_alg->cra_type == &crypto_shash_type)
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700522 return crypto_init_ahash_using_shash(tfm);
Herbert Xu88056ec2009-07-14 12:28:26 +0800523
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700524 ahash_set_needkey(hash, alg);
Herbert Xu88056ec2009-07-14 12:28:26 +0800525
Herbert Xue73d3402020-08-18 18:25:34 +1000526 if (alg->exit_tfm)
527 tfm->exit = crypto_ahash_exit_tfm;
528
529 return alg->init_tfm ? alg->init_tfm(hash) : 0;
Herbert Xu88056ec2009-07-14 12:28:26 +0800530}
531
532static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
533{
Eric Biggers85b843272023-10-22 01:10:59 -0700534 if (alg->cra_type == &crypto_shash_type)
Herbert Xu2495cf22016-06-29 18:03:47 +0800535 return sizeof(struct crypto_shash *);
Herbert Xu88056ec2009-07-14 12:28:26 +0800536
Herbert Xu2495cf22016-06-29 18:03:47 +0800537 return crypto_alg_extsize(alg);
Herbert Xu88056ec2009-07-14 12:28:26 +0800538}
539
Eric Biggers48fb3e52020-01-02 20:04:35 -0800540static void crypto_ahash_free_instance(struct crypto_instance *inst)
541{
542 struct ahash_instance *ahash = ahash_instance(inst);
543
Eric Biggers48fb3e52020-01-02 20:04:35 -0800544 ahash->free(ahash);
545}
546
Herbert Xuc0f9e012023-02-16 18:35:28 +0800547static int __maybe_unused crypto_ahash_report(
548 struct sk_buff *skb, struct crypto_alg *alg)
Steffen Klassert6238cba2011-09-27 07:41:07 +0200549{
550 struct crypto_report_hash rhash;
551
Eric Biggers37db69e2018-11-03 14:56:03 -0700552 memset(&rhash, 0, sizeof(rhash));
553
554 strscpy(rhash.type, "ahash", sizeof(rhash.type));
Steffen Klassert6238cba2011-09-27 07:41:07 +0200555
556 rhash.blocksize = alg->cra_blocksize;
557 rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize;
558
Eric Biggers37db69e2018-11-03 14:56:03 -0700559 return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
Steffen Klassert6238cba2011-09-27 07:41:07 +0200560}
561
Loc Ho004a4032008-05-14 20:41:47 +0800562static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
Gideon Israel Dsouzad8c34b92016-12-31 21:26:23 +0530563 __maybe_unused;
Loc Ho004a4032008-05-14 20:41:47 +0800564static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
565{
566 seq_printf(m, "type : ahash\n");
567 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
568 "yes" : "no");
569 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
Herbert Xu88056ec2009-07-14 12:28:26 +0800570 seq_printf(m, "digestsize : %u\n",
571 __crypto_hash_alg_common(alg)->digestsize);
Loc Ho004a4032008-05-14 20:41:47 +0800572}
573
Herbert Xu42808e52023-02-16 18:35:15 +0800574static int __maybe_unused crypto_ahash_report_stat(
575 struct sk_buff *skb, struct crypto_alg *alg)
576{
577 return crypto_hash_report_stat(skb, alg, "ahash");
578}
579
Eric Biggers6d1b41f2020-01-02 19:59:07 -0800580static const struct crypto_type crypto_ahash_type = {
Herbert Xu88056ec2009-07-14 12:28:26 +0800581 .extsize = crypto_ahash_extsize,
582 .init_tfm = crypto_ahash_init_tfm,
Eric Biggers48fb3e52020-01-02 20:04:35 -0800583 .free = crypto_ahash_free_instance,
Loc Ho004a4032008-05-14 20:41:47 +0800584#ifdef CONFIG_PROC_FS
585 .show = crypto_ahash_show,
586#endif
Ondrej Mosnacekb8969a12023-05-02 10:02:33 +0200587#if IS_ENABLED(CONFIG_CRYPTO_USER)
Steffen Klassert6238cba2011-09-27 07:41:07 +0200588 .report = crypto_ahash_report,
Herbert Xuc0f9e012023-02-16 18:35:28 +0800589#endif
Herbert Xu42808e52023-02-16 18:35:15 +0800590#ifdef CONFIG_CRYPTO_STATS
591 .report_stat = crypto_ahash_report_stat,
592#endif
Herbert Xu88056ec2009-07-14 12:28:26 +0800593 .maskclear = ~CRYPTO_ALG_TYPE_MASK,
594 .maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
595 .type = CRYPTO_ALG_TYPE_AHASH,
596 .tfmsize = offsetof(struct crypto_ahash, base),
Loc Ho004a4032008-05-14 20:41:47 +0800597};
Loc Ho004a4032008-05-14 20:41:47 +0800598
Eric Biggers84a9c932020-01-02 19:58:50 -0800599int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
600 struct crypto_instance *inst,
601 const char *name, u32 type, u32 mask)
602{
603 spawn->base.frontend = &crypto_ahash_type;
604 return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
605}
606EXPORT_SYMBOL_GPL(crypto_grab_ahash);
607
Herbert Xu88056ec2009-07-14 12:28:26 +0800608struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
609 u32 mask)
610{
611 return crypto_alloc_tfm(alg_name, &crypto_ahash_type, type, mask);
612}
613EXPORT_SYMBOL_GPL(crypto_alloc_ahash);
614
Herbert Xu8d18e342016-01-23 13:52:40 +0800615int crypto_has_ahash(const char *alg_name, u32 type, u32 mask)
616{
617 return crypto_type_has_alg(alg_name, &crypto_ahash_type, type, mask);
618}
619EXPORT_SYMBOL_GPL(crypto_has_ahash);
620
Herbert Xued3630b2023-04-13 14:24:19 +0800621struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *hash)
622{
623 struct hash_alg_common *halg = crypto_hash_alg_common(hash);
624 struct crypto_tfm *tfm = crypto_ahash_tfm(hash);
625 struct crypto_ahash *nhash;
626 struct ahash_alg *alg;
627 int err;
628
629 if (!crypto_hash_alg_has_setkey(halg)) {
630 tfm = crypto_tfm_get(tfm);
631 if (IS_ERR(tfm))
632 return ERR_CAST(tfm);
633
634 return hash;
635 }
636
637 nhash = crypto_clone_tfm(&crypto_ahash_type, tfm);
638
639 if (IS_ERR(nhash))
640 return nhash;
641
Herbert Xued3630b2023-04-13 14:24:19 +0800642 nhash->reqsize = hash->reqsize;
Herbert Xuc7535fb2023-04-20 18:05:16 +0800643 nhash->statesize = hash->statesize;
Herbert Xued3630b2023-04-13 14:24:19 +0800644
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700645 if (likely(hash->using_shash)) {
646 struct crypto_shash **nctx = crypto_ahash_ctx(nhash);
647 struct crypto_shash *shash;
648
649 shash = crypto_clone_shash(ahash_to_shash(hash));
650 if (IS_ERR(shash)) {
651 err = PTR_ERR(shash);
652 goto out_free_nhash;
653 }
Dmitry Safonov9aedd102023-11-07 02:37:17 +0000654 nhash->using_shash = true;
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700655 *nctx = shash;
656 return nhash;
657 }
Herbert Xued3630b2023-04-13 14:24:19 +0800658
659 err = -ENOSYS;
660 alg = crypto_ahash_alg(hash);
661 if (!alg->clone_tfm)
662 goto out_free_nhash;
663
664 err = alg->clone_tfm(nhash, hash);
665 if (err)
666 goto out_free_nhash;
667
668 return nhash;
669
670out_free_nhash:
671 crypto_free_ahash(nhash);
672 return ERR_PTR(err);
673}
674EXPORT_SYMBOL_GPL(crypto_clone_ahash);
675
Herbert Xu01c2dec2009-07-14 14:06:06 +0800676static int ahash_prepare_alg(struct ahash_alg *alg)
677{
678 struct crypto_alg *base = &alg->halg.base;
Herbert Xu42808e52023-02-16 18:35:15 +0800679 int err;
Herbert Xu01c2dec2009-07-14 14:06:06 +0800680
Herbert Xu42808e52023-02-16 18:35:15 +0800681 if (alg->halg.statesize == 0)
Herbert Xu01c2dec2009-07-14 14:06:06 +0800682 return -EINVAL;
683
Herbert Xu42808e52023-02-16 18:35:15 +0800684 err = hash_prepare_alg(&alg->halg);
685 if (err)
686 return err;
687
Herbert Xu01c2dec2009-07-14 14:06:06 +0800688 base->cra_type = &crypto_ahash_type;
Herbert Xu01c2dec2009-07-14 14:06:06 +0800689 base->cra_flags |= CRYPTO_ALG_TYPE_AHASH;
690
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700691 if (!alg->finup)
692 alg->finup = ahash_def_finup;
693 if (!alg->setkey)
694 alg->setkey = ahash_nosetkey;
695
Herbert Xu01c2dec2009-07-14 14:06:06 +0800696 return 0;
697}
698
699int crypto_register_ahash(struct ahash_alg *alg)
700{
701 struct crypto_alg *base = &alg->halg.base;
702 int err;
703
704 err = ahash_prepare_alg(alg);
705 if (err)
706 return err;
707
708 return crypto_register_alg(base);
709}
710EXPORT_SYMBOL_GPL(crypto_register_ahash);
711
Eric Biggersc6d633a2019-12-15 15:51:19 -0800712void crypto_unregister_ahash(struct ahash_alg *alg)
Herbert Xu01c2dec2009-07-14 14:06:06 +0800713{
Eric Biggersc6d633a2019-12-15 15:51:19 -0800714 crypto_unregister_alg(&alg->halg.base);
Herbert Xu01c2dec2009-07-14 14:06:06 +0800715}
716EXPORT_SYMBOL_GPL(crypto_unregister_ahash);
717
Rabin Vincent6f7473c2017-08-10 14:53:52 +0200718int crypto_register_ahashes(struct ahash_alg *algs, int count)
719{
720 int i, ret;
721
722 for (i = 0; i < count; i++) {
723 ret = crypto_register_ahash(&algs[i]);
724 if (ret)
725 goto err;
726 }
727
728 return 0;
729
730err:
731 for (--i; i >= 0; --i)
732 crypto_unregister_ahash(&algs[i]);
733
734 return ret;
735}
736EXPORT_SYMBOL_GPL(crypto_register_ahashes);
737
738void crypto_unregister_ahashes(struct ahash_alg *algs, int count)
739{
740 int i;
741
742 for (i = count - 1; i >= 0; --i)
743 crypto_unregister_ahash(&algs[i]);
744}
745EXPORT_SYMBOL_GPL(crypto_unregister_ahashes);
746
Herbert Xu01c2dec2009-07-14 14:06:06 +0800747int ahash_register_instance(struct crypto_template *tmpl,
748 struct ahash_instance *inst)
749{
750 int err;
751
Eric Biggersd4fdc2d2020-01-02 20:04:40 -0800752 if (WARN_ON(!inst->free))
753 return -EINVAL;
754
Herbert Xu01c2dec2009-07-14 14:06:06 +0800755 err = ahash_prepare_alg(&inst->alg);
756 if (err)
757 return err;
758
759 return crypto_register_instance(tmpl, ahash_crypto_instance(inst));
760}
761EXPORT_SYMBOL_GPL(ahash_register_instance);
762
Eric Biggerscd6ed772018-01-03 11:16:22 -0800763bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)
764{
765 struct crypto_alg *alg = &halg->base;
766
Eric Biggers85b843272023-10-22 01:10:59 -0700767 if (alg->cra_type == &crypto_shash_type)
Eric Biggerscd6ed772018-01-03 11:16:22 -0800768 return crypto_shash_alg_has_setkey(__crypto_shash_alg(alg));
769
Eric Biggers2f1f34c2023-10-22 01:11:00 -0700770 return __crypto_ahash_alg(alg)->setkey != ahash_nosetkey;
Eric Biggerscd6ed772018-01-03 11:16:22 -0800771}
772EXPORT_SYMBOL_GPL(crypto_hash_alg_has_setkey);
773
Loc Ho004a4032008-05-14 20:41:47 +0800774MODULE_LICENSE("GPL");
775MODULE_DESCRIPTION("Asynchronous cryptographic hash type");