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

TOMOYO Linux Cross Reference
Linux/crypto/skcipher.c

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

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