[linux-block.git] / crypto / shash.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Synchronous Cryptographic Hash operations.
 *
 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
 */

#include <crypto/scatterwalk.h>
#include <linux/cryptouser.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <net/netlink.h>

#include "hash.h"

static inline struct crypto_istat_hash *shash_get_stat(struct shash_alg *alg)
{
	return hash_get_stat(&alg->halg);
}

static inline int crypto_shash_errstat(struct shash_alg *alg, int err)
{
	if (IS_ENABLED(CONFIG_CRYPTO_STATS) && err)
		atomic64_inc(&shash_get_stat(alg)->err_cnt);
	return err;
}

int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
		    unsigned int keylen)
{
	return -ENOSYS;
}
EXPORT_SYMBOL_GPL(shash_no_setkey);

static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
{
	if (crypto_shash_alg_needs_key(alg))
		crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
}

int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
			unsigned int keylen)
{
	struct shash_alg *shash = crypto_shash_alg(tfm);
	int err;

	err = shash->setkey(tfm, key, keylen);
	if (unlikely(err)) {
		shash_set_needkey(tfm, shash);
		return err;
	}

	crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
	return 0;
}
EXPORT_SYMBOL_GPL(crypto_shash_setkey);

int crypto_shash_update(struct shash_desc *desc, const u8 *data,
			unsigned int len)
{
	struct shash_alg *shash = crypto_shash_alg(desc->tfm);
	int err;

	if (IS_ENABLED(CONFIG_CRYPTO_STATS))
		atomic64_add(len, &shash_get_stat(shash)->hash_tlen);

	err = shash->update(desc, data, len);

	return crypto_shash_errstat(shash, err);
}
EXPORT_SYMBOL_GPL(crypto_shash_update);

int crypto_shash_final(struct shash_desc *desc, u8 *out)
{
	struct shash_alg *shash = crypto_shash_alg(desc->tfm);
	int err;

	if (IS_ENABLED(CONFIG_CRYPTO_STATS))
		atomic64_inc(&shash_get_stat(shash)->hash_cnt);

	err = shash->final(desc, out);

	return crypto_shash_errstat(shash, err);
}
EXPORT_SYMBOL_GPL(crypto_shash_final);

static int shash_default_finup(struct shash_desc *desc, const u8 *data,
			       unsigned int len, u8 *out)
{
	struct shash_alg *shash = crypto_shash_alg(desc->tfm);

	return shash->update(desc, data, len) ?:
	       shash->final(desc, out);
}

int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
		       unsigned int len, u8 *out)
{
	struct crypto_shash *tfm = desc->tfm;
	struct shash_alg *shash = crypto_shash_alg(tfm);
	int err;

	if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
		struct crypto_istat_hash *istat = shash_get_stat(shash);

		atomic64_inc(&istat->hash_cnt);
		atomic64_add(len, &istat->hash_tlen);
	}

	err = shash->finup(desc, data, len, out);

	return crypto_shash_errstat(shash, err);
}
EXPORT_SYMBOL_GPL(crypto_shash_finup);

static int shash_default_digest(struct shash_desc *desc, const u8 *data,
				unsigned int len, u8 *out)
{
	struct shash_alg *shash = crypto_shash_alg(desc->tfm);

	return shash->init(desc) ?:
	       shash->finup(desc, data, len, out);
}

int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
			unsigned int len, u8 *out)
{
	struct crypto_shash *tfm = desc->tfm;
	struct shash_alg *shash = crypto_shash_alg(tfm);
	int err;

	if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
		struct crypto_istat_hash *istat = shash_get_stat(shash);

		atomic64_inc(&istat->hash_cnt);
		atomic64_add(len, &istat->hash_tlen);
	}

	if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
		err = -ENOKEY;
	else
		err = shash->digest(desc, data, len, out);

	return crypto_shash_errstat(shash, err);
}
EXPORT_SYMBOL_GPL(crypto_shash_digest);

int crypto_shash_tfm_digest(struct crypto_shash *tfm, const u8 *data,
			    unsigned int len, u8 *out)
{
	SHASH_DESC_ON_STACK(desc, tfm);
	int err;

	desc->tfm = tfm;

	err = crypto_shash_digest(desc, data, len, out);

	shash_desc_zero(desc);

	return err;
}
EXPORT_SYMBOL_GPL(crypto_shash_tfm_digest);

int crypto_shash_export(struct shash_desc *desc, void *out)
{
	struct crypto_shash *tfm = desc->tfm;
	struct shash_alg *shash = crypto_shash_alg(tfm);

	if (shash->export)
		return shash->export(desc, out);

	memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(tfm));
	return 0;
}
EXPORT_SYMBOL_GPL(crypto_shash_export);

int crypto_shash_import(struct shash_desc *desc, const void *in)
{
	struct crypto_shash *tfm = desc->tfm;
	struct shash_alg *shash = crypto_shash_alg(tfm);

	if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
		return -ENOKEY;

	if (shash->import)
		return shash->import(desc, in);

	memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(tfm));
	return 0;
}
EXPORT_SYMBOL_GPL(crypto_shash_import);

static void crypto_shash_exit_tfm(struct crypto_tfm *tfm)
{
	struct crypto_shash *hash = __crypto_shash_cast(tfm);
	struct shash_alg *alg = crypto_shash_alg(hash);

	alg->exit_tfm(hash);
}

static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
{
	struct crypto_shash *hash = __crypto_shash_cast(tfm);
	struct shash_alg *alg = crypto_shash_alg(hash);
	int err;

	hash->descsize = alg->descsize;

	shash_set_needkey(hash, alg);

	if (alg->exit_tfm)
		tfm->exit = crypto_shash_exit_tfm;

	if (!alg->init_tfm)
		return 0;

	err = alg->init_tfm(hash);
	if (err)
		return err;

	/* ->init_tfm() may have increased the descsize. */
	if (WARN_ON_ONCE(hash->descsize > HASH_MAX_DESCSIZE)) {
		if (alg->exit_tfm)
			alg->exit_tfm(hash);
		return -EINVAL;
	}

	return 0;
}

static void crypto_shash_free_instance(struct crypto_instance *inst)
{
	struct shash_instance *shash = shash_instance(inst);

	shash->free(shash);
}

static int __maybe_unused crypto_shash_report(
	struct sk_buff *skb, struct crypto_alg *alg)
{
	struct crypto_report_hash rhash;
	struct shash_alg *salg = __crypto_shash_alg(alg);

	memset(&rhash, 0, sizeof(rhash));

	strscpy(rhash.type, "shash", sizeof(rhash.type));

	rhash.blocksize = alg->cra_blocksize;
	rhash.digestsize = salg->digestsize;

	return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
}

static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
	__maybe_unused;
static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
{
	struct shash_alg *salg = __crypto_shash_alg(alg);

	seq_printf(m, "type         : shash\n");
	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
	seq_printf(m, "digestsize   : %u\n", salg->digestsize);
}

static int __maybe_unused crypto_shash_report_stat(
	struct sk_buff *skb, struct crypto_alg *alg)
{
	return crypto_hash_report_stat(skb, alg, "shash");
}

const struct crypto_type crypto_shash_type = {
	.extsize = crypto_alg_extsize,
	.init_tfm = crypto_shash_init_tfm,
	.free = crypto_shash_free_instance,
#ifdef CONFIG_PROC_FS
	.show = crypto_shash_show,
#endif
#if IS_ENABLED(CONFIG_CRYPTO_USER)
	.report = crypto_shash_report,
#endif
#ifdef CONFIG_CRYPTO_STATS
	.report_stat = crypto_shash_report_stat,
#endif
	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	.maskset = CRYPTO_ALG_TYPE_MASK,
	.type = CRYPTO_ALG_TYPE_SHASH,
	.tfmsize = offsetof(struct crypto_shash, base),
};

int crypto_grab_shash(struct crypto_shash_spawn *spawn,
		      struct crypto_instance *inst,
		      const char *name, u32 type, u32 mask)
{
	spawn->base.frontend = &crypto_shash_type;
	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_grab_shash);

struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
					u32 mask)
{
	return crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_alloc_shash);

