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
  66 static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
  67 {
  68         return !(walk->entrylen | walk->total);
  69 }
  70
  71 int crypto_register_ahash(struct ahash_alg *alg);
  72 void crypto_unregister_ahash(struct ahash_alg *alg);
  73 int crypto_register_ahashes(struct ahash_alg *algs, int count);
  74 void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
  75 int ahash_register_instance(struct crypto_template *tmpl,
  76                             struct ahash_instance *inst);
  77
  78 int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
  79                     unsigned int keylen);
  80
  81 static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
  82 {
  83         return alg->setkey != shash_no_setkey;
  84 }
  85
  86 static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg)
  87 {
  88         return crypto_shash_alg_has_setkey(alg) &&
  89                 !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY);
  90 }
  91
  92 bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);
  93
  94 int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
  95                       struct crypto_instance *inst,
  96                       const char *name, u32 type, u32 mask);
  97
  98 static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
  99 {
 100         crypto_drop_spawn(&spawn->base);
 101 }
 102
 103 static inline struct hash_alg_common *crypto_spawn_ahash_alg(
 104         struct crypto_ahash_spawn *spawn)
 105 {
 106         return __crypto_hash_alg_common(spawn->base.alg);
 107 }
 108
 109 int crypto_register_shash(struct shash_alg *alg);
 110 void crypto_unregister_shash(struct shash_alg *alg);
 111 int crypto_register_shashes(struct shash_alg *algs, int count);
 112 void crypto_unregister_shashes(struct shash_alg *algs, int count);
 113 int shash_register_instance(struct crypto_template *tmpl,
 114                             struct shash_instance *inst);
 115 void shash_free_singlespawn_instance(struct shash_instance *inst);
 116
 117 int crypto_grab_shash(struct crypto_shash_spawn *spawn,
 118                       struct crypto_instance *inst,
 119                       const char *name, u32 type, u32 mask);
 120
 121 static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
 122 {
 123         crypto_drop_spawn(&spawn->base);
 124 }
 125
 126 static inline struct shash_alg *crypto_spawn_shash_alg(
 127         struct crypto_shash_spawn *spawn)
 128 {
 129         return __crypto_shash_alg(spawn->base.alg);
 130 }
 131
 132 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
 133 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
 134 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
 135
 136 static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
 137 {
 138         return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
 139 }
 140
 141 static inline void *crypto_ahash_ctx_dma(struct crypto_ahash *tfm)
 142 {
 143         return crypto_tfm_ctx_dma(crypto_ahash_tfm(tfm));
 144 }
 145
 146 static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
 147 {
 148         return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
 149                             halg);
 150 }
 151
 152 static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash)
 153 {
 154         return container_of(crypto_hash_alg_common(hash), struct ahash_alg,
 155                             halg);
 156 }
 157
 158 static inline void crypto_ahash_set_statesize(struct crypto_ahash *tfm,
 159                                               unsigned int size)
 160 {
 161         tfm->statesize = size;
 162 }
 163
 164 static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
 165                                             unsigned int reqsize)
 166 {
 167         tfm->reqsize = reqsize;
 168 }
 169
 170 static inline void crypto_ahash_set_reqsize_dma(struct crypto_ahash *ahash,
 171                                                 unsigned int reqsize)
 172 {
 173         reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
 174         ahash->reqsize = reqsize;
 175 }
 176
 177 static inline struct crypto_instance *ahash_crypto_instance(
 178         struct ahash_instance *inst)
 179 {
 180         return &inst->s.base;
 181 }
 182
 183 static inline struct ahash_instance *ahash_instance(
 184         struct crypto_instance *inst)
 185 {
 186         return container_of(inst, struct ahash_instance, s.base);
 187 }
 188
 189 static inline struct ahash_instance *ahash_alg_instance(
 190         struct crypto_ahash *ahash)
 191 {
 192         return ahash_instance(crypto_tfm_alg_instance(&ahash->base));
 193 }
 194
 195 static inline void *ahash_instance_ctx(struct ahash_instance *inst)
 196 {
 197         return crypto_instance_ctx(ahash_crypto_instance(inst));
 198 }
 199
 200 static inline void *ahash_request_ctx_dma(struct ahash_request *req)
 201 {
 202         unsigned int align = crypto_dma_align();
 203
 204         if (align <= crypto_tfm_ctx_alignment())
 205                 align = 1;
 206
 207         return PTR_ALIGN(ahash_request_ctx(req), align);
 208 }
 209
 210 static inline void ahash_request_complete(struct ahash_request *req, int err)
 211 {
 212         crypto_request_complete(&req->base, err);
 213 }
 214
 215 static inline u32 ahash_request_flags(struct ahash_request *req)
 216 {
 217         return req->base.flags;
 218 }
 219
 220 static inline struct crypto_ahash *crypto_spawn_ahash(
 221         struct crypto_ahash_spawn *spawn)
 222 {
 223         return crypto_spawn_tfm2(&spawn->base);
 224 }
 225
 226 static inline int ahash_enqueue_request(struct crypto_queue *queue,
 227                                              struct ahash_request *request)
 228 {
 229         return crypto_enqueue_request(queue, &request->base);
 230 }
 231
 232 static inline struct ahash_request *ahash_dequeue_request(
 233         struct crypto_queue *queue)
 234 {
 235         return ahash_request_cast(crypto_dequeue_request(queue));
 236 }
 237
 238 static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
 239 {
 240         return crypto_tfm_ctx(&tfm->base);
 241 }
 242
 243 static inline struct crypto_instance *shash_crypto_instance(
 244         struct shash_instance *inst)
 245 {
 246         return &inst->s.base;
 247 }
 248
 249 static inline struct shash_instance *shash_instance(
 250         struct crypto_instance *inst)
 251 {
 252         return container_of(inst, struct shash_instance, s.base);
 253 }
 254
 255 static inline struct shash_instance *shash_alg_instance(
 256         struct crypto_shash *shash)
 257 {
 258         return shash_instance(crypto_tfm_alg_instance(&shash->base));
 259 }
 260
 261 static inline void *shash_instance_ctx(struct shash_instance *inst)
 262 {
 263         return crypto_instance_ctx(shash_crypto_instance(inst));
 264 }
 265
 266 static inline struct crypto_shash *crypto_spawn_shash(
 267         struct crypto_shash_spawn *spawn)
 268 {
 269         return crypto_spawn_tfm2(&spawn->base);
 270 }
 271
 272 static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
 273 {
 274         return crypto_tfm_ctx_aligned(&tfm->base);
 275 }
 276
 277 static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
 278 {
 279         return container_of(tfm, struct crypto_shash, base);
 280 }
 281
 282 #endif  /* _CRYPTO_INTERNAL_HASH_H */
 283