1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Synchronous Cryptographic Hash operations.
4 *
5 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
6 */
7
8#include <crypto/scatterwalk.h>
9#include <linux/cryptouser.h>
10#include <linux/err.h>
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <linux/seq_file.h>
14#include <linux/string.h>
15#include <net/netlink.h>
16
17#include "hash.h"
18
19static inline struct crypto_istat_hash *shash_get_stat(struct shash_alg *alg)
20{
21 return hash_get_stat(alg: &alg->halg);
22}
23
24static inline int crypto_shash_errstat(struct shash_alg *alg, int err)
25{
26 if (!IS_ENABLED(CONFIG_CRYPTO_STATS))
27 return err;
28
29 if (err && err != -EINPROGRESS && err != -EBUSY)
30 atomic64_inc(v: &shash_get_stat(alg)->err_cnt);
31
32 return err;
33}
34
35int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
36 unsigned int keylen)
37{
38 return -ENOSYS;
39}
40EXPORT_SYMBOL_GPL(shash_no_setkey);
41
42static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
43{
44 if (crypto_shash_alg_needs_key(alg))
45 crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
46}
47
48int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
49 unsigned int keylen)
50{
51 struct shash_alg *shash = crypto_shash_alg(tfm);
52 int err;
53
54 err = shash->setkey(tfm, key, keylen);
55 if (unlikely(err)) {
56 shash_set_needkey(tfm, alg: shash);
57 return err;
58 }
59
60 crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
61 return 0;
62}
63EXPORT_SYMBOL_GPL(crypto_shash_setkey);
64
65int crypto_shash_update(struct shash_desc *desc, const u8 *data,
66 unsigned int len)
67{
68 struct shash_alg *shash = crypto_shash_alg(tfm: desc->tfm);
69 int err;
70
71 if (IS_ENABLED(CONFIG_CRYPTO_STATS))
72 atomic64_add(i: len, v: &shash_get_stat(alg: shash)->hash_tlen);
73
74 err = shash->update(desc, data, len);
75
76 return crypto_shash_errstat(alg: shash, err);
77}
78EXPORT_SYMBOL_GPL(crypto_shash_update);
79
80int crypto_shash_final(struct shash_desc *desc, u8 *out)
81{
82 struct shash_alg *shash = crypto_shash_alg(tfm: desc->tfm);
83 int err;
84
85 if (IS_ENABLED(CONFIG_CRYPTO_STATS))
86 atomic64_inc(v: &shash_get_stat(alg: shash)->hash_cnt);
87
88 err = shash->final(desc, out);
89
90 return crypto_shash_errstat(alg: shash, err);
91}
92EXPORT_SYMBOL_GPL(crypto_shash_final);
93
94static int shash_default_finup(struct shash_desc *desc, const u8 *data,
95 unsigned int len, u8 *out)
96{
97 struct shash_alg *shash = crypto_shash_alg(tfm: desc->tfm);
98
99 return shash->update(desc, data, len) ?:
100 shash->final(desc, out);
101}
102
103int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
104 unsigned int len, u8 *out)
105{
106 struct crypto_shash *tfm = desc->tfm;
107 struct shash_alg *shash = crypto_shash_alg(tfm);
108 int err;
109
110 if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
111 struct crypto_istat_hash *istat = shash_get_stat(alg: shash);
112
113 atomic64_inc(v: &istat->hash_cnt);
114 atomic64_add(i: len, v: &istat->hash_tlen);
115 }
116
117 err = shash->finup(desc, data, len, out);
118
119 return crypto_shash_errstat(alg: shash, err);
120}
121EXPORT_SYMBOL_GPL(crypto_shash_finup);
122
123static int shash_default_digest(struct shash_desc *desc, const u8 *data,
124 unsigned int len, u8 *out)
125{
126 struct shash_alg *shash = crypto_shash_alg(tfm: desc->tfm);
127
128 return shash->init(desc) ?:
129 shash->finup(desc, data, len, out);
130}
131
132int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
133 unsigned int len, u8 *out)
134{
135 struct crypto_shash *tfm = desc->tfm;
136 struct shash_alg *shash = crypto_shash_alg(tfm);
137 int err;
138
139 if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
140 struct crypto_istat_hash *istat = shash_get_stat(alg: shash);
141
142 atomic64_inc(v: &istat->hash_cnt);
143 atomic64_add(i: len, v: &istat->hash_tlen);
144 }
145
146 if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
147 err = -ENOKEY;
148 else
149 err = shash->digest(desc, data, len, out);
150
151 return crypto_shash_errstat(alg: shash, err);
152}
153EXPORT_SYMBOL_GPL(crypto_shash_digest);
154
155int crypto_shash_tfm_digest(struct crypto_shash *tfm, const u8 *data,
156 unsigned int len, u8 *out)
157{
158 SHASH_DESC_ON_STACK(desc, tfm);
159 int err;
160
161 desc->tfm = tfm;
162
163 err = crypto_shash_digest(desc, data, len, out);
164
165 shash_desc_zero(desc);
166
167 return err;
168}
169EXPORT_SYMBOL_GPL(crypto_shash_tfm_digest);
170
171int crypto_shash_export(struct shash_desc *desc, void *out)
172{
173 struct crypto_shash *tfm = desc->tfm;
174 struct shash_alg *shash = crypto_shash_alg(tfm);
175
176 if (shash->export)
177 return shash->export(desc, out);
178
179 memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(tfm));
180 return 0;
181}
182EXPORT_SYMBOL_GPL(crypto_shash_export);
183
184int crypto_shash_import(struct shash_desc *desc, const void *in)
185{
186 struct crypto_shash *tfm = desc->tfm;
187 struct shash_alg *shash = crypto_shash_alg(tfm);
188
189 if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
190 return -ENOKEY;
191
192 if (shash->import)
193 return shash->import(desc, in);
194
195 memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(tfm));
196 return 0;
197}
198EXPORT_SYMBOL_GPL(crypto_shash_import);
199
200static void crypto_shash_exit_tfm(struct crypto_tfm *tfm)
201{
202 struct crypto_shash *hash = __crypto_shash_cast(tfm);
203 struct shash_alg *alg = crypto_shash_alg(tfm: hash);
204
205 alg->exit_tfm(hash);
206}
207
208static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
209{
210 struct crypto_shash *hash = __crypto_shash_cast(tfm);
211 struct shash_alg *alg = crypto_shash_alg(tfm: hash);
212 int err;
213
214 hash->descsize = alg->descsize;
215
216 shash_set_needkey(tfm: hash, alg);
217
218 if (alg->exit_tfm)
219 tfm->exit = crypto_shash_exit_tfm;
220
221 if (!alg->init_tfm)
222 return 0;
223
224 err = alg->init_tfm(hash);
225 if (err)
226 return err;
227
228 /* ->init_tfm() may have increased the descsize. */
229 if (WARN_ON_ONCE(hash->descsize > HASH_MAX_DESCSIZE)) {
230 if (alg->exit_tfm)
231 alg->exit_tfm(hash);
232 return -EINVAL;
233 }
234
235 return 0;
236}
237
238static void crypto_shash_free_instance(struct crypto_instance *inst)
239{
240 struct shash_instance *shash = shash_instance(inst);
241
242 shash->free(shash);
243}
244
245static int __maybe_unused crypto_shash_report(
246 struct sk_buff *skb, struct crypto_alg *alg)
247{
248 struct crypto_report_hash rhash;
249 struct shash_alg *salg = __crypto_shash_alg(alg);
250
251 memset(&rhash, 0, sizeof(rhash));
252
253 strscpy(p: rhash.type, q: "shash", size: sizeof(rhash.type));
254
255 rhash.blocksize = alg->cra_blocksize;
256 rhash.digestsize = salg->digestsize;
257
258 return nla_put(skb, attrtype: CRYPTOCFGA_REPORT_HASH, attrlen: sizeof(rhash), data: &rhash);
259}
260
261static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
262 __maybe_unused;
263static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
264{
265 struct shash_alg *salg = __crypto_shash_alg(alg);
266
267 seq_printf(m, fmt: "type : shash\n");
268 seq_printf(m, fmt: "blocksize : %u\n", alg->cra_blocksize);
269 seq_printf(m, fmt: "digestsize : %u\n", salg->digestsize);
270}
271
272static int __maybe_unused crypto_shash_report_stat(
273 struct sk_buff *skb, struct crypto_alg *alg)
274{
275 return crypto_hash_report_stat(skb, alg, type: "shash");
276}
277
278const struct crypto_type crypto_shash_type = {
279 .extsize = crypto_alg_extsize,
280 .init_tfm = crypto_shash_init_tfm,
281 .free = crypto_shash_free_instance,
282#ifdef CONFIG_PROC_FS
283 .show = crypto_shash_show,
284#endif
285#if IS_ENABLED(CONFIG_CRYPTO_USER)
286 .report = crypto_shash_report,
287#endif
288#ifdef CONFIG_CRYPTO_STATS
289 .report_stat = crypto_shash_report_stat,
290#endif
291 .maskclear = ~CRYPTO_ALG_TYPE_MASK,
292 .maskset = CRYPTO_ALG_TYPE_MASK,
293 .type = CRYPTO_ALG_TYPE_SHASH,
294 .tfmsize = offsetof(struct crypto_shash, base),
295};
296
297int crypto_grab_shash(struct crypto_shash_spawn *spawn,
298 struct crypto_instance *inst,
299 const char *name, u32 type, u32 mask)
300{
301 spawn->base.frontend = &crypto_shash_type;
302 return crypto_grab_spawn(spawn: &spawn->base, inst, name, type, mask);
303}
304EXPORT_SYMBOL_GPL(crypto_grab_shash);
305
306struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
307 u32 mask)
308{
309 return crypto_alloc_tfm(alg_name, frontend: &crypto_shash_type, type, mask);
310}
311EXPORT_SYMBOL_GPL(crypto_alloc_shash);
312
313int crypto_has_shash(const char *alg_name, u32 type, u32 mask)
314{
315 return crypto_type_has_alg(name: alg_name, frontend: &crypto_shash_type, type, mask);
316}
317EXPORT_SYMBOL_GPL(crypto_has_shash);
318
319struct crypto_shash *crypto_clone_shash(struct crypto_shash *hash)
320{
321 struct crypto_tfm *tfm = crypto_shash_tfm(tfm: hash);
322 struct shash_alg *alg = crypto_shash_alg(tfm: hash);
323 struct crypto_shash *nhash;
324 int err;
325
326 if (!crypto_shash_alg_has_setkey(alg)) {
327 tfm = crypto_tfm_get(tfm);
328 if (IS_ERR(ptr: tfm))
329 return ERR_CAST(ptr: tfm);
330
331 return hash;
332 }
333
334 if (!alg->clone_tfm && (alg->init_tfm || alg->base.cra_init))
335 return ERR_PTR(error: -ENOSYS);
336
337 nhash = crypto_clone_tfm(frontend: &crypto_shash_type, otfm: tfm);
338 if (IS_ERR(ptr: nhash))
339 return nhash;
340
341 nhash->descsize = hash->descsize;
342
343 if (alg->clone_tfm) {
344 err = alg->clone_tfm(nhash, hash);
345 if (err) {
346 crypto_free_shash(tfm: nhash);
347 return ERR_PTR(error: err);
348 }
349 }
350
351 return nhash;
352}
353EXPORT_SYMBOL_GPL(crypto_clone_shash);
354
355int hash_prepare_alg(struct hash_alg_common *alg)
356{
357 struct crypto_istat_hash *istat = hash_get_stat(alg);
358 struct crypto_alg *base = &alg->base;
359
360 if (alg->digestsize > HASH_MAX_DIGESTSIZE)
361 return -EINVAL;
362
363 /* alignmask is not useful for hashes, so it is not supported. */
364 if (base->cra_alignmask)
365 return -EINVAL;
366
367 base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
368
369 if (IS_ENABLED(CONFIG_CRYPTO_STATS))
370 memset(istat, 0, sizeof(*istat));
371
372 return 0;
373}
374
375static int shash_prepare_alg(struct shash_alg *alg)
376{
377 struct crypto_alg *base = &alg->halg.base;
378 int err;
379
380 if (alg->descsize > HASH_MAX_DESCSIZE)
381 return -EINVAL;
382
383 if ((alg->export && !alg->import) || (alg->import && !alg->export))
384 return -EINVAL;
385
386 err = hash_prepare_alg(alg: &alg->halg);
387 if (err)
388 return err;
389
390 base->cra_type = &crypto_shash_type;
391 base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
392
393 /*
394 * Handle missing optional functions. For each one we can either
395 * install a default here, or we can leave the pointer as NULL and check
396 * the pointer for NULL in crypto_shash_*(), avoiding an indirect call
397 * when the default behavior is desired. For ->finup and ->digest we
398 * install defaults, since for optimal performance algorithms should
399 * implement these anyway. On the other hand, for ->import and
400 * ->export the common case and best performance comes from the simple
401 * memcpy of the shash_desc_ctx, so when those pointers are NULL we
402 * leave them NULL and provide the memcpy with no indirect call.
403 */
404 if (!alg->finup)
405 alg->finup = shash_default_finup;
406 if (!alg->digest)
407 alg->digest = shash_default_digest;
408 if (!alg->export)
409 alg->halg.statesize = alg->descsize;
410 if (!alg->setkey)
411 alg->setkey = shash_no_setkey;
412
413 return 0;
414}
415
416int crypto_register_shash(struct shash_alg *alg)
417{
418 struct crypto_alg *base = &alg->base;
419 int err;
420
421 err = shash_prepare_alg(alg);
422 if (err)
423 return err;
424
425 return crypto_register_alg(alg: base);
426}
427EXPORT_SYMBOL_GPL(crypto_register_shash);
428
429void crypto_unregister_shash(struct shash_alg *alg)
430{
431 crypto_unregister_alg(alg: &alg->base);
432}
433EXPORT_SYMBOL_GPL(crypto_unregister_shash);
434
435int crypto_register_shashes(struct shash_alg *algs, int count)
436{
437 int i, ret;
438
439 for (i = 0; i < count; i++) {
440 ret = crypto_register_shash(&algs[i]);
441 if (ret)
442 goto err;
443 }
444
445 return 0;
446
447err:
448 for (--i; i >= 0; --i)
449 crypto_unregister_shash(&algs[i]);
450
451 return ret;
452}
453EXPORT_SYMBOL_GPL(crypto_register_shashes);
454
455void crypto_unregister_shashes(struct shash_alg *algs, int count)
456{
457 int i;
458
459 for (i = count - 1; i >= 0; --i)
460 crypto_unregister_shash(&algs[i]);
461}
462EXPORT_SYMBOL_GPL(crypto_unregister_shashes);
463
464int shash_register_instance(struct crypto_template *tmpl,
465 struct shash_instance *inst)
466{
467 int err;
468
469 if (WARN_ON(!inst->free))
470 return -EINVAL;
471
472 err = shash_prepare_alg(alg: &inst->alg);
473 if (err)
474 return err;
475
476 return crypto_register_instance(tmpl, inst: shash_crypto_instance(inst));
477}
478EXPORT_SYMBOL_GPL(shash_register_instance);
479
480void shash_free_singlespawn_instance(struct shash_instance *inst)
481{
482 crypto_drop_spawn(spawn: shash_instance_ctx(inst));
483 kfree(objp: inst);
484}
485EXPORT_SYMBOL_GPL(shash_free_singlespawn_instance);
486
487MODULE_LICENSE("GPL");
488MODULE_DESCRIPTION("Synchronous cryptographic hash type");
489

source code of linux/crypto/shash.c