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