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         void (*free)(struct ahash_instance *inst);
  34         union {
  35                 struct {
  36                         char head[offsetof(struct ahash_alg, halg.base)];
  37                         struct crypto_instance base;
  38                 } s;
  39                 struct ahash_alg alg;
  40         };
  41 };
  42
  43 struct shash_instance {
  44         void (*free)(struct shash_instance *inst);
  45         union {
  46                 struct {
  47                         char head[offsetof(struct shash_alg, base)];
  48                         struct crypto_instance base;
  49                 } s;
  50                 struct shash_alg alg;
  51         };
  52 };
  53
  54 struct crypto_ahash_spawn {
  55         struct crypto_spawn base;
  56 };
  57
  58 struct crypto_shash_spawn {
  59         struct crypto_spawn base;
  60 };
  61
  62 int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
  63 int crypto_hash_walk_first(struct ahash_request *req,
  64                            struct crypto_hash_walk *walk);
  65 int crypto_ahash_walk_first(struct ahash_request *req,
  66                            struct crypto_hash_walk *walk);
  67
  68 static inline int crypto_ahash_walk_done(struct crypto_hash_walk *walk,
  69                                          int err)
  70 {
  71         return crypto_hash_walk_done(walk, err);
  72 }
  73
  74 static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
  75 {
  76         return !(walk->entrylen | walk->total);
  77 }
  78
  79 static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
  80 {
  81         return crypto_hash_walk_last(walk);
  82 }
  83
  84 int crypto_register_ahash(struct ahash_alg *alg);
  85 void crypto_unregister_ahash(struct ahash_alg *alg);
  86 int crypto_register_ahashes(struct ahash_alg *algs, int count);
  87 void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
  88 int ahash_register_instance(struct crypto_template *tmpl,
  89                             struct ahash_instance *inst);
  90
  91 int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
  92                     unsigned int keylen);
  93
  94 static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
  95 {
  96         return alg->setkey != shash_no_setkey;
  97 }
  98
  99 static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg)
 100 {
 101         return crypto_shash_alg_has_setkey(alg) &&
 102                 !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY);
 103 }
 104
 105 bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);
 106
 107 int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
 108                       struct crypto_instance *inst,
 109                       const char *name, u32 type, u32 mask);
 110
 111 static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
 112 {
 113         crypto_drop_spawn(&spawn->base);
 114 }
 115
 116 static inline struct hash_alg_common *crypto_spawn_ahash_alg(
 117         struct crypto_ahash_spawn *spawn)
 118 {
 119         return __crypto_hash_alg_common(spawn->base.alg);
 120 }
 121
 122 int crypto_register_shash(struct shash_alg *alg);
 123 void crypto_unregister_shash(struct shash_alg *alg);
 124 int crypto_register_shashes(struct shash_alg *algs, int count);
 125 void crypto_unregister_shashes(struct shash_alg *algs, int count);
 126 int shash_register_instance(struct crypto_template *tmpl,
 127                             struct shash_instance *inst);
 128 void shash_free_singlespawn_instance(struct shash_instance *inst);
 129
 130 int crypto_grab_shash(struct crypto_shash_spawn *spawn,
 131                       struct crypto_instance *inst,
 132                       const char *name, u32 type, u32 mask);
 133
 134 static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
 135 {
 136         crypto_drop_spawn(&spawn->base);
 137 }
 138
 139 static inline struct shash_alg *crypto_spawn_shash_alg(
 140         struct crypto_shash_spawn *spawn)
 141 {
 142         return __crypto_shash_alg(spawn->base.alg);
 143 }
 144
 145 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
 146 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
 147 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
 148
 149 int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
 150
 151 static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
 152 {
 153         return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
 154 }
 155
 156 static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
 157 {
 158         return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
 159                             halg);
 160 }
 161
 162 static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
 163                                             unsigned int reqsize)
 164 {
 165         tfm->reqsize = reqsize;
 166 }
 167
 168 static inline struct crypto_instance *ahash_crypto_instance(
 169         struct ahash_instance *inst)
 170 {
 171         return &inst->s.base;
 172 }
 173
 174 static inline struct ahash_instance *ahash_instance(
 175         struct crypto_instance *inst)
 176 {
 177         return container_of(inst, struct ahash_instance, s.base);
 178 }
 179
 180 static inline void *ahash_instance_ctx(struct ahash_instance *inst)
 181 {
 182         return crypto_instance_ctx(ahash_crypto_instance(inst));
 183 }
 184
 185 static inline void ahash_request_complete(struct ahash_request *req, int err)
 186 {
 187         req->base.complete(&req->base, err);
 188 }
 189
 190 static inline u32 ahash_request_flags(struct ahash_request *req)
 191 {
 192         return req->base.flags;
 193 }
 194
 195 static inline struct crypto_ahash *crypto_spawn_ahash(
 196         struct crypto_ahash_spawn *spawn)
 197 {
 198         return crypto_spawn_tfm2(&spawn->base);
 199 }
 200
 201 static inline int ahash_enqueue_request(struct crypto_queue *queue,
 202                                              struct ahash_request *request)
 203 {
 204         return crypto_enqueue_request(queue, &request->base);
 205 }
 206
 207 static inline struct ahash_request *ahash_dequeue_request(
 208         struct crypto_queue *queue)
 209 {
 210         return ahash_request_cast(crypto_dequeue_request(queue));
 211 }
 212
 213 static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
 214 {
 215         return crypto_tfm_ctx(&tfm->base);
 216 }
 217
 218 static inline struct crypto_instance *shash_crypto_instance(
 219         struct shash_instance *inst)
 220 {
 221         return &inst->s.base;
 222 }
 223
 224 static inline struct shash_instance *shash_instance(
 225         struct crypto_instance *inst)
 226 {
 227         return container_of(inst, struct shash_instance, s.base);
 228 }
 229
 230 static inline struct shash_instance *shash_alg_instance(
 231         struct crypto_shash *shash)
 232 {
 233         return shash_instance(crypto_tfm_alg_instance(&shash->base));
 234 }
 235
 236 static inline void *shash_instance_ctx(struct shash_instance *inst)
 237 {
 238         return crypto_instance_ctx(shash_crypto_instance(inst));
 239 }
 240
 241 static inline struct crypto_shash *crypto_spawn_shash(
 242         struct crypto_shash_spawn *spawn)
 243 {
 244         return crypto_spawn_tfm2(&spawn->base);
 245 }
 246
 247 static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
 248 {
 249         return crypto_tfm_ctx_aligned(&tfm->base);
 250 }
 251
 252 static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
 253 {
 254         return container_of(tfm, struct crypto_shash, base);
 255 }
 256
 257 #endif  /* _CRYPTO_INTERNAL_HASH_H */
 258