2 * AEAD: Authenticated Encryption with Associated Data
4 * This file provides API support for AEAD algorithms.
6 * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
15 #include <crypto/internal/aead.h>
16 #include <linux/err.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 #include <linux/seq_file.h>
24 #include <linux/cryptouser.h>
25 #include <net/netlink.h>
29 static int setkey_unaligned(struct crypto_aead
*tfm
, const u8
*key
,
32 struct aead_alg
*aead
= crypto_aead_alg(tfm
);
33 unsigned long alignmask
= crypto_aead_alignmask(tfm
);
35 u8
*buffer
, *alignbuffer
;
38 absize
= keylen
+ alignmask
;
39 buffer
= kmalloc(absize
, GFP_ATOMIC
);
43 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
44 memcpy(alignbuffer
, key
, keylen
);
45 ret
= aead
->setkey(tfm
, alignbuffer
, keylen
);
46 memset(alignbuffer
, 0, keylen
);
51 static int setkey(struct crypto_aead
*tfm
, const u8
*key
, unsigned int keylen
)
53 struct aead_alg
*aead
= crypto_aead_alg(tfm
);
54 unsigned long alignmask
= crypto_aead_alignmask(tfm
);
56 if ((unsigned long)key
& alignmask
)
57 return setkey_unaligned(tfm
, key
, keylen
);
59 return aead
->setkey(tfm
, key
, keylen
);
62 int crypto_aead_setauthsize(struct crypto_aead
*tfm
, unsigned int authsize
)
64 struct aead_tfm
*crt
= crypto_aead_crt(tfm
);
67 if (authsize
> crypto_aead_alg(tfm
)->maxauthsize
)
70 if (crypto_aead_alg(tfm
)->setauthsize
) {
71 err
= crypto_aead_alg(tfm
)->setauthsize(crt
->base
, authsize
);
76 crypto_aead_crt(crt
->base
)->authsize
= authsize
;
77 crt
->authsize
= authsize
;
80 EXPORT_SYMBOL_GPL(crypto_aead_setauthsize
);
82 static unsigned int crypto_aead_ctxsize(struct crypto_alg
*alg
, u32 type
,
85 return alg
->cra_ctxsize
;
88 static int no_givcrypt(struct aead_givcrypt_request
*req
)
93 static int crypto_init_aead_ops(struct crypto_tfm
*tfm
, u32 type
, u32 mask
)
95 struct aead_alg
*alg
= &tfm
->__crt_alg
->cra_aead
;
96 struct aead_tfm
*crt
= &tfm
->crt_aead
;
98 if (max(alg
->maxauthsize
, alg
->ivsize
) > PAGE_SIZE
/ 8)
101 crt
->setkey
= tfm
->__crt_alg
->cra_flags
& CRYPTO_ALG_GENIV
?
102 alg
->setkey
: setkey
;
103 crt
->encrypt
= alg
->encrypt
;
104 crt
->decrypt
= alg
->decrypt
;
105 crt
->givencrypt
= alg
->givencrypt
?: no_givcrypt
;
106 crt
->givdecrypt
= alg
->givdecrypt
?: no_givcrypt
;
107 crt
->base
= __crypto_aead_cast(tfm
);
108 crt
->ivsize
= alg
->ivsize
;
109 crt
->authsize
= alg
->maxauthsize
;
114 static int crypto_aead_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
116 struct crypto_report_aead raead
;
117 struct aead_alg
*aead
= &alg
->cra_aead
;
119 snprintf(raead
.type
, CRYPTO_MAX_ALG_NAME
, "%s", "aead");
120 snprintf(raead
.geniv
, CRYPTO_MAX_ALG_NAME
, "%s",
121 aead
->geniv
?: "<built-in>");
123 raead
.blocksize
= alg
->cra_blocksize
;
124 raead
.maxauthsize
= aead
->maxauthsize
;
125 raead
.ivsize
= aead
->ivsize
;
127 NLA_PUT(skb
, CRYPTOCFGA_REPORT_AEAD
,
128 sizeof(struct crypto_report_aead
), &raead
);
136 static void crypto_aead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
137 __attribute__ ((unused
));
138 static void crypto_aead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
140 struct aead_alg
*aead
= &alg
->cra_aead
;
142 seq_printf(m
, "type : aead\n");
143 seq_printf(m
, "async : %s\n", alg
->cra_flags
& CRYPTO_ALG_ASYNC
?
145 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
146 seq_printf(m
, "ivsize : %u\n", aead
->ivsize
);
147 seq_printf(m
, "maxauthsize : %u\n", aead
->maxauthsize
);
148 seq_printf(m
, "geniv : %s\n", aead
->geniv
?: "<built-in>");
151 const struct crypto_type crypto_aead_type
= {
152 .ctxsize
= crypto_aead_ctxsize
,
153 .init
= crypto_init_aead_ops
,
154 #ifdef CONFIG_PROC_FS
155 .show
= crypto_aead_show
,
157 .report
= crypto_aead_report
,
159 EXPORT_SYMBOL_GPL(crypto_aead_type
);
161 static int aead_null_givencrypt(struct aead_givcrypt_request
*req
)
163 return crypto_aead_encrypt(&req
->areq
);
166 static int aead_null_givdecrypt(struct aead_givcrypt_request
*req
)
168 return crypto_aead_decrypt(&req
->areq
);
171 static int crypto_init_nivaead_ops(struct crypto_tfm
*tfm
, u32 type
, u32 mask
)
173 struct aead_alg
*alg
= &tfm
->__crt_alg
->cra_aead
;
174 struct aead_tfm
*crt
= &tfm
->crt_aead
;
176 if (max(alg
->maxauthsize
, alg
->ivsize
) > PAGE_SIZE
/ 8)
179 crt
->setkey
= setkey
;
180 crt
->encrypt
= alg
->encrypt
;
181 crt
->decrypt
= alg
->decrypt
;
183 crt
->givencrypt
= aead_null_givencrypt
;
184 crt
->givdecrypt
= aead_null_givdecrypt
;
186 crt
->base
= __crypto_aead_cast(tfm
);
187 crt
->ivsize
= alg
->ivsize
;
188 crt
->authsize
= alg
->maxauthsize
;
193 static void crypto_nivaead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
194 __attribute__ ((unused
));
195 static void crypto_nivaead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
197 struct aead_alg
*aead
= &alg
->cra_aead
;
199 seq_printf(m
, "type : nivaead\n");
200 seq_printf(m
, "async : %s\n", alg
->cra_flags
& CRYPTO_ALG_ASYNC
?
202 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
203 seq_printf(m
, "ivsize : %u\n", aead
->ivsize
);
204 seq_printf(m
, "maxauthsize : %u\n", aead
->maxauthsize
);
205 seq_printf(m
, "geniv : %s\n", aead
->geniv
);
208 const struct crypto_type crypto_nivaead_type
= {
209 .ctxsize
= crypto_aead_ctxsize
,
210 .init
= crypto_init_nivaead_ops
,
211 #ifdef CONFIG_PROC_FS
212 .show
= crypto_nivaead_show
,
215 EXPORT_SYMBOL_GPL(crypto_nivaead_type
);
217 static int crypto_grab_nivaead(struct crypto_aead_spawn
*spawn
,
218 const char *name
, u32 type
, u32 mask
)
220 struct crypto_alg
*alg
;
223 type
&= ~(CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
);
224 type
|= CRYPTO_ALG_TYPE_AEAD
;
225 mask
|= CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
;
227 alg
= crypto_alg_mod_lookup(name
, type
, mask
);
231 err
= crypto_init_spawn(&spawn
->base
, alg
, spawn
->base
.inst
, mask
);
236 struct crypto_instance
*aead_geniv_alloc(struct crypto_template
*tmpl
,
237 struct rtattr
**tb
, u32 type
,
241 struct crypto_aead_spawn
*spawn
;
242 struct crypto_attr_type
*algt
;
243 struct crypto_instance
*inst
;
244 struct crypto_alg
*alg
;
247 algt
= crypto_get_attr_type(tb
);
252 if ((algt
->type
^ (CRYPTO_ALG_TYPE_AEAD
| CRYPTO_ALG_GENIV
)) &
254 return ERR_PTR(-EINVAL
);
256 name
= crypto_attr_alg_name(tb
[1]);
261 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
263 return ERR_PTR(-ENOMEM
);
265 spawn
= crypto_instance_ctx(inst
);
267 /* Ignore async algorithms if necessary. */
268 mask
|= crypto_requires_sync(algt
->type
, algt
->mask
);
270 crypto_set_aead_spawn(spawn
, inst
);
271 err
= crypto_grab_nivaead(spawn
, name
, type
, mask
);
275 alg
= crypto_aead_spawn_alg(spawn
);
278 if (!alg
->cra_aead
.ivsize
)
282 * This is only true if we're constructing an algorithm with its
283 * default IV generator. For the default generator we elide the
284 * template name and double-check the IV generator.
286 if (algt
->mask
& CRYPTO_ALG_GENIV
) {
287 if (strcmp(tmpl
->name
, alg
->cra_aead
.geniv
))
290 memcpy(inst
->alg
.cra_name
, alg
->cra_name
, CRYPTO_MAX_ALG_NAME
);
291 memcpy(inst
->alg
.cra_driver_name
, alg
->cra_driver_name
,
292 CRYPTO_MAX_ALG_NAME
);
295 if (snprintf(inst
->alg
.cra_name
, CRYPTO_MAX_ALG_NAME
,
296 "%s(%s)", tmpl
->name
, alg
->cra_name
) >=
299 if (snprintf(inst
->alg
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
300 "%s(%s)", tmpl
->name
, alg
->cra_driver_name
) >=
305 inst
->alg
.cra_flags
= CRYPTO_ALG_TYPE_AEAD
| CRYPTO_ALG_GENIV
;
306 inst
->alg
.cra_flags
|= alg
->cra_flags
& CRYPTO_ALG_ASYNC
;
307 inst
->alg
.cra_priority
= alg
->cra_priority
;
308 inst
->alg
.cra_blocksize
= alg
->cra_blocksize
;
309 inst
->alg
.cra_alignmask
= alg
->cra_alignmask
;
310 inst
->alg
.cra_type
= &crypto_aead_type
;
312 inst
->alg
.cra_aead
.ivsize
= alg
->cra_aead
.ivsize
;
313 inst
->alg
.cra_aead
.maxauthsize
= alg
->cra_aead
.maxauthsize
;
314 inst
->alg
.cra_aead
.geniv
= alg
->cra_aead
.geniv
;
316 inst
->alg
.cra_aead
.setkey
= alg
->cra_aead
.setkey
;
317 inst
->alg
.cra_aead
.setauthsize
= alg
->cra_aead
.setauthsize
;
318 inst
->alg
.cra_aead
.encrypt
= alg
->cra_aead
.encrypt
;
319 inst
->alg
.cra_aead
.decrypt
= alg
->cra_aead
.decrypt
;
325 crypto_drop_aead(spawn
);
331 EXPORT_SYMBOL_GPL(aead_geniv_alloc
);
333 void aead_geniv_free(struct crypto_instance
*inst
)
335 crypto_drop_aead(crypto_instance_ctx(inst
));
338 EXPORT_SYMBOL_GPL(aead_geniv_free
);
340 int aead_geniv_init(struct crypto_tfm
*tfm
)
342 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
343 struct crypto_aead
*aead
;
345 aead
= crypto_spawn_aead(crypto_instance_ctx(inst
));
347 return PTR_ERR(aead
);
349 tfm
->crt_aead
.base
= aead
;
350 tfm
->crt_aead
.reqsize
+= crypto_aead_reqsize(aead
);
354 EXPORT_SYMBOL_GPL(aead_geniv_init
);
356 void aead_geniv_exit(struct crypto_tfm
*tfm
)
358 crypto_free_aead(tfm
->crt_aead
.base
);
360 EXPORT_SYMBOL_GPL(aead_geniv_exit
);
362 static int crypto_nivaead_default(struct crypto_alg
*alg
, u32 type
, u32 mask
)
364 struct rtattr
*tb
[3];
367 struct crypto_attr_type data
;
371 struct crypto_attr_alg data
;
373 struct crypto_template
*tmpl
;
374 struct crypto_instance
*inst
;
375 struct crypto_alg
*larval
;
379 larval
= crypto_larval_lookup(alg
->cra_driver_name
,
380 CRYPTO_ALG_TYPE_AEAD
| CRYPTO_ALG_GENIV
,
381 CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
);
382 err
= PTR_ERR(larval
);
387 if (!crypto_is_larval(larval
))
390 ptype
.attr
.rta_len
= sizeof(ptype
);
391 ptype
.attr
.rta_type
= CRYPTOA_TYPE
;
392 ptype
.data
.type
= type
| CRYPTO_ALG_GENIV
;
393 /* GENIV tells the template that we're making a default geniv. */
394 ptype
.data
.mask
= mask
| CRYPTO_ALG_GENIV
;
397 palg
.attr
.rta_len
= sizeof(palg
);
398 palg
.attr
.rta_type
= CRYPTOA_ALG
;
399 /* Must use the exact name to locate ourselves. */
400 memcpy(palg
.data
.name
, alg
->cra_driver_name
, CRYPTO_MAX_ALG_NAME
);
405 geniv
= alg
->cra_aead
.geniv
;
407 tmpl
= crypto_lookup_template(geniv
);
412 inst
= tmpl
->alloc(tb
);
417 if ((err
= crypto_register_instance(tmpl
, inst
))) {
422 /* Redo the lookup to use the instance we just registered. */
426 crypto_tmpl_put(tmpl
);
428 crypto_larval_kill(larval
);
430 crypto_mod_put(larval
);
436 static struct crypto_alg
*crypto_lookup_aead(const char *name
, u32 type
,
439 struct crypto_alg
*alg
;
441 alg
= crypto_alg_mod_lookup(name
, type
, mask
);
445 if (alg
->cra_type
== &crypto_aead_type
)
448 if (!alg
->cra_aead
.ivsize
)
452 alg
= crypto_alg_mod_lookup(name
, type
| CRYPTO_ALG_TESTED
,
453 mask
& ~CRYPTO_ALG_TESTED
);
457 if (alg
->cra_type
== &crypto_aead_type
) {
458 if ((alg
->cra_flags
^ type
^ ~mask
) & CRYPTO_ALG_TESTED
) {
460 alg
= ERR_PTR(-ENOENT
);
465 BUG_ON(!alg
->cra_aead
.ivsize
);
467 return ERR_PTR(crypto_nivaead_default(alg
, type
, mask
));
470 int crypto_grab_aead(struct crypto_aead_spawn
*spawn
, const char *name
,
473 struct crypto_alg
*alg
;
476 type
&= ~(CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
);
477 type
|= CRYPTO_ALG_TYPE_AEAD
;
478 mask
&= ~(CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
);
479 mask
|= CRYPTO_ALG_TYPE_MASK
;
481 alg
= crypto_lookup_aead(name
, type
, mask
);
485 err
= crypto_init_spawn(&spawn
->base
, alg
, spawn
->base
.inst
, mask
);
489 EXPORT_SYMBOL_GPL(crypto_grab_aead
);
491 struct crypto_aead
*crypto_alloc_aead(const char *alg_name
, u32 type
, u32 mask
)
493 struct crypto_tfm
*tfm
;
496 type
&= ~(CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
);
497 type
|= CRYPTO_ALG_TYPE_AEAD
;
498 mask
&= ~(CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_GENIV
);
499 mask
|= CRYPTO_ALG_TYPE_MASK
;
502 struct crypto_alg
*alg
;
504 alg
= crypto_lookup_aead(alg_name
, type
, mask
);
510 tfm
= __crypto_alloc_tfm(alg
, type
, mask
);
512 return __crypto_aead_cast(tfm
);
520 if (signal_pending(current
)) {
528 EXPORT_SYMBOL_GPL(crypto_alloc_aead
);
530 MODULE_LICENSE("GPL");
531 MODULE_DESCRIPTION("Authenticated Encryption with Associated Data (AEAD)");