include/crypto/hash.h

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