int crypto_has_shash(const char *alg_name, u32 type, u32 mask)
{
	return crypto_type_has_alg(alg_name, &crypto_shash_type, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_has_shash);

struct crypto_shash *crypto_clone_shash(struct crypto_shash *hash)
{
	struct crypto_tfm *tfm = crypto_shash_tfm(hash);
	struct shash_alg *alg = crypto_shash_alg(hash);
	struct crypto_shash *nhash;
	int err;

	if (!crypto_shash_alg_has_setkey(alg)) {
		tfm = crypto_tfm_get(tfm);
		if (IS_ERR(tfm))
			return ERR_CAST(tfm);

		return hash;
	}

	if (!alg->clone_tfm && (alg->init_tfm || alg->base.cra_init))
		return ERR_PTR(-ENOSYS);

	nhash = crypto_clone_tfm(&crypto_shash_type, tfm);
	if (IS_ERR(nhash))
		return nhash;

	nhash->descsize = hash->descsize;

	if (alg->clone_tfm) {
		err = alg->clone_tfm(nhash, hash);
		if (err) {
			crypto_free_shash(nhash);
			return ERR_PTR(err);
		}
	}

	return nhash;
}
EXPORT_SYMBOL_GPL(crypto_clone_shash);

int hash_prepare_alg(struct hash_alg_common *alg)
{
	struct crypto_istat_hash *istat = hash_get_stat(alg);
	struct crypto_alg *base = &alg->base;

	if (alg->digestsize > HASH_MAX_DIGESTSIZE)
		return -EINVAL;

	/* alignmask is not useful for hashes, so it is not supported. */
	if (base->cra_alignmask)
		return -EINVAL;

	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;

	if (IS_ENABLED(CONFIG_CRYPTO_STATS))
		memset(istat, 0, sizeof(*istat));

	return 0;
}

static int shash_prepare_alg(struct shash_alg *alg)
{
	struct crypto_alg *base = &alg->halg.base;
	int err;

	if (alg->descsize > HASH_MAX_DESCSIZE)
		return -EINVAL;

	if ((alg->export && !alg->import) || (alg->import && !alg->export))
		return -EINVAL;

	err = hash_prepare_alg(&alg->halg);
	if (err)
		return err;

	base->cra_type = &crypto_shash_type;
	base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;

	/*
	 * Handle missing optional functions.  For each one we can either
	 * install a default here, or we can leave the pointer as NULL and check
	 * the pointer for NULL in crypto_shash_*(), avoiding an indirect call
	 * when the default behavior is desired.  For ->finup and ->digest we
	 * install defaults, since for optimal performance algorithms should
	 * implement these anyway.  On the other hand, for ->import and
	 * ->export the common case and best performance comes from the simple
	 * memcpy of the shash_desc_ctx, so when those pointers are NULL we
	 * leave them NULL and provide the memcpy with no indirect call.
	 */
	if (!alg->finup)
		alg->finup = shash_default_finup;
	if (!alg->digest)
		alg->digest = shash_default_digest;
	if (!alg->export)
		alg->halg.statesize = alg->descsize;
	if (!alg->setkey)
		alg->setkey = shash_no_setkey;

	return 0;
}

int crypto_register_shash(struct shash_alg *alg)
{
	struct crypto_alg *base = &alg->base;
	int err;

	err = shash_prepare_alg(alg);
	if (err)
		return err;

	return crypto_register_alg(base);
}
EXPORT_SYMBOL_GPL(crypto_register_shash);

void crypto_unregister_shash(struct shash_alg *alg)
{
	crypto_unregister_alg(&alg->base);
}
EXPORT_SYMBOL_GPL(crypto_unregister_shash);

int crypto_register_shashes(struct shash_alg *algs, int count)
{
	int i, ret;

	for (i = 0; i < count; i++) {
		ret = crypto_register_shash(&algs[i]);
		if (ret)
			goto err;
	}

	return 0;

err:
	for (--i; i >= 0; --i)
		crypto_unregister_shash(&algs[i]);

	return ret;
}
EXPORT_SYMBOL_GPL(crypto_register_shashes);

void crypto_unregister_shashes(struct shash_alg *algs, int count)
{
	int i;

	for (i = count - 1; i >= 0; --i)
		crypto_unregister_shash(&algs[i]);
}
EXPORT_SYMBOL_GPL(crypto_unregister_shashes);

int shash_register_instance(struct crypto_template *tmpl,
			    struct shash_instance *inst)
{
	int err;

	if (WARN_ON(!inst->free))
		return -EINVAL;

	err = shash_prepare_alg(&inst->alg);
	if (err)
		return err;

	return crypto_register_instance(tmpl, shash_crypto_instance(inst));
}
EXPORT_SYMBOL_GPL(shash_register_instance);

void shash_free_singlespawn_instance(struct shash_instance *inst)
{
	crypto_drop_spawn(shash_instance_ctx(inst));
	kfree(inst);
}
EXPORT_SYMBOL_GPL(shash_free_singlespawn_instance);

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