include/crypto/internal/hash.h

   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_H
   9 #define _CRYPTO_INTERNAL_HASH_H
  10
  11 #include <crypto/algapi.h>
  12 #include <crypto/hash.h>
  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
  32 struct ahash_instance {
  33         struct ahash_alg alg;
  34 };
  35
  36 struct shash_instance {
  37         struct shash_alg alg;
  38 };
  39
  40 struct crypto_ahash_spawn {
  41         struct crypto_spawn base;
  42 };
  43
  44 struct crypto_shash_spawn {
  45         struct crypto_spawn base;
  46 };
  47
  48 extern const struct crypto_type crypto_ahash_type;
  49
  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);
  53 int crypto_ahash_walk_first(struct ahash_request *req,
  54                            struct crypto_hash_walk *walk);
  55
  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
  62 static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
  63 {
  64         return !(walk->entrylen | walk->total);
  65 }
  66
  67 static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
  68 {
  69         return crypto_hash_walk_last(walk);
  70 }
  71
  72 int crypto_register_ahash(struct ahash_alg *alg);
  73 int crypto_unregister_ahash(struct ahash_alg *alg);
  74 int crypto_register_ahashes(struct ahash_alg *algs, int count);
  75 void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
  76 int ahash_register_instance(struct crypto_template *tmpl,
  77                             struct ahash_instance *inst);
  78 void ahash_free_instance(struct crypto_instance *inst);
  79
  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
  88 bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);
  89
  90 int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
  91                             struct hash_alg_common *alg,
  92                             struct crypto_instance *inst);
  93
  94 static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
  95 {
  96         crypto_drop_spawn(&spawn->base);
  97 }
  98
  99 struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
 100
 101 int crypto_register_shash(struct shash_alg *alg);
 102 int crypto_unregister_shash(struct shash_alg *alg);
 103 int crypto_register_shashes(struct shash_alg *algs, int count);
 104 int crypto_unregister_shashes(struct shash_alg *algs, int count);
 105 int shash_register_instance(struct crypto_template *tmpl,
 106                             struct shash_instance *inst);
 107 void shash_free_instance(struct crypto_instance *inst);
 108
 109 int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
 110                             struct shash_alg *alg,
 111                             struct crypto_instance *inst);
 112
 113 static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
 114 {
 115         crypto_drop_spawn(&spawn->base);
 116 }
 117
 118 struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
 119
 120 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
 121 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
 122 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
 123
 124 int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
 125
 126 static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
 127 {
 128         return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
 129 }
 130
 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
 137 static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
 138                                             unsigned int reqsize)
 139 {
 140         tfm->reqsize = reqsize;
 141 }
 142
 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 {
 168         return crypto_alloc_instance(name, alg, ahash_instance_headroom());
 169 }
 170
 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
 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
 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
 199 static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
 200                                           struct crypto_ahash *tfm)
 201 {
 202         return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
 203 }
 204
 205 static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
 206 {
 207         return crypto_tfm_ctx(&tfm->base);
 208 }
 209
 210 static inline struct crypto_instance *shash_crypto_instance(
 211         struct shash_instance *inst)
 212 {
 213         return container_of(&inst->alg.base, struct crypto_instance, alg);
 214 }
 215
 216 static inline struct shash_instance *shash_instance(
 217         struct crypto_instance *inst)
 218 {
 219         return container_of(__crypto_shash_alg(&inst->alg),
 220                             struct shash_instance, alg);
 221 }
 222
 223 static inline void *shash_instance_ctx(struct shash_instance *inst)
 224 {
 225         return crypto_instance_ctx(shash_crypto_instance(inst));
 226 }
 227
 228 static inline struct shash_instance *shash_alloc_instance(
 229         const char *name, struct crypto_alg *alg)
 230 {
 231         return crypto_alloc_instance(name, alg,
 232                                      sizeof(struct shash_alg) - sizeof(*alg));
 233 }
 234
 235 static inline struct crypto_shash *crypto_spawn_shash(
 236         struct crypto_shash_spawn *spawn)
 237 {
 238         return crypto_spawn_tfm2(&spawn->base);
 239 }
 240
 241 static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
 242 {
 243         return crypto_tfm_ctx_aligned(&tfm->base);
 244 }
 245
 246 static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
 247 {
 248         return container_of(tfm, struct crypto_shash, base);
 249 }
 250
 251 #endif  /* _CRYPTO_INTERNAL_HASH_H */
 252