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