2 * AEAD: Authenticated Encryption with Associated Data
4 * This file provides API support for AEAD algorithms.
6 * Copyright (c) 2007-2015 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/geniv.h>
16 #include <crypto/internal/rng.h>
17 #include <crypto/null.h>
18 #include <crypto/scatterwalk.h>
19 #include <linux/err.h>
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/rtnetlink.h>
24 #include <linux/slab.h>
25 #include <linux/seq_file.h>
26 #include <linux/cryptouser.h>
27 #include <linux/compiler.h>
28 #include <net/netlink.h>
32 static int setkey_unaligned(struct crypto_aead
*tfm
, const u8
*key
,
35 unsigned long alignmask
= crypto_aead_alignmask(tfm
);
37 u8
*buffer
, *alignbuffer
;
40 absize
= keylen
+ alignmask
;
41 buffer
= kmalloc(absize
, GFP_ATOMIC
);
45 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
46 memcpy(alignbuffer
, key
, keylen
);
47 ret
= crypto_aead_alg(tfm
)->setkey(tfm
, alignbuffer
, keylen
);
48 memset(alignbuffer
, 0, keylen
);
53 int crypto_aead_setkey(struct crypto_aead
*tfm
,
54 const u8
*key
, unsigned int keylen
)
56 unsigned long alignmask
= crypto_aead_alignmask(tfm
);
59 if ((unsigned long)key
& alignmask
)
60 err
= setkey_unaligned(tfm
, key
, keylen
);
62 err
= crypto_aead_alg(tfm
)->setkey(tfm
, key
, keylen
);
67 crypto_aead_clear_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
70 EXPORT_SYMBOL_GPL(crypto_aead_setkey
);
72 int crypto_aead_setauthsize(struct crypto_aead
*tfm
, unsigned int authsize
)
76 if (authsize
> crypto_aead_maxauthsize(tfm
))
79 if (crypto_aead_alg(tfm
)->setauthsize
) {
80 err
= crypto_aead_alg(tfm
)->setauthsize(tfm
, authsize
);
85 tfm
->authsize
= authsize
;
88 EXPORT_SYMBOL_GPL(crypto_aead_setauthsize
);
90 static void crypto_aead_exit_tfm(struct crypto_tfm
*tfm
)
92 struct crypto_aead
*aead
= __crypto_aead_cast(tfm
);
93 struct aead_alg
*alg
= crypto_aead_alg(aead
);
98 static int crypto_aead_init_tfm(struct crypto_tfm
*tfm
)
100 struct crypto_aead
*aead
= __crypto_aead_cast(tfm
);
101 struct aead_alg
*alg
= crypto_aead_alg(aead
);
103 crypto_aead_set_flags(aead
, CRYPTO_TFM_NEED_KEY
);
105 aead
->authsize
= alg
->maxauthsize
;
108 aead
->base
.exit
= crypto_aead_exit_tfm
;
111 return alg
->init(aead
);
117 static int crypto_aead_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
119 struct crypto_report_aead raead
;
120 struct aead_alg
*aead
= container_of(alg
, struct aead_alg
, base
);
122 memset(&raead
, 0, sizeof(raead
));
124 strscpy(raead
.type
, "aead", sizeof(raead
.type
));
125 strscpy(raead
.geniv
, "<none>", sizeof(raead
.geniv
));
127 raead
.blocksize
= alg
->cra_blocksize
;
128 raead
.maxauthsize
= aead
->maxauthsize
;
129 raead
.ivsize
= aead
->ivsize
;
131 return nla_put(skb
, CRYPTOCFGA_REPORT_AEAD
, sizeof(raead
), &raead
);
134 static int crypto_aead_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
140 static void crypto_aead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
142 static void crypto_aead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
144 struct aead_alg
*aead
= container_of(alg
, struct aead_alg
, base
);
146 seq_printf(m
, "type : aead\n");
147 seq_printf(m
, "async : %s\n", alg
->cra_flags
& CRYPTO_ALG_ASYNC
?
149 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
150 seq_printf(m
, "ivsize : %u\n", aead
->ivsize
);
151 seq_printf(m
, "maxauthsize : %u\n", aead
->maxauthsize
);
152 seq_printf(m
, "geniv : <none>\n");
155 static void crypto_aead_free_instance(struct crypto_instance
*inst
)
157 struct aead_instance
*aead
= aead_instance(inst
);
160 inst
->tmpl
->free(inst
);
167 static const struct crypto_type crypto_aead_type
= {
168 .extsize
= crypto_alg_extsize
,
169 .init_tfm
= crypto_aead_init_tfm
,
170 .free
= crypto_aead_free_instance
,
171 #ifdef CONFIG_PROC_FS
172 .show
= crypto_aead_show
,
174 .report
= crypto_aead_report
,
175 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
176 .maskset
= CRYPTO_ALG_TYPE_MASK
,
177 .type
= CRYPTO_ALG_TYPE_AEAD
,
178 .tfmsize
= offsetof(struct crypto_aead
, base
),
181 static int aead_geniv_setkey(struct crypto_aead
*tfm
,
182 const u8
*key
, unsigned int keylen
)
184 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(tfm
);
186 return crypto_aead_setkey(ctx
->child
, key
, keylen
);
189 static int aead_geniv_setauthsize(struct crypto_aead
*tfm
,
190 unsigned int authsize
)
192 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(tfm
);
194 return crypto_aead_setauthsize(ctx
->child
, authsize
);
197 struct aead_instance
*aead_geniv_alloc(struct crypto_template
*tmpl
,
198 struct rtattr
**tb
, u32 type
, u32 mask
)
201 struct crypto_aead_spawn
*spawn
;
202 struct crypto_attr_type
*algt
;
203 struct aead_instance
*inst
;
204 struct aead_alg
*alg
;
206 unsigned int maxauthsize
;
209 algt
= crypto_get_attr_type(tb
);
211 return ERR_CAST(algt
);
213 if ((algt
->type
^ CRYPTO_ALG_TYPE_AEAD
) & algt
->mask
)
214 return ERR_PTR(-EINVAL
);
216 name
= crypto_attr_alg_name(tb
[1]);
218 return ERR_CAST(name
);
220 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
222 return ERR_PTR(-ENOMEM
);
224 spawn
= aead_instance_ctx(inst
);
226 /* Ignore async algorithms if necessary. */
227 mask
|= crypto_requires_sync(algt
->type
, algt
->mask
);
229 crypto_set_aead_spawn(spawn
, aead_crypto_instance(inst
));
230 err
= crypto_grab_aead(spawn
, name
, type
, mask
);
234 alg
= crypto_spawn_aead_alg(spawn
);
236 ivsize
= crypto_aead_alg_ivsize(alg
);
237 maxauthsize
= crypto_aead_alg_maxauthsize(alg
);
240 if (ivsize
< sizeof(u64
))
244 if (snprintf(inst
->alg
.base
.cra_name
, CRYPTO_MAX_ALG_NAME
,
245 "%s(%s)", tmpl
->name
, alg
->base
.cra_name
) >=
248 if (snprintf(inst
->alg
.base
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
249 "%s(%s)", tmpl
->name
, alg
->base
.cra_driver_name
) >=
253 inst
->alg
.base
.cra_flags
= alg
->base
.cra_flags
& CRYPTO_ALG_ASYNC
;
254 inst
->alg
.base
.cra_priority
= alg
->base
.cra_priority
;
255 inst
->alg
.base
.cra_blocksize
= alg
->base
.cra_blocksize
;
256 inst
->alg
.base
.cra_alignmask
= alg
->base
.cra_alignmask
;
257 inst
->alg
.base
.cra_ctxsize
= sizeof(struct aead_geniv_ctx
);
259 inst
->alg
.setkey
= aead_geniv_setkey
;
260 inst
->alg
.setauthsize
= aead_geniv_setauthsize
;
262 inst
->alg
.ivsize
= ivsize
;
263 inst
->alg
.maxauthsize
= maxauthsize
;
269 crypto_drop_aead(spawn
);
275 EXPORT_SYMBOL_GPL(aead_geniv_alloc
);
277 void aead_geniv_free(struct aead_instance
*inst
)
279 crypto_drop_aead(aead_instance_ctx(inst
));
282 EXPORT_SYMBOL_GPL(aead_geniv_free
);
284 int aead_init_geniv(struct crypto_aead
*aead
)
286 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(aead
);
287 struct aead_instance
*inst
= aead_alg_instance(aead
);
288 struct crypto_aead
*child
;
291 spin_lock_init(&ctx
->lock
);
293 err
= crypto_get_default_rng();
297 err
= crypto_rng_get_bytes(crypto_default_rng
, ctx
->salt
,
298 crypto_aead_ivsize(aead
));
299 crypto_put_default_rng();
303 ctx
->sknull
= crypto_get_default_null_skcipher();
304 err
= PTR_ERR(ctx
->sknull
);
305 if (IS_ERR(ctx
->sknull
))
308 child
= crypto_spawn_aead(aead_instance_ctx(inst
));
309 err
= PTR_ERR(child
);
314 crypto_aead_set_reqsize(aead
, crypto_aead_reqsize(child
) +
315 sizeof(struct aead_request
));
323 crypto_put_default_null_skcipher();
326 EXPORT_SYMBOL_GPL(aead_init_geniv
);
328 void aead_exit_geniv(struct crypto_aead
*tfm
)
330 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(tfm
);
332 crypto_free_aead(ctx
->child
);
333 crypto_put_default_null_skcipher();
335 EXPORT_SYMBOL_GPL(aead_exit_geniv
);
337 int crypto_grab_aead(struct crypto_aead_spawn
*spawn
, const char *name
,
340 spawn
->base
.frontend
= &crypto_aead_type
;
341 return crypto_grab_spawn(&spawn
->base
, name
, type
, mask
);
343 EXPORT_SYMBOL_GPL(crypto_grab_aead
);
345 struct crypto_aead
*crypto_alloc_aead(const char *alg_name
, u32 type
, u32 mask
)
347 return crypto_alloc_tfm(alg_name
, &crypto_aead_type
, type
, mask
);
349 EXPORT_SYMBOL_GPL(crypto_alloc_aead
);
351 static int aead_prepare_alg(struct aead_alg
*alg
)
353 struct crypto_alg
*base
= &alg
->base
;
355 if (max3(alg
->maxauthsize
, alg
->ivsize
, alg
->chunksize
) >
360 alg
->chunksize
= base
->cra_blocksize
;
362 base
->cra_type
= &crypto_aead_type
;
363 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
364 base
->cra_flags
|= CRYPTO_ALG_TYPE_AEAD
;
369 int crypto_register_aead(struct aead_alg
*alg
)
371 struct crypto_alg
*base
= &alg
->base
;
374 err
= aead_prepare_alg(alg
);
378 return crypto_register_alg(base
);
380 EXPORT_SYMBOL_GPL(crypto_register_aead
);
382 void crypto_unregister_aead(struct aead_alg
*alg
)
384 crypto_unregister_alg(&alg
->base
);
386 EXPORT_SYMBOL_GPL(crypto_unregister_aead
);
388 int crypto_register_aeads(struct aead_alg
*algs
, int count
)
392 for (i
= 0; i
< count
; i
++) {
393 ret
= crypto_register_aead(&algs
[i
]);
401 for (--i
; i
>= 0; --i
)
402 crypto_unregister_aead(&algs
[i
]);
406 EXPORT_SYMBOL_GPL(crypto_register_aeads
);
408 void crypto_unregister_aeads(struct aead_alg
*algs
, int count
)
412 for (i
= count
- 1; i
>= 0; --i
)
413 crypto_unregister_aead(&algs
[i
]);
415 EXPORT_SYMBOL_GPL(crypto_unregister_aeads
);
417 int aead_register_instance(struct crypto_template
*tmpl
,
418 struct aead_instance
*inst
)
422 err
= aead_prepare_alg(&inst
->alg
);
426 return crypto_register_instance(tmpl
, aead_crypto_instance(inst
));
428 EXPORT_SYMBOL_GPL(aead_register_instance
);
430 MODULE_LICENSE("GPL");
431 MODULE_DESCRIPTION("Authenticated Encryption with Associated Data (AEAD)");