1/* 2 * eseqiv: Encrypted Sequence Number 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 * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au> 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the Free 13 * Software Foundation; either version 2 of the License, or (at your option) 14 * any later version. 15 * 16 */ 17 18#include <crypto/internal/skcipher.h> 19#include <crypto/rng.h> 20#include <crypto/scatterwalk.h> 21#include <linux/err.h> 22#include <linux/init.h> 23#include <linux/kernel.h> 24#include <linux/mm.h> 25#include <linux/module.h> 26#include <linux/scatterlist.h> 27#include <linux/spinlock.h> 28#include <linux/string.h> 29 30struct eseqiv_request_ctx { 31 struct scatterlist src[2]; 32 struct scatterlist dst[2]; 33 char tail[]; 34}; 35 36struct eseqiv_ctx { 37 spinlock_t lock; 38 unsigned int reqoff; 39 char salt[]; 40}; 41 42static void eseqiv_complete2(struct skcipher_givcrypt_request *req) 43{ 44 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 45 struct eseqiv_request_ctx *reqctx = skcipher_givcrypt_reqctx(req); 46 47 memcpy(req->giv, PTR_ALIGN((u8 *)reqctx->tail, 48 crypto_ablkcipher_alignmask(geniv) + 1), 49 crypto_ablkcipher_ivsize(geniv)); 50} 51 52static void eseqiv_complete(struct crypto_async_request *base, int err) 53{ 54 struct skcipher_givcrypt_request *req = base->data; 55 56 if (err) 57 goto out; 58 59 eseqiv_complete2(req); 60 61out: 62 skcipher_givcrypt_complete(req, err); 63} 64 65static void eseqiv_chain(struct scatterlist *head, struct scatterlist *sg, 66 int chain) 67{ 68 if (chain) { 69 head->length += sg->length; 70 sg = scatterwalk_sg_next(sg); 71 } 72 73 if (sg) 74 scatterwalk_sg_chain(head, 2, sg); 75 else 76 sg_mark_end(head); 77} 78 79static int eseqiv_givencrypt(struct skcipher_givcrypt_request *req) 80{ 81 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 82 struct eseqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 83 struct eseqiv_request_ctx *reqctx = skcipher_givcrypt_reqctx(req); 84 struct ablkcipher_request *subreq; 85 crypto_completion_t complete; 86 void *data; 87 struct scatterlist *osrc, *odst; 88 struct scatterlist *dst; 89 struct page *srcp; 90 struct page *dstp; 91 u8 *giv; 92 u8 *vsrc; 93 u8 *vdst; 94 __be64 seq; 95 unsigned int ivsize; 96 unsigned int len; 97 int err; 98 99 subreq = (void *)(reqctx->tail + ctx->reqoff); 100 ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv)); 101 102 giv = req->giv; 103 complete = req->creq.base.complete; 104 data = req->creq.base.data; 105 106 osrc = req->creq.src; 107 odst = req->creq.dst; 108 srcp = sg_page(osrc); 109 dstp = sg_page(odst); 110 vsrc = PageHighMem(srcp) ? NULL : page_address(srcp) + osrc->offset; 111 vdst = PageHighMem(dstp) ? NULL : page_address(dstp) + odst->offset; 112 113 ivsize = crypto_ablkcipher_ivsize(geniv); 114 115 if (vsrc != giv + ivsize && vdst != giv + ivsize) { 116 giv = PTR_ALIGN((u8 *)reqctx->tail, 117 crypto_ablkcipher_alignmask(geniv) + 1); 118 complete = eseqiv_complete; 119 data = req; 120 } 121 122 ablkcipher_request_set_callback(subreq, req->creq.base.flags, complete, 123 data); 124 125 sg_init_table(reqctx->src, 2); 126 sg_set_buf(reqctx->src, giv, ivsize); 127 eseqiv_chain(reqctx->src, osrc, vsrc == giv + ivsize); 128 129 dst = reqctx->src; 130 if (osrc != odst) { 131 sg_init_table(reqctx->dst, 2); 132 sg_set_buf(reqctx->dst, giv, ivsize); 133 eseqiv_chain(reqctx->dst, odst, vdst == giv + ivsize); 134 135 dst = reqctx->dst; 136 } 137 138 ablkcipher_request_set_crypt(subreq, reqctx->src, dst, 139 req->creq.nbytes + ivsize, 140 req->creq.info); 141 142 memcpy(req->creq.info, ctx->salt, ivsize); 143 144 len = ivsize; 145 if (ivsize > sizeof(u64)) { 146 memset(req->giv, 0, ivsize - sizeof(u64)); 147 len = sizeof(u64); 148 } 149 seq = cpu_to_be64(req->seq); 150 memcpy(req->giv + ivsize - len, &seq, len); 151 152 err = crypto_ablkcipher_encrypt(subreq); 153 if (err) 154 goto out; 155 156 if (giv != req->giv) 157 eseqiv_complete2(req); 158 159out: 160 return err; 161} 162 163static int eseqiv_givencrypt_first(struct skcipher_givcrypt_request *req) 164{ 165 struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req); 166 struct eseqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 167 int err = 0; 168 169 spin_lock_bh(&ctx->lock); 170 if (crypto_ablkcipher_crt(geniv)->givencrypt != eseqiv_givencrypt_first) 171 goto unlock; 172 173 crypto_ablkcipher_crt(geniv)->givencrypt = eseqiv_givencrypt; 174 err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt, 175 crypto_ablkcipher_ivsize(geniv)); 176 177unlock: 178 spin_unlock_bh(&ctx->lock); 179 180 if (err) 181 return err; 182 183 return eseqiv_givencrypt(req); 184} 185 186static int eseqiv_init(struct crypto_tfm *tfm) 187{ 188 struct crypto_ablkcipher *geniv = __crypto_ablkcipher_cast(tfm); 189 struct eseqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv); 190 unsigned long alignmask; 191 unsigned int reqsize; 192 193 spin_lock_init(&ctx->lock); 194 195 alignmask = crypto_tfm_ctx_alignment() - 1; 196 reqsize = sizeof(struct eseqiv_request_ctx); 197 198 if (alignmask & reqsize) { 199 alignmask &= reqsize; 200 alignmask--; 201 } 202 203 alignmask = ~alignmask; 204 alignmask &= crypto_ablkcipher_alignmask(geniv); 205 206 reqsize += alignmask; 207 reqsize += crypto_ablkcipher_ivsize(geniv); 208 reqsize = ALIGN(reqsize, crypto_tfm_ctx_alignment()); 209 210 ctx->reqoff = reqsize - sizeof(struct eseqiv_request_ctx); 211 212 tfm->crt_ablkcipher.reqsize = reqsize + 213 sizeof(struct ablkcipher_request); 214 215 return skcipher_geniv_init(tfm); 216} 217 218static struct crypto_template eseqiv_tmpl; 219 220static struct crypto_instance *eseqiv_alloc(struct rtattr **tb) 221{ 222 struct crypto_instance *inst; 223 int err; 224 225 err = crypto_get_default_rng(); 226 if (err) 227 return ERR_PTR(err); 228 229 inst = skcipher_geniv_alloc(&eseqiv_tmpl, tb, 0, 0); 230 if (IS_ERR(inst)) 231 goto put_rng; 232 233 err = -EINVAL; 234 if (inst->alg.cra_ablkcipher.ivsize != inst->alg.cra_blocksize) 235 goto free_inst; 236 237 inst->alg.cra_ablkcipher.givencrypt = eseqiv_givencrypt_first; 238 239 inst->alg.cra_init = eseqiv_init; 240 inst->alg.cra_exit = skcipher_geniv_exit; 241 242 inst->alg.cra_ctxsize = sizeof(struct eseqiv_ctx); 243 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; 244 245out: 246 return inst; 247 248free_inst: 249 skcipher_geniv_free(inst); 250 inst = ERR_PTR(err); 251put_rng: 252 crypto_put_default_rng(); 253 goto out; 254} 255 256static void eseqiv_free(struct crypto_instance *inst) 257{ 258 skcipher_geniv_free(inst); 259 crypto_put_default_rng(); 260} 261 262static struct crypto_template eseqiv_tmpl = { 263 .name = "eseqiv", 264 .alloc = eseqiv_alloc, 265 .free = eseqiv_free, 266 .module = THIS_MODULE, 267}; 268 269static int __init eseqiv_module_init(void) 270{ 271 return crypto_register_template(&eseqiv_tmpl); 272} 273 274static void __exit eseqiv_module_exit(void) 275{ 276 crypto_unregister_template(&eseqiv_tmpl); 277} 278 279module_init(eseqiv_module_init); 280module_exit(eseqiv_module_exit); 281 282MODULE_LICENSE("GPL"); 283MODULE_DESCRIPTION("Encrypted Sequence Number IV Generator"); 284