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/internal/cipher.h>
13 #include <crypto/skcipher.h>
14 #include <linux/types.h>
15 
16 /*
17  * Set this if your algorithm is sync but needs a reqsize larger
18  * than MAX_SYNC_SKCIPHER_REQSIZE.
19  *
20  * Reuse bit that is specific to hash algorithms.
21  */
22 #define CRYPTO_ALG_SKCIPHER_REQSIZE_LARGE CRYPTO_ALG_OPTIONAL_KEY
23 
24 struct aead_request;
25 struct rtattr;
26 
27 struct skcipher_instance {
28 	void (*free)(struct skcipher_instance *inst);
29 	union {
30 		struct {
31 			char head[offsetof(struct skcipher_alg, base)];
32 			struct crypto_instance base;
33 		} s;
34 		struct skcipher_alg alg;
35 	};
36 };
37 
38 struct lskcipher_instance {
39 	void (*free)(struct lskcipher_instance *inst);
40 	union {
41 		struct {
42 			char head[offsetof(struct lskcipher_alg, co.base)];
43 			struct crypto_instance base;
44 		} s;
45 		struct lskcipher_alg alg;
46 	};
47 };
48 
49 struct crypto_skcipher_spawn {
50 	struct crypto_spawn base;
51 };
52 
53 struct crypto_lskcipher_spawn {
54 	struct crypto_spawn base;
55 };
56 
57 struct skcipher_walk {
58 	union {
59 		/* Virtual address of the source. */
60 		struct {
61 			struct {
62 				const void *const addr;
63 			} virt;
64 		} src;
65 
66 		/* Private field for the API, do not use. */
67 		struct scatter_walk in;
68 	};
69 
70 	unsigned int nbytes;
71 
72 	union {
73 		/* Virtual address of the destination. */
74 		struct {
75 			struct {
76 				void *const addr;
77 			} virt;
78 		} dst;
79 
80 		/* Private field for the API, do not use. */
81 		struct scatter_walk out;
82 	};
83 
84 	unsigned int total;
85 
86 	u8 *page;
87 	u8 *buffer;
88 	u8 *oiv;
89 	void *iv;
90 
91 	unsigned int ivsize;
92 
93 	int flags;
94 	unsigned int blocksize;
95 	unsigned int stride;
96 	unsigned int alignmask;
97 };
98 
skcipher_crypto_instance(struct skcipher_instance * inst)99 static inline struct crypto_instance *skcipher_crypto_instance(
100 	struct skcipher_instance *inst)
101 {
102 	return &inst->s.base;
103 }
104 
lskcipher_crypto_instance(struct lskcipher_instance * inst)105 static inline struct crypto_instance *lskcipher_crypto_instance(
106 	struct lskcipher_instance *inst)
107 {
108 	return &inst->s.base;
109 }
110 
skcipher_alg_instance(struct crypto_skcipher * skcipher)111 static inline struct skcipher_instance *skcipher_alg_instance(
112 	struct crypto_skcipher *skcipher)
113 {
114 	return container_of(crypto_skcipher_alg(skcipher),
115 			    struct skcipher_instance, alg);
116 }
117 
lskcipher_alg_instance(struct crypto_lskcipher * lskcipher)118 static inline struct lskcipher_instance *lskcipher_alg_instance(
119 	struct crypto_lskcipher *lskcipher)
120 {
121 	return container_of(crypto_lskcipher_alg(lskcipher),
122 			    struct lskcipher_instance, alg);
123 }
124 
skcipher_instance_ctx(struct skcipher_instance * inst)125 static inline void *skcipher_instance_ctx(struct skcipher_instance *inst)
126 {
127 	return crypto_instance_ctx(skcipher_crypto_instance(inst));
128 }
129 
lskcipher_instance_ctx(struct lskcipher_instance * inst)130 static inline void *lskcipher_instance_ctx(struct lskcipher_instance *inst)
131 {
132 	return crypto_instance_ctx(lskcipher_crypto_instance(inst));
133 }
134 
skcipher_request_complete(struct skcipher_request * req,int err)135 static inline void skcipher_request_complete(struct skcipher_request *req, int err)
136 {
137 	crypto_request_complete(&req->base, err);
138 }
139 
140 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
141 			 struct crypto_instance *inst,
142 			 const char *name, u32 type, u32 mask);
143 
144 int crypto_grab_lskcipher(struct crypto_lskcipher_spawn *spawn,
145 			  struct crypto_instance *inst,
146 			  const char *name, u32 type, u32 mask);
147 
crypto_drop_skcipher(struct crypto_skcipher_spawn * spawn)148 static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
149 {
150 	crypto_drop_spawn(&spawn->base);
151 }
152 
crypto_drop_lskcipher(struct crypto_lskcipher_spawn * spawn)153 static inline void crypto_drop_lskcipher(struct crypto_lskcipher_spawn *spawn)
154 {
155 	crypto_drop_spawn(&spawn->base);
156 }
157 
crypto_lskcipher_spawn_alg(struct crypto_lskcipher_spawn * spawn)158 static inline struct lskcipher_alg *crypto_lskcipher_spawn_alg(
159 	struct crypto_lskcipher_spawn *spawn)
160 {
161 	return container_of(spawn->base.alg, struct lskcipher_alg, co.base);
162 }
163 
crypto_spawn_skcipher_alg_common(struct crypto_skcipher_spawn * spawn)164 static inline struct skcipher_alg_common *crypto_spawn_skcipher_alg_common(
165 	struct crypto_skcipher_spawn *spawn)
166 {
167 	return container_of(spawn->base.alg, struct skcipher_alg_common, base);
168 }
169 
crypto_spawn_lskcipher_alg(struct crypto_lskcipher_spawn * spawn)170 static inline struct lskcipher_alg *crypto_spawn_lskcipher_alg(
171 	struct crypto_lskcipher_spawn *spawn)
172 {
173 	return crypto_lskcipher_spawn_alg(spawn);
174 }
175 
crypto_spawn_skcipher(struct crypto_skcipher_spawn * spawn)176 static inline struct crypto_skcipher *crypto_spawn_skcipher(
177 	struct crypto_skcipher_spawn *spawn)
178 {
179 	return crypto_spawn_tfm2(&spawn->base);
180 }
181 
crypto_spawn_lskcipher(struct crypto_lskcipher_spawn * spawn)182 static inline struct crypto_lskcipher *crypto_spawn_lskcipher(
183 	struct crypto_lskcipher_spawn *spawn)
184 {
185 	return crypto_spawn_tfm2(&spawn->base);
186 }
187 
crypto_skcipher_set_reqsize(struct crypto_skcipher * skcipher,unsigned int reqsize)188 static inline void crypto_skcipher_set_reqsize(
189 	struct crypto_skcipher *skcipher, unsigned int reqsize)
190 {
191 	skcipher->reqsize = reqsize;
192 }
193 
crypto_skcipher_set_reqsize_dma(struct crypto_skcipher * skcipher,unsigned int reqsize)194 static inline void crypto_skcipher_set_reqsize_dma(
195 	struct crypto_skcipher *skcipher, unsigned int reqsize)
196 {
197 	reqsize += crypto_dma_align() & ~(crypto_tfm_ctx_alignment() - 1);
198 	skcipher->reqsize = reqsize;
199 }
200 
201 int crypto_register_skcipher(struct skcipher_alg *alg);
202 void crypto_unregister_skcipher(struct skcipher_alg *alg);
203 int crypto_register_skciphers(struct skcipher_alg *algs, int count);
204 void crypto_unregister_skciphers(struct skcipher_alg *algs, int count);
205 int skcipher_register_instance(struct crypto_template *tmpl,
206 			       struct skcipher_instance *inst);
207 
208 int crypto_register_lskcipher(struct lskcipher_alg *alg);
209 void crypto_unregister_lskcipher(struct lskcipher_alg *alg);
210 int crypto_register_lskciphers(struct lskcipher_alg *algs, int count);
211 void crypto_unregister_lskciphers(struct lskcipher_alg *algs, int count);
212 int lskcipher_register_instance(struct crypto_template *tmpl,
213 				struct lskcipher_instance *inst);
214 
215 int skcipher_walk_done(struct skcipher_walk *walk, int res);
216 int skcipher_walk_virt(struct skcipher_walk *__restrict walk,
217 		       struct skcipher_request *__restrict req,
218 		       bool atomic);
219 int skcipher_walk_aead_encrypt(struct skcipher_walk *__restrict walk,
220 			       struct aead_request *__restrict req,
221 			       bool atomic);
222 int skcipher_walk_aead_decrypt(struct skcipher_walk *__restrict walk,
223 			       struct aead_request *__restrict req,
224 			       bool atomic);
225 
skcipher_walk_abort(struct skcipher_walk * walk)226 static inline void skcipher_walk_abort(struct skcipher_walk *walk)
227 {
228 	skcipher_walk_done(walk, -ECANCELED);
229 }
230 
crypto_skcipher_ctx(struct crypto_skcipher * tfm)231 static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm)
232 {
233 	return crypto_tfm_ctx(&tfm->base);
234 }
235 
crypto_lskcipher_ctx(struct crypto_lskcipher * tfm)236 static inline void *crypto_lskcipher_ctx(struct crypto_lskcipher *tfm)
237 {
238 	return crypto_tfm_ctx(&tfm->base);
239 }
240 
crypto_skcipher_ctx_dma(struct crypto_skcipher * tfm)241 static inline void *crypto_skcipher_ctx_dma(struct crypto_skcipher *tfm)
242 {
243 	return crypto_tfm_ctx_dma(&tfm->base);
244 }
245 
skcipher_request_ctx(struct skcipher_request * req)246 static inline void *skcipher_request_ctx(struct skcipher_request *req)
247 {
248 	return req->__ctx;
249 }
250 
skcipher_request_ctx_dma(struct skcipher_request * req)251 static inline void *skcipher_request_ctx_dma(struct skcipher_request *req)
252 {
253 	unsigned int align = crypto_dma_align();
254 
255 	if (align <= crypto_tfm_ctx_alignment())
256 		align = 1;
257 
258 	return PTR_ALIGN(skcipher_request_ctx(req), align);
259 }
260 
skcipher_request_flags(struct skcipher_request * req)261 static inline u32 skcipher_request_flags(struct skcipher_request *req)
262 {
263 	return req->base.flags;
264 }
265 
266 /* Helpers for simple block cipher modes of operation */
267 struct skcipher_ctx_simple {
268 	struct crypto_cipher *cipher;	/* underlying block cipher */
269 };
270 static inline struct crypto_cipher *
skcipher_cipher_simple(struct crypto_skcipher * tfm)271 skcipher_cipher_simple(struct crypto_skcipher *tfm)
272 {
273 	struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);
274 
275 	return ctx->cipher;
276 }
277 
278 struct skcipher_instance *skcipher_alloc_instance_simple(
279 	struct crypto_template *tmpl, struct rtattr **tb);
280 
skcipher_ialg_simple(struct skcipher_instance * inst)281 static inline struct crypto_alg *skcipher_ialg_simple(
282 	struct skcipher_instance *inst)
283 {
284 	struct crypto_cipher_spawn *spawn = skcipher_instance_ctx(inst);
285 
286 	return crypto_spawn_cipher_alg(spawn);
287 }
288 
lskcipher_cipher_simple(struct crypto_lskcipher * tfm)289 static inline struct crypto_lskcipher *lskcipher_cipher_simple(
290 	struct crypto_lskcipher *tfm)
291 {
292 	struct crypto_lskcipher **ctx = crypto_lskcipher_ctx(tfm);
293 
294 	return *ctx;
295 }
296 
297 struct lskcipher_instance *lskcipher_alloc_instance_simple(
298 	struct crypto_template *tmpl, struct rtattr **tb);
299 
lskcipher_ialg_simple(struct lskcipher_instance * inst)300 static inline struct lskcipher_alg *lskcipher_ialg_simple(
301 	struct lskcipher_instance *inst)
302 {
303 	struct crypto_lskcipher_spawn *spawn = lskcipher_instance_ctx(inst);
304 
305 	return crypto_lskcipher_spawn_alg(spawn);
306 }
307 
308 #endif	/* _CRYPTO_INTERNAL_SKCIPHER_H */
309 
310