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

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

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ 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 /* SPDX-License-Identifier: GPL-2.0-or-later */
  2 /*
  3  * Symmetric key ciphers.
  4  * 
  5  * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
  6  */
  7 
  8 #ifndef _CRYPTO_INTERNAL_SKCIPHER_H
  9 #define _CRYPTO_INTERNAL_SKCIPHER_H
 10 
 11 #include <crypto/algapi.h>
 12 #include <crypto/skcipher.h>
 13 #include <linux/list.h>
 14 #include <linux/types.h>
 15 
 16 struct aead_request;
 17 struct rtattr;
 18 
 19 struct skcipher_instance {
 20         void (*free)(struct skcipher_instance *inst);
 21         union {
 22                 struct {
 23                         char head[offsetof(struct skcipher_alg, base)];
 24                         struct crypto_instance base;
 25                 } s;
 26                 struct skcipher_alg alg;
 27         };
 28 };
 29 
 30 struct crypto_skcipher_spawn {
 31         struct crypto_spawn base;
 32 };
 33 
 34 struct skcipher_walk {
 35         union {
 36                 struct {
 37                         struct page *page;
 38                         unsigned long offset;
 39                 } phys;
 40 
 41                 struct {
 42                         u8 *page;
 43                         void *addr;
 44                 } virt;
 45         } src, dst;
 46 
 47         struct scatter_walk in;
 48         unsigned int nbytes;
 49 
 50         struct scatter_walk out;
 51         unsigned int total;
 52 
 53         struct list_head buffers;
 54 
 55         u8 *page;
 56         u8 *buffer;
 57         u8 *oiv;
 58         void *iv;
 59 
 60         unsigned int ivsize;
 61 
 62         int flags;
 63         unsigned int blocksize;
 64         unsigned int stride;
 65         unsigned int alignmask;
 66 };
 67 
 68 static inline struct crypto_instance *skcipher_crypto_instance(
 69         struct skcipher_instance *inst)
 70 {
 71         return &inst->s.base;
 72 }
 73 
 74 static inline struct skcipher_instance *skcipher_alg_instance(
 75         struct crypto_skcipher *skcipher)
 76 {
 77         return container_of(crypto_skcipher_alg(skcipher),
 78                             struct skcipher_instance, alg);
 79 }
 80 
 81 static inline void *skcipher_instance_ctx(struct skcipher_instance *inst)
 82 {
 83         return crypto_instance_ctx(skcipher_crypto_instance(inst));
 84 }
 85 
 86 static inline void skcipher_request_complete(struct skcipher_request *req, int err)
 87 {
 88         req->base.complete(&req->base, err);
 89 }
 90 
 91 static inline void crypto_set_skcipher_spawn(
 92         struct crypto_skcipher_spawn *spawn, struct crypto_instance *inst)
 93 {
 94         crypto_set_spawn(&spawn->base, inst);
 95 }
 96 
 97 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
 98                          u32 type, u32 mask);
 99 
