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 16 struct ahash_instance { 17 void (*free)(struct ahash_instance *inst); 18 union { 19 struct { 20 char head[offsetof(struct ahash_alg, halg.base)]; 21 struct crypto_instance base; 22 } s; 23 struct ahash_alg alg; 24 }; 25 }; 26 27 struct shash_instance { 28 void (*free)(struct shash_instance *inst); 29 union { 30 struct { 31 char head[offsetof(struct shash_alg, base)]; 32 struct crypto_instance base; 33 } s; 34 struct shash_alg alg; 35 }; 36 }; 37 38 struct crypto_ahash_spawn { 39 struct crypto_spawn base; 40 }; 41 42 struct crypto_shash_spawn { 43 struct crypto_spawn base; 44 }; 45 46 int crypto_register_ahash(struct ahash_alg *alg); 47 void crypto_unregister_ahash(struct ahash_alg *alg); 48 int crypto_register_ahashes(struct ahash_alg *algs, int count); 49 void crypto_unregister_ahashes(struct ahash_alg *algs, int count); 50 int ahash_register_instance(struct crypto_template *tmpl, 51 struct ahash_instance *inst); 52 53 int shash_no_setkey(struct crypto_shash *tfm, const u8 *key, 54 unsigned int keylen); 55 56 static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg) 57 { 58 return alg->setkey != shash_no_setkey; 59 } 60 61 static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg) 62 { 63 return crypto_shash_alg_has_setkey(alg) && 64 !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY); 65 } 66 67 int crypto_grab_ahash(struct crypto_ahash_spawn *spawn, 68 struct crypto_instance *inst, 69 const char *name, u32 type, u32 mask); 70 71 static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn) 72 { 73 crypto_drop_spawn(&spawn->base); 74 } 75 76 static inline struct hash_alg_common *crypto_spawn_ahash_alg( 77 struct crypto_ahash_spawn *spawn) 78 { 79 return __crypto_hash_alg_common(spawn->base.alg); 80 } 81 82 int crypto_register_shash(struct shash_alg *alg); 83 void crypto_unregister_shash(struct shash_alg *alg); 84 int crypto_register_shashes(struct shash_alg *algs, int count); 85 void crypto_unregister_shashes(struct shash_alg *algs, int count); 86 int shash_register_instance(struct crypto_template *tmpl, 87 struct shash_instance *inst); 88 void shash_free_singlespawn_instance(struct shash_instance *inst); 89 90 int crypto_grab_shash(struct crypto_shash_spawn *spawn, 91 struct crypto_instance *inst, 92 const char *name, u32 type, u32 mask); 93 94 static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn) 95 { 96 crypto_drop_spawn(&spawn->base); 97 } 98 99 static inline struct shash_alg *crypto_spawn_shash_alg( 100 struct crypto_shash_spawn *spawn) 101 { 102 return __crypto_shash_alg(spawn->base.alg); 103 } 104 105 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc); 106 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc); 107 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc); 108 109 static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm) 110 { 111 return crypto_tfm_ctx(crypto_ahash_tfm(tfm)); 112 } 113 114 static inline void *crypto_ahash_ctx_dma(struct crypto_ahash *tfm) 115 { 116 return crypto_tfm_ctx_dma(crypto_ahash_tfm(tfm)); 117 } 118 119 static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg) 120 { 121 return container_of(__crypto_hash_alg_common(alg), struct ahash_alg, 122 halg); 123 } 124 125 static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash) 126 { 127 return container_of(crypto_hash_alg_common(hash), struct ahash_alg, 128 halg); 129 } 130 131 static inline void crypto_ahash_set_statesize(struct crypto_ahash *tfm, 132 unsigned int size) 133 { 134 tfm->statesize = size; 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 void crypto_ahash_set_reqsize_dma(struct crypto_ahash *ahash, 144 unsigned int reqsize) 145 { 146 reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1); 147 ahash->reqsize = reqsize; 148 } 149 150 static inline struct crypto_instance *ahash_crypto_instance( 151 struct ahash_instance *inst) 152 { 153 return &inst->s.base; 154 } 155 156 static inline struct ahash_instance *ahash_instance( 157 struct crypto_instance *inst) 158 { 159 return container_of(inst, struct ahash_instance, s.base); 160 } 161 162 static inline struct ahash_instance *ahash_alg_instance( 163 struct crypto_ahash *ahash) 164 { 165 return ahash_instance(crypto_tfm_alg_instance(&ahash->base)); 166 } 167 168 static inline void *ahash_instance_ctx(struct ahash_instance *inst) 169 { 170 return crypto_instance_ctx(ahash_crypto_instance(inst)); 171 } 172 173 static inline void *ahash_request_ctx_dma(struct ahash_request *req) 174 { 175 unsigned int align = crypto_dma_align(); 176 177 if (align <= crypto_tfm_ctx_alignment()) 178 align = 1; 179 180 return PTR_ALIGN(ahash_request_ctx(req), align); 181 } 182 183 static inline void ahash_request_complete(struct ahash_request *req, int err) 184 { 185 crypto_request_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 struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm) 246 { 247 return container_of(tfm, struct crypto_shash, base); 248 } 249 250 #endif /* _CRYPTO_INTERNAL_HASH_H */ 251 252