1 /* 2 * Hash: Hash algorithms under the crypto API 3 * 4 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the Free 8 * Software Foundation; either version 2 of the License, or (at your option) 9 * any later version. 10 * 11 */ 12 13 #ifndef _CRYPTO_HASH_H 14 #define _CRYPTO_HASH_H 15 16 #include <linux/crypto.h> 17 18 struct crypto_ahash; 19 20 struct hash_alg_common { 21 unsigned int digestsize; 22 unsigned int statesize; 23 24 struct crypto_alg base; 25 }; 26 27 struct ahash_request { 28 struct crypto_async_request base; 29 30 unsigned int nbytes; 31 struct scatterlist *src; 32 u8 *result; 33 34 /* This field may only be used by the ahash API code. */ 35 void *priv; 36 37 void *__ctx[] CRYPTO_MINALIGN_ATTR; 38 }; 39 40 struct ahash_alg { 41 int (*init)(struct ahash_request *req); 42 int (*update)(struct ahash_request *req); 43 int (*final)(struct ahash_request *req); 44 int (*finup)(struct ahash_request *req); 45 int (*digest)(struct ahash_request *req); 46 int (*export)(struct ahash_request *req, void *out); 47 int (*import)(struct ahash_request *req, const void *in); 48 int (*setkey)(struct crypto_ahash *tfm, const u8 *key, 49 unsigned int keylen); 50 51 struct hash_alg_common halg; 52 }; 53 54 struct shash_desc { 55 struct crypto_shash *tfm; 56 u32 flags; 57 58 void *__ctx[] CRYPTO_MINALIGN_ATTR; 59 }; 60 61 #define SHASH_DESC_ON_STACK(shash, ctx) \ 62 char __##shash##_desc[sizeof(struct shash_desc) + \ 63 crypto_shash_descsize(ctx)] CRYPTO_MINALIGN_ATTR; \ 64 struct shash_desc *shash = (struct shash_desc *)__##shash##_desc 65 66 struct shash_alg { 67 int (*init)(struct shash_desc *desc); 68 int (*update)(struct shash_desc *desc, const u8 *data, 69 unsigned int len); 70 int (*final)(struct shash_desc *desc, u8 *out); 71 int (*finup)(struct shash_desc *desc, const u8 *data, 72 unsigned int len, u8 *out); 73 int (*digest)(struct shash_desc *desc, const u8 *data, 74 unsigned int len, u8 *out); 75 int (*export)(struct shash_desc *desc, void *out); 76 int (*import)(struct shash_desc *desc, const void *in); 77 int (*setkey)(struct crypto_shash *tfm, const u8 *key, 78 unsigned int keylen); 79 80 unsigned int descsize; 81 82 /* These fields must match hash_alg_common. */ 83 unsigned int digestsize 84 __attribute__ ((aligned(__alignof__(struct hash_alg_common)))); 85 unsigned int statesize; 86 87 struct crypto_alg base; 88 }; 89 90 struct crypto_ahash { 91 int (*init)(struct ahash_request *req); 92 int (*update)(struct ahash_request *req); 93 int (*final)(struct ahash_request *req); 94 int (*finup)(struct ahash_request *req); 95 int (*digest)(struct ahash_request *req); 96 int (*export)(struct ahash_request *req, void *out); 97 int (*import)(struct ahash_request *req, const void *in); 98 int (*setkey)(struct crypto_ahash *tfm, const u8 *key, 99 unsigned int keylen); 100 101 unsigned int reqsize; 102 struct crypto_tfm base; 103 }; 104 105 struct crypto_shash { 106 unsigned int descsize; 107 struct crypto_tfm base; 108 }; 109 110 static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm) 111 { 112 return container_of(tfm, struct crypto_ahash, base); 113 } 114 115 struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type, 116 u32 mask); 117 118 static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm) 119 { 120 return &tfm->base; 121 } 122 123 static inline void crypto_free_ahash(struct crypto_ahash *tfm) 124 { 125 crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm)); 126 } 127 128 static inline unsigned int crypto_ahash_alignmask( 129 struct crypto_ahash *tfm) 130 { 131 return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm)); 132 } 133 134 static inline struct hash_alg_common *__crypto_hash_alg_common( 135 struct crypto_alg *alg) 136 { 137 return container_of(alg, struct hash_alg_common, base); 138 } 139 140 static inline struct hash_alg_common *crypto_hash_alg_common( 141 struct crypto_ahash *tfm) 142 { 143 return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg); 144 } 145 146 static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm) 147 { 148 return crypto_hash_alg_common(tfm)->digestsize; 149 } 150 151 static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm) 152 { 153 return crypto_hash_alg_common(tfm)->statesize; 154 } 155 156 static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm) 157 { 158 return crypto_tfm_get_flags(crypto_ahash_tfm(tfm)); 159 } 160 161 static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags) 162 { 163 crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags); 164 } 165 166 static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags) 167 { 168 crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags); 169 } 170 171 static inline struct crypto_ahash *crypto_ahash_reqtfm( 172 struct ahash_request *req) 173 { 174 return __crypto_ahash_cast(req->base.tfm); 175 } 176 177 static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm) 178 { 179 return tfm->reqsize; 180 } 181 182 static inline void *ahash_request_ctx(struct ahash_request *req) 183 { 184 return req->__ctx; 185 } 186 187 int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key, 188 unsigned int keylen); 189 int crypto_ahash_finup(struct ahash_request *req); 190 int crypto_ahash_final(struct ahash_request *req); 191 int crypto_ahash_digest(struct ahash_request *req); 192 193 static inline int crypto_ahash_export(struct ahash_request *req, void *out) 194 { 195 return crypto_ahash_reqtfm(req)->export(req, out); 196 } 197 198 static inline int crypto_ahash_import(struct ahash_request *req, const void *in) 199 { 200 return crypto_ahash_reqtfm(req)->import(req, in); 201 } 202 203 static inline int crypto_ahash_init(struct ahash_request *req) 204 { 205 return crypto_ahash_reqtfm(req)->init(req); 206 } 207 208 static inline int crypto_ahash_update(struct ahash_request *req) 209 { 210 return crypto_ahash_reqtfm(req)->update(req); 211 } 212 213 static inline void ahash_request_set_tfm(struct ahash_request *req, 214 struct crypto_ahash *tfm) 215 { 216 req->base.tfm = crypto_ahash_tfm(tfm); 217 } 218 219 static inline struct ahash_request *ahash_request_alloc( 220 struct crypto_ahash *tfm, gfp_t gfp) 221 { 222 struct ahash_request *req; 223 224 req = kmalloc(sizeof(struct ahash_request) + 225 crypto_ahash_reqsize(tfm), gfp); 226 227 if (likely(req)) 228 ahash_request_set_tfm(req, tfm); 229 230 return req; 231 } 232 233 static inline void ahash_request_free(struct ahash_request *req) 234 { 235 kzfree(req); 236 } 237 238 static inline struct ahash_request *ahash_request_cast( 239 struct crypto_async_request *req) 240 { 241 return container_of(req, struct ahash_request, base); 242 } 243 244 static inline void ahash_request_set_callback(struct ahash_request *req, 245 u32 flags, 246 crypto_completion_t compl, 247 void *data) 248 { 249 req->base.complete = compl; 250 req->base.data = data; 251 req->base.flags = flags; 252 } 253 254 static inline void ahash_request_set_crypt(struct ahash_request *req, 255 struct scatterlist *src, u8 *result, 256 unsigned int nbytes) 257 { 258 req->src = src; 259 req->nbytes = nbytes; 260 req->result = result; 261 } 262 263 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type, 264 u32 mask); 265 266 static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm) 267 { 268 return &tfm->base; 269 } 270 271 static inline void crypto_free_shash(struct crypto_shash *tfm) 272 { 273 crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm)); 274 } 275 276 static inline unsigned int crypto_shash_alignmask( 277 struct crypto_shash *tfm) 278 { 279 return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm)); 280 } 281 282 static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm) 283 { 284 return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm)); 285 } 286 287 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg) 288 { 289 return container_of(alg, struct shash_alg, base); 290 } 291 292 static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm) 293 { 294 return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg); 295 } 296 297 static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm) 298 { 299 return crypto_shash_alg(tfm)->digestsize; 300 } 301 302 static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm) 303 { 304 return crypto_shash_alg(tfm)->statesize; 305 } 306 307 static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm) 308 { 309 return crypto_tfm_get_flags(crypto_shash_tfm(tfm)); 310 } 311 312 static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags) 313 { 314 crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags); 315 } 316 317 static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags) 318 { 319 crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags); 320 } 321 322 static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm) 323 { 324 return tfm->descsize; 325 } 326 327 static inline void *shash_desc_ctx(struct shash_desc *desc) 328 { 329 return desc->__ctx; 330 } 331 332 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key, 333 unsigned int keylen); 334 int crypto_shash_digest(struct shash_desc *desc, const u8 *data, 335 unsigned int len, u8 *out); 336 337 static inline int crypto_shash_export(struct shash_desc *desc, void *out) 338 { 339 return crypto_shash_alg(desc->tfm)->export(desc, out); 340 } 341 342 static inline int crypto_shash_import(struct shash_desc *desc, const void *in) 343 { 344 return crypto_shash_alg(desc->tfm)->import(desc, in); 345 } 346 347 static inline int crypto_shash_init(struct shash_desc *desc) 348 { 349 return crypto_shash_alg(desc->tfm)->init(desc); 350 } 351 352 int crypto_shash_update(struct shash_desc *desc, const u8 *data, 353 unsigned int len); 354 int crypto_shash_final(struct shash_desc *desc, u8 *out); 355 int crypto_shash_finup(struct shash_desc *desc, const u8 *data, 356 unsigned int len, u8 *out); 357 358 #endif /* _CRYPTO_HASH_H */ 359