100 static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
101 {
102         crypto_drop_spawn(&spawn->base);
103 }
104 
105 static inline struct skcipher_alg *crypto_skcipher_spawn_alg(
106         struct crypto_skcipher_spawn *spawn)
107 {
108         return container_of(spawn->base.alg, struct skcipher_alg, base);
109 }
110 
111 static inline struct skcipher_alg *crypto_spawn_skcipher_alg(
112         struct crypto_skcipher_spawn *spawn)
113 {
114         return crypto_skcipher_spawn_alg(spawn);
115 }
116 
117 static inline struct crypto_skcipher *crypto_spawn_skcipher(
118         struct crypto_skcipher_spawn *spawn)
119 {
120         return crypto_spawn_tfm2(&spawn->base);
121 }
122 
123 static inline void crypto_skcipher_set_reqsize(
124         struct crypto_skcipher *skcipher, unsigned int reqsize)
125 {
126         skcipher->reqsize = reqsize;
127 }
128 
129 int crypto_register_skcipher(struct skcipher_alg *alg);
130 void crypto_unregister_skcipher(struct skcipher_alg *alg);
131 int crypto_register_skciphers(struct skcipher_alg *algs, int count);
132 void crypto_unregister_skciphers(struct skcipher_alg *algs, int count);
133 int skcipher_register_instance(struct crypto_template *tmpl,
134                                struct skcipher_instance *inst);
135 
136 int skcipher_walk_done(struct skcipher_walk *walk, int err);
137 int skcipher_walk_virt(struct skcipher_walk *walk,
138                        struct skcipher_request *req,
139                        bool atomic);
140 void skcipher_walk_atomise(struct skcipher_walk *walk);
141 int skcipher_walk_async(struct skcipher_walk *walk,
142                         struct skcipher_request *req);
143 int skcipher_walk_aead(struct skcipher_walk *walk, struct aead_request *req,
144                        bool atomic);
145 int skcipher_walk_aead_encrypt(struct skcipher_walk *walk,
146                                struct aead_request *req, bool atomic);
147 int skcipher_walk_aead_decrypt(struct skcipher_walk *walk,
148                                struct aead_request *req, bool atomic);
149 void skcipher_walk_complete(struct skcipher_walk *walk, int err);
150 
151 static inline void ablkcipher_request_complete(struct ablkcipher_request *req,
152                                                int err)
153 {
154         req->base.complete(&req->base, err);
155 }
156 
157 static inline u32 ablkcipher_request_flags(struct ablkcipher_request *req)
158 {
159         return req->base.flags;
160 }
161 
162 static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm)
163 {
164         return crypto_tfm_ctx(&tfm->base);
165 }
166 
167 static inline void *skcipher_request_ctx(struct skcipher_request *req)
168 {
169         return req->__ctx;
170 }
171 
172 static inline u32 skcipher_request_flags(struct skcipher_request *req)
173 {
174         return req->base.flags;
175 }
176 
177 static inline unsigned int crypto_skcipher_alg_min_keysize(
178         struct skcipher_alg *alg)
179 {
180         if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
181             CRYPTO_ALG_TYPE_BLKCIPHER)
182                 return alg->base.cra_blkcipher.min_keysize;
183 
184         if (alg->base.cra_ablkcipher.encrypt)
185                 return alg->base.cra_ablkcipher.min_keysize;
186 
187         return alg->min_keysize;
188 }
189 
190 static inline unsigned int crypto_skcipher_alg_max_keysize(
191         struct skcipher_alg *alg)
192 {
193         if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
194             CRYPTO_ALG_TYPE_BLKCIPHER)
195                 return alg->base.cra_blkcipher.max_keysize;
196 
197         if (alg->base.cra_ablkcipher.encrypt)
198                 return alg->base.cra_ablkcipher.max_keysize;
199 
200         return alg->max_keysize;
201 }
202 
203 static inline unsigned int crypto_skcipher_alg_chunksize(
204         struct skcipher_alg *alg)
205 {
206         if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
207             CRYPTO_ALG_TYPE_BLKCIPHER)
208                 return alg->base.cra_blocksize;
209 
210         if (alg->base.cra_ablkcipher.encrypt)
211                 return alg->base.cra_blocksize;
212 
213         return alg->chunksize;
214 }
215 
216 static inline unsigned int crypto_skcipher_alg_walksize(
217         struct skcipher_alg *alg)
218 {
219         if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
220             CRYPTO_ALG_TYPE_BLKCIPHER)
221                 return alg->base.cra_blocksize;
222 
223         if (alg->base.cra_ablkcipher.encrypt)
224                 return alg->base.cra_blocksize;
225 
226         return alg->walksize;
227 }
228 
229 /**
230  * crypto_skcipher_chunksize() - obtain chunk size
231  * @tfm: cipher handle
232  *
233  * The block size is set to one for ciphers such as CTR.  However,
234  * you still need to provide incremental updates in multiples of
235  * the underlying block size as the IV does not have sub-block
236  * granularity.  This is known in this API as the chunk size.
237  *
238  * Return: chunk size in bytes
239  */
240 static inline unsigned int crypto_skcipher_chunksize(
241         struct crypto_skcipher *tfm)
242 {
243         return crypto_skcipher_alg_chunksize(crypto_skcipher_alg(tfm));
244 }
245 
246 /**
247  * crypto_skcipher_walksize() - obtain walk size
248  * @tfm: cipher handle
249  *
250  * In some cases, algorithms can only perform optimally when operating on
251  * multiple blocks in parallel. This is reflected by the walksize, which
252  * must be a multiple of the chunksize (or equal if the concern does not
253  * apply)
254  *
255  * Return: walk size in bytes
256  */
257 static inline unsigned int crypto_skcipher_walksize(
258         struct crypto_skcipher *tfm)
259 {
260         return crypto_skcipher_alg_walksize(crypto_skcipher_alg(tfm));
261 }
262 
263 /* Helpers for simple block cipher modes of operation */
264 struct skcipher_ctx_simple {
265         struct crypto_cipher *cipher;   /* underlying block cipher */
266 };
267 static inline struct crypto_cipher *
268 skcipher_cipher_simple(struct crypto_skcipher *tfm)
269 {
270         struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);
271 
272         return ctx->cipher;
273 }
274 struct skcipher_instance *
275 skcipher_alloc_instance_simple(struct crypto_template *tmpl, struct rtattr **tb,
276                                struct crypto_alg **cipher_alg_ret);
277 
278 #endif  /* _CRYPTO_INTERNAL_SKCIPHER_H */
279 
280 

~ [ 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