linux/include/crypto/internal/hash.h
<<
>>
Prefs
   1/*
   2 * Hash algorithms.
   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_INTERNAL_HASH_H
  14#define _CRYPTO_INTERNAL_HASH_H
  15
  16#include <crypto/algapi.h>
  17#include <crypto/hash.h>
  18
  19struct ahash_request;
  20struct scatterlist;
  21
  22struct crypto_hash_walk {
  23        char *data;
  24
  25        unsigned int offset;
  26        unsigned int alignmask;
  27
  28        struct page *pg;
  29        unsigned int entrylen;
  30
  31        unsigned int total;
  32        struct scatterlist *sg;
  33
  34        unsigned int flags;
  35};
  36
  37struct ahash_instance {
  38        struct ahash_alg alg;
  39};
  40
  41struct shash_instance {
  42        struct shash_alg alg;
  43};
  44
  45struct crypto_ahash_spawn {
  46        struct crypto_spawn base;
  47};
  48
  49struct crypto_shash_spawn {
  50        struct crypto_spawn base;
  51};
  52
  53extern const struct crypto_type crypto_ahash_type;
  54
  55int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
  56int crypto_hash_walk_first(struct ahash_request *req,
  57                           struct crypto_hash_walk *walk);
  58int crypto_hash_walk_first_compat(struct hash_desc *hdesc,
  59                                  struct crypto_hash_walk *walk,
  60                                  struct scatterlist *sg, unsigned int len);
  61
  62static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
  63{
  64        return !(walk->entrylen | walk->total);
  65}
  66
  67int crypto_register_ahash(struct ahash_alg *alg);
  68int crypto_unregister_ahash(struct ahash_alg *alg);
  69int ahash_register_instance(struct crypto_template *tmpl,
  70                            struct ahash_instance *inst);
  71void ahash_free_instance(struct crypto_instance *inst);
  72
  73int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
  74                            struct hash_alg_common *alg,
  75                            struct crypto_instance *inst);
  76
  77static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
  78{
  79        crypto_drop_spawn(&spawn->base);
  80}
  81
  82struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
  83
  84int crypto_register_shash(struct shash_alg *alg);
  85int crypto_unregister_shash(struct shash_alg *alg);
  86int shash_register_instance(struct crypto_template *tmpl,
  87                            struct shash_instance *inst);
  88void shash_free_instance(struct crypto_instance *inst);
  89
  90int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
  91                            struct shash_alg *alg,
  92                            struct crypto_instance *inst);
  93
  94static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
  95{
  96        crypto_drop_spawn(&spawn->base);
  97}
  98
  99struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
 100
 101int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
 102int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
 103int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
 104
 105int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
 106
 107static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
 108{
 109        return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
 110}
 111
 112static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
 113{
 114        return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
 115                            halg);
 116}
 117
 118static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
 119                                            unsigned int reqsize)
 120{
 121        tfm->reqsize = reqsize;
 122}
 123
 124static inline struct crypto_instance *ahash_crypto_instance(
 125        struct ahash_instance *inst)
 126{
 127        return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
 128}
 129
 130static inline struct ahash_instance *ahash_instance(
 131        struct crypto_instance *inst)
 132{
 133        return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
 134}
 135
 136static inline void *ahash_instance_ctx(struct ahash_instance *inst)
 137{
 138        return crypto_instance_ctx(ahash_crypto_instance(inst));
 139}
 140
 141static inline unsigned int ahash_instance_headroom(void)
 142{
 143        return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
 144}
 145
 146static inline struct ahash_instance *ahash_alloc_instance(
 147        const char *name, struct crypto_alg *alg)
 148{
 149        return crypto_alloc_instance2(name, alg, ahash_instance_headroom());
 150}
 151
 152static inline struct crypto_ahash *crypto_spawn_ahash(
 153        struct crypto_ahash_spawn *spawn)
 154{
 155        return crypto_spawn_tfm2(&spawn->base);
 156}
 157
 158static inline int ahash_enqueue_request(struct crypto_queue *queue,
 159                                             struct ahash_request *request)
 160{
 161        return crypto_enqueue_request(queue, &request->base);
 162}
 163
 164static inline struct ahash_request *ahash_dequeue_request(
 165        struct crypto_queue *queue)
 166{
 167        return ahash_request_cast(crypto_dequeue_request(queue));
 168}
 169
 170static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
 171                                          struct crypto_ahash *tfm)
 172{
 173        return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
 174}
 175
 176static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
 177{
 178        return crypto_tfm_ctx(&tfm->base);
 179}
 180
 181static inline struct crypto_instance *shash_crypto_instance(
 182        struct shash_instance *inst)
 183{
 184        return container_of(&inst->alg.base, struct crypto_instance, alg);
 185}
 186
 187static inline struct shash_instance *shash_instance(
 188        struct crypto_instance *inst)
 189{
 190        return container_of(__crypto_shash_alg(&inst->alg),
 191                            struct shash_instance, alg);
 192}
 193
 194static inline void *shash_instance_ctx(struct shash_instance *inst)
 195{
 196        return crypto_instance_ctx(shash_crypto_instance(inst));
 197}
 198
 199static inline struct shash_instance *shash_alloc_instance(
 200        const char *name, struct crypto_alg *alg)
 201{
 202        return crypto_alloc_instance2(name, alg,
 203                                      sizeof(struct shash_alg) - sizeof(*alg));
 204}
 205
 206static inline struct crypto_shash *crypto_spawn_shash(
 207        struct crypto_shash_spawn *spawn)
 208{
 209        return crypto_spawn_tfm2(&spawn->base);
 210}
 211
 212static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
 213{
 214        return crypto_tfm_ctx_aligned(&tfm->base);
 215}
 216
 217static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
 218{
 219        return container_of(tfm, struct crypto_shash, base);
 220}
 221
 222#endif  /* _CRYPTO_INTERNAL_HASH_H */
 223
 224