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