crypto/echainiv.c

   1 /*
   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
  21 #include <crypto/internal/geniv.h>
  22 #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
  36 struct echainiv_ctx {
  37         /* aead_geniv_ctx must be first the element */
  38         struct aead_geniv_ctx geniv;
  39         struct crypto_blkcipher *null;
  40         u8 salt[] __attribute__ ((aligned(__alignof__(u32))));
  41 };
  42
  43 static DEFINE_PER_CPU(u32 [MAX_IV_SIZE / sizeof(u32)], echainiv_iv);
  44
  45 /* We don't care if we get preempted and read/write IVs from the next CPU. */
  46 static void echainiv_read_iv(u8 *dst, unsigned size)
  47 {
  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
  57 static void echainiv_write_iv(const u8 *src, unsigned size)
  58 {
  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
  69 static 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
  89 out:
  90         if (req->iv != subreq->iv)
  91                 kzfree(subreq->iv);
  92 }
  93
  94 static 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
 103 static 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;
 111         unsigned int ivsize = crypto_aead_ivsize(geniv);
 112         int err;
 113
 114         if (req->cryptlen < ivsize)
 115                 return -EINVAL;
 116
 117         aead_request_set_tfm(subreq, ctx->geniv.child);
 118
 119         compl = echainiv_encrypt_complete;
 120         data = req;
 121         info = req->iv;
 122
 123         if (req->src != req->dst) {
 124                 struct blkcipher_desc desc = {
 125                         .tfm = ctx->null,
 126                 };
 127
 128                 err = crypto_blkcipher_encrypt(
 129                         &desc, req->dst, req->src,
 130                         req->assoclen + req->cryptlen);
 131                 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, info);
 149         aead_request_set_ad(subreq, req->assoclen);
 150
 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
 160 static 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;
 167         unsigned int ivsize = crypto_aead_ivsize(geniv);
 168
 169         if (req->cryptlen < ivsize)
 170                 return -EINVAL;
 171
 172         aead_request_set_tfm(subreq, ctx->geniv.child);
 173
 174         compl = req->base.complete;
 175         data = req->base.data;
 176
 177         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);
 180         aead_request_set_ad(subreq, req->assoclen + ivsize);
 181
 182         scatterwalk_map_and_copy(req->iv, req->src, req->assoclen, ivsize, 0);
 183
 184         return crypto_aead_decrypt(subreq);
 185 }
 186
 187 static int echainiv_init(struct crypto_aead *geniv)
 188 {
 189         struct echainiv_ctx *ctx = crypto_aead_ctx(geniv);
 190         int err;
 191
 192         spin_lock_init(&ctx->geniv.lock);
 193
 194         crypto_aead_set_reqsize(geniv, sizeof(struct aead_request));
 195
 196         err = crypto_get_default_rng();
 197         if (err)
 198                 goto out;
 199
 200         err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt,
 201                                    crypto_aead_ivsize(geniv));
 202         crypto_put_default_rng();
 203         if (err)
 204                 goto out;
 205
 206         ctx->null = crypto_get_default_null_skcipher();
 207         err = PTR_ERR(ctx->null);
 208         if (IS_ERR(ctx->null))
 209                 goto out;
 210
 211         err = aead_geniv_init(crypto_aead_tfm(geniv));
 212         if (err)
 213                 goto drop_null;
 214
 215         ctx->geniv.child = geniv->child;
 216         geniv->child = geniv;
 217
 218 out:
 219         return err;
 220
 221 drop_null:
 222         crypto_put_default_null_skcipher();
 223         goto out;
 224 }
 225
 226 static void echainiv_exit(struct crypto_aead *tfm)
 227 {
 228         struct echainiv_ctx *ctx = crypto_aead_ctx(tfm);
 229
 230         crypto_free_aead(ctx->geniv.child);
 231         crypto_put_default_null_skcipher();
 232 }
 233
 234 static int echainiv_aead_create(struct crypto_template *tmpl,
 235                                 struct rtattr **tb)
 236 {
 237         struct aead_instance *inst;
 238         struct crypto_aead_spawn *spawn;
 239         struct aead_alg *alg;
 240         int err;
 241
 242         inst = aead_geniv_alloc(tmpl, tb, 0, 0);
 243
 244         if (IS_ERR(inst))
 245                 return PTR_ERR(inst);
 246
 247         spawn = aead_instance_ctx(inst);
 248         alg = crypto_spawn_aead_alg(spawn);
 249
 250         if (alg->base.cra_aead.encrypt)
 251                 goto done;
 252
 253         err = -EINVAL;
 254         if (inst->alg.ivsize & (sizeof(u32) - 1) ||
 255             inst->alg.ivsize > MAX_IV_SIZE)
 256                 goto free_inst;
 257
 258         inst->alg.encrypt = echainiv_encrypt;
 259         inst->alg.decrypt = echainiv_decrypt;
 260
 261         inst->alg.init = echainiv_init;
 262         inst->alg.exit = echainiv_exit;
 263
 264         inst->alg.base.cra_alignmask |= __alignof__(u32) - 1;
 265         inst->alg.base.cra_ctxsize = sizeof(struct echainiv_ctx);
 266         inst->alg.base.cra_ctxsize += inst->alg.ivsize;
 267
 268         inst->free = aead_geniv_free;
 269
 270 done:
 271         err = aead_register_instance(tmpl, inst);
 272         if (err)
 273                 goto free_inst;
 274
 275 out:
 276         return err;
 277
 278 free_inst:
 279         aead_geniv_free(inst);
 280         goto out;
 281 }
 282
 283 static void echainiv_free(struct crypto_instance *inst)
 284 {
 285         aead_geniv_free(aead_instance(inst));
 286 }
 287
 288 static struct crypto_template echainiv_tmpl = {
 289         .name = "echainiv",
 290         .create = echainiv_aead_create,
 291         .free = echainiv_free,
 292         .module = THIS_MODULE,
 293 };
 294
 295 static int __init echainiv_module_init(void)
 296 {
 297         return crypto_register_template(&echainiv_tmpl);
 298 }
 299
 300 static void __exit echainiv_module_exit(void)
 301 {
 302         crypto_unregister_template(&echainiv_tmpl);
 303 }
 304
 305 module_init(echainiv_module_init);
 306 module_exit(echainiv_module_exit);
 307
 308 MODULE_LICENSE("GPL");
 309 MODULE_DESCRIPTION("Encrypted Chain IV Generator");
 310 MODULE_ALIAS_CRYPTO("echainiv");