[mirror_ubuntu-focal-kernel.git] / include / crypto / internal / hash.h

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

#ifndef _CRYPTO_INTERNAL_HASH_H
#define _CRYPTO_INTERNAL_HASH_H

#include <crypto/algapi.h>
#include <crypto/hash.h>

struct ahash_request;
struct scatterlist;

struct crypto_hash_walk {
	char *data;

	unsigned int offset;
	unsigned int alignmask;

	struct page *pg;
	unsigned int entrylen;

	unsigned int total;
	struct scatterlist *sg;

	unsigned int flags;
};

struct ahash_instance {
	struct ahash_alg alg;
};

struct shash_instance {
	struct shash_alg alg;
};

struct crypto_ahash_spawn {
	struct crypto_spawn base;
};

struct crypto_shash_spawn {
	struct crypto_spawn base;
};

extern const struct crypto_type crypto_ahash_type;

int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
int crypto_hash_walk_first(struct ahash_request *req,
			   struct crypto_hash_walk *walk);
int crypto_ahash_walk_first(struct ahash_request *req,
			   struct crypto_hash_walk *walk);

static inline int crypto_ahash_walk_done(struct crypto_hash_walk *walk,
					 int err)
{
	return crypto_hash_walk_done(walk, err);
}

static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
{
	return !(walk->entrylen | walk->total);
}

static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
{
	return crypto_hash_walk_last(walk);
}

int crypto_register_ahash(struct ahash_alg *alg);
int crypto_unregister_ahash(struct ahash_alg *alg);
int crypto_register_ahashes(struct ahash_alg *algs, int count);
void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
int ahash_register_instance(struct crypto_template *tmpl,
			    struct ahash_instance *inst);
void ahash_free_instance(struct crypto_instance *inst);

int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
		    unsigned int keylen);

static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
{
	return alg->setkey != shash_no_setkey;
}

bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);

int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
			    struct hash_alg_common *alg,
			    struct crypto_instance *inst);

static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
{
	crypto_drop_spawn(&spawn->base);
}

struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);

int crypto_register_shash(struct shash_alg *alg);
int crypto_unregister_shash(struct shash_alg *alg);
int crypto_register_shashes(struct shash_alg *algs, int count);
int crypto_unregister_shashes(struct shash_alg *algs, int count);
int shash_register_instance(struct crypto_template *tmpl,
			    struct shash_instance *inst);
void shash_free_instance(struct crypto_instance *inst);

int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
			    struct shash_alg *alg,
			    struct crypto_instance *inst);

static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
{
	crypto_drop_spawn(&spawn->base);
}

struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);

int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);

int crypto_init_shash_ops_async(struct crypto_tfm *tfm);

static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
{
	return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
}

static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
{
	return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
			    halg);
}

static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
					    unsigned int reqsize)
{
	tfm->reqsize = reqsize;
}

static inline struct crypto_instance *ahash_crypto_instance(
	struct ahash_instance *inst)
{
	return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
}

static inline struct ahash_instance *ahash_instance(
	struct crypto_instance *inst)
{
	return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
}

static inline void *ahash_instance_ctx(struct ahash_instance *inst)
{
	return crypto_instance_ctx(ahash_crypto_instance(inst));
}

static inline unsigned int ahash_instance_headroom(void)
{
	return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
}

static inline struct ahash_instance *ahash_alloc_instance(
	const char *name, struct crypto_alg *alg)
{
	return crypto_alloc_instance(name, alg, ahash_instance_headroom());
}

static inline void ahash_request_complete(struct ahash_request *req, int err)
{
	req->base.complete(&req->base, err);
}

static inline u32 ahash_request_flags(struct ahash_request *req)
{
	return req->base.flags;
}

static inline struct crypto_ahash *crypto_spawn_ahash(
	struct crypto_ahash_spawn *spawn)
{
	return crypto_spawn_tfm2(&spawn->base);
}

static inline int ahash_enqueue_request(struct crypto_queue *queue,
					     struct ahash_request *request)
{
	return crypto_enqueue_request(queue, &request->base);
}

static inline struct ahash_request *ahash_dequeue_request(
	struct crypto_queue *queue)
{
	return ahash_request_cast(crypto_dequeue_request(queue));
}

static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
{
	return crypto_tfm_ctx(&tfm->base);
}

static inline struct crypto_instance *shash_crypto_instance(
	struct shash_instance *inst)
{
	return container_of(&inst->alg.base, struct crypto_instance, alg);
}

static inline struct shash_instance *shash_instance(
	struct crypto_instance *inst)
{
	return container_of(__crypto_shash_alg(&inst->alg),
			    struct shash_instance, alg);
}

static inline void *shash_instance_ctx(struct shash_instance *inst)
{
	return crypto_instance_ctx(shash_crypto_instance(inst));
}

static inline struct shash_instance *shash_alloc_instance(
	const char *name, struct crypto_alg *alg)
{
	return crypto_alloc_instance(name, alg,
				     sizeof(struct shash_alg) - sizeof(*alg));
}

