~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/crypto/internal/hash.h

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp