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 shash_desc {
  19         struct crypto_shash *tfm;
  20         u32 flags;
  21
  22         void *__ctx[] CRYPTO_MINALIGN_ATTR;
  23 };
  24
  25 struct shash_alg {
  26         int (*init)(struct shash_desc *desc);
  27         int (*reinit)(struct shash_desc *desc);
  28         int (*update)(struct shash_desc *desc, const u8 *data,
  29                       unsigned int len);
  30         int (*final)(struct shash_desc *desc, u8 *out);
  31         int (*finup)(struct shash_desc *desc, const u8 *data,
  32                      unsigned int len, u8 *out);
  33         int (*digest)(struct shash_desc *desc, const u8 *data,
  34                       unsigned int len, u8 *out);
  35         int (*setkey)(struct crypto_shash *tfm, const u8 *key,
  36                       unsigned int keylen);
  37
  38         unsigned int descsize;
  39         unsigned int digestsize;
  40
  41         struct crypto_alg base;
  42 };
  43
  44 struct crypto_ahash {
  45         struct crypto_tfm base;
  46 };
  47
  48 struct crypto_shash {
  49         struct crypto_tfm base;
  50 };
  51
  52 static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
  53 {
  54         return (struct crypto_ahash *)tfm;
  55 }
  56
  57 static inline struct crypto_ahash *crypto_alloc_ahash(const char *alg_name,
  58                                                       u32 type, u32 mask)
  59 {
  60         type &= ~CRYPTO_ALG_TYPE_MASK;
  61         mask &= ~CRYPTO_ALG_TYPE_MASK;
  62         type |= CRYPTO_ALG_TYPE_AHASH;
  63         mask |= CRYPTO_ALG_TYPE_AHASH_MASK;
  64
  65         return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, mask));
  66 }
  67
  68 static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
  69 {
  70         return &tfm->base;
  71 }
  72
  73 static inline void crypto_free_ahash(struct crypto_ahash *tfm)
  74 {
  75         crypto_free_tfm(crypto_ahash_tfm(tfm));
  76 }
  77
  78 static inline unsigned int crypto_ahash_alignmask(
  79         struct crypto_ahash *tfm)
  80 {
  81         return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
  82 }
  83
  84 static inline struct ahash_tfm *crypto_ahash_crt(struct crypto_ahash *tfm)
  85 {
  86         return &crypto_ahash_tfm(tfm)->crt_ahash;
  87 }
  88
  89 static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
  90 {
  91         return crypto_ahash_crt(tfm)->digestsize;
  92 }
  93
  94 static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
  95 {
  96         return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
  97 }
  98
  99 static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
 100 {
 101         crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
 102 }
 103
 104 static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
 105 {
 106         crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
 107 }
 108
 109 static inline struct crypto_ahash *crypto_ahash_reqtfm(
 110         struct ahash_request *req)
 111 {
 112         return __crypto_ahash_cast(req->base.tfm);
 113 }
 114
 115 static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
 116 {
 117         return crypto_ahash_crt(tfm)->reqsize;
 118 }
 119
 120 static inline void *ahash_request_ctx(struct ahash_request *req)
 121 {
 122         return req->__ctx;
 123 }
 124
 125 static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
 126                                       const u8 *key, unsigned int keylen)
 127 {
 128         struct ahash_tfm *crt = crypto_ahash_crt(tfm);
 129
 130         return crt->setkey(tfm, key, keylen);
 131 }
 132
 133 static inline int crypto_ahash_digest(struct ahash_request *req)
 134 {
 135         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
 136         return crt->digest(req);
 137 }
 138
 139 static inline void crypto_ahash_export(struct ahash_request *req, u8 *out)
 140 {
 141         memcpy(out, ahash_request_ctx(req),
 142                crypto_ahash_reqsize(crypto_ahash_reqtfm(req)));
 143 }
 144
 145 int crypto_ahash_import(struct ahash_request *req, const u8 *in);
 146
 147 static inline int crypto_ahash_init(struct ahash_request *req)
 148 {
 149         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
 150         return crt->init(req);
 151 }
 152
 153 static inline int crypto_ahash_update(struct ahash_request *req)
 154 {
 155         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
 156         return crt->update(req);
 157 }
 158
 159 static inline int crypto_ahash_final(struct ahash_request *req)
 160 {
 161         struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
 162         return crt->final(req);
 163 }
 164
 165 static inline void ahash_request_set_tfm(struct ahash_request *req,
 166                                          struct crypto_ahash *tfm)
 167 {
 168         req->base.tfm = crypto_ahash_tfm(tfm);
 169 }
 170
 171 static inline struct ahash_request *ahash_request_alloc(
 172         struct crypto_ahash *tfm, gfp_t gfp)
 173 {
 174         struct ahash_request *req;
 175
 176         req = kmalloc(sizeof(struct ahash_request) +
 177                       crypto_ahash_reqsize(tfm), gfp);
 178
 179         if (likely(req))
 180                 ahash_request_set_tfm(req, tfm);
 181
 182         return req;
 183 }
 184
 185 static inline void ahash_request_free(struct ahash_request *req)
 186 {
 187         kfree(req);
 188 }
 189
 190 static inline struct ahash_request *ahash_request_cast(
 191         struct crypto_async_request *req)
 192 {
 193         return container_of(req, struct ahash_request, base);
 194 }
 195
 196 static inline void ahash_request_set_callback(struct ahash_request *req,
 197                                               u32 flags,
 198                                               crypto_completion_t complete,
 199                                               void *data)
 200 {
 201         req->base.complete = complete;
 202         req->base.data = data;
 203         req->base.flags = flags;
 204 }
 205
 206 static inline void ahash_request_set_crypt(struct ahash_request *req,
 207                                            struct scatterlist *src, u8 *result,
 208                                            unsigned int nbytes)
 209 {
 210         req->src = src;
 211         req->nbytes = nbytes;
 212         req->result = result;
 213 }
 214
 215 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
 216                                         u32 mask);
 217
 218 static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
 219 {
 220         return &tfm->base;
 221 }
 222
 223 static inline void crypto_free_shash(struct crypto_shash *tfm)
 224 {
 225         crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
 226 }
 227
 228 static inline unsigned int crypto_shash_alignmask(
 229         struct crypto_shash *tfm)
 230 {
 231         return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
 232 }
 233
 234 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
 235 {
 236         return container_of(alg, struct shash_alg, base);
 237 }
 238
 239 static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
 240 {
 241         return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
 242 }
 243
 244 static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
 245 {
 246         return crypto_shash_alg(tfm)->digestsize;
 247 }
 248
 249 static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
 250 {
 251         return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
 252 }
 253
 254 static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
 255 {
 256         crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
 257 }
 258
 259 static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
 260 {
 261         crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
 262 }
 263
 264 static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
 265 {
 266         return crypto_shash_alg(tfm)->descsize;
 267 }
 268
 269 static inline void *shash_desc_ctx(struct shash_desc *desc)
 270 {
 271         return desc->__ctx;
 272 }
 273
 274 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
 275                         unsigned int keylen);
 276 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
 277                         unsigned int len, u8 *out);
 278
 279 static inline void crypto_shash_export(struct shash_desc *desc, u8 *out)
 280 {
 281         memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
 282 }
 283
 284 int crypto_shash_import(struct shash_desc *desc, const u8 *in);
 285
 286 static inline int crypto_shash_init(struct shash_desc *desc)
 287 {
 288         return crypto_shash_alg(desc->tfm)->init(desc);
 289 }
 290
 291 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
 292                         unsigned int len);
 293 int crypto_shash_final(struct shash_desc *desc, u8 *out);
 294 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
 295                        unsigned int len, u8 *out);
 296
 297 #endif  /* _CRYPTO_HASH_H */