blob: 0f79fc668ad4764996b50b71afb88bf5d06a7327 [file] [log] [blame]
Herbert Xua10f5542015-05-21 15:11:15 +08001/*
2 * echainiv: Encrypted Chain IV Generator
3 *
4 * This generator generates an IV based on a sequence number by xoring it
5 * with a salt and then encrypting it with the same key as used to encrypt
6 * the plain text. This algorithm requires that the block size be equal
7 * to the IV size. It is mainly useful for CBC.
8 *
9 * This generator can only be used by algorithms where authentication
10 * is performed after encryption (i.e., authenc).
11 *
12 * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
13 *
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the Free
16 * Software Foundation; either version 2 of the License, or (at your option)
17 * any later version.
18 *
19 */
20
Herbert Xud97de472015-05-27 14:37:33 +080021#include <crypto/internal/geniv.h>
Herbert Xua10f5542015-05-21 15:11:15 +080022#include <crypto/null.h>
23#include <crypto/rng.h>
24#include <crypto/scatterwalk.h>
25#include <linux/err.h>
26#include <linux/init.h>
27#include <linux/kernel.h>
28#include <linux/mm.h>
29#include <linux/module.h>
30#include <linux/percpu.h>
31#include <linux/spinlock.h>
32#include <linux/string.h>
33
34#define MAX_IV_SIZE 16
35
Herbert Xua10f5542015-05-21 15:11:15 +080036struct echainiv_ctx {
Herbert Xud97de472015-05-27 14:37:33 +080037 /* aead_geniv_ctx must be first the element */
38 struct aead_geniv_ctx geniv;
Herbert Xua10f5542015-05-21 15:11:15 +080039 struct crypto_blkcipher *null;
40 u8 salt[] __attribute__ ((aligned(__alignof__(u32))));
41};
42
43static DEFINE_PER_CPU(u32 [MAX_IV_SIZE / sizeof(u32)], echainiv_iv);
44
Herbert Xua10f5542015-05-21 15:11:15 +080045/* We don't care if we get preempted and read/write IVs from the next CPU. */
Wu Fengguang622ff872015-05-23 11:22:47 +080046static void echainiv_read_iv(u8 *dst, unsigned size)
Herbert Xua10f5542015-05-21 15:11:15 +080047{
48 u32 *a = (u32 *)dst;
49 u32 __percpu *b = echainiv_iv;
50
51 for (; size >= 4; size -= 4) {
52 *a++ = this_cpu_read(*b);
53 b++;
54 }
55}
56
Wu Fengguang622ff872015-05-23 11:22:47 +080057static void echainiv_write_iv(const u8 *src, unsigned size)
Herbert Xua10f5542015-05-21 15:11:15 +080058{
59 const u32 *a = (const u32 *)src;
60 u32 __percpu *b = echainiv_iv;
61
62 for (; size >= 4; size -= 4) {
63 this_cpu_write(*b, *a);
64 a++;
65 b++;
66 }
67}
68
Herbert Xua10f5542015-05-21 15:11:15 +080069static void echainiv_encrypt_complete2(struct aead_request *req, int err)
70{
71 struct aead_request *subreq = aead_request_ctx(req);
72 struct crypto_aead *geniv;
73 unsigned int ivsize;
74
75 if (err == -EINPROGRESS)
76 return;
77
78 if (err)
79 goto out;
80
81 geniv = crypto_aead_reqtfm(req);
82 ivsize = crypto_aead_ivsize(geniv);
83
84 echainiv_write_iv(subreq->iv, ivsize);
85
86 if (req->iv != subreq->iv)
87 memcpy(req->iv, subreq->iv, ivsize);
88
89out:
90 if (req->iv != subreq->iv)
91 kzfree(subreq->iv);
92}
93
94static void echainiv_encrypt_complete(struct crypto_async_request *base,
95 int err)
96{
97 struct aead_request *req = base->data;
98
99 echainiv_encrypt_complete2(req, err);
100 aead_request_complete(req, err);
101}
102
Herbert Xua10f5542015-05-21 15:11:15 +0800103static int echainiv_encrypt(struct aead_request *req)
104{
105 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
106 struct echainiv_ctx *ctx = crypto_aead_ctx(geniv);
107 struct aead_request *subreq = aead_request_ctx(req);
108 crypto_completion_t compl;
109 void *data;
110 u8 *info;
Herbert Xu823655c2015-05-23 15:41:54 +0800111 unsigned int ivsize = crypto_aead_ivsize(geniv);
Herbert Xua10f5542015-05-21 15:11:15 +0800112 int err;
113
Herbert Xu823655c2015-05-23 15:41:54 +0800114 if (req->cryptlen < ivsize)
115 return -EINVAL;
116
Herbert Xud97de472015-05-27 14:37:33 +0800117 aead_request_set_tfm(subreq, ctx->geniv.child);
Herbert Xua10f5542015-05-21 15:11:15 +0800118
119 compl = echainiv_encrypt_complete;
120 data = req;
121 info = req->iv;
122
Herbert Xua10f5542015-05-21 15:11:15 +0800123 if (req->src != req->dst) {
Herbert Xua10f5542015-05-21 15:11:15 +0800124 struct blkcipher_desc desc = {
125 .tfm = ctx->null,
126 };
127
128 err = crypto_blkcipher_encrypt(
Herbert Xu838c9d562015-05-27 14:37:31 +0800129 &desc, req->dst, req->src,
130 req->assoclen + req->cryptlen);
Herbert Xua10f5542015-05-21 15:11:15 +0800131 if (err)
132 return err;
133 }
134
135 if (unlikely(!IS_ALIGNED((unsigned long)info,
136 crypto_aead_alignmask(geniv) + 1))) {
137 info = kmalloc(ivsize, req->base.flags &
138 CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL:
139 GFP_ATOMIC);
140 if (!info)
141 return -ENOMEM;
142
143 memcpy(info, req->iv, ivsize);
144 }
145
146 aead_request_set_callback(subreq, req->base.flags, compl, data);
147 aead_request_set_crypt(subreq, req->dst, req->dst,
148 req->cryptlen - ivsize, info);
Herbert Xu374d4ad2015-05-23 15:41:57 +0800149 aead_request_set_ad(subreq, req->assoclen + ivsize);
Herbert Xua10f5542015-05-21 15:11:15 +0800150
151 crypto_xor(info, ctx->salt, ivsize);
152 scatterwalk_map_and_copy(info, req->dst, req->assoclen, ivsize, 1);
153 echainiv_read_iv(info, ivsize);
154
155 err = crypto_aead_encrypt(subreq);
156 echainiv_encrypt_complete2(req, err);
157 return err;
158}
159
Herbert Xua10f5542015-05-21 15:11:15 +0800160static int echainiv_decrypt(struct aead_request *req)
161{
162 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
163 struct echainiv_ctx *ctx = crypto_aead_ctx(geniv);
164 struct aead_request *subreq = aead_request_ctx(req);
165 crypto_completion_t compl;
166 void *data;
Herbert Xu823655c2015-05-23 15:41:54 +0800167 unsigned int ivsize = crypto_aead_ivsize(geniv);
168
169 if (req->cryptlen < ivsize + crypto_aead_authsize(geniv))
170 return -EINVAL;
Herbert Xua10f5542015-05-21 15:11:15 +0800171
Herbert Xud97de472015-05-27 14:37:33 +0800172 aead_request_set_tfm(subreq, ctx->geniv.child);
Herbert Xua10f5542015-05-21 15:11:15 +0800173
174 compl = req->base.complete;
175 data = req->base.data;
176
Herbert Xua10f5542015-05-21 15:11:15 +0800177 aead_request_set_callback(subreq, req->base.flags, compl, data);
178 aead_request_set_crypt(subreq, req->src, req->dst,
179 req->cryptlen - ivsize, req->iv);
Herbert Xu374d4ad2015-05-23 15:41:57 +0800180 aead_request_set_ad(subreq, req->assoclen + ivsize);
Herbert Xua10f5542015-05-21 15:11:15 +0800181
182 scatterwalk_map_and_copy(req->iv, req->src, req->assoclen, ivsize, 0);
183 if (req->src != req->dst)
184 scatterwalk_map_and_copy(req->iv, req->dst,
185 req->assoclen, ivsize, 1);
186
187 return crypto_aead_decrypt(subreq);
188}
189
Herbert Xua10f5542015-05-21 15:11:15 +0800190static int echainiv_encrypt_first(struct aead_request *req)
191{
192 struct crypto_aead *geniv = crypto_aead_reqtfm(req);
193 struct echainiv_ctx *ctx = crypto_aead_ctx(geniv);
194 int err = 0;
195
Herbert Xud97de472015-05-27 14:37:33 +0800196 spin_lock_bh(&ctx->geniv.lock);
Herbert Xua10f5542015-05-21 15:11:15 +0800197 if (geniv->encrypt != echainiv_encrypt_first)
198 goto unlock;
199
200 geniv->encrypt = echainiv_encrypt;
201 err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,
202 crypto_aead_ivsize(geniv));
203
204unlock:
Herbert Xud97de472015-05-27 14:37:33 +0800205 spin_unlock_bh(&ctx->geniv.lock);
Herbert Xua10f5542015-05-21 15:11:15 +0800206
207 if (err)
208 return err;
209
210 return echainiv_encrypt(req);
211}
212
Herbert Xua10f5542015-05-21 15:11:15 +0800213static int echainiv_init(struct crypto_tfm *tfm)
214{
215 struct crypto_aead *geniv = __crypto_aead_cast(tfm);
216 struct echainiv_ctx *ctx = crypto_aead_ctx(geniv);
217 int err;
218
Herbert Xud97de472015-05-27 14:37:33 +0800219 spin_lock_init(&ctx->geniv.lock);
Herbert Xua10f5542015-05-21 15:11:15 +0800220
221 crypto_aead_set_reqsize(geniv, sizeof(struct aead_request));
222
223 ctx->null = crypto_get_default_null_skcipher();
224 err = PTR_ERR(ctx->null);
225 if (IS_ERR(ctx->null))
226 goto out;
227
228 err = aead_geniv_init(tfm);
229 if (err)
230 goto drop_null;
231
Herbert Xud97de472015-05-27 14:37:33 +0800232 ctx->geniv.child = geniv->child;
Herbert Xua10f5542015-05-21 15:11:15 +0800233 geniv->child = geniv;
234
235out:
236 return err;
237
238drop_null:
239 crypto_put_default_null_skcipher();
240 goto out;
241}
242
Herbert Xua10f5542015-05-21 15:11:15 +0800243static void echainiv_exit(struct crypto_tfm *tfm)
244{
245 struct echainiv_ctx *ctx = crypto_tfm_ctx(tfm);
246
Herbert Xud97de472015-05-27 14:37:33 +0800247 crypto_free_aead(ctx->geniv.child);
Herbert Xua10f5542015-05-21 15:11:15 +0800248 crypto_put_default_null_skcipher();
249}
250
Herbert Xu1e419c72015-05-23 15:41:52 +0800251static int echainiv_aead_create(struct crypto_template *tmpl,
252 struct rtattr **tb)
Herbert Xua10f5542015-05-21 15:11:15 +0800253{
254 struct aead_instance *inst;
255 struct crypto_aead_spawn *spawn;
256 struct aead_alg *alg;
Herbert Xu1e419c72015-05-23 15:41:52 +0800257 int err;
Herbert Xua10f5542015-05-21 15:11:15 +0800258
Herbert Xu1e419c72015-05-23 15:41:52 +0800259 inst = aead_geniv_alloc(tmpl, tb, 0, 0);
Herbert Xua10f5542015-05-21 15:11:15 +0800260
261 if (IS_ERR(inst))
Herbert Xu1e419c72015-05-23 15:41:52 +0800262 return PTR_ERR(inst);
Herbert Xua10f5542015-05-21 15:11:15 +0800263
Herbert Xua10f5542015-05-21 15:11:15 +0800264 spawn = aead_instance_ctx(inst);
265 alg = crypto_spawn_aead_alg(spawn);
266
Herbert Xud97de472015-05-27 14:37:33 +0800267 if (alg->base.cra_aead.encrypt)
268 goto done;
269
270 err = -EINVAL;
271 if (inst->alg.ivsize & (sizeof(u32) - 1) ||
272 inst->alg.ivsize > MAX_IV_SIZE)
273 goto free_inst;
274
Herbert Xua10f5542015-05-21 15:11:15 +0800275 inst->alg.encrypt = echainiv_encrypt_first;
276 inst->alg.decrypt = echainiv_decrypt;
277
278 inst->alg.base.cra_init = echainiv_init;
279 inst->alg.base.cra_exit = echainiv_exit;
280
281 inst->alg.base.cra_alignmask |= __alignof__(u32) - 1;
282 inst->alg.base.cra_ctxsize = sizeof(struct echainiv_ctx);
283 inst->alg.base.cra_ctxsize += inst->alg.base.cra_aead.ivsize;
284
Herbert Xud97de472015-05-27 14:37:33 +0800285done:
Herbert Xu1e419c72015-05-23 15:41:52 +0800286 err = aead_register_instance(tmpl, inst);
287 if (err)
288 goto free_inst;
289
Herbert Xua10f5542015-05-21 15:11:15 +0800290out:
Herbert Xu1e419c72015-05-23 15:41:52 +0800291 return err;
292
293free_inst:
294 aead_geniv_free(inst);
295 goto out;
Herbert Xua10f5542015-05-21 15:11:15 +0800296}
297
Herbert Xu1e419c72015-05-23 15:41:52 +0800298static int echainiv_create(struct crypto_template *tmpl, struct rtattr **tb)
Herbert Xua10f5542015-05-21 15:11:15 +0800299{
Herbert Xua10f5542015-05-21 15:11:15 +0800300 int err;
301
302 err = crypto_get_default_rng();
303 if (err)
Herbert Xu1e419c72015-05-23 15:41:52 +0800304 goto out;
Herbert Xua10f5542015-05-21 15:11:15 +0800305
Herbert Xu1e419c72015-05-23 15:41:52 +0800306 err = echainiv_aead_create(tmpl, tb);
307 if (err)
Herbert Xua10f5542015-05-21 15:11:15 +0800308 goto put_rng;
309
310out:
Herbert Xu1e419c72015-05-23 15:41:52 +0800311 return err;
Herbert Xua10f5542015-05-21 15:11:15 +0800312
313put_rng:
314 crypto_put_default_rng();
315 goto out;
316}
317
318static void echainiv_free(struct crypto_instance *inst)
319{
320 aead_geniv_free(aead_instance(inst));
321 crypto_put_default_rng();
322}
323
324static struct crypto_template echainiv_tmpl = {
325 .name = "echainiv",
Herbert Xu1e419c72015-05-23 15:41:52 +0800326 .create = echainiv_create,
Herbert Xua10f5542015-05-21 15:11:15 +0800327 .free = echainiv_free,
328 .module = THIS_MODULE,
329};
330
331static int __init echainiv_module_init(void)
332{
333 return crypto_register_template(&echainiv_tmpl);
334}
335
336static void __exit echainiv_module_exit(void)
337{
338 crypto_unregister_template(&echainiv_tmpl);
339}
340
341module_init(echainiv_module_init);
342module_exit(echainiv_module_exit);
343
344MODULE_LICENSE("GPL");
345MODULE_DESCRIPTION("Encrypted Chain IV Generator");
346MODULE_ALIAS_CRYPTO("echainiv");