Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Symmetric key cipher operations.
4 : : *
5 : : * Generic encrypt/decrypt wrapper for ciphers, handles operations across
6 : : * multiple page boundaries by using temporary blocks. In user context,
7 : : * the kernel is given a chance to schedule us once per page.
8 : : *
9 : : * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
10 : : */
11 : :
12 : : #include <crypto/internal/aead.h>
13 : : #include <crypto/internal/skcipher.h>
14 : : #include <crypto/scatterwalk.h>
15 : : #include <linux/bug.h>
16 : : #include <linux/cryptouser.h>
17 : : #include <linux/compiler.h>
18 : : #include <linux/list.h>
19 : : #include <linux/module.h>
20 : : #include <linux/rtnetlink.h>
21 : : #include <linux/seq_file.h>
22 : : #include <net/netlink.h>
23 : :
24 : : #include "internal.h"
25 : :
26 : : enum {
27 : : SKCIPHER_WALK_PHYS = 1 << 0,
28 : : SKCIPHER_WALK_SLOW = 1 << 1,
29 : : SKCIPHER_WALK_COPY = 1 << 2,
30 : : SKCIPHER_WALK_DIFF = 1 << 3,
31 : : SKCIPHER_WALK_SLEEP = 1 << 4,
32 : : };
33 : :
34 : : struct skcipher_walk_buffer {
35 : : struct list_head entry;
36 : : struct scatter_walk dst;
37 : : unsigned int len;
38 : : u8 *data;
39 : : u8 buffer[];
40 : : };
41 : :
42 : : static int skcipher_walk_next(struct skcipher_walk *walk);
43 : :
44 : 0 : static inline void skcipher_unmap(struct scatter_walk *walk, void *vaddr)
45 : : {
46 : 0 : if (PageHighMem(scatterwalk_page(walk)))
47 : 0 : kunmap_atomic(vaddr);
48 : : }
49 : :
50 : 0 : static inline void *skcipher_map(struct scatter_walk *walk)
51 : : {
52 : 0 : struct page *page = scatterwalk_page(walk);
53 : :
54 [ # # # # ]: 0 : return (PageHighMem(page) ? kmap_atomic(page) : page_address(page)) +
55 : 0 : offset_in_page(walk->offset);
56 : : }
57 : :
58 : 0 : static inline void skcipher_map_src(struct skcipher_walk *walk)
59 : : {
60 : 0 : walk->src.virt.addr = skcipher_map(&walk->in);
61 : : }
62 : :
63 : 0 : static inline void skcipher_map_dst(struct skcipher_walk *walk)
64 : : {
65 : 0 : walk->dst.virt.addr = skcipher_map(&walk->out);
66 : 0 : }
67 : :
68 : 0 : static inline void skcipher_unmap_src(struct skcipher_walk *walk)
69 : : {
70 : 0 : skcipher_unmap(&walk->in, walk->src.virt.addr);
71 : : }
72 : :
73 : 0 : static inline void skcipher_unmap_dst(struct skcipher_walk *walk)
74 : : {
75 : 0 : skcipher_unmap(&walk->out, walk->dst.virt.addr);
76 : : }
77 : :
78 : 0 : static inline gfp_t skcipher_walk_gfp(struct skcipher_walk *walk)
79 : : {
80 : 0 : return walk->flags & SKCIPHER_WALK_SLEEP ? GFP_KERNEL : GFP_ATOMIC;
81 : : }
82 : :
83 : : /* Get a spot of the specified length that does not straddle a page.
84 : : * The caller needs to ensure that there is enough space for this operation.
85 : : */
86 : 0 : static inline u8 *skcipher_get_spot(u8 *start, unsigned int len)
87 : : {
88 : 0 : u8 *end_page = (u8 *)(((unsigned long)(start + len - 1)) & PAGE_MASK);
89 : :
90 : 0 : return max(start, end_page);
91 : : }
92 : :
93 : 0 : static int skcipher_done_slow(struct skcipher_walk *walk, unsigned int bsize)
94 : : {
95 : 0 : u8 *addr;
96 : :
97 : 0 : addr = (u8 *)ALIGN((unsigned long)walk->buffer, walk->alignmask + 1);
98 : 0 : addr = skcipher_get_spot(addr, bsize);
99 : 0 : scatterwalk_copychunks(addr, &walk->out, bsize,
100 : 0 : (walk->flags & SKCIPHER_WALK_PHYS) ? 2 : 1);
101 : 0 : return 0;
102 : : }
103 : :
104 : 0 : int skcipher_walk_done(struct skcipher_walk *walk, int err)
105 : : {
106 : 0 : unsigned int n = walk->nbytes;
107 : 0 : unsigned int nbytes = 0;
108 : :
109 [ # # ]: 0 : if (!n)
110 : 0 : goto finish;
111 : :
112 [ # # ]: 0 : if (likely(err >= 0)) {
113 : 0 : n -= err;
114 : 0 : nbytes = walk->total - n;
115 : : }
116 : :
117 [ # # ]: 0 : if (likely(!(walk->flags & (SKCIPHER_WALK_PHYS |
118 : : SKCIPHER_WALK_SLOW |
119 : : SKCIPHER_WALK_COPY |
120 : : SKCIPHER_WALK_DIFF)))) {
121 : 0 : unmap_src:
122 : : skcipher_unmap_src(walk);
123 [ # # ]: 0 : } else if (walk->flags & SKCIPHER_WALK_DIFF) {
124 : 0 : skcipher_unmap_dst(walk);
125 : 0 : goto unmap_src;
126 [ # # ]: 0 : } else if (walk->flags & SKCIPHER_WALK_COPY) {
127 : 0 : skcipher_map_dst(walk);
128 : 0 : memcpy(walk->dst.virt.addr, walk->page, n);
129 : 0 : skcipher_unmap_dst(walk);
130 [ # # ]: 0 : } else if (unlikely(walk->flags & SKCIPHER_WALK_SLOW)) {
131 [ # # ]: 0 : if (err > 0) {
132 : : /*
133 : : * Didn't process all bytes. Either the algorithm is
134 : : * broken, or this was the last step and it turned out
135 : : * the message wasn't evenly divisible into blocks but
136 : : * the algorithm requires it.
137 : : */
138 : : err = -EINVAL;
139 : : nbytes = 0;
140 : : } else
141 : 0 : n = skcipher_done_slow(walk, n);
142 : : }
143 : :
144 : 0 : if (err > 0)
145 : : err = 0;
146 : :
147 : 0 : walk->total = nbytes;
148 : 0 : walk->nbytes = 0;
149 : :
150 : 0 : scatterwalk_advance(&walk->in, n);
151 : 0 : scatterwalk_advance(&walk->out, n);
152 : 0 : scatterwalk_done(&walk->in, 0, nbytes);
153 : 0 : scatterwalk_done(&walk->out, 1, nbytes);
154 : :
155 [ # # ]: 0 : if (nbytes) {
156 : 0 : crypto_yield(walk->flags & SKCIPHER_WALK_SLEEP ?
157 [ # # ]: 0 : CRYPTO_TFM_REQ_MAY_SLEEP : 0);
158 : 0 : return skcipher_walk_next(walk);
159 : : }
160 : :
161 : 0 : finish:
162 : : /* Short-circuit for the common/fast path. */
163 [ # # ]: 0 : if (!((unsigned long)walk->buffer | (unsigned long)walk->page))
164 : 0 : goto out;
165 : :
166 [ # # ]: 0 : if (walk->flags & SKCIPHER_WALK_PHYS)
167 : 0 : goto out;
168 : :
169 [ # # ]: 0 : if (walk->iv != walk->oiv)
170 : 0 : memcpy(walk->oiv, walk->iv, walk->ivsize);
171 [ # # ]: 0 : if (walk->buffer != walk->page)
172 : 0 : kfree(walk->buffer);
173 [ # # ]: 0 : if (walk->page)
174 : 0 : free_page((unsigned long)walk->page);
175 : :
176 : 0 : out:
177 : : return err;
178 : : }
179 : : EXPORT_SYMBOL_GPL(skcipher_walk_done);
180 : :
181 : 0 : void skcipher_walk_complete(struct skcipher_walk *walk, int err)
182 : : {
183 : 0 : struct skcipher_walk_buffer *p, *tmp;
184 : :
185 [ # # ]: 0 : list_for_each_entry_safe(p, tmp, &walk->buffers, entry) {
186 : 0 : u8 *data;
187 : :
188 [ # # ]: 0 : if (err)
189 : 0 : goto done;
190 : :
191 : 0 : data = p->data;
192 [ # # ]: 0 : if (!data) {
193 : 0 : data = PTR_ALIGN(&p->buffer[0], walk->alignmask + 1);
194 : 0 : data = skcipher_get_spot(data, walk->stride);
195 : : }
196 : :
197 : 0 : scatterwalk_copychunks(data, &p->dst, p->len, 1);
198 : :
199 [ # # ]: 0 : if (offset_in_page(p->data) + p->len + walk->stride >
200 : : PAGE_SIZE)
201 : 0 : free_page((unsigned long)p->data);
202 : :
203 : 0 : done:
204 : 0 : list_del(&p->entry);
205 : 0 : kfree(p);
206 : : }
207 : :
208 [ # # # # ]: 0 : if (!err && walk->iv != walk->oiv)
209 : 0 : memcpy(walk->oiv, walk->iv, walk->ivsize);
210 [ # # ]: 0 : if (walk->buffer != walk->page)
211 : 0 : kfree(walk->buffer);
212 [ # # ]: 0 : if (walk->page)
213 : 0 : free_page((unsigned long)walk->page);
214 : 0 : }
215 : : EXPORT_SYMBOL_GPL(skcipher_walk_complete);
216 : :
217 : 0 : static void skcipher_queue_write(struct skcipher_walk *walk,
218 : : struct skcipher_walk_buffer *p)
219 : : {
220 : 0 : p->dst = walk->out;
221 : 0 : list_add_tail(&p->entry, &walk->buffers);
222 : : }
223 : :
224 : 0 : static int skcipher_next_slow(struct skcipher_walk *walk, unsigned int bsize)
225 : : {
226 : 0 : bool phys = walk->flags & SKCIPHER_WALK_PHYS;
227 : 0 : unsigned alignmask = walk->alignmask;
228 : 0 : struct skcipher_walk_buffer *p;
229 : 0 : unsigned a;
230 : 0 : unsigned n;
231 : 0 : u8 *buffer;
232 : 0 : void *v;
233 : :
234 [ # # ]: 0 : if (!phys) {
235 [ # # ]: 0 : if (!walk->buffer)
236 : 0 : walk->buffer = walk->page;
237 : 0 : buffer = walk->buffer;
238 [ # # ]: 0 : if (buffer)
239 : 0 : goto ok;
240 : : }
241 : :
242 : : /* Start with the minimum alignment of kmalloc. */
243 [ # # ]: 0 : a = crypto_tfm_ctx_alignment() - 1;
244 : 0 : n = bsize;
245 : :
246 [ # # ]: 0 : if (phys) {
247 : : /* Calculate the minimum alignment of p->buffer. */
248 : 0 : a &= (sizeof(*p) ^ (sizeof(*p) - 1)) >> 1;
249 : 0 : n += sizeof(*p);
250 : : }
251 : :
252 : : /* Minimum size to align p->buffer by alignmask. */
253 : 0 : n += alignmask & ~a;
254 : :
255 : : /* Minimum size to ensure p->buffer does not straddle a page. */
256 : 0 : n += (bsize - 1) & ~(alignmask | a);
257 : :
258 [ # # ]: 0 : v = kzalloc(n, skcipher_walk_gfp(walk));
259 [ # # ]: 0 : if (!v)
260 : 0 : return skcipher_walk_done(walk, -ENOMEM);
261 : :
262 [ # # ]: 0 : if (phys) {
263 : 0 : p = v;
264 : 0 : p->len = bsize;
265 : 0 : skcipher_queue_write(walk, p);
266 : 0 : buffer = p->buffer;
267 : : } else {
268 : 0 : walk->buffer = v;
269 : 0 : buffer = v;
270 : : }
271 : :
272 : 0 : ok:
273 : 0 : walk->dst.virt.addr = PTR_ALIGN(buffer, alignmask + 1);
274 : 0 : walk->dst.virt.addr = skcipher_get_spot(walk->dst.virt.addr, bsize);
275 : 0 : walk->src.virt.addr = walk->dst.virt.addr;
276 : :
277 : 0 : scatterwalk_copychunks(walk->src.virt.addr, &walk->in, bsize, 0);
278 : :
279 : 0 : walk->nbytes = bsize;
280 : 0 : walk->flags |= SKCIPHER_WALK_SLOW;
281 : :
282 : 0 : return 0;
283 : : }
284 : :
285 : 0 : static int skcipher_next_copy(struct skcipher_walk *walk)
286 : : {
287 : 0 : struct skcipher_walk_buffer *p;
288 : 0 : u8 *tmp = walk->page;
289 : :
290 [ # # ]: 0 : skcipher_map_src(walk);
291 : 0 : memcpy(tmp, walk->src.virt.addr, walk->nbytes);
292 : 0 : skcipher_unmap_src(walk);
293 : :
294 : 0 : walk->src.virt.addr = tmp;
295 : 0 : walk->dst.virt.addr = tmp;
296 : :
297 [ # # ]: 0 : if (!(walk->flags & SKCIPHER_WALK_PHYS))
298 : : return 0;
299 : :
300 [ # # ]: 0 : p = kmalloc(sizeof(*p), skcipher_walk_gfp(walk));
301 [ # # ]: 0 : if (!p)
302 : : return -ENOMEM;
303 : :
304 : 0 : p->data = walk->page;
305 : 0 : p->len = walk->nbytes;
306 [ # # ]: 0 : skcipher_queue_write(walk, p);
307 : :
308 [ # # ]: 0 : if (offset_in_page(walk->page) + walk->nbytes + walk->stride >
309 : : PAGE_SIZE)
310 : 0 : walk->page = NULL;
311 : : else
312 : 0 : walk->page += walk->nbytes;
313 : :
314 : : return 0;
315 : : }
316 : :
317 : 0 : static int skcipher_next_fast(struct skcipher_walk *walk)
318 : : {
319 : 0 : unsigned long diff;
320 : :
321 [ # # ]: 0 : walk->src.phys.page = scatterwalk_page(&walk->in);
322 : 0 : walk->src.phys.offset = offset_in_page(walk->in.offset);
323 : 0 : walk->dst.phys.page = scatterwalk_page(&walk->out);
324 : 0 : walk->dst.phys.offset = offset_in_page(walk->out.offset);
325 : :
326 [ # # ]: 0 : if (walk->flags & SKCIPHER_WALK_PHYS)
327 : : return 0;
328 : :
329 : 0 : diff = walk->src.phys.offset - walk->dst.phys.offset;
330 : 0 : diff |= walk->src.virt.page - walk->dst.virt.page;
331 : :
332 [ # # ]: 0 : skcipher_map_src(walk);
333 : 0 : walk->dst.virt.addr = walk->src.virt.addr;
334 : :
335 [ # # ]: 0 : if (diff) {
336 : 0 : walk->flags |= SKCIPHER_WALK_DIFF;
337 : 0 : skcipher_map_dst(walk);
338 : : }
339 : :
340 : : return 0;
341 : : }
342 : :
343 : 0 : static int skcipher_walk_next(struct skcipher_walk *walk)
344 : : {
345 : 0 : unsigned int bsize;
346 : 0 : unsigned int n;
347 : 0 : int err;
348 : :
349 : 0 : walk->flags &= ~(SKCIPHER_WALK_SLOW | SKCIPHER_WALK_COPY |
350 : : SKCIPHER_WALK_DIFF);
351 : :
352 : 0 : n = walk->total;
353 : 0 : bsize = min(walk->stride, max(n, walk->blocksize));
354 [ # # ]: 0 : n = scatterwalk_clamp(&walk->in, n);
355 : 0 : n = scatterwalk_clamp(&walk->out, n);
356 : :
357 [ # # ]: 0 : if (unlikely(n < bsize)) {
358 [ # # ]: 0 : if (unlikely(walk->total < walk->blocksize))
359 : 0 : return skcipher_walk_done(walk, -EINVAL);
360 : :
361 : 0 : slow_path:
362 : 0 : err = skcipher_next_slow(walk, bsize);
363 : 0 : goto set_phys_lowmem;
364 : : }
365 : :
366 [ # # ]: 0 : if (unlikely((walk->in.offset | walk->out.offset) & walk->alignmask)) {
367 [ # # ]: 0 : if (!walk->page) {
368 [ # # ]: 0 : gfp_t gfp = skcipher_walk_gfp(walk);
369 : :
370 : 0 : walk->page = (void *)__get_free_page(gfp);
371 [ # # ]: 0 : if (!walk->page)
372 : 0 : goto slow_path;
373 : : }
374 : :
375 : 0 : walk->nbytes = min_t(unsigned, n,
376 : : PAGE_SIZE - offset_in_page(walk->page));
377 : 0 : walk->flags |= SKCIPHER_WALK_COPY;
378 : 0 : err = skcipher_next_copy(walk);
379 : 0 : goto set_phys_lowmem;
380 : : }
381 : :
382 : 0 : walk->nbytes = n;
383 : :
384 : 0 : return skcipher_next_fast(walk);
385 : :
386 : 0 : set_phys_lowmem:
387 [ # # # # ]: 0 : if (!err && (walk->flags & SKCIPHER_WALK_PHYS)) {
388 [ # # ]: 0 : walk->src.phys.page = virt_to_page(walk->src.virt.addr);
389 [ # # ]: 0 : walk->dst.phys.page = virt_to_page(walk->dst.virt.addr);
390 : 0 : walk->src.phys.offset &= PAGE_SIZE - 1;
391 : 0 : walk->dst.phys.offset &= PAGE_SIZE - 1;
392 : : }
393 : : return err;
394 : : }
395 : :
396 : 0 : static int skcipher_copy_iv(struct skcipher_walk *walk)
397 : : {
398 [ # # ]: 0 : unsigned a = crypto_tfm_ctx_alignment() - 1;
399 : 0 : unsigned alignmask = walk->alignmask;
400 : 0 : unsigned ivsize = walk->ivsize;
401 : 0 : unsigned bs = walk->stride;
402 : 0 : unsigned aligned_bs;
403 : 0 : unsigned size;
404 : 0 : u8 *iv;
405 : :
406 : 0 : aligned_bs = ALIGN(bs, alignmask + 1);
407 : :
408 : : /* Minimum size to align buffer by alignmask. */
409 : 0 : size = alignmask & ~a;
410 : :
411 [ # # ]: 0 : if (walk->flags & SKCIPHER_WALK_PHYS)
412 : 0 : size += ivsize;
413 : : else {
414 : 0 : size += aligned_bs + ivsize;
415 : :
416 : : /* Minimum size to ensure buffer does not straddle a page. */
417 : 0 : size += (bs - 1) & ~(alignmask | a);
418 : : }
419 : :
420 [ # # # # ]: 0 : walk->buffer = kmalloc(size, skcipher_walk_gfp(walk));
421 [ # # ]: 0 : if (!walk->buffer)
422 : : return -ENOMEM;
423 : :
424 : 0 : iv = PTR_ALIGN(walk->buffer, alignmask + 1);
425 : 0 : iv = skcipher_get_spot(iv, bs) + aligned_bs;
426 : :
427 : 0 : walk->iv = memcpy(iv, walk->iv, walk->ivsize);
428 : 0 : return 0;
429 : : }
430 : :
431 : 0 : static int skcipher_walk_first(struct skcipher_walk *walk)
432 : : {
433 [ # # # # ]: 0 : if (WARN_ON_ONCE(in_irq()))
434 : : return -EDEADLK;
435 : :
436 : 0 : walk->buffer = NULL;
437 [ # # ]: 0 : if (unlikely(((unsigned long)walk->iv & walk->alignmask))) {
438 : 0 : int err = skcipher_copy_iv(walk);
439 [ # # ]: 0 : if (err)
440 : : return err;
441 : : }
442 : :
443 : 0 : walk->page = NULL;
444 : :
445 : 0 : return skcipher_walk_next(walk);
446 : : }
447 : :
448 : 0 : static int skcipher_walk_skcipher(struct skcipher_walk *walk,
449 : : struct skcipher_request *req)
450 : : {
451 [ # # ]: 0 : struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
452 : :
453 : 0 : walk->total = req->cryptlen;
454 : 0 : walk->nbytes = 0;
455 : 0 : walk->iv = req->iv;
456 : 0 : walk->oiv = req->iv;
457 : :
458 [ # # ]: 0 : if (unlikely(!walk->total))
459 : : return 0;
460 : :
461 : 0 : scatterwalk_start(&walk->in, req->src);
462 : 0 : scatterwalk_start(&walk->out, req->dst);
463 : :
464 : 0 : walk->flags &= ~SKCIPHER_WALK_SLEEP;
465 : 0 : walk->flags |= req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ?
466 : 0 : SKCIPHER_WALK_SLEEP : 0;
467 : :
468 : 0 : walk->blocksize = crypto_skcipher_blocksize(tfm);
469 : 0 : walk->stride = crypto_skcipher_walksize(tfm);
470 : 0 : walk->ivsize = crypto_skcipher_ivsize(tfm);
471 : 0 : walk->alignmask = crypto_skcipher_alignmask(tfm);
472 : :
473 : 0 : return skcipher_walk_first(walk);
474 : : }
475 : :
476 : 0 : int skcipher_walk_virt(struct skcipher_walk *walk,
477 : : struct skcipher_request *req, bool atomic)
478 : : {
479 : 0 : int err;
480 : :
481 [ # # ]: 0 : might_sleep_if(req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
482 : :
483 : 0 : walk->flags &= ~SKCIPHER_WALK_PHYS;
484 : :
485 : 0 : err = skcipher_walk_skcipher(walk, req);
486 : :
487 [ # # ]: 0 : walk->flags &= atomic ? ~SKCIPHER_WALK_SLEEP : ~0;
488 : :
489 : 0 : return err;
490 : : }
491 : : EXPORT_SYMBOL_GPL(skcipher_walk_virt);
492 : :
493 : 0 : void skcipher_walk_atomise(struct skcipher_walk *walk)
494 : : {
495 : 0 : walk->flags &= ~SKCIPHER_WALK_SLEEP;
496 : 0 : }
497 : : EXPORT_SYMBOL_GPL(skcipher_walk_atomise);
498 : :
499 : 0 : int skcipher_walk_async(struct skcipher_walk *walk,
500 : : struct skcipher_request *req)
501 : : {
502 : 0 : walk->flags |= SKCIPHER_WALK_PHYS;
503 : :
504 : 0 : INIT_LIST_HEAD(&walk->buffers);
505 : :
506 : 0 : return skcipher_walk_skcipher(walk, req);
507 : : }
508 : : EXPORT_SYMBOL_GPL(skcipher_walk_async);
509 : :
510 : 0 : static int skcipher_walk_aead_common(struct skcipher_walk *walk,
511 : : struct aead_request *req, bool atomic)
512 : : {
513 [ # # ]: 0 : struct crypto_aead *tfm = crypto_aead_reqtfm(req);
514 : 0 : int err;
515 : :
516 : 0 : walk->nbytes = 0;
517 : 0 : walk->iv = req->iv;
518 : 0 : walk->oiv = req->iv;
519 : :
520 [ # # ]: 0 : if (unlikely(!walk->total))
521 : : return 0;
522 : :
523 : 0 : walk->flags &= ~SKCIPHER_WALK_PHYS;
524 : :
525 : 0 : scatterwalk_start(&walk->in, req->src);
526 : 0 : scatterwalk_start(&walk->out, req->dst);
527 : :
528 : 0 : scatterwalk_copychunks(NULL, &walk->in, req->assoclen, 2);
529 : 0 : scatterwalk_copychunks(NULL, &walk->out, req->assoclen, 2);
530 : :
531 : 0 : scatterwalk_done(&walk->in, 0, walk->total);
532 : 0 : scatterwalk_done(&walk->out, 0, walk->total);
533 : :
534 [ # # ]: 0 : if (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP)
535 : 0 : walk->flags |= SKCIPHER_WALK_SLEEP;
536 : : else
537 : 0 : walk->flags &= ~SKCIPHER_WALK_SLEEP;
538 : :
539 : 0 : walk->blocksize = crypto_aead_blocksize(tfm);
540 : 0 : walk->stride = crypto_aead_chunksize(tfm);
541 : 0 : walk->ivsize = crypto_aead_ivsize(tfm);
542 : 0 : walk->alignmask = crypto_aead_alignmask(tfm);
543 : :
544 : 0 : err = skcipher_walk_first(walk);
545 : :
546 [ # # ]: 0 : if (atomic)
547 : 0 : walk->flags &= ~SKCIPHER_WALK_SLEEP;
548 : :
549 : : return err;
550 : : }
551 : :
552 : 0 : int skcipher_walk_aead_encrypt(struct skcipher_walk *walk,
553 : : struct aead_request *req, bool atomic)
554 : : {
555 : 0 : walk->total = req->cryptlen;
556 : :
557 : 0 : return skcipher_walk_aead_common(walk, req, atomic);
558 : : }
559 : : EXPORT_SYMBOL_GPL(skcipher_walk_aead_encrypt);
560 : :
561 : 0 : int skcipher_walk_aead_decrypt(struct skcipher_walk *walk,
562 : : struct aead_request *req, bool atomic)
563 : : {
564 : 0 : struct crypto_aead *tfm = crypto_aead_reqtfm(req);
565 : :
566 : 0 : walk->total = req->cryptlen - crypto_aead_authsize(tfm);
567 : :
568 : 0 : return skcipher_walk_aead_common(walk, req, atomic);
569 : : }
570 : : EXPORT_SYMBOL_GPL(skcipher_walk_aead_decrypt);
571 : :
572 : 0 : static void skcipher_set_needkey(struct crypto_skcipher *tfm)
573 : : {
574 : 0 : if (crypto_skcipher_max_keysize(tfm) != 0)
575 : 0 : crypto_skcipher_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
576 : : }
577 : :
578 : 0 : static int skcipher_setkey_unaligned(struct crypto_skcipher *tfm,
579 : : const u8 *key, unsigned int keylen)
580 : : {
581 [ # # ]: 0 : unsigned long alignmask = crypto_skcipher_alignmask(tfm);
582 [ # # ]: 0 : struct skcipher_alg *cipher = crypto_skcipher_alg(tfm);
583 : 0 : u8 *buffer, *alignbuffer;
584 : 0 : unsigned long absize;
585 : 0 : int ret;
586 : :
587 : 0 : absize = keylen + alignmask;
588 [ # # ]: 0 : buffer = kmalloc(absize, GFP_ATOMIC);
589 [ # # ]: 0 : if (!buffer)
590 : : return -ENOMEM;
591 : :
592 : 0 : alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
593 : 0 : memcpy(alignbuffer, key, keylen);
594 : 0 : ret = cipher->setkey(tfm, alignbuffer, keylen);
595 : 0 : kzfree(buffer);
596 : 0 : return ret;
597 : : }
598 : :
599 : 0 : int crypto_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
600 : : unsigned int keylen)
601 : : {
602 [ # # ]: 0 : struct skcipher_alg *cipher = crypto_skcipher_alg(tfm);
603 [ # # ]: 0 : unsigned long alignmask = crypto_skcipher_alignmask(tfm);
604 : 0 : int err;
605 : :
606 [ # # # # ]: 0 : if (keylen < cipher->min_keysize || keylen > cipher->max_keysize)
607 : : return -EINVAL;
608 : :
609 [ # # ]: 0 : if ((unsigned long)key & alignmask)
610 : 0 : err = skcipher_setkey_unaligned(tfm, key, keylen);
611 : : else
612 : 0 : err = cipher->setkey(tfm, key, keylen);
613 : :
614 [ # # ]: 0 : if (unlikely(err)) {
615 [ # # ]: 0 : skcipher_set_needkey(tfm);
616 : 0 : return err;
617 : : }
618 : :
619 : 0 : crypto_skcipher_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
620 : 0 : return 0;
621 : : }
622 : : EXPORT_SYMBOL_GPL(crypto_skcipher_setkey);
623 : :
624 : 0 : int crypto_skcipher_encrypt(struct skcipher_request *req)
625 : : {
626 [ # # ]: 0 : struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
627 : 0 : struct crypto_alg *alg = tfm->base.__crt_alg;
628 : 0 : unsigned int cryptlen = req->cryptlen;
629 : 0 : int ret;
630 : :
631 [ # # ]: 0 : crypto_stats_get(alg);
632 [ # # ]: 0 : if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
633 : : ret = -ENOKEY;
634 : : else
635 : 0 : ret = crypto_skcipher_alg(tfm)->encrypt(req);
636 : 0 : crypto_stats_skcipher_encrypt(cryptlen, ret, alg);
637 : 0 : return ret;
638 : : }
639 : : EXPORT_SYMBOL_GPL(crypto_skcipher_encrypt);
640 : :
641 : 0 : int crypto_skcipher_decrypt(struct skcipher_request *req)
642 : : {
643 [ # # ]: 0 : struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
644 : 0 : struct crypto_alg *alg = tfm->base.__crt_alg;
645 : 0 : unsigned int cryptlen = req->cryptlen;
646 : 0 : int ret;
647 : :
648 [ # # ]: 0 : crypto_stats_get(alg);
649 [ # # ]: 0 : if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
650 : : ret = -ENOKEY;
651 : : else
652 : 0 : ret = crypto_skcipher_alg(tfm)->decrypt(req);
653 : 0 : crypto_stats_skcipher_decrypt(cryptlen, ret, alg);
654 : 0 : return ret;
655 : : }
656 : : EXPORT_SYMBOL_GPL(crypto_skcipher_decrypt);
657 : :
658 : 0 : static void crypto_skcipher_exit_tfm(struct crypto_tfm *tfm)
659 : : {
660 : 0 : struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
661 : 0 : struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);
662 : :
663 : 0 : alg->exit(skcipher);
664 : 0 : }
665 : :
666 : 0 : static int crypto_skcipher_init_tfm(struct crypto_tfm *tfm)
667 : : {
668 [ # # ]: 0 : struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
669 [ # # ]: 0 : struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);
670 : :
671 [ # # ]: 0 : skcipher_set_needkey(skcipher);
672 : :
673 [ # # ]: 0 : if (alg->exit)
674 : 0 : skcipher->base.exit = crypto_skcipher_exit_tfm;
675 : :
676 [ # # ]: 0 : if (alg->init)
677 : 0 : return alg->init(skcipher);
678 : :
679 : : return 0;
680 : : }
681 : :
682 : 0 : static void crypto_skcipher_free_instance(struct crypto_instance *inst)
683 : : {
684 : 0 : struct skcipher_instance *skcipher =
685 : 0 : container_of(inst, struct skcipher_instance, s.base);
686 : :
687 : 0 : skcipher->free(skcipher);
688 : 0 : }
689 : :
690 : : static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
691 : : __maybe_unused;
692 : 0 : static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
693 : : {
694 : 0 : struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
695 : : base);
696 : :
697 : 0 : seq_printf(m, "type : skcipher\n");
698 : 0 : seq_printf(m, "async : %s\n",
699 [ # # ]: 0 : alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
700 : 0 : seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
701 : 0 : seq_printf(m, "min keysize : %u\n", skcipher->min_keysize);
702 : 0 : seq_printf(m, "max keysize : %u\n", skcipher->max_keysize);
703 : 0 : seq_printf(m, "ivsize : %u\n", skcipher->ivsize);
704 : 0 : seq_printf(m, "chunksize : %u\n", skcipher->chunksize);
705 : 0 : seq_printf(m, "walksize : %u\n", skcipher->walksize);
706 : 0 : }
707 : :
708 : : #ifdef CONFIG_NET
709 : 0 : static int crypto_skcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
710 : : {
711 : 0 : struct crypto_report_blkcipher rblkcipher;
712 : 0 : struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
713 : : base);
714 : :
715 : 0 : memset(&rblkcipher, 0, sizeof(rblkcipher));
716 : :
717 : 0 : strscpy(rblkcipher.type, "skcipher", sizeof(rblkcipher.type));
718 : 0 : strscpy(rblkcipher.geniv, "<none>", sizeof(rblkcipher.geniv));
719 : :
720 : 0 : rblkcipher.blocksize = alg->cra_blocksize;
721 : 0 : rblkcipher.min_keysize = skcipher->min_keysize;
722 : 0 : rblkcipher.max_keysize = skcipher->max_keysize;
723 : 0 : rblkcipher.ivsize = skcipher->ivsize;
724 : :
725 : 0 : return nla_put(skb, CRYPTOCFGA_REPORT_BLKCIPHER,
726 : : sizeof(rblkcipher), &rblkcipher);
727 : : }
728 : : #else
729 : : static int crypto_skcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
730 : : {
731 : : return -ENOSYS;
732 : : }
733 : : #endif
734 : :
735 : : static const struct crypto_type crypto_skcipher_type = {
736 : : .extsize = crypto_alg_extsize,
737 : : .init_tfm = crypto_skcipher_init_tfm,
738 : : .free = crypto_skcipher_free_instance,
739 : : #ifdef CONFIG_PROC_FS
740 : : .show = crypto_skcipher_show,
741 : : #endif
742 : : .report = crypto_skcipher_report,
743 : : .maskclear = ~CRYPTO_ALG_TYPE_MASK,
744 : : .maskset = CRYPTO_ALG_TYPE_MASK,
745 : : .type = CRYPTO_ALG_TYPE_SKCIPHER,
746 : : .tfmsize = offsetof(struct crypto_skcipher, base),
747 : : };
748 : :
749 : 0 : int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
750 : : struct crypto_instance *inst,
751 : : const char *name, u32 type, u32 mask)
752 : : {
753 : 0 : spawn->base.frontend = &crypto_skcipher_type;
754 : 0 : return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
755 : : }
756 : : EXPORT_SYMBOL_GPL(crypto_grab_skcipher);
757 : :
758 : 0 : struct crypto_skcipher *crypto_alloc_skcipher(const char *alg_name,
759 : : u32 type, u32 mask)
760 : : {
761 : 0 : return crypto_alloc_tfm(alg_name, &crypto_skcipher_type, type, mask);
762 : : }
763 : : EXPORT_SYMBOL_GPL(crypto_alloc_skcipher);
764 : :
765 : 0 : struct crypto_sync_skcipher *crypto_alloc_sync_skcipher(
766 : : const char *alg_name, u32 type, u32 mask)
767 : : {
768 : 0 : struct crypto_skcipher *tfm;
769 : :
770 : : /* Only sync algorithms allowed. */
771 : 0 : mask |= CRYPTO_ALG_ASYNC;
772 : :
773 : 0 : tfm = crypto_alloc_tfm(alg_name, &crypto_skcipher_type, type, mask);
774 : :
775 : : /*
776 : : * Make sure we do not allocate something that might get used with
777 : : * an on-stack request: check the request size.
778 : : */
779 [ # # # # : 0 : if (!IS_ERR(tfm) && WARN_ON(crypto_skcipher_reqsize(tfm) >
# # ]
780 : : MAX_SYNC_SKCIPHER_REQSIZE)) {
781 : 0 : crypto_free_skcipher(tfm);
782 : 0 : return ERR_PTR(-EINVAL);
783 : : }
784 : :
785 : : return (struct crypto_sync_skcipher *)tfm;
786 : : }
787 : : EXPORT_SYMBOL_GPL(crypto_alloc_sync_skcipher);
788 : :
789 : 0 : int crypto_has_skcipher(const char *alg_name, u32 type, u32 mask)
790 : : {
791 : 0 : return crypto_type_has_alg(alg_name, &crypto_skcipher_type, type, mask);
792 : : }
793 : : EXPORT_SYMBOL_GPL(crypto_has_skcipher);
794 : :
795 : 13 : static int skcipher_prepare_alg(struct skcipher_alg *alg)
796 : : {
797 : 13 : struct crypto_alg *base = &alg->base;
798 : :
799 [ - - + - ]: 13 : if (alg->ivsize > PAGE_SIZE / 8 || alg->chunksize > PAGE_SIZE / 8 ||
800 [ - - + - ]: 13 : alg->walksize > PAGE_SIZE / 8)
801 : : return -EINVAL;
802 : :
803 [ - - + - ]: 13 : if (!alg->chunksize)
804 : 13 : alg->chunksize = base->cra_blocksize;
805 [ - - + - ]: 13 : if (!alg->walksize)
806 : 13 : alg->walksize = alg->chunksize;
807 : :
808 : 13 : base->cra_type = &crypto_skcipher_type;
809 : 13 : base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
810 : 13 : base->cra_flags |= CRYPTO_ALG_TYPE_SKCIPHER;
811 : :
812 : 13 : return 0;
813 : : }
814 : :
815 : 13 : int crypto_register_skcipher(struct skcipher_alg *alg)
816 : : {
817 : 13 : struct crypto_alg *base = &alg->base;
818 : 13 : int err;
819 : :
820 [ + - ]: 13 : err = skcipher_prepare_alg(alg);
821 : 13 : if (err)
822 : : return err;
823 : :
824 : 13 : return crypto_register_alg(base);
825 : : }
826 : : EXPORT_SYMBOL_GPL(crypto_register_skcipher);
827 : :
828 : 0 : void crypto_unregister_skcipher(struct skcipher_alg *alg)
829 : : {
830 : 0 : crypto_unregister_alg(&alg->base);
831 : 0 : }
832 : : EXPORT_SYMBOL_GPL(crypto_unregister_skcipher);
833 : :
834 : 0 : int crypto_register_skciphers(struct skcipher_alg *algs, int count)
835 : : {
836 : 0 : int i, ret;
837 : :
838 [ # # ]: 0 : for (i = 0; i < count; i++) {
839 : 0 : ret = crypto_register_skcipher(&algs[i]);
840 [ # # ]: 0 : if (ret)
841 : 0 : goto err;
842 : : }
843 : :
844 : : return 0;
845 : :
846 : : err:
847 [ # # ]: 0 : for (--i; i >= 0; --i)
848 : 0 : crypto_unregister_skcipher(&algs[i]);
849 : :
850 : : return ret;
851 : : }
852 : : EXPORT_SYMBOL_GPL(crypto_register_skciphers);
853 : :
854 : 0 : void crypto_unregister_skciphers(struct skcipher_alg *algs, int count)
855 : : {
856 : 0 : int i;
857 : :
858 [ # # ]: 0 : for (i = count - 1; i >= 0; --i)
859 : 0 : crypto_unregister_skcipher(&algs[i]);
860 : 0 : }
861 : : EXPORT_SYMBOL_GPL(crypto_unregister_skciphers);
862 : :
863 : 0 : int skcipher_register_instance(struct crypto_template *tmpl,
864 : : struct skcipher_instance *inst)
865 : : {
866 : 0 : int err;
867 : :
868 [ # # # # ]: 0 : if (WARN_ON(!inst->free))
869 : : return -EINVAL;
870 : :
871 [ # # ]: 0 : err = skcipher_prepare_alg(&inst->alg);
872 : 0 : if (err)
873 : : return err;
874 : :
875 : 0 : return crypto_register_instance(tmpl, skcipher_crypto_instance(inst));
876 : : }
877 : : EXPORT_SYMBOL_GPL(skcipher_register_instance);
878 : :
879 : 0 : static int skcipher_setkey_simple(struct crypto_skcipher *tfm, const u8 *key,
880 : : unsigned int keylen)
881 : : {
882 : 0 : struct crypto_cipher *cipher = skcipher_cipher_simple(tfm);
883 : :
884 : 0 : crypto_cipher_clear_flags(cipher, CRYPTO_TFM_REQ_MASK);
885 : 0 : crypto_cipher_set_flags(cipher, crypto_skcipher_get_flags(tfm) &
886 : : CRYPTO_TFM_REQ_MASK);
887 : 0 : return crypto_cipher_setkey(cipher, key, keylen);
888 : : }
889 : :
890 : 0 : static int skcipher_init_tfm_simple(struct crypto_skcipher *tfm)
891 : : {
892 : 0 : struct skcipher_instance *inst = skcipher_alg_instance(tfm);
893 : 0 : struct crypto_cipher_spawn *spawn = skcipher_instance_ctx(inst);
894 : 0 : struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);
895 : 0 : struct crypto_cipher *cipher;
896 : :
897 : 0 : cipher = crypto_spawn_cipher(spawn);
898 [ # # ]: 0 : if (IS_ERR(cipher))
899 : 0 : return PTR_ERR(cipher);
900 : :
901 : 0 : ctx->cipher = cipher;
902 : 0 : return 0;
903 : : }
904 : :
905 : 0 : static void skcipher_exit_tfm_simple(struct crypto_skcipher *tfm)
906 : : {
907 : 0 : struct skcipher_ctx_simple *ctx = crypto_skcipher_ctx(tfm);
908 : :
909 : 0 : crypto_free_cipher(ctx->cipher);
910 : 0 : }
911 : :
912 : 0 : static void skcipher_free_instance_simple(struct skcipher_instance *inst)
913 : : {
914 : 0 : crypto_drop_cipher(skcipher_instance_ctx(inst));
915 : 0 : kfree(inst);
916 : 0 : }
917 : :
918 : : /**
919 : : * skcipher_alloc_instance_simple - allocate instance of simple block cipher mode
920 : : *
921 : : * Allocate an skcipher_instance for a simple block cipher mode of operation,
922 : : * e.g. cbc or ecb. The instance context will have just a single crypto_spawn,
923 : : * that for the underlying cipher. The {min,max}_keysize, ivsize, blocksize,
924 : : * alignmask, and priority are set from the underlying cipher but can be
925 : : * overridden if needed. The tfm context defaults to skcipher_ctx_simple, and
926 : : * default ->setkey(), ->init(), and ->exit() methods are installed.
927 : : *
928 : : * @tmpl: the template being instantiated
929 : : * @tb: the template parameters
930 : : *
931 : : * Return: a pointer to the new instance, or an ERR_PTR(). The caller still
932 : : * needs to register the instance.
933 : : */
934 : 0 : struct skcipher_instance *skcipher_alloc_instance_simple(
935 : : struct crypto_template *tmpl, struct rtattr **tb)
936 : : {
937 : 0 : struct crypto_attr_type *algt;
938 : 0 : u32 mask;
939 : 0 : struct skcipher_instance *inst;
940 : 0 : struct crypto_cipher_spawn *spawn;
941 : 0 : struct crypto_alg *cipher_alg;
942 : 0 : int err;
943 : :
944 : 0 : algt = crypto_get_attr_type(tb);
945 [ # # ]: 0 : if (IS_ERR(algt))
946 : : return ERR_CAST(algt);
947 : :
948 [ # # ]: 0 : if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
949 : : return ERR_PTR(-EINVAL);
950 : :
951 : 0 : mask = crypto_requires_off(algt->type, algt->mask,
952 : : CRYPTO_ALG_NEED_FALLBACK);
953 : :
954 : 0 : inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
955 [ # # ]: 0 : if (!inst)
956 : : return ERR_PTR(-ENOMEM);
957 : 0 : spawn = skcipher_instance_ctx(inst);
958 : :
959 : 0 : err = crypto_grab_cipher(spawn, skcipher_crypto_instance(inst),
960 : : crypto_attr_alg_name(tb[1]), 0, mask);
961 [ # # ]: 0 : if (err)
962 : 0 : goto err_free_inst;
963 : 0 : cipher_alg = crypto_spawn_cipher_alg(spawn);
964 : :
965 : 0 : err = crypto_inst_setname(skcipher_crypto_instance(inst), tmpl->name,
966 : : cipher_alg);
967 [ # # ]: 0 : if (err)
968 : 0 : goto err_free_inst;
969 : :
970 : 0 : inst->free = skcipher_free_instance_simple;
971 : :
972 : : /* Default algorithm properties, can be overridden */
973 : 0 : inst->alg.base.cra_blocksize = cipher_alg->cra_blocksize;
974 : 0 : inst->alg.base.cra_alignmask = cipher_alg->cra_alignmask;
975 : 0 : inst->alg.base.cra_priority = cipher_alg->cra_priority;
976 : 0 : inst->alg.min_keysize = cipher_alg->cra_cipher.cia_min_keysize;
977 : 0 : inst->alg.max_keysize = cipher_alg->cra_cipher.cia_max_keysize;
978 : 0 : inst->alg.ivsize = cipher_alg->cra_blocksize;
979 : :
980 : : /* Use skcipher_ctx_simple by default, can be overridden */
981 : 0 : inst->alg.base.cra_ctxsize = sizeof(struct skcipher_ctx_simple);
982 : 0 : inst->alg.setkey = skcipher_setkey_simple;
983 : 0 : inst->alg.init = skcipher_init_tfm_simple;
984 : 0 : inst->alg.exit = skcipher_exit_tfm_simple;
985 : :
986 : 0 : return inst;
987 : :
988 : 0 : err_free_inst:
989 : 0 : skcipher_free_instance_simple(inst);
990 : 0 : return ERR_PTR(err);
991 : : }
992 : : EXPORT_SYMBOL_GPL(skcipher_alloc_instance_simple);
993 : :
994 : : MODULE_LICENSE("GPL");
995 : : MODULE_DESCRIPTION("Symmetric key cipher type");
|