static inline struct crypto_shash *crypto_spawn_shash(
	struct crypto_shash_spawn *spawn)
{
	return crypto_spawn_tfm2(&spawn->base);
}

static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
{
	return crypto_tfm_ctx_aligned(&tfm->base);
}

static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
{
	return container_of(tfm, struct crypto_shash, base);
}

#endif	/* _CRYPTO_INTERNAL_HASH_H */
Commit	Line	Data
2874c5fd	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
20036252 HX	2	/*
	3	* Hash algorithms.
	4	*
	5	* Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
20036252 HX	6	*/
	7
	8	#ifndef _CRYPTO_INTERNAL_HASH_H
	9	#define _CRYPTO_INTERNAL_HASH_H
	10
	11	#include <crypto/algapi.h>
18e33e6d	12	#include <crypto/hash.h>
20036252 HX	13
	14	struct ahash_request;
	15	struct scatterlist;
	16
	17	struct crypto_hash_walk {
	18	char *data;
	19
	20	unsigned int offset;
	21	unsigned int alignmask;
	22
	23	struct page *pg;
	24	unsigned int entrylen;
	25
	26	unsigned int total;
	27	struct scatterlist *sg;
	28
	29	unsigned int flags;
	30	};
	31
01c2dece HX	32	struct ahash_instance {
	33	struct ahash_alg alg;
	34	};
	35
2e4fddd8 HX	36	struct shash_instance {
	37	struct shash_alg alg;
	38	};
	39
01c2dece HX	40	struct crypto_ahash_spawn {
	41	struct crypto_spawn base;
	42	};
	43
94296999 HX	44	struct crypto_shash_spawn {
	45	struct crypto_spawn base;
	46	};
	47
18e33e6d HX	48	extern const struct crypto_type crypto_ahash_type;
18e33e6d HX	49
20036252 HX	50	int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
	51	int crypto_hash_walk_first(struct ahash_request *req,
	52	struct crypto_hash_walk *walk);
75ecb231 HX	53	int crypto_ahash_walk_first(struct ahash_request *req,
75ecb231 HX	54	struct crypto_hash_walk *walk);
20036252	55
75ecb231 HX	56	static inline int crypto_ahash_walk_done(struct crypto_hash_walk *walk,
	57	int err)
	58	{
	59	return crypto_hash_walk_done(walk, err);
	60	}
	61
66f6ce5e HX	62	static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
	63	{
	64	return !(walk->entrylen \| walk->total);
	65	}
	66
75ecb231 HX	67	static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
	68	{
	69	return crypto_hash_walk_last(walk);
	70	}
	71
88056ec3 HX	72	int crypto_register_ahash(struct ahash_alg *alg);
88056ec3 HX	73	int crypto_unregister_ahash(struct ahash_alg *alg);
6f7473c5 RV	74	int crypto_register_ahashes(struct ahash_alg *algs, int count);
6f7473c5 RV	75	void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
01c2dece HX	76	int ahash_register_instance(struct crypto_template *tmpl,
	77	struct ahash_instance *inst);
	78	void ahash_free_instance(struct crypto_instance *inst);
	79
af3ff804 EB	80	int shash_no_setkey(struct crypto_shash tfm, const u8 key,
	81	unsigned int keylen);
	82
	83	static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
	84	{
	85	return alg->setkey != shash_no_setkey;
	86	}
	87
cd6ed77a EB	88	bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);
cd6ed77a EB	89
01c2dece HX	90	int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
	91	struct hash_alg_common *alg,
	92	struct crypto_instance *inst);
	93
52861c7c HX	94	static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
	95	{
	96	crypto_drop_spawn(&spawn->base);
	97	}
	98
01c2dece	99	struct hash_alg_common ahash_attr_alg(struct rtattr rta, u32 type, u32 mask);
88056ec3	100
7b5a080b HX	101	int crypto_register_shash(struct shash_alg *alg);
7b5a080b HX	102	int crypto_unregister_shash(struct shash_alg *alg);
50fc3e8d JK	103	int crypto_register_shashes(struct shash_alg *algs, int count);
50fc3e8d JK	104	int crypto_unregister_shashes(struct shash_alg *algs, int count);
619a6ebd HX	105	int shash_register_instance(struct crypto_template *tmpl,
619a6ebd HX	106	struct shash_instance *inst);
2e4fddd8 HX	107	void shash_free_instance(struct crypto_instance *inst);
2e4fddd8 HX	108
94296999 HX	109	int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
	110	struct shash_alg *alg,
	111	struct crypto_instance *inst);
	112
52861c7c HX	113	static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
	114	{
	115	crypto_drop_spawn(&spawn->base);
	116	}
	117
