275 lines · c
1/* SPDX-License-Identifier: GPL-2.0-or-later */2/*3 * Hash algorithms.4 * 5 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>6 */7 8#ifndef _CRYPTO_INTERNAL_HASH_H9#define _CRYPTO_INTERNAL_HASH_H10 11#include <crypto/algapi.h>12#include <crypto/hash.h>13 14struct ahash_request;15struct scatterlist;16 17struct crypto_hash_walk {18 char *data;19 20 unsigned int offset;21 unsigned int flags;22 23 struct page *pg;24 unsigned int entrylen;25 26 unsigned int total;27 struct scatterlist *sg;28};29 30struct ahash_instance {31 void (*free)(struct ahash_instance *inst);32 union {33 struct {34 char head[offsetof(struct ahash_alg, halg.base)];35 struct crypto_instance base;36 } s;37 struct ahash_alg alg;38 };39};40 41struct shash_instance {42 void (*free)(struct shash_instance *inst);43 union {44 struct {45 char head[offsetof(struct shash_alg, base)];46 struct crypto_instance base;47 } s;48 struct shash_alg alg;49 };50};51 52struct crypto_ahash_spawn {53 struct crypto_spawn base;54};55 56struct crypto_shash_spawn {57 struct crypto_spawn base;58};59 60int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);61int crypto_hash_walk_first(struct ahash_request *req,62 struct crypto_hash_walk *walk);63 64static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)65{66 return !(walk->entrylen | walk->total);67}68 69int crypto_register_ahash(struct ahash_alg *alg);70void crypto_unregister_ahash(struct ahash_alg *alg);71int crypto_register_ahashes(struct ahash_alg *algs, int count);72void crypto_unregister_ahashes(struct ahash_alg *algs, int count);73int ahash_register_instance(struct crypto_template *tmpl,74 struct ahash_instance *inst);75 76int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,77 unsigned int keylen);78 79static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)80{81 return alg->setkey != shash_no_setkey;82}83 84static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg)85{86 return crypto_shash_alg_has_setkey(alg) &&87 !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY);88}89 90int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,91 struct crypto_instance *inst,92 const char *name, u32 type, u32 mask);93 94static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)95{96 crypto_drop_spawn(&spawn->base);97}98 99static inline struct hash_alg_common *crypto_spawn_ahash_alg(100 struct crypto_ahash_spawn *spawn)101{102 return __crypto_hash_alg_common(spawn->base.alg);103}104 105int crypto_register_shash(struct shash_alg *alg);106void crypto_unregister_shash(struct shash_alg *alg);107int crypto_register_shashes(struct shash_alg *algs, int count);108void crypto_unregister_shashes(struct shash_alg *algs, int count);109int shash_register_instance(struct crypto_template *tmpl,110 struct shash_instance *inst);111void shash_free_singlespawn_instance(struct shash_instance *inst);112 113int crypto_grab_shash(struct crypto_shash_spawn *spawn,114 struct crypto_instance *inst,115 const char *name, u32 type, u32 mask);116 117static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)118{119 crypto_drop_spawn(&spawn->base);120}121 122static inline struct shash_alg *crypto_spawn_shash_alg(123 struct crypto_shash_spawn *spawn)124{125 return __crypto_shash_alg(spawn->base.alg);126}127 128int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);129int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);130int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);131 132static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)133{134 return crypto_tfm_ctx(crypto_ahash_tfm(tfm));135}136 137static inline void *crypto_ahash_ctx_dma(struct crypto_ahash *tfm)138{139 return crypto_tfm_ctx_dma(crypto_ahash_tfm(tfm));140}141 142static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)143{144 return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,145 halg);146}147 148static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash)149{150 return container_of(crypto_hash_alg_common(hash), struct ahash_alg,151 halg);152}153 154static inline void crypto_ahash_set_statesize(struct crypto_ahash *tfm,155 unsigned int size)156{157 tfm->statesize = size;158}159 160static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,161 unsigned int reqsize)162{163 tfm->reqsize = reqsize;164}165 166static inline void crypto_ahash_set_reqsize_dma(struct crypto_ahash *ahash,167 unsigned int reqsize)168{169 reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);170 ahash->reqsize = reqsize;171}172 173static inline struct crypto_instance *ahash_crypto_instance(174 struct ahash_instance *inst)175{176 return &inst->s.base;177}178 179static inline struct ahash_instance *ahash_instance(180 struct crypto_instance *inst)181{182 return container_of(inst, struct ahash_instance, s.base);183}184 185static inline struct ahash_instance *ahash_alg_instance(186 struct crypto_ahash *ahash)187{188 return ahash_instance(crypto_tfm_alg_instance(&ahash->base));189}190 191static inline void *ahash_instance_ctx(struct ahash_instance *inst)192{193 return crypto_instance_ctx(ahash_crypto_instance(inst));194}195 196static inline void *ahash_request_ctx_dma(struct ahash_request *req)197{198 unsigned int align = crypto_dma_align();199 200 if (align <= crypto_tfm_ctx_alignment())201 align = 1;202 203 return PTR_ALIGN(ahash_request_ctx(req), align);204}205 206static inline void ahash_request_complete(struct ahash_request *req, int err)207{208 crypto_request_complete(&req->base, err);209}210 211static inline u32 ahash_request_flags(struct ahash_request *req)212{213 return req->base.flags;214}215 216static inline struct crypto_ahash *crypto_spawn_ahash(217 struct crypto_ahash_spawn *spawn)218{219 return crypto_spawn_tfm2(&spawn->base);220}221 222static inline int ahash_enqueue_request(struct crypto_queue *queue,223 struct ahash_request *request)224{225 return crypto_enqueue_request(queue, &request->base);226}227 228static inline struct ahash_request *ahash_dequeue_request(229 struct crypto_queue *queue)230{231 return ahash_request_cast(crypto_dequeue_request(queue));232}233 234static inline void *crypto_shash_ctx(struct crypto_shash *tfm)235{236 return crypto_tfm_ctx(&tfm->base);237}238 239static inline struct crypto_instance *shash_crypto_instance(240 struct shash_instance *inst)241{242 return &inst->s.base;243}244 245static inline struct shash_instance *shash_instance(246 struct crypto_instance *inst)247{248 return container_of(inst, struct shash_instance, s.base);249}250 251static inline struct shash_instance *shash_alg_instance(252 struct crypto_shash *shash)253{254 return shash_instance(crypto_tfm_alg_instance(&shash->base));255}256 257static inline void *shash_instance_ctx(struct shash_instance *inst)258{259 return crypto_instance_ctx(shash_crypto_instance(inst));260}261 262static inline struct crypto_shash *crypto_spawn_shash(263 struct crypto_shash_spawn *spawn)264{265 return crypto_spawn_tfm2(&spawn->base);266}267 268static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)269{270 return container_of(tfm, struct crypto_shash, base);271}272 273#endif /* _CRYPTO_INTERNAL_HASH_H */274 275