1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * AEAD: Authenticated Encryption with Associated Data
5 * This file provides API support for AEAD algorithms.
7 * Copyright (c) 2007-2015 Herbert Xu <herbert@gondor.apana.org.au>
10 #include <crypto/internal/geniv.h>
11 #include <crypto/internal/rng.h>
12 #include <crypto/null.h>
13 #include <crypto/scatterwalk.h>
14 #include <linux/err.h>
15 #include <linux/init.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/slab.h>
20 #include <linux/seq_file.h>
21 #include <linux/cryptouser.h>
22 #include <linux/compiler.h>
23 #include <net/netlink.h>
27 static int setkey_unaligned(struct crypto_aead
*tfm
, const u8
*key
,
30 unsigned long alignmask
= crypto_aead_alignmask(tfm
);
32 u8
*buffer
, *alignbuffer
;
35 absize
= keylen
+ alignmask
;
36 buffer
= kmalloc(absize
, GFP_ATOMIC
);
40 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
41 memcpy(alignbuffer
, key
, keylen
);
42 ret
= crypto_aead_alg(tfm
)->setkey(tfm
, alignbuffer
, keylen
);
43 memset(alignbuffer
, 0, keylen
);
48 int crypto_aead_setkey(struct crypto_aead
*tfm
,
49 const u8
*key
, unsigned int keylen
)
51 unsigned long alignmask
= crypto_aead_alignmask(tfm
);
54 if ((unsigned long)key
& alignmask
)
55 err
= setkey_unaligned(tfm
, key
, keylen
);
57 err
= crypto_aead_alg(tfm
)->setkey(tfm
, key
, keylen
);
60 crypto_aead_set_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
64 crypto_aead_clear_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
67 EXPORT_SYMBOL_GPL(crypto_aead_setkey
);
69 int crypto_aead_setauthsize(struct crypto_aead
*tfm
, unsigned int authsize
)
73 if (authsize
> crypto_aead_maxauthsize(tfm
))
76 if (crypto_aead_alg(tfm
)->setauthsize
) {
77 err
= crypto_aead_alg(tfm
)->setauthsize(tfm
, authsize
);
82 tfm
->authsize
= authsize
;
85 EXPORT_SYMBOL_GPL(crypto_aead_setauthsize
);
87 static void crypto_aead_exit_tfm(struct crypto_tfm
*tfm
)
89 struct crypto_aead
*aead
= __crypto_aead_cast(tfm
);
90 struct aead_alg
*alg
= crypto_aead_alg(aead
);
95 static int crypto_aead_init_tfm(struct crypto_tfm
*tfm
)
97 struct crypto_aead
*aead
= __crypto_aead_cast(tfm
);
98 struct aead_alg
*alg
= crypto_aead_alg(aead
);
100 crypto_aead_set_flags(aead
, CRYPTO_TFM_NEED_KEY
);
102 aead
->authsize
= alg
->maxauthsize
;
105 aead
->base
.exit
= crypto_aead_exit_tfm
;
108 return alg
->init(aead
);
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
= container_of(alg
, struct aead_alg
, base
);
119 memset(&raead
, 0, sizeof(raead
));
121 strscpy(raead
.type
, "aead", sizeof(raead
.type
));
122 strscpy(raead
.geniv
, "<none>", sizeof(raead
.geniv
));
124 raead
.blocksize
= alg
->cra_blocksize
;
125 raead
.maxauthsize
= aead
->maxauthsize
;
126 raead
.ivsize
= aead
->ivsize
;
128 return nla_put(skb
, CRYPTOCFGA_REPORT_AEAD
, sizeof(raead
), &raead
);
131 static int crypto_aead_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
137 static void crypto_aead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
139 static void crypto_aead_show(struct seq_file
*m
, struct crypto_alg
*alg
)
141 struct aead_alg
*aead
= container_of(alg
, struct aead_alg
, base
);
143 seq_printf(m
, "type : aead\n");
144 seq_printf(m
, "async : %s\n", alg
->cra_flags
& CRYPTO_ALG_ASYNC
?
146 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
147 seq_printf(m
, "ivsize : %u\n", aead
->ivsize
);
148 seq_printf(m
, "maxauthsize : %u\n", aead
->maxauthsize
);
149 seq_printf(m
, "geniv : <none>\n");
152 static void crypto_aead_free_instance(struct crypto_instance
*inst
)
154 struct aead_instance
*aead
= aead_instance(inst
);
157 inst
->tmpl
->free(inst
);
164 static const struct crypto_type crypto_aead_type
= {
165 .extsize
= crypto_alg_extsize
,
166 .init_tfm
= crypto_aead_init_tfm
,
167 .free
= crypto_aead_free_instance
,
168 #ifdef CONFIG_PROC_FS
169 .show
= crypto_aead_show
,
171 .report
= crypto_aead_report
,
172 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
173 .maskset
= CRYPTO_ALG_TYPE_MASK
,
174 .type
= CRYPTO_ALG_TYPE_AEAD
,
175 .tfmsize
= offsetof(struct crypto_aead
, base
),
178 static int aead_geniv_setkey(struct crypto_aead
*tfm
,
179 const u8
*key
, unsigned int keylen
)
181 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(tfm
);
183 return crypto_aead_setkey(ctx
->child
, key
, keylen
);
186 static int aead_geniv_setauthsize(struct crypto_aead
*tfm
,
187 unsigned int authsize
)
189 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(tfm
);
191 return crypto_aead_setauthsize(ctx
->child
, authsize
);
194 struct aead_instance
*aead_geniv_alloc(struct crypto_template
*tmpl
,
195 struct rtattr
**tb
, u32 type
, u32 mask
)
198 struct crypto_aead_spawn
*spawn
;
199 struct crypto_attr_type
*algt
;
200 struct aead_instance
*inst
;
201 struct aead_alg
*alg
;
203 unsigned int maxauthsize
;
206 algt
= crypto_get_attr_type(tb
);
208 return ERR_CAST(algt
);
210 if ((algt
->type
^ CRYPTO_ALG_TYPE_AEAD
) & algt
->mask
)
211 return ERR_PTR(-EINVAL
);
213 name
= crypto_attr_alg_name(tb
[1]);
215 return ERR_CAST(name
);
217 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
219 return ERR_PTR(-ENOMEM
);
221 spawn
= aead_instance_ctx(inst
);
223 /* Ignore async algorithms if necessary. */
224 mask
|= crypto_requires_sync(algt
->type
, algt
->mask
);
226 crypto_set_aead_spawn(spawn
, aead_crypto_instance(inst
));
227 err
= crypto_grab_aead(spawn
, name
, type
, mask
);
231 alg
= crypto_spawn_aead_alg(spawn
);
233 ivsize
= crypto_aead_alg_ivsize(alg
);
234 maxauthsize
= crypto_aead_alg_maxauthsize(alg
);
237 if (ivsize
< sizeof(u64
))
241 if (snprintf(inst
->alg
.base
.cra_name
, CRYPTO_MAX_ALG_NAME
,
242 "%s(%s)", tmpl
->name
, alg
->base
.cra_name
) >=
245 if (snprintf(inst
->alg
.base
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
,
246 "%s(%s)", tmpl
->name
, alg
->base
.cra_driver_name
) >=
250 inst
->alg
.base
.cra_flags
= alg
->base
.cra_flags
& CRYPTO_ALG_ASYNC
;
251 inst
->alg
.base
.cra_priority
= alg
->base
.cra_priority
;
252 inst
->alg
.base
.cra_blocksize
= alg
->base
.cra_blocksize
;
253 inst
->alg
.base
.cra_alignmask
= alg
->base
.cra_alignmask
;
254 inst
->alg
.base
.cra_ctxsize
= sizeof(struct aead_geniv_ctx
);
256 inst
->alg
.setkey
= aead_geniv_setkey
;
257 inst
->alg
.setauthsize
= aead_geniv_setauthsize
;
259 inst
->alg
.ivsize
= ivsize
;
260 inst
->alg
.maxauthsize
= maxauthsize
;
266 crypto_drop_aead(spawn
);
272 EXPORT_SYMBOL_GPL(aead_geniv_alloc
);
274 void aead_geniv_free(struct aead_instance
*inst
)
276 crypto_drop_aead(aead_instance_ctx(inst
));
279 EXPORT_SYMBOL_GPL(aead_geniv_free
);
281 int aead_init_geniv(struct crypto_aead
*aead
)
283 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(aead
);
284 struct aead_instance
*inst
= aead_alg_instance(aead
);
285 struct crypto_aead
*child
;
288 spin_lock_init(&ctx
->lock
);
290 err
= crypto_get_default_rng();
294 err
= crypto_rng_get_bytes(crypto_default_rng
, ctx
->salt
,
295 crypto_aead_ivsize(aead
));
296 crypto_put_default_rng();
300 ctx
->sknull
= crypto_get_default_null_skcipher();
301 err
= PTR_ERR(ctx
->sknull
);
302 if (IS_ERR(ctx
->sknull
))
305 child
= crypto_spawn_aead(aead_instance_ctx(inst
));
306 err
= PTR_ERR(child
);
311 crypto_aead_set_reqsize(aead
, crypto_aead_reqsize(child
) +
312 sizeof(struct aead_request
));
320 crypto_put_default_null_skcipher();
323 EXPORT_SYMBOL_GPL(aead_init_geniv
);
325 void aead_exit_geniv(struct crypto_aead
*tfm
)
327 struct aead_geniv_ctx
*ctx
= crypto_aead_ctx(tfm
);
329 crypto_free_aead(ctx
->child
);
330 crypto_put_default_null_skcipher();
332 EXPORT_SYMBOL_GPL(aead_exit_geniv
);
334 int crypto_grab_aead(struct crypto_aead_spawn
*spawn
, const char *name
,
337 spawn
->base
.frontend
= &crypto_aead_type
;
338 return crypto_grab_spawn(&spawn
->base
, name
, type
, mask
);
340 EXPORT_SYMBOL_GPL(crypto_grab_aead
);
342 struct crypto_aead
*crypto_alloc_aead(const char *alg_name
, u32 type
, u32 mask
)
344 return crypto_alloc_tfm(alg_name
, &crypto_aead_type
, type
, mask
);
346 EXPORT_SYMBOL_GPL(crypto_alloc_aead
);
348 static int aead_prepare_alg(struct aead_alg
*alg
)
350 struct crypto_alg
*base
= &alg
->base
;
352 if (max3(alg
->maxauthsize
, alg
->ivsize
, alg
->chunksize
) >
357 alg
->chunksize
= base
->cra_blocksize
;
359 base
->cra_type
= &crypto_aead_type
;
360 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
361 base
->cra_flags
|= CRYPTO_ALG_TYPE_AEAD
;
366 int crypto_register_aead(struct aead_alg
*alg
)
368 struct crypto_alg
*base
= &alg
->base
;
371 err
= aead_prepare_alg(alg
);
375 return crypto_register_alg(base
);
377 EXPORT_SYMBOL_GPL(crypto_register_aead
);
379 void crypto_unregister_aead(struct aead_alg
*alg
)
381 crypto_unregister_alg(&alg
->base
);
383 EXPORT_SYMBOL_GPL(crypto_unregister_aead
);
385 int crypto_register_aeads(struct aead_alg
*algs
, int count
)
389 for (i
= 0; i
< count
; i
++) {
390 ret
= crypto_register_aead(&algs
[i
]);
398 for (--i
; i
>= 0; --i
)
399 crypto_unregister_aead(&algs
[i
]);
403 EXPORT_SYMBOL_GPL(crypto_register_aeads
);
405 void crypto_unregister_aeads(struct aead_alg
*algs
, int count
)
409 for (i
= count
- 1; i
>= 0; --i
)
410 crypto_unregister_aead(&algs
[i
]);
412 EXPORT_SYMBOL_GPL(crypto_unregister_aeads
);
414 int aead_register_instance(struct crypto_template
*tmpl
,
415 struct aead_instance
*inst
)
419 err
= aead_prepare_alg(&inst
->alg
);
423 return crypto_register_instance(tmpl
, aead_crypto_instance(inst
));
425 EXPORT_SYMBOL_GPL(aead_register_instance
);
427 MODULE_LICENSE("GPL");
428 MODULE_DESCRIPTION("Authenticated Encryption with Associated Data (AEAD)");