1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Symmetric key cipher operations.
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.
9 * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
12 #include <crypto/internal/aead.h>
13 #include <crypto/internal/cipher.h>
14 #include <crypto/internal/skcipher.h>
15 #include <crypto/scatterwalk.h>
16 #include <linux/bug.h>
17 #include <linux/cryptouser.h>
18 #include <linux/compiler.h>
19 #include <linux/list.h>
20 #include <linux/module.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/seq_file.h>
23 #include <net/netlink.h>
28 SKCIPHER_WALK_PHYS
= 1 << 0,
29 SKCIPHER_WALK_SLOW
= 1 << 1,
30 SKCIPHER_WALK_COPY
= 1 << 2,
31 SKCIPHER_WALK_DIFF
= 1 << 3,
32 SKCIPHER_WALK_SLEEP
= 1 << 4,
35 struct skcipher_walk_buffer
{
36 struct list_head entry
;
37 struct scatter_walk dst
;
43 static int skcipher_walk_next(struct skcipher_walk
*walk
);
45 static inline void skcipher_unmap(struct scatter_walk
*walk
, void *vaddr
)
47 if (PageHighMem(scatterwalk_page(walk
)))
51 static inline void *skcipher_map(struct scatter_walk
*walk
)
53 struct page
*page
= scatterwalk_page(walk
);
55 return (PageHighMem(page
) ? kmap_atomic(page
) : page_address(page
)) +
56 offset_in_page(walk
->offset
);
59 static inline void skcipher_map_src(struct skcipher_walk
*walk
)
61 walk
->src
.virt
.addr
= skcipher_map(&walk
->in
);
64 static inline void skcipher_map_dst(struct skcipher_walk
*walk
)
66 walk
->dst
.virt
.addr
= skcipher_map(&walk
->out
);
69 static inline void skcipher_unmap_src(struct skcipher_walk
*walk
)
71 skcipher_unmap(&walk
->in
, walk
->src
.virt
.addr
);
74 static inline void skcipher_unmap_dst(struct skcipher_walk
*walk
)
76 skcipher_unmap(&walk
->out
, walk
->dst
.virt
.addr
);
79 static inline gfp_t
skcipher_walk_gfp(struct skcipher_walk
*walk
)
81 return walk
->flags
& SKCIPHER_WALK_SLEEP
? GFP_KERNEL
: GFP_ATOMIC
;
84 /* Get a spot of the specified length that does not straddle a page.
85 * The caller needs to ensure that there is enough space for this operation.
87 static inline u8
*skcipher_get_spot(u8
*start
, unsigned int len
)
89 u8
*end_page
= (u8
*)(((unsigned long)(start
+ len
- 1)) & PAGE_MASK
);
91 return max(start
, end_page
);
94 static int skcipher_done_slow(struct skcipher_walk
*walk
, unsigned int bsize
)
98 addr
= (u8
*)ALIGN((unsigned long)walk
->buffer
, walk
->alignmask
+ 1);
99 addr
= skcipher_get_spot(addr
, bsize
);
100 scatterwalk_copychunks(addr
, &walk
->out
, bsize
,
101 (walk
->flags
& SKCIPHER_WALK_PHYS
) ? 2 : 1);
105 int skcipher_walk_done(struct skcipher_walk
*walk
, int err
)
107 unsigned int n
= walk
->nbytes
;
108 unsigned int nbytes
= 0;
113 if (likely(err
>= 0)) {
115 nbytes
= walk
->total
- n
;
118 if (likely(!(walk
->flags
& (SKCIPHER_WALK_PHYS
|
121 SKCIPHER_WALK_DIFF
)))) {
123 skcipher_unmap_src(walk
);
124 } else if (walk
->flags
& SKCIPHER_WALK_DIFF
) {
125 skcipher_unmap_dst(walk
);
127 } else if (walk
->flags
& SKCIPHER_WALK_COPY
) {
128 skcipher_map_dst(walk
);
129 memcpy(walk
->dst
.virt
.addr
, walk
->page
, n
);
130 skcipher_unmap_dst(walk
);
131 } else if (unlikely(walk
->flags
& SKCIPHER_WALK_SLOW
)) {
134 * Didn't process all bytes. Either the algorithm is
135 * broken, or this was the last step and it turned out
136 * the message wasn't evenly divisible into blocks but
137 * the algorithm requires it.
142 n
= skcipher_done_slow(walk
, n
);
148 walk
->total
= nbytes
;
151 scatterwalk_advance(&walk
->in
, n
);
152 scatterwalk_advance(&walk
->out
, n
);
153 scatterwalk_done(&walk
->in
, 0, nbytes
);
154 scatterwalk_done(&walk
->out
, 1, nbytes
);
157 crypto_yield(walk
->flags
& SKCIPHER_WALK_SLEEP
?
158 CRYPTO_TFM_REQ_MAY_SLEEP
: 0);
159 return skcipher_walk_next(walk
);
163 /* Short-circuit for the common/fast path. */
164 if (!((unsigned long)walk
->buffer
| (unsigned long)walk
->page
))
167 if (walk
->flags
& SKCIPHER_WALK_PHYS
)
170 if (walk
->iv
!= walk
->oiv
)
171 memcpy(walk
->oiv
, walk
->iv
, walk
->ivsize
);
172 if (walk
->buffer
!= walk
->page
)
175 free_page((unsigned long)walk
->page
);
180 EXPORT_SYMBOL_GPL(skcipher_walk_done
);
182 void skcipher_walk_complete(struct skcipher_walk
*walk
, int err
)
184 struct skcipher_walk_buffer
*p
, *tmp
;
186 list_for_each_entry_safe(p
, tmp
, &walk
->buffers
, entry
) {
194 data
= PTR_ALIGN(&p
->buffer
[0], walk
->alignmask
+ 1);
195 data
= skcipher_get_spot(data
, walk
->stride
);
198 scatterwalk_copychunks(data
, &p
->dst
, p
->len
, 1);
200 if (offset_in_page(p
->data
) + p
->len
+ walk
->stride
>
202 free_page((unsigned long)p
->data
);
209 if (!err
&& walk
->iv
!= walk
->oiv
)
210 memcpy(walk
->oiv
, walk
->iv
, walk
->ivsize
);
211 if (walk
->buffer
!= walk
->page
)
214 free_page((unsigned long)walk
->page
);
216 EXPORT_SYMBOL_GPL(skcipher_walk_complete
);
218 static void skcipher_queue_write(struct skcipher_walk
*walk
,
219 struct skcipher_walk_buffer
*p
)
222 list_add_tail(&p
->entry
, &walk
->buffers
);
225 static int skcipher_next_slow(struct skcipher_walk
*walk
, unsigned int bsize
)
227 bool phys
= walk
->flags
& SKCIPHER_WALK_PHYS
;
228 unsigned alignmask
= walk
->alignmask
;
229 struct skcipher_walk_buffer
*p
;
237 walk
->buffer
= walk
->page
;
238 buffer
= walk
->buffer
;
243 /* Start with the minimum alignment of kmalloc. */
244 a
= crypto_tfm_ctx_alignment() - 1;
248 /* Calculate the minimum alignment of p->buffer. */
249 a
&= (sizeof(*p
) ^ (sizeof(*p
) - 1)) >> 1;
253 /* Minimum size to align p->buffer by alignmask. */
256 /* Minimum size to ensure p->buffer does not straddle a page. */
257 n
+= (bsize
- 1) & ~(alignmask
| a
);
259 v
= kzalloc(n
, skcipher_walk_gfp(walk
));
261 return skcipher_walk_done(walk
, -ENOMEM
);
266 skcipher_queue_write(walk
, p
);
274 walk
->dst
.virt
.addr
= PTR_ALIGN(buffer
, alignmask
+ 1);
275 walk
->dst
.virt
.addr
= skcipher_get_spot(walk
->dst
.virt
.addr
, bsize
);
276 walk
->src
.virt
.addr
= walk
->dst
.virt
.addr
;
278 scatterwalk_copychunks(walk
->src
.virt
.addr
, &walk
->in
, bsize
, 0);
280 walk
->nbytes
= bsize
;
281 walk
->flags
|= SKCIPHER_WALK_SLOW
;
286 static int skcipher_next_copy(struct skcipher_walk
*walk
)
288 struct skcipher_walk_buffer
*p
;
289 u8
*tmp
= walk
->page
;
291 skcipher_map_src(walk
);
292 memcpy(tmp
, walk
->src
.virt
.addr
, walk
->nbytes
);
293 skcipher_unmap_src(walk
);
295 walk
->src
.virt
.addr
= tmp
;
296 walk
->dst
.virt
.addr
= tmp
;
298 if (!(walk
->flags
& SKCIPHER_WALK_PHYS
))
301 p
= kmalloc(sizeof(*p
), skcipher_walk_gfp(walk
));
305 p
->data
= walk
->page
;
306 p
->len
= walk
->nbytes
;
307 skcipher_queue_write(walk
, p
);
309 if (offset_in_page(walk
->page
) + walk
->nbytes
+ walk
->stride
>
313 walk
->page
+= walk
->nbytes
;
318 static int skcipher_next_fast(struct skcipher_walk
*walk
)
322 walk
->src
.phys
.page
= scatterwalk_page(&walk
->in
);
323 walk
->src
.phys
.offset
= offset_in_page(walk
->in
.offset
);
324 walk
->dst
.phys
.page
= scatterwalk_page(&walk
->out
);
325 walk
->dst
.phys
.offset
= offset_in_page(walk
->out
.offset
);
327 if (walk
->flags
& SKCIPHER_WALK_PHYS
)
330 diff
= walk
->src
.phys
.offset
- walk
->dst
.phys
.offset
;
331 diff
|= walk
->src
.virt
.page
- walk
->dst
.virt
.page
;
333 skcipher_map_src(walk
);
334 walk
->dst
.virt
.addr
= walk
->src
.virt
.addr
;
337 walk
->flags
|= SKCIPHER_WALK_DIFF
;
338 skcipher_map_dst(walk
);
344 static int skcipher_walk_next(struct skcipher_walk
*walk
)
350 walk
->flags
&= ~(SKCIPHER_WALK_SLOW
| SKCIPHER_WALK_COPY
|
354 bsize
= min(walk
->stride
, max(n
, walk
->blocksize
));
355 n
= scatterwalk_clamp(&walk
->in
, n
);
356 n
= scatterwalk_clamp(&walk
->out
, n
);
358 if (unlikely(n
< bsize
)) {
359 if (unlikely(walk
->total
< walk
->blocksize
))
360 return skcipher_walk_done(walk
, -EINVAL
);
363 err
= skcipher_next_slow(walk
, bsize
);
364 goto set_phys_lowmem
;
367 if (unlikely((walk
->in
.offset
| walk
->out
.offset
) & walk
->alignmask
)) {
369 gfp_t gfp
= skcipher_walk_gfp(walk
);
371 walk
->page
= (void *)__get_free_page(gfp
);
376 walk
->nbytes
= min_t(unsigned, n
,
377 PAGE_SIZE
- offset_in_page(walk
->page
));
378 walk
->flags
|= SKCIPHER_WALK_COPY
;
379 err
= skcipher_next_copy(walk
);
380 goto set_phys_lowmem
;
385 return skcipher_next_fast(walk
);
388 if (!err
&& (walk
->flags
& SKCIPHER_WALK_PHYS
)) {
389 walk
->src
.phys
.page
= virt_to_page(walk
->src
.virt
.addr
);
390 walk
->dst
.phys
.page
= virt_to_page(walk
->dst
.virt
.addr
);
391 walk
->src
.phys
.offset
&= PAGE_SIZE
- 1;
392 walk
->dst
.phys
.offset
&= PAGE_SIZE
- 1;
397 static int skcipher_copy_iv(struct skcipher_walk
*walk
)
399 unsigned a
= crypto_tfm_ctx_alignment() - 1;
400 unsigned alignmask
= walk
->alignmask
;
401 unsigned ivsize
= walk
->ivsize
;
402 unsigned bs
= walk
->stride
;
407 aligned_bs
= ALIGN(bs
, alignmask
+ 1);
409 /* Minimum size to align buffer by alignmask. */
410 size
= alignmask
& ~a
;
412 if (walk
->flags
& SKCIPHER_WALK_PHYS
)
415 size
+= aligned_bs
+ ivsize
;
417 /* Minimum size to ensure buffer does not straddle a page. */
418 size
+= (bs
- 1) & ~(alignmask
| a
);
421 walk
->buffer
= kmalloc(size
, skcipher_walk_gfp(walk
));
425 iv
= PTR_ALIGN(walk
->buffer
, alignmask
+ 1);
426 iv
= skcipher_get_spot(iv
, bs
) + aligned_bs
;
428 walk
->iv
= memcpy(iv
, walk
->iv
, walk
->ivsize
);
432 static int skcipher_walk_first(struct skcipher_walk
*walk
)
434 if (WARN_ON_ONCE(in_irq()))
438 if (unlikely(((unsigned long)walk
->iv
& walk
->alignmask
))) {
439 int err
= skcipher_copy_iv(walk
);
446 return skcipher_walk_next(walk
);
449 static int skcipher_walk_skcipher(struct skcipher_walk
*walk
,
450 struct skcipher_request
*req
)
452 struct crypto_skcipher
*tfm
= crypto_skcipher_reqtfm(req
);
454 walk
->total
= req
->cryptlen
;
459 if (unlikely(!walk
->total
))
462 scatterwalk_start(&walk
->in
, req
->src
);
463 scatterwalk_start(&walk
->out
, req
->dst
);
465 walk
->flags
&= ~SKCIPHER_WALK_SLEEP
;
466 walk
->flags
|= req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
?
467 SKCIPHER_WALK_SLEEP
: 0;
469 walk
->blocksize
= crypto_skcipher_blocksize(tfm
);
470 walk
->stride
= crypto_skcipher_walksize(tfm
);
471 walk
->ivsize
= crypto_skcipher_ivsize(tfm
);
472 walk
->alignmask
= crypto_skcipher_alignmask(tfm
);
474 return skcipher_walk_first(walk
);
477 int skcipher_walk_virt(struct skcipher_walk
*walk
,
478 struct skcipher_request
*req
, bool atomic
)
482 might_sleep_if(req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
);
484 walk
->flags
&= ~SKCIPHER_WALK_PHYS
;
486 err
= skcipher_walk_skcipher(walk
, req
);
488 walk
->flags
&= atomic
? ~SKCIPHER_WALK_SLEEP
: ~0;
492 EXPORT_SYMBOL_GPL(skcipher_walk_virt
);
494 int skcipher_walk_async(struct skcipher_walk
*walk
,
495 struct skcipher_request
*req
)
497 walk
->flags
|= SKCIPHER_WALK_PHYS
;
499 INIT_LIST_HEAD(&walk
->buffers
);
501 return skcipher_walk_skcipher(walk
, req
);
503 EXPORT_SYMBOL_GPL(skcipher_walk_async
);
505 static int skcipher_walk_aead_common(struct skcipher_walk
*walk
,
506 struct aead_request
*req
, bool atomic
)
508 struct crypto_aead
*tfm
= crypto_aead_reqtfm(req
);
515 if (unlikely(!walk
->total
))
518 walk
->flags
&= ~SKCIPHER_WALK_PHYS
;
520 scatterwalk_start(&walk
->in
, req
->src
);
521 scatterwalk_start(&walk
->out
, req
->dst
);
523 scatterwalk_copychunks(NULL
, &walk
->in
, req
->assoclen
, 2);
524 scatterwalk_copychunks(NULL
, &walk
->out
, req
->assoclen
, 2);
526 scatterwalk_done(&walk
->in
, 0, walk
->total
);
527 scatterwalk_done(&walk
->out
, 0, walk
->total
);
529 if (req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
)
530 walk
->flags
|= SKCIPHER_WALK_SLEEP
;
532 walk
->flags
&= ~SKCIPHER_WALK_SLEEP
;
534 walk
->blocksize
= crypto_aead_blocksize(tfm
);
535 walk
->stride
= crypto_aead_chunksize(tfm
);
536 walk
->ivsize
= crypto_aead_ivsize(tfm
);
537 walk
->alignmask
= crypto_aead_alignmask(tfm
);
539 err
= skcipher_walk_first(walk
);
542 walk
->flags
&= ~SKCIPHER_WALK_SLEEP
;
547 int skcipher_walk_aead_encrypt(struct skcipher_walk
*walk
,
548 struct aead_request
*req
, bool atomic
)
550 walk
->total
= req
->cryptlen
;
552 return skcipher_walk_aead_common(walk
, req
, atomic
);
554 EXPORT_SYMBOL_GPL(skcipher_walk_aead_encrypt
);
556 int skcipher_walk_aead_decrypt(struct skcipher_walk
*walk
,
557 struct aead_request
*req
, bool atomic
)
559 struct crypto_aead
*tfm
= crypto_aead_reqtfm(req
);
561 walk
->total
= req
->cryptlen
- crypto_aead_authsize(tfm
);
563 return skcipher_walk_aead_common(walk
, req
, atomic
);
565 EXPORT_SYMBOL_GPL(skcipher_walk_aead_decrypt
);
567 static void skcipher_set_needkey(struct crypto_skcipher
*tfm
)
569 if (crypto_skcipher_max_keysize(tfm
) != 0)
570 crypto_skcipher_set_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
573 static int skcipher_setkey_unaligned(struct crypto_skcipher
*tfm
,
574 const u8
*key
, unsigned int keylen
)
576 unsigned long alignmask
= crypto_skcipher_alignmask(tfm
);
577 struct skcipher_alg
*cipher
= crypto_skcipher_alg(tfm
);
578 u8
*buffer
, *alignbuffer
;
579 unsigned long absize
;
582 absize
= keylen
+ alignmask
;
583 buffer
= kmalloc(absize
, GFP_ATOMIC
);
587 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
588 memcpy(alignbuffer
, key
, keylen
);
589 ret
= cipher
->setkey(tfm
, alignbuffer
, keylen
);
590 kfree_sensitive(buffer
);
594 int crypto_skcipher_setkey(struct crypto_skcipher
*tfm
, const u8
*key
,
597 struct skcipher_alg
*cipher
= crypto_skcipher_alg(tfm
);
598 unsigned long alignmask
= crypto_skcipher_alignmask(tfm
);
601 if (keylen
< cipher
->min_keysize
|| keylen
> cipher
->max_keysize
)
604 if ((unsigned long)key
& alignmask
)
605 err
= skcipher_setkey_unaligned(tfm
, key
, keylen
);
607 err
= cipher
->setkey(tfm
, key
, keylen
);
610 skcipher_set_needkey(tfm
);
614 crypto_skcipher_clear_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
617 EXPORT_SYMBOL_GPL(crypto_skcipher_setkey
);
619 int crypto_skcipher_encrypt(struct skcipher_request
*req
)
621 struct crypto_skcipher
*tfm
= crypto_skcipher_reqtfm(req
);
622 struct crypto_alg
*alg
= tfm
->base
.__crt_alg
;
623 unsigned int cryptlen
= req
->cryptlen
;
626 crypto_stats_get(alg
);
627 if (crypto_skcipher_get_flags(tfm
) & CRYPTO_TFM_NEED_KEY
)
630 ret
= crypto_skcipher_alg(tfm
)->encrypt(req
);
631 crypto_stats_skcipher_encrypt(cryptlen
, ret
, alg
);
634 EXPORT_SYMBOL_GPL(crypto_skcipher_encrypt
);
636 int crypto_skcipher_decrypt(struct skcipher_request
*req
)
638 struct crypto_skcipher
*tfm
= crypto_skcipher_reqtfm(req
);
639 struct crypto_alg
*alg
= tfm
->base
.__crt_alg
;
640 unsigned int cryptlen
= req
->cryptlen
;
643 crypto_stats_get(alg
);
644 if (crypto_skcipher_get_flags(tfm
) & CRYPTO_TFM_NEED_KEY
)
647 ret
= crypto_skcipher_alg(tfm
)->decrypt(req
);
648 crypto_stats_skcipher_decrypt(cryptlen
, ret
, alg
);
651 EXPORT_SYMBOL_GPL(crypto_skcipher_decrypt
);
653 static void crypto_skcipher_exit_tfm(struct crypto_tfm
*tfm
)
655 struct crypto_skcipher
*skcipher
= __crypto_skcipher_cast(tfm
);
656 struct skcipher_alg
*alg
= crypto_skcipher_alg(skcipher
);
661 static int crypto_skcipher_init_tfm(struct crypto_tfm
*tfm
)
663 struct crypto_skcipher
*skcipher
= __crypto_skcipher_cast(tfm
);
664 struct skcipher_alg
*alg
= crypto_skcipher_alg(skcipher
);
666 skcipher_set_needkey(skcipher
);
669 skcipher
->base
.exit
= crypto_skcipher_exit_tfm
;
672 return alg
->init(skcipher
);
677 static void crypto_skcipher_free_instance(struct crypto_instance
*inst
)
679 struct skcipher_instance
*skcipher
=
680 container_of(inst
, struct skcipher_instance
, s
.base
);
682 skcipher
->free(skcipher
);
685 static void crypto_skcipher_show(struct seq_file
*m
, struct crypto_alg
*alg
)
687 static void crypto_skcipher_show(struct seq_file
*m
, struct crypto_alg
*alg
)
689 struct skcipher_alg
*skcipher
= container_of(alg
, struct skcipher_alg
,
692 seq_printf(m
, "type : skcipher\n");
693 seq_printf(m
, "async : %s\n",
694 alg
->cra_flags
& CRYPTO_ALG_ASYNC
? "yes" : "no");
695 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
696 seq_printf(m
, "min keysize : %u\n", skcipher
->min_keysize
);
697 seq_printf(m
, "max keysize : %u\n", skcipher
->max_keysize
);
698 seq_printf(m
, "ivsize : %u\n", skcipher
->ivsize
);
699 seq_printf(m
, "chunksize : %u\n", skcipher
->chunksize
);
700 seq_printf(m
, "walksize : %u\n", skcipher
->walksize
);
704 static int crypto_skcipher_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
706 struct crypto_report_blkcipher rblkcipher
;
707 struct skcipher_alg
*skcipher
= container_of(alg
, struct skcipher_alg
,
710 memset(&rblkcipher
, 0, sizeof(rblkcipher
));
712 strscpy(rblkcipher
.type
, "skcipher", sizeof(rblkcipher
.type
));
713 strscpy(rblkcipher
.geniv
, "<none>", sizeof(rblkcipher
.geniv
));
715 rblkcipher
.blocksize
= alg
->cra_blocksize
;
716 rblkcipher
.min_keysize
= skcipher
->min_keysize
;
717 rblkcipher
.max_keysize
= skcipher
->max_keysize
;
718 rblkcipher
.ivsize
= skcipher
->ivsize
;
720 return nla_put(skb
, CRYPTOCFGA_REPORT_BLKCIPHER
,
721 sizeof(rblkcipher
), &rblkcipher
);
724 static int crypto_skcipher_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
730 static const struct crypto_type crypto_skcipher_type
= {
731 .extsize
= crypto_alg_extsize
,
732 .init_tfm
= crypto_skcipher_init_tfm
,
733 .free
= crypto_skcipher_free_instance
,
734 #ifdef CONFIG_PROC_FS
735 .show
= crypto_skcipher_show
,
737 .report
= crypto_skcipher_report
,
738 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
739 .maskset
= CRYPTO_ALG_TYPE_MASK
,
740 .type
= CRYPTO_ALG_TYPE_SKCIPHER
,
741 .tfmsize
= offsetof(struct crypto_skcipher
, base
),
744 int crypto_grab_skcipher(struct crypto_skcipher_spawn
*spawn
,
745 struct crypto_instance
*inst
,
746 const char *name
, u32 type
, u32 mask
)
748 spawn
->base
.frontend
= &crypto_skcipher_type
;
749 return crypto_grab_spawn(&spawn
->base
, inst
, name
, type
, mask
);
751 EXPORT_SYMBOL_GPL(crypto_grab_skcipher
);
753 struct crypto_skcipher
*crypto_alloc_skcipher(const char *alg_name
,
756 return crypto_alloc_tfm(alg_name
, &crypto_skcipher_type
, type
, mask
);
758 EXPORT_SYMBOL_GPL(crypto_alloc_skcipher
);
760 struct crypto_sync_skcipher
*crypto_alloc_sync_skcipher(
761 const char *alg_name
, u32 type
, u32 mask
)
763 struct crypto_skcipher
*tfm
;
765 /* Only sync algorithms allowed. */
766 mask
|= CRYPTO_ALG_ASYNC
;
768 tfm
= crypto_alloc_tfm(alg_name
, &crypto_skcipher_type
, type
, mask
);
771 * Make sure we do not allocate something that might get used with
772 * an on-stack request: check the request size.
774 if (!IS_ERR(tfm
) && WARN_ON(crypto_skcipher_reqsize(tfm
) >
775 MAX_SYNC_SKCIPHER_REQSIZE
)) {
776 crypto_free_skcipher(tfm
);
777 return ERR_PTR(-EINVAL
);
780 return (struct crypto_sync_skcipher
*)tfm
;
782 EXPORT_SYMBOL_GPL(crypto_alloc_sync_skcipher
);
784 int crypto_has_skcipher(const char *alg_name
, u32 type
, u32 mask
)
786 return crypto_type_has_alg(alg_name
, &crypto_skcipher_type
, type
, mask
);
788 EXPORT_SYMBOL_GPL(crypto_has_skcipher
);
790 static int skcipher_prepare_alg(struct skcipher_alg
*alg
)
792 struct crypto_alg
*base
= &alg
->base
;
794 if (alg
->ivsize
> PAGE_SIZE
/ 8 || alg
->chunksize
> PAGE_SIZE
/ 8 ||
795 alg
->walksize
> PAGE_SIZE
/ 8)
799 alg
->chunksize
= base
->cra_blocksize
;
801 alg
->walksize
= alg
->chunksize
;
803 base
->cra_type
= &crypto_skcipher_type
;
804 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
805 base
->cra_flags
|= CRYPTO_ALG_TYPE_SKCIPHER
;
810 int crypto_register_skcipher(struct skcipher_alg
*alg
)
812 struct crypto_alg
*base
= &alg
->base
;
815 err
= skcipher_prepare_alg(alg
);
819 return crypto_register_alg(base
);
821 EXPORT_SYMBOL_GPL(crypto_register_skcipher
);
823 void crypto_unregister_skcipher(struct skcipher_alg
*alg
)
825 crypto_unregister_alg(&alg
->base
);
827 EXPORT_SYMBOL_GPL(crypto_unregister_skcipher
);
829 int crypto_register_skciphers(struct skcipher_alg
*algs
, int count
)
833 for (i
= 0; i
< count
; i
++) {
834 ret
= crypto_register_skcipher(&algs
[i
]);
842 for (--i
; i
>= 0; --i
)
843 crypto_unregister_skcipher(&algs
[i
]);
847 EXPORT_SYMBOL_GPL(crypto_register_skciphers
);
849 void crypto_unregister_skciphers(struct skcipher_alg
*algs
, int count
)
853 for (i
= count
- 1; i
>= 0; --i
)
854 crypto_unregister_skcipher(&algs
[i
]);
856 EXPORT_SYMBOL_GPL(crypto_unregister_skciphers
);
858 int skcipher_register_instance(struct crypto_template
*tmpl
,
859 struct skcipher_instance
*inst
)
863 if (WARN_ON(!inst
->free
))
866 err
= skcipher_prepare_alg(&inst
->alg
);
870 return crypto_register_instance(tmpl
, skcipher_crypto_instance(inst
));
872 EXPORT_SYMBOL_GPL(skcipher_register_instance
);
874 static int skcipher_setkey_simple(struct crypto_skcipher
*tfm
, const u8
*key
,
877 struct crypto_cipher
*cipher
= skcipher_cipher_simple(tfm
);
879 crypto_cipher_clear_flags(cipher
, CRYPTO_TFM_REQ_MASK
);
880 crypto_cipher_set_flags(cipher
, crypto_skcipher_get_flags(tfm
) &
881 CRYPTO_TFM_REQ_MASK
);
882 return crypto_cipher_setkey(cipher
, key
, keylen
);
885 static int skcipher_init_tfm_simple(struct crypto_skcipher
*tfm
)
887 struct skcipher_instance
*inst
= skcipher_alg_instance(tfm
);
888 struct crypto_cipher_spawn
*spawn
= skcipher_instance_ctx(inst
);
889 struct skcipher_ctx_simple
*ctx
= crypto_skcipher_ctx(tfm
);
890 struct crypto_cipher
*cipher
;
892 cipher
= crypto_spawn_cipher(spawn
);
894 return PTR_ERR(cipher
);
896 ctx
->cipher
= cipher
;
900 static void skcipher_exit_tfm_simple(struct crypto_skcipher
*tfm
)
902 struct skcipher_ctx_simple
*ctx
= crypto_skcipher_ctx(tfm
);
904 crypto_free_cipher(ctx
->cipher
);
907 static void skcipher_free_instance_simple(struct skcipher_instance
*inst
)
909 crypto_drop_cipher(skcipher_instance_ctx(inst
));
914 * skcipher_alloc_instance_simple - allocate instance of simple block cipher mode
916 * Allocate an skcipher_instance for a simple block cipher mode of operation,
917 * e.g. cbc or ecb. The instance context will have just a single crypto_spawn,
918 * that for the underlying cipher. The {min,max}_keysize, ivsize, blocksize,
919 * alignmask, and priority are set from the underlying cipher but can be
920 * overridden if needed. The tfm context defaults to skcipher_ctx_simple, and
921 * default ->setkey(), ->init(), and ->exit() methods are installed.
923 * @tmpl: the template being instantiated
924 * @tb: the template parameters
926 * Return: a pointer to the new instance, or an ERR_PTR(). The caller still
927 * needs to register the instance.
929 struct skcipher_instance
*skcipher_alloc_instance_simple(
930 struct crypto_template
*tmpl
, struct rtattr
**tb
)
933 struct skcipher_instance
*inst
;
934 struct crypto_cipher_spawn
*spawn
;
935 struct crypto_alg
*cipher_alg
;
938 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SKCIPHER
, &mask
);
942 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
944 return ERR_PTR(-ENOMEM
);
945 spawn
= skcipher_instance_ctx(inst
);
947 err
= crypto_grab_cipher(spawn
, skcipher_crypto_instance(inst
),
948 crypto_attr_alg_name(tb
[1]), 0, mask
);
951 cipher_alg
= crypto_spawn_cipher_alg(spawn
);
953 err
= crypto_inst_setname(skcipher_crypto_instance(inst
), tmpl
->name
,
958 inst
->free
= skcipher_free_instance_simple
;
960 /* Default algorithm properties, can be overridden */
961 inst
->alg
.base
.cra_blocksize
= cipher_alg
->cra_blocksize
;
962 inst
->alg
.base
.cra_alignmask
= cipher_alg
->cra_alignmask
;
963 inst
->alg
.base
.cra_priority
= cipher_alg
->cra_priority
;
964 inst
->alg
.min_keysize
= cipher_alg
->cra_cipher
.cia_min_keysize
;
965 inst
->alg
.max_keysize
= cipher_alg
->cra_cipher
.cia_max_keysize
;
966 inst
->alg
.ivsize
= cipher_alg
->cra_blocksize
;
968 /* Use skcipher_ctx_simple by default, can be overridden */
969 inst
->alg
.base
.cra_ctxsize
= sizeof(struct skcipher_ctx_simple
);
970 inst
->alg
.setkey
= skcipher_setkey_simple
;
971 inst
->alg
.init
= skcipher_init_tfm_simple
;
972 inst
->alg
.exit
= skcipher_exit_tfm_simple
;
977 skcipher_free_instance_simple(inst
);
980 EXPORT_SYMBOL_GPL(skcipher_alloc_instance_simple
);
982 MODULE_LICENSE("GPL");
983 MODULE_DESCRIPTION("Symmetric key cipher type");
984 MODULE_IMPORT_NS(CRYPTO_INTERNAL
);