4 * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
13 #include <crypto/algapi.h>
14 #include <linux/err.h>
15 #include <linux/init.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/random.h>
19 #include <linux/scatterlist.h>
20 #include <linux/slab.h>
22 struct ctr_instance_ctx
{
23 struct crypto_spawn alg
;
24 unsigned int noncesize
;
26 unsigned int countersize
;
29 struct crypto_ctr_ctx
{
30 struct crypto_cipher
*child
;
34 static int crypto_ctr_setkey(struct crypto_tfm
*parent
, const u8
*key
,
37 struct crypto_ctr_ctx
*ctx
= crypto_tfm_ctx(parent
);
38 struct crypto_cipher
*child
= ctx
->child
;
39 struct ctr_instance_ctx
*ictx
=
40 crypto_instance_ctx(crypto_tfm_alg_instance(parent
));
41 unsigned int noncelen
= ictx
->noncesize
;
44 /* the nonce is stored in bytes at end of key */
45 if (keylen
< noncelen
)
48 memcpy(ctx
->nonce
, key
+ (keylen
- noncelen
), noncelen
);
52 crypto_cipher_clear_flags(child
, CRYPTO_TFM_REQ_MASK
);
53 crypto_cipher_set_flags(child
, crypto_tfm_get_flags(parent
) &
55 err
= crypto_cipher_setkey(child
, key
, keylen
);
56 crypto_tfm_set_flags(parent
, crypto_cipher_get_flags(child
) &
62 static int crypto_ctr_crypt_segment(struct blkcipher_walk
*walk
,
63 struct crypto_cipher
*tfm
, u8
*ctrblk
,
64 unsigned int countersize
)
66 void (*fn
)(struct crypto_tfm
*, u8
*, const u8
*) =
67 crypto_cipher_alg(tfm
)->cia_encrypt
;
68 unsigned int bsize
= crypto_cipher_blocksize(tfm
);
69 unsigned long alignmask
= crypto_cipher_alignmask(tfm
) |
70 (__alignof__(u32
) - 1);
71 u8 ks
[bsize
+ alignmask
];
72 u8
*keystream
= (u8
*)ALIGN((unsigned long)ks
, alignmask
+ 1);
73 u8
*src
= walk
->src
.virt
.addr
;
74 u8
*dst
= walk
->dst
.virt
.addr
;
75 unsigned int nbytes
= walk
->nbytes
;
78 /* create keystream */
79 fn(crypto_cipher_tfm(tfm
), keystream
, ctrblk
);
80 crypto_xor(keystream
, src
, min(nbytes
, bsize
));
82 /* copy result into dst */
83 memcpy(dst
, keystream
, min(nbytes
, bsize
));
85 /* increment counter in counterblock */
86 crypto_inc(ctrblk
+ bsize
- countersize
, countersize
);
100 static int crypto_ctr_crypt_inplace(struct blkcipher_walk
*walk
,
101 struct crypto_cipher
*tfm
, u8
*ctrblk
,
102 unsigned int countersize
)
104 void (*fn
)(struct crypto_tfm
*, u8
*, const u8
*) =
105 crypto_cipher_alg(tfm
)->cia_encrypt
;
106 unsigned int bsize
= crypto_cipher_blocksize(tfm
);
107 unsigned long alignmask
= crypto_cipher_alignmask(tfm
) |
108 (__alignof__(u32
) - 1);
109 unsigned int nbytes
= walk
->nbytes
;
110 u8
*src
= walk
->src
.virt
.addr
;
111 u8 ks
[bsize
+ alignmask
];
112 u8
*keystream
= (u8
*)ALIGN((unsigned long)ks
, alignmask
+ 1);
115 /* create keystream */
116 fn(crypto_cipher_tfm(tfm
), keystream
, ctrblk
);
117 crypto_xor(src
, keystream
, min(nbytes
, bsize
));
119 /* increment counter in counterblock */
120 crypto_inc(ctrblk
+ bsize
- countersize
, countersize
);
133 static int crypto_ctr_crypt(struct blkcipher_desc
*desc
,
134 struct scatterlist
*dst
, struct scatterlist
*src
,
137 struct blkcipher_walk walk
;
138 struct crypto_blkcipher
*tfm
= desc
->tfm
;
139 struct crypto_ctr_ctx
*ctx
= crypto_blkcipher_ctx(tfm
);
140 struct crypto_cipher
*child
= ctx
->child
;
141 unsigned int bsize
= crypto_cipher_blocksize(child
);
142 struct ctr_instance_ctx
*ictx
=
143 crypto_instance_ctx(crypto_tfm_alg_instance(&tfm
->base
));
144 unsigned long alignmask
= crypto_cipher_alignmask(child
) |
145 (__alignof__(u32
) - 1);
146 u8 cblk
[bsize
+ alignmask
];
147 u8
*counterblk
= (u8
*)ALIGN((unsigned long)cblk
, alignmask
+ 1);
150 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
151 err
= blkcipher_walk_virt_block(desc
, &walk
, bsize
);
153 /* set up counter block */
154 memset(counterblk
, 0 , bsize
);
155 memcpy(counterblk
, ctx
->nonce
, ictx
->noncesize
);
156 memcpy(counterblk
+ ictx
->noncesize
, walk
.iv
, ictx
->ivsize
);
158 /* initialize counter portion of counter block */
159 crypto_inc(counterblk
+ bsize
- ictx
->countersize
, ictx
->countersize
);
161 while (walk
.nbytes
) {
162 if (walk
.src
.virt
.addr
== walk
.dst
.virt
.addr
)
163 nbytes
= crypto_ctr_crypt_inplace(&walk
, child
,
167 nbytes
= crypto_ctr_crypt_segment(&walk
, child
,
171 err
= blkcipher_walk_done(desc
, &walk
, nbytes
);
176 static int crypto_ctr_init_tfm(struct crypto_tfm
*tfm
)
178 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
179 struct ctr_instance_ctx
*ictx
= crypto_instance_ctx(inst
);
180 struct crypto_ctr_ctx
*ctx
= crypto_tfm_ctx(tfm
);
181 struct crypto_cipher
*cipher
;
183 ctx
->nonce
= kzalloc(ictx
->noncesize
, GFP_KERNEL
);
187 cipher
= crypto_spawn_cipher(&ictx
->alg
);
189 return PTR_ERR(cipher
);
196 static void crypto_ctr_exit_tfm(struct crypto_tfm
*tfm
)
198 struct crypto_ctr_ctx
*ctx
= crypto_tfm_ctx(tfm
);
201 crypto_free_cipher(ctx
->child
);
204 static struct crypto_instance
*crypto_ctr_alloc(struct rtattr
**tb
)
206 struct crypto_instance
*inst
;
207 struct crypto_alg
*alg
;
208 struct ctr_instance_ctx
*ictx
;
209 unsigned int noncesize
;
211 unsigned int countersize
;
214 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_BLKCIPHER
);
218 alg
= crypto_attr_alg(tb
[1], CRYPTO_ALG_TYPE_CIPHER
,
219 CRYPTO_ALG_TYPE_MASK
);
221 return ERR_PTR(PTR_ERR(alg
));
223 err
= crypto_attr_u32(tb
[2], &noncesize
);
227 err
= crypto_attr_u32(tb
[3], &ivsize
);
231 err
= crypto_attr_u32(tb
[4], &countersize
);
235 /* verify size of nonce + iv + counter
236 * counter must be >= 4 bytes.
239 if (((noncesize
+ ivsize
+ countersize
) < alg
->cra_blocksize
) ||
240 ((noncesize
+ ivsize
) > alg
->cra_blocksize
) ||
241 (countersize
> alg
->cra_blocksize
) || (countersize
< 4))
244 /* If this is false we'd fail the alignment of crypto_inc. */
245 if ((alg
->cra_blocksize
- countersize
) % 4)
248 inst
= kzalloc(sizeof(*inst
) + sizeof(*ictx
), GFP_KERNEL
);
254 if (snprintf(inst
->alg
.cra_name
, CRYPTO_MAX_ALG_NAME
,
255 "ctr(%s,%u,%u,%u)", alg
->cra_name
, noncesize
,
256 ivsize
, countersize
) >= CRYPTO_MAX_ALG_NAME
) {
260 if (snprintf(inst
->alg
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
261 "ctr(%s,%u,%u,%u)", alg
->cra_driver_name
, noncesize
,
262 ivsize
, countersize
) >= CRYPTO_MAX_ALG_NAME
) {
266 ictx
= crypto_instance_ctx(inst
);
267 ictx
->noncesize
= noncesize
;
268 ictx
->ivsize
= ivsize
;
269 ictx
->countersize
= countersize
;
271 err
= crypto_init_spawn(&ictx
->alg
, alg
, inst
,
272 CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_ASYNC
);
277 inst
->alg
.cra_flags
= CRYPTO_ALG_TYPE_BLKCIPHER
;
278 inst
->alg
.cra_priority
= alg
->cra_priority
;
279 inst
->alg
.cra_blocksize
= 1;
280 inst
->alg
.cra_alignmask
= __alignof__(u32
) - 1;
281 inst
->alg
.cra_type
= &crypto_blkcipher_type
;
283 inst
->alg
.cra_blkcipher
.ivsize
= ivsize
;
284 inst
->alg
.cra_blkcipher
.min_keysize
= alg
->cra_cipher
.cia_min_keysize
286 inst
->alg
.cra_blkcipher
.max_keysize
= alg
->cra_cipher
.cia_max_keysize
289 inst
->alg
.cra_ctxsize
= sizeof(struct crypto_ctr_ctx
);
291 inst
->alg
.cra_init
= crypto_ctr_init_tfm
;
292 inst
->alg
.cra_exit
= crypto_ctr_exit_tfm
;
294 inst
->alg
.cra_blkcipher
.setkey
= crypto_ctr_setkey
;
295 inst
->alg
.cra_blkcipher
.encrypt
= crypto_ctr_crypt
;
296 inst
->alg
.cra_blkcipher
.decrypt
= crypto_ctr_crypt
;
311 static void crypto_ctr_free(struct crypto_instance
*inst
)
313 struct ctr_instance_ctx
*ictx
= crypto_instance_ctx(inst
);
315 crypto_drop_spawn(&ictx
->alg
);
319 static struct crypto_template crypto_ctr_tmpl
= {
321 .alloc
= crypto_ctr_alloc
,
322 .free
= crypto_ctr_free
,
323 .module
= THIS_MODULE
,
326 static int __init
crypto_ctr_module_init(void)
328 return crypto_register_template(&crypto_ctr_tmpl
);
331 static void __exit
crypto_ctr_module_exit(void)
333 crypto_unregister_template(&crypto_ctr_tmpl
);
336 module_init(crypto_ctr_module_init
);
337 module_exit(crypto_ctr_module_exit
);
339 MODULE_LICENSE("GPL");
340 MODULE_DESCRIPTION("CTR Counter block mode");