7d6f5640 HX	118	struct shash_alg shash_attr_alg(struct rtattr rta, u32 type, u32 mask);
7d6f5640 HX	119
7eddf95e	120	int shash_ahash_update(struct ahash_request req, struct shash_desc desc);
66f6ce5e	121	int shash_ahash_finup(struct ahash_request req, struct shash_desc desc);
7eddf95e	122	int shash_ahash_digest(struct ahash_request req, struct shash_desc desc);
1e65b81a	123
88056ec3 HX	124	int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
88056ec3 HX	125
18e33e6d HX	126	static inline void crypto_ahash_ctx(struct crypto_ahash tfm)
18e33e6d HX	127	{
88056ec3	128	return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
18e33e6d HX	129	}
18e33e6d HX	130
4dc10c01 HX	131	static inline struct ahash_alg __crypto_ahash_alg(struct crypto_alg alg)
	132	{
	133	return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
	134	halg);
	135	}
	136
fc00127f HX	137	static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
	138	unsigned int reqsize)
	139	{
88056ec3	140	tfm->reqsize = reqsize;
fc00127f HX	141	}
fc00127f HX	142
01c2dece HX	143	static inline struct crypto_instance *ahash_crypto_instance(
	144	struct ahash_instance *inst)
	145	{
	146	return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
	147	}
	148
	149	static inline struct ahash_instance *ahash_instance(
	150	struct crypto_instance *inst)
	151	{
	152	return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
	153	}
	154
	155	static inline void ahash_instance_ctx(struct ahash_instance inst)
	156	{
	157	return crypto_instance_ctx(ahash_crypto_instance(inst));
	158	}
	159
	160	static inline unsigned int ahash_instance_headroom(void)
	161	{
	162	return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
	163	}
	164
	165	static inline struct ahash_instance *ahash_alloc_instance(
	166	const char name, struct crypto_alg alg)
	167	{
14aa1a83	168	return crypto_alloc_instance(name, alg, ahash_instance_headroom());
01c2dece HX	169	}
01c2dece HX	170
ef0579b6 HX	171	static inline void ahash_request_complete(struct ahash_request *req, int err)
	172	{
	173	req->base.complete(&req->base, err);
	174	}
	175
	176	static inline u32 ahash_request_flags(struct ahash_request *req)
	177	{
	178	return req->base.flags;
	179	}
	180
01c2dece HX	181	static inline struct crypto_ahash *crypto_spawn_ahash(
	182	struct crypto_ahash_spawn *spawn)
	183	{
	184	return crypto_spawn_tfm2(&spawn->base);
	185	}
	186
18e33e6d HX	187	static inline int ahash_enqueue_request(struct crypto_queue *queue,
	188	struct ahash_request *request)
	189	{
	190	return crypto_enqueue_request(queue, &request->base);
	191	}
	192
	193	static inline struct ahash_request *ahash_dequeue_request(
	194	struct crypto_queue *queue)
	195	{
	196	return ahash_request_cast(crypto_dequeue_request(queue));
	197	}
	198
7b5a080b HX	199	static inline void crypto_shash_ctx(struct crypto_shash tfm)
	200	{
	201	return crypto_tfm_ctx(&tfm->base);
	202	}
	203
2e4fddd8 HX	204	static inline struct crypto_instance *shash_crypto_instance(
	205	struct shash_instance *inst)
	206	{
	207	return container_of(&inst->alg.base, struct crypto_instance, alg);
	208	}
	209
	210	static inline struct shash_instance *shash_instance(
	211	struct crypto_instance *inst)
	212	{
	213	return container_of(__crypto_shash_alg(&inst->alg),
	214	struct shash_instance, alg);
	215	}
	216
ef5d590c HX	217	static inline void shash_instance_ctx(struct shash_instance inst)
	218	{
	219	return crypto_instance_ctx(shash_crypto_instance(inst));
	220	}
	221
2e4fddd8 HX	222	static inline struct shash_instance *shash_alloc_instance(
	223	const char name, struct crypto_alg alg)
	224	{
14aa1a83 EB	225	return crypto_alloc_instance(name, alg,
14aa1a83 EB	226	sizeof(struct shash_alg) - sizeof(*alg));
2e4fddd8 HX	227	}
2e4fddd8 HX	228
94296999 HX	229	static inline struct crypto_shash *crypto_spawn_shash(
	230	struct crypto_shash_spawn *spawn)
	231	{
	232	return crypto_spawn_tfm2(&spawn->base);
	233	}
	234
cde6263f HX	235	static inline void crypto_shash_ctx_aligned(struct crypto_shash tfm)
	236	{
	237	return crypto_tfm_ctx_aligned(&tfm->base);
	238	}
	239
0390e6ae HX	240	static inline struct crypto_shash __crypto_shash_cast(struct crypto_tfm tfm)
0390e6ae HX	241	{
113adefc	242	return container_of(tfm, struct crypto_shash, base);
0390e6ae HX	243	}
0390e6ae HX	244
20036252 HX	245	#endif /* _CRYPTO_INTERNAL_HASH_H */
20036252 HX	246