blob: c3c158ba988303114aa22baaeb0540ac00405914 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Herbert Xu1ae97822007-08-30 15:36:14 +08002/*
3 * AEAD: Authenticated Encryption with Associated Data
Richard Hartmann39225382010-02-16 20:24:07 +08004 *
Herbert Xu1ae97822007-08-30 15:36:14 +08005 * This file provides API support for AEAD algorithms.
6 *
Herbert Xub0d955b2015-08-14 15:30:41 +08007 * Copyright (c) 2007-2015 Herbert Xu <herbert@gondor.apana.org.au>
Herbert Xu1ae97822007-08-30 15:36:14 +08008 */
9
Herbert Xu63504492015-05-27 14:37:30 +080010#include <crypto/internal/geniv.h>
Herbert Xu149a3972015-08-13 17:28:58 +080011#include <crypto/internal/rng.h>
12#include <crypto/null.h>
Herbert Xu996d98d2015-05-21 15:11:01 +080013#include <crypto/scatterwalk.h>
Herbert Xu5b6d2d72007-12-12 19:23:36 +080014#include <linux/err.h>
Herbert Xu1ae97822007-08-30 15:36:14 +080015#include <linux/init.h>
16#include <linux/kernel.h>
17#include <linux/module.h>
Herbert Xud29ce982007-12-12 19:24:27 +080018#include <linux/rtnetlink.h>
Herbert Xu1ae97822007-08-30 15:36:14 +080019#include <linux/slab.h>
20#include <linux/seq_file.h>
Steffen Klassert6ad414f2011-09-27 07:44:27 +020021#include <linux/cryptouser.h>
Gideon Israel Dsouzad8c34b92016-12-31 21:26:23 +053022#include <linux/compiler.h>
Steffen Klassert6ad414f2011-09-27 07:44:27 +020023#include <net/netlink.h>
Herbert Xu1ae97822007-08-30 15:36:14 +080024
Herbert Xu5b6d2d72007-12-12 19:23:36 +080025#include "internal.h"
26
Herbert Xu1ae97822007-08-30 15:36:14 +080027static int setkey_unaligned(struct crypto_aead *tfm, const u8 *key,
28 unsigned int keylen)
29{
Herbert Xu1ae97822007-08-30 15:36:14 +080030 unsigned long alignmask = crypto_aead_alignmask(tfm);
31 int ret;
32 u8 *buffer, *alignbuffer;
33 unsigned long absize;
34
35 absize = keylen + alignmask;
36 buffer = kmalloc(absize, GFP_ATOMIC);
37 if (!buffer)
38 return -ENOMEM;
39
40 alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
41 memcpy(alignbuffer, key, keylen);
Herbert Xub0d955b2015-08-14 15:30:41 +080042 ret = crypto_aead_alg(tfm)->setkey(tfm, alignbuffer, keylen);
Herbert Xu1ae97822007-08-30 15:36:14 +080043 memset(alignbuffer, 0, keylen);
44 kfree(buffer);
45 return ret;
46}
47
Herbert Xu5d1d65f2015-05-11 17:48:12 +080048int crypto_aead_setkey(struct crypto_aead *tfm,
49 const u8 *key, unsigned int keylen)
Herbert Xu1ae97822007-08-30 15:36:14 +080050{
Herbert Xu1ae97822007-08-30 15:36:14 +080051 unsigned long alignmask = crypto_aead_alignmask(tfm);
Eric Biggersdc26c172018-01-03 11:16:30 -080052 int err;
Herbert Xu1ae97822007-08-30 15:36:14 +080053
54 if ((unsigned long)key & alignmask)
Eric Biggersdc26c172018-01-03 11:16:30 -080055 err = setkey_unaligned(tfm, key, keylen);
56 else
57 err = crypto_aead_alg(tfm)->setkey(tfm, key, keylen);
Herbert Xu1ae97822007-08-30 15:36:14 +080058
Eric Biggers6ebc9702019-01-06 18:47:44 -080059 if (unlikely(err)) {
60 crypto_aead_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
Eric Biggersdc26c172018-01-03 11:16:30 -080061 return err;
Eric Biggers6ebc9702019-01-06 18:47:44 -080062 }
Eric Biggersdc26c172018-01-03 11:16:30 -080063
64 crypto_aead_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
65 return 0;
Herbert Xu1ae97822007-08-30 15:36:14 +080066}
Herbert Xu5d1d65f2015-05-11 17:48:12 +080067EXPORT_SYMBOL_GPL(crypto_aead_setkey);
Herbert Xu1ae97822007-08-30 15:36:14 +080068
Herbert Xu7ba683a2007-12-02 18:49:21 +110069int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
70{
71 int err;
72
Herbert Xu30e4c012015-05-22 16:30:48 +080073 if (authsize > crypto_aead_maxauthsize(tfm))
Herbert Xu7ba683a2007-12-02 18:49:21 +110074 return -EINVAL;
75
Herbert Xub0d955b2015-08-14 15:30:41 +080076 if (crypto_aead_alg(tfm)->setauthsize) {
77 err = crypto_aead_alg(tfm)->setauthsize(tfm, authsize);
Herbert Xu7ba683a2007-12-02 18:49:21 +110078 if (err)
79 return err;
80 }
81
Herbert Xu5d1d65f2015-05-11 17:48:12 +080082 tfm->authsize = authsize;
Herbert Xu7ba683a2007-12-02 18:49:21 +110083 return 0;
84}
85EXPORT_SYMBOL_GPL(crypto_aead_setauthsize);
86
Herbert Xu5eb8ec62015-05-28 22:07:53 +080087static void crypto_aead_exit_tfm(struct crypto_tfm *tfm)
88{
89 struct crypto_aead *aead = __crypto_aead_cast(tfm);
90 struct aead_alg *alg = crypto_aead_alg(aead);
91
92 alg->exit(aead);
93}
94
Herbert Xu63293c62015-05-21 15:11:08 +080095static int crypto_aead_init_tfm(struct crypto_tfm *tfm)
96{
97 struct crypto_aead *aead = __crypto_aead_cast(tfm);
98 struct aead_alg *alg = crypto_aead_alg(aead);
99
Eric Biggersdc26c172018-01-03 11:16:30 -0800100 crypto_aead_set_flags(aead, CRYPTO_TFM_NEED_KEY);
101
Herbert Xu63293c62015-05-21 15:11:08 +0800102 aead->authsize = alg->maxauthsize;
103
Herbert Xu5eb8ec62015-05-28 22:07:53 +0800104 if (alg->exit)
105 aead->base.exit = crypto_aead_exit_tfm;
106
107 if (alg->init)
108 return alg->init(aead);
109
Herbert Xu63293c62015-05-21 15:11:08 +0800110 return 0;
111}
112
Herbert Xu3acc8472011-11-03 23:46:07 +1100113#ifdef CONFIG_NET
Herbert Xu63293c62015-05-21 15:11:08 +0800114static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg)
115{
116 struct crypto_report_aead raead;
117 struct aead_alg *aead = container_of(alg, struct aead_alg, base);
118
Eric Biggers37db69e2018-11-03 14:56:03 -0700119 memset(&raead, 0, sizeof(raead));
120
121 strscpy(raead.type, "aead", sizeof(raead.type));
122 strscpy(raead.geniv, "<none>", sizeof(raead.geniv));
Herbert Xu63293c62015-05-21 15:11:08 +0800123
124 raead.blocksize = alg->cra_blocksize;
125 raead.maxauthsize = aead->maxauthsize;
126 raead.ivsize = aead->ivsize;
127
Eric Biggers37db69e2018-11-03 14:56:03 -0700128 return nla_put(skb, CRYPTOCFGA_REPORT_AEAD, sizeof(raead), &raead);
Herbert Xu63293c62015-05-21 15:11:08 +0800129}
130#else
Herbert Xu3acc8472011-11-03 23:46:07 +1100131static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg)
132{
133 return -ENOSYS;
134}
135#endif
Steffen Klassert6ad414f2011-09-27 07:44:27 +0200136
Herbert Xu1ae97822007-08-30 15:36:14 +0800137static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
Gideon Israel Dsouzad8c34b92016-12-31 21:26:23 +0530138 __maybe_unused;
Herbert Xu1ae97822007-08-30 15:36:14 +0800139static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
140{
Herbert Xu63293c62015-05-21 15:11:08 +0800141 struct aead_alg *aead = container_of(alg, struct aead_alg, base);
Herbert Xu1ae97822007-08-30 15:36:14 +0800142
143 seq_printf(m, "type : aead\n");
Herbert Xu189ed662007-12-14 22:29:37 +0800144 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
145 "yes" : "no");
Herbert Xu1ae97822007-08-30 15:36:14 +0800146 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
147 seq_printf(m, "ivsize : %u\n", aead->ivsize);
Herbert Xu7ba683a2007-12-02 18:49:21 +1100148 seq_printf(m, "maxauthsize : %u\n", aead->maxauthsize);
Herbert Xu63293c62015-05-21 15:11:08 +0800149 seq_printf(m, "geniv : <none>\n");
Herbert Xu1ae97822007-08-30 15:36:14 +0800150}
151
Herbert Xuba75e152015-07-09 07:17:17 +0800152static void crypto_aead_free_instance(struct crypto_instance *inst)
153{
154 struct aead_instance *aead = aead_instance(inst);
155
156 if (!aead->free) {
157 inst->tmpl->free(inst);
158 return;
159 }
160
161 aead->free(aead);
162}
163
Herbert Xub0d955b2015-08-14 15:30:41 +0800164static const struct crypto_type crypto_aead_type = {
Herbert Xu5d1d65f2015-05-11 17:48:12 +0800165 .extsize = crypto_alg_extsize,
166 .init_tfm = crypto_aead_init_tfm,
Herbert Xuba75e152015-07-09 07:17:17 +0800167 .free = crypto_aead_free_instance,
Herbert Xu1ae97822007-08-30 15:36:14 +0800168#ifdef CONFIG_PROC_FS
169 .show = crypto_aead_show,
170#endif
Steffen Klassert6ad414f2011-09-27 07:44:27 +0200171 .report = crypto_aead_report,
Herbert Xu63293c62015-05-21 15:11:08 +0800172 .maskclear = ~CRYPTO_ALG_TYPE_MASK,
Herbert Xu5d1d65f2015-05-11 17:48:12 +0800173 .maskset = CRYPTO_ALG_TYPE_MASK,
174 .type = CRYPTO_ALG_TYPE_AEAD,
175 .tfmsize = offsetof(struct crypto_aead, base),
Herbert Xu1ae97822007-08-30 15:36:14 +0800176};
Herbert Xu1ae97822007-08-30 15:36:14 +0800177
Herbert Xu63504492015-05-27 14:37:30 +0800178static int aead_geniv_setkey(struct crypto_aead *tfm,
179 const u8 *key, unsigned int keylen)
180{
181 struct aead_geniv_ctx *ctx = crypto_aead_ctx(tfm);
182
183 return crypto_aead_setkey(ctx->child, key, keylen);
184}
185
186static int aead_geniv_setauthsize(struct crypto_aead *tfm,
187 unsigned int authsize)
188{
189 struct aead_geniv_ctx *ctx = crypto_aead_ctx(tfm);
190
191 return crypto_aead_setauthsize(ctx->child, authsize);
192}
193
Herbert Xu856e3f402015-05-21 15:11:13 +0800194struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl,
195 struct rtattr **tb, u32 type, u32 mask)
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800196{
197 const char *name;
198 struct crypto_aead_spawn *spawn;
199 struct crypto_attr_type *algt;
Herbert Xu856e3f402015-05-21 15:11:13 +0800200 struct aead_instance *inst;
201 struct aead_alg *alg;
202 unsigned int ivsize;
203 unsigned int maxauthsize;
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800204 int err;
205
206 algt = crypto_get_attr_type(tb);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800207 if (IS_ERR(algt))
Julia Lawall3e8afe32013-01-22 12:29:26 +0100208 return ERR_CAST(algt);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800209
Herbert Xu5e4b8c12015-08-13 17:29:06 +0800210 if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800211 return ERR_PTR(-EINVAL);
212
213 name = crypto_attr_alg_name(tb[1]);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800214 if (IS_ERR(name))
Julia Lawall3e8afe32013-01-22 12:29:26 +0100215 return ERR_CAST(name);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800216
217 inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
218 if (!inst)
219 return ERR_PTR(-ENOMEM);
220
Herbert Xu856e3f402015-05-21 15:11:13 +0800221 spawn = aead_instance_ctx(inst);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800222
223 /* Ignore async algorithms if necessary. */
224 mask |= crypto_requires_sync(algt->type, algt->mask);
225
Herbert Xu856e3f402015-05-21 15:11:13 +0800226 crypto_set_aead_spawn(spawn, aead_crypto_instance(inst));
Herbert Xub0d955b2015-08-14 15:30:41 +0800227 err = crypto_grab_aead(spawn, name, type, mask);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800228 if (err)
229 goto err_free_inst;
230
Herbert Xu856e3f402015-05-21 15:11:13 +0800231 alg = crypto_spawn_aead_alg(spawn);
232
Herbert Xu30e4c012015-05-22 16:30:48 +0800233 ivsize = crypto_aead_alg_ivsize(alg);
234 maxauthsize = crypto_aead_alg_maxauthsize(alg);
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800235
236 err = -EINVAL;
Herbert Xu63504492015-05-27 14:37:30 +0800237 if (ivsize < sizeof(u64))
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800238 goto err_drop_alg;
239
Herbert Xu856e3f402015-05-21 15:11:13 +0800240 err = -ENAMETOOLONG;
241 if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
242 "%s(%s)", tmpl->name, alg->base.cra_name) >=
243 CRYPTO_MAX_ALG_NAME)
244 goto err_drop_alg;
245 if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
246 "%s(%s)", tmpl->name, alg->base.cra_driver_name) >=
247 CRYPTO_MAX_ALG_NAME)
248 goto err_drop_alg;
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800249
Herbert Xu5e4b8c12015-08-13 17:29:06 +0800250 inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
Herbert Xu856e3f402015-05-21 15:11:13 +0800251 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;
Herbert Xu63504492015-05-27 14:37:30 +0800254 inst->alg.base.cra_ctxsize = sizeof(struct aead_geniv_ctx);
255
256 inst->alg.setkey = aead_geniv_setkey;
257 inst->alg.setauthsize = aead_geniv_setauthsize;
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800258
Herbert Xu856e3f402015-05-21 15:11:13 +0800259 inst->alg.ivsize = ivsize;
260 inst->alg.maxauthsize = maxauthsize;
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800261
262out:
263 return inst;
264
265err_drop_alg:
266 crypto_drop_aead(spawn);
267err_free_inst:
268 kfree(inst);
269 inst = ERR_PTR(err);
270 goto out;
271}
272EXPORT_SYMBOL_GPL(aead_geniv_alloc);
273
Herbert Xu856e3f402015-05-21 15:11:13 +0800274void aead_geniv_free(struct aead_instance *inst)
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800275{
Herbert Xu856e3f402015-05-21 15:11:13 +0800276 crypto_drop_aead(aead_instance_ctx(inst));
Herbert Xu5b6d2d72007-12-12 19:23:36 +0800277 kfree(inst);
278}
279EXPORT_SYMBOL_GPL(aead_geniv_free);
280
Herbert Xu149a3972015-08-13 17:28:58 +0800281int aead_init_geniv(struct crypto_aead *aead)
282{
283 struct aead_geniv_ctx *ctx = crypto_aead_ctx(aead);
284 struct aead_instance *inst = aead_alg_instance(aead);
285 struct crypto_aead *child;
286 int err;
287
288 spin_lock_init(&ctx->lock);
289
290 err = crypto_get_default_rng();
291 if (err)
292 goto out;
293
294 err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,
295 crypto_aead_ivsize(aead));
296 crypto_put_default_rng();
297 if (err)
298 goto out;
299
Eric Biggers3a2d4fb2017-12-07 10:56:34 -0800300 ctx->sknull = crypto_get_default_null_skcipher();
Herbert Xuca0494c2016-07-12 13:17:42 +0800301 err = PTR_ERR(ctx->sknull);
302 if (IS_ERR(ctx->sknull))
303 goto out;
304
Herbert Xu149a3972015-08-13 17:28:58 +0800305 child = crypto_spawn_aead(aead_instance_ctx(inst));
306 err = PTR_ERR(child);
307 if (IS_ERR(child))
308 goto drop_null;
309
310 ctx->child = child;
311 crypto_aead_set_reqsize(aead, crypto_aead_reqsize(child) +
312 sizeof(struct aead_request));
313
314 err = 0;
315
316out:
317 return err;
318
319drop_null:
Eric Biggers3a2d4fb2017-12-07 10:56:34 -0800320 crypto_put_default_null_skcipher();
Herbert Xu149a3972015-08-13 17:28:58 +0800321 goto out;
322}
323EXPORT_SYMBOL_GPL(aead_init_geniv);
324
325void aead_exit_geniv(struct crypto_aead *tfm)
326{
327 struct aead_geniv_ctx *ctx = crypto_aead_ctx(tfm);
328
329 crypto_free_aead(ctx->child);
Eric Biggers3a2d4fb2017-12-07 10:56:34 -0800330 crypto_put_default_null_skcipher();
Herbert Xu149a3972015-08-13 17:28:58 +0800331}
332EXPORT_SYMBOL_GPL(aead_exit_geniv);
333
Herbert Xud29ce982007-12-12 19:24:27 +0800334int crypto_grab_aead(struct crypto_aead_spawn *spawn, const char *name,
335 u32 type, u32 mask)
336{
Herbert Xu5d1d65f2015-05-11 17:48:12 +0800337 spawn->base.frontend = &crypto_aead_type;
338 return crypto_grab_spawn(&spawn->base, name, type, mask);
Herbert Xud29ce982007-12-12 19:24:27 +0800339}
340EXPORT_SYMBOL_GPL(crypto_grab_aead);
341
342struct crypto_aead *crypto_alloc_aead(const char *alg_name, u32 type, u32 mask)
343{
Herbert Xu5d1d65f2015-05-11 17:48:12 +0800344 return crypto_alloc_tfm(alg_name, &crypto_aead_type, type, mask);
Herbert Xud29ce982007-12-12 19:24:27 +0800345}
346EXPORT_SYMBOL_GPL(crypto_alloc_aead);
347
Herbert Xu63293c62015-05-21 15:11:08 +0800348static int aead_prepare_alg(struct aead_alg *alg)
349{
350 struct crypto_alg *base = &alg->base;
351
Herbert Xu7a530aa2016-07-12 13:17:33 +0800352 if (max3(alg->maxauthsize, alg->ivsize, alg->chunksize) >
353 PAGE_SIZE / 8)
Herbert Xu63293c62015-05-21 15:11:08 +0800354 return -EINVAL;
355
Herbert Xu7a530aa2016-07-12 13:17:33 +0800356 if (!alg->chunksize)
357 alg->chunksize = base->cra_blocksize;
358
Herbert Xub0d955b2015-08-14 15:30:41 +0800359 base->cra_type = &crypto_aead_type;
Herbert Xu63293c62015-05-21 15:11:08 +0800360 base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
361 base->cra_flags |= CRYPTO_ALG_TYPE_AEAD;
362
363 return 0;
364}
365
366int crypto_register_aead(struct aead_alg *alg)
367{
368 struct crypto_alg *base = &alg->base;
369 int err;
370
371 err = aead_prepare_alg(alg);
372 if (err)
373 return err;
374
375 return crypto_register_alg(base);
376}
377EXPORT_SYMBOL_GPL(crypto_register_aead);
378
Herbert Xu43615362015-05-28 22:07:57 +0800379void crypto_unregister_aead(struct aead_alg *alg)
Herbert Xu63293c62015-05-21 15:11:08 +0800380{
Herbert Xu43615362015-05-28 22:07:57 +0800381 crypto_unregister_alg(&alg->base);
Herbert Xu63293c62015-05-21 15:11:08 +0800382}
383EXPORT_SYMBOL_GPL(crypto_unregister_aead);
384
Herbert Xucaab9462015-05-28 22:07:59 +0800385int crypto_register_aeads(struct aead_alg *algs, int count)
386{
387 int i, ret;
388
389 for (i = 0; i < count; i++) {
390 ret = crypto_register_aead(&algs[i]);
391 if (ret)
392 goto err;
393 }
394
395 return 0;
396
397err:
398 for (--i; i >= 0; --i)
399 crypto_unregister_aead(&algs[i]);
400
401 return ret;
402}
403EXPORT_SYMBOL_GPL(crypto_register_aeads);
404
405void crypto_unregister_aeads(struct aead_alg *algs, int count)
406{
407 int i;
408
409 for (i = count - 1; i >= 0; --i)
410 crypto_unregister_aead(&algs[i]);
411}
412EXPORT_SYMBOL_GPL(crypto_unregister_aeads);
413
Herbert Xu63293c62015-05-21 15:11:08 +0800414int aead_register_instance(struct crypto_template *tmpl,
415 struct aead_instance *inst)
416{
417 int err;
418
419 err = aead_prepare_alg(&inst->alg);
420 if (err)
421 return err;
422
423 return crypto_register_instance(tmpl, aead_crypto_instance(inst));
424}
425EXPORT_SYMBOL_GPL(aead_register_instance);
426
Herbert Xu1ae97822007-08-30 15:36:14 +0800427MODULE_LICENSE("GPL");
428MODULE_DESCRIPTION("Authenticated Encryption with Associated Data (AEAD)");