~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/crypto/pcbc.c

Version: ~ [ linux-5.6-rc7 ] ~ [ linux-5.5.11 ] ~ [ linux-5.4.27 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.112 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * PCBC: Propagating Cipher Block Chaining mode
  3  *
  4  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
  5  * Written by David Howells (dhowells@redhat.com)
  6  *
  7  * Derived from cbc.c
  8  * - Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
  9  *
 10  * This program is free software; you can redistribute it and/or modify it
 11  * under the terms of the GNU General Public License as published by the Free
 12  * Software Foundation; either version 2 of the License, or (at your option)
 13  * any later version.
 14  *
 15  */
 16 
 17 #include <crypto/algapi.h>
 18 #include <linux/err.h>
 19 #include <linux/init.h>
 20 #include <linux/kernel.h>
 21 #include <linux/module.h>
 22 #include <linux/scatterlist.h>
 23 #include <linux/slab.h>
 24 
 25 struct crypto_pcbc_ctx {
 26         struct crypto_cipher *child;
 27 };
 28 
 29 static int crypto_pcbc_setkey(struct crypto_tfm *parent, const u8 *key,
 30                               unsigned int keylen)
 31 {
 32         struct crypto_pcbc_ctx *ctx = crypto_tfm_ctx(parent);
 33         struct crypto_cipher *child = ctx->child;
 34         int err;
 35 
 36         crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
 37         crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) &
 38                                 CRYPTO_TFM_REQ_MASK);
 39         err = crypto_cipher_setkey(child, key, keylen);
 40         crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) &
 41                              CRYPTO_TFM_RES_MASK);
 42         return err;
 43 }
 44 
 45 static int crypto_pcbc_encrypt_segment(struct blkcipher_desc *desc,
 46                                        struct blkcipher_walk *walk,
 47                                        struct crypto_cipher *tfm)
 48 {
 49         void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
 50                 crypto_cipher_alg(tfm)->cia_encrypt;
 51         int bsize = crypto_cipher_blocksize(tfm);
 52         unsigned int nbytes = walk->nbytes;
 53         u8 *src = walk->src.virt.addr;
 54         u8 *dst = walk->dst.virt.addr;
 55         u8 *iv = walk->iv;
 56 
 57         do {
 58                 crypto_xor(iv, src, bsize);
 59                 fn(crypto_cipher_tfm(tfm), dst, iv);
 60                 memcpy(iv, dst, bsize);
 61                 crypto_xor(iv, src, bsize);
 62 
 63                 src += bsize;
 64                 dst += bsize;
 65         } while ((nbytes -= bsize) >= bsize);
 66 
 67         return nbytes;
 68 }
 69 
 70 static int crypto_pcbc_encrypt_inplace(struct blkcipher_desc *desc,
 71                                        struct blkcipher_walk *walk,
 72                                        struct crypto_cipher *tfm)
 73 {
 74         void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
 75                 crypto_cipher_alg(tfm)->cia_encrypt;
 76         int bsize = crypto_cipher_blocksize(tfm);
 77         unsigned int nbytes = walk->nbytes;
 78         u8 *src = walk->src.virt.addr;
 79         u8 *iv = walk->iv;
 80         u8 tmpbuf[bsize];
 81 
 82         do {
 83                 memcpy(tmpbuf, src, bsize);
 84                 crypto_xor(iv, src, bsize);
 85                 fn(crypto_cipher_tfm(tfm), src, iv);
 86                 memcpy(iv, tmpbuf, bsize);
 87                 crypto_xor(iv, src, bsize);
 88 
 89                 src += bsize;
 90         } while ((nbytes -= bsize) >= bsize);
 91 
 92         memcpy(walk->iv, iv, bsize);
 93 
 94         return nbytes;
 95 }
 96 
 97 static int crypto_pcbc_encrypt(struct blkcipher_desc *desc,
 98                                struct scatterlist *dst, struct scatterlist *src,
 99                                unsigned int nbytes)
100 {
101         struct blkcipher_walk walk;
102         struct crypto_blkcipher *tfm = desc->tfm;
103         struct crypto_pcbc_ctx *ctx = crypto_blkcipher_ctx(tfm);
104         struct crypto_cipher *child = ctx->child;
105         int err;
106 
107         blkcipher_walk_init(&walk, dst, src, nbytes);
108         err = blkcipher_walk_virt(desc, &walk);
109 
110         while ((nbytes = walk.nbytes)) {
111                 if (walk.src.virt.addr == walk.dst.virt.addr)
112                         nbytes = crypto_pcbc_encrypt_inplace(desc, &walk,
113                                                              child);
114                 else
115                         nbytes = crypto_pcbc_encrypt_segment(desc, &walk,
116                                                              child);
117                 err = blkcipher_walk_done(desc, &walk, nbytes);
118         }
119 
120         return err;
121 }
122 
123 static int crypto_pcbc_decrypt_segment(struct blkcipher_desc *desc,
124                                        struct blkcipher_walk *walk,
125                                        struct crypto_cipher *tfm)
126 {
127         void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
128                 crypto_cipher_alg(tfm)->cia_decrypt;
129         int bsize = crypto_cipher_blocksize(tfm);
130         unsigned int nbytes = walk->nbytes;
131         u8 *src = walk->src.virt.addr;
132         u8 *dst = walk->dst.virt.addr;
133         u8 *iv = walk->iv;
134 
135         do {
136                 fn(crypto_cipher_tfm(tfm), dst, src);
137                 crypto_xor(dst, iv, bsize);
138                 memcpy(iv, src, bsize);
139                 crypto_xor(iv, dst, bsize);
140 
141                 src += bsize;
142                 dst += bsize;
143         } while ((nbytes -= bsize) >= bsize);
144 
145         memcpy(walk->iv, iv, bsize);
146 
147         return nbytes;
148 }
149 
150 static int crypto_pcbc_decrypt_inplace(struct blkcipher_desc *desc,
151                                        struct blkcipher_walk *walk,
152                                        struct crypto_cipher *tfm)
153 {
154         void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
155                 crypto_cipher_alg(tfm)->cia_decrypt;
156         int bsize = crypto_cipher_blocksize(tfm);
157         unsigned int nbytes = walk->nbytes;
158         u8 *src = walk->src.virt.addr;
159         u8 *iv = walk->iv;
160         u8 tmpbuf[bsize];
161 
162         do {
163                 memcpy(tmpbuf, src, bsize);
164                 fn(crypto_cipher_tfm(tfm), src, src);
165                 crypto_xor(src, iv, bsize);
166                 memcpy(iv, tmpbuf, bsize);
167                 crypto_xor(iv, src, bsize);
168 
169                 src += bsize;
170         } while ((nbytes -= bsize) >= bsize);
171 
172         memcpy(walk->iv, iv, bsize);
173 
174         return nbytes;
175 }
176 
177 static int crypto_pcbc_decrypt(struct blkcipher_desc *desc,
178                                struct scatterlist *dst, struct scatterlist *src,
179                                unsigned int nbytes)
180 {
181         struct blkcipher_walk walk;
182         struct crypto_blkcipher *tfm = desc->tfm;
183         struct crypto_pcbc_ctx *ctx = crypto_blkcipher_ctx(tfm);
184         struct crypto_cipher *child = ctx->child;
185         int err;
186 
187         blkcipher_walk_init(&walk, dst, src, nbytes);
188         err = blkcipher_walk_virt(desc, &walk);
189 
190         while ((nbytes = walk.nbytes)) {
191                 if (walk.src.virt.addr == walk.dst.virt.addr)
192                         nbytes = crypto_pcbc_decrypt_inplace(desc, &walk,
193                                                              child);
194                 else
195                         nbytes = crypto_pcbc_decrypt_segment(desc, &walk,
196                                                              child);
197                 err = blkcipher_walk_done(desc, &walk, nbytes);
198         }
199 
200         return err;
201 }
202 
203 static int crypto_pcbc_init_tfm(struct crypto_tfm *tfm)
204 {
205         struct crypto_instance *inst = (void *)tfm->__crt_alg;
206         struct crypto_spawn *spawn = crypto_instance_ctx(inst);
207         struct crypto_pcbc_ctx *ctx = crypto_tfm_ctx(tfm);
208         struct crypto_cipher *cipher;
209 
210         cipher = crypto_spawn_cipher(spawn);
211         if (IS_ERR(cipher))
212                 return PTR_ERR(cipher);
213 
214         ctx->child = cipher;
215         return 0;
216 }
217 
218 static void crypto_pcbc_exit_tfm(struct crypto_tfm *tfm)
219 {
220         struct crypto_pcbc_ctx *ctx = crypto_tfm_ctx(tfm);
221         crypto_free_cipher(ctx->child);
222 }
223 
224 static struct crypto_instance *crypto_pcbc_alloc(struct rtattr **tb)
225 {
226         struct crypto_instance *inst;
227         struct crypto_alg *alg;
228         int err;
229 
230         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER);
231         if (err)
232                 return ERR_PTR(err);
233 
234         alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
235                                   CRYPTO_ALG_TYPE_MASK);
236         if (IS_ERR(alg))
237                 return ERR_CAST(alg);
238 
239         inst = crypto_alloc_instance("pcbc", alg);
240         if (IS_ERR(inst))
241                 goto out_put_alg;
242 
243         inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER;
244         inst->alg.cra_priority = alg->cra_priority;
245         inst->alg.cra_blocksize = alg->cra_blocksize;
246         inst->alg.cra_alignmask = alg->cra_alignmask;
247         inst->alg.cra_type = &crypto_blkcipher_type;
248 
249         /* We access the data as u32s when xoring. */
250         inst->alg.cra_alignmask |= __alignof__(u32) - 1;
251 
252         inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize;
253         inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
254         inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
255 
256         inst->alg.cra_ctxsize = sizeof(struct crypto_pcbc_ctx);
257 
258         inst->alg.cra_init = crypto_pcbc_init_tfm;
259         inst->alg.cra_exit = crypto_pcbc_exit_tfm;
260 
261         inst->alg.cra_blkcipher.setkey = crypto_pcbc_setkey;
262         inst->alg.cra_blkcipher.encrypt = crypto_pcbc_encrypt;
263         inst->alg.cra_blkcipher.decrypt = crypto_pcbc_decrypt;
264 
265 out_put_alg:
266         crypto_mod_put(alg);
267         return inst;
268 }
269 
270 static void crypto_pcbc_free(struct crypto_instance *inst)
271 {
272         crypto_drop_spawn(crypto_instance_ctx(inst));
273         kfree(inst);
274 }
275 
276 static struct crypto_template crypto_pcbc_tmpl = {
277         .name = "pcbc",
278         .alloc = crypto_pcbc_alloc,
279         .free = crypto_pcbc_free,
280         .module = THIS_MODULE,
281 };
282 
283 static int __init crypto_pcbc_module_init(void)
284 {
285         return crypto_register_template(&crypto_pcbc_tmpl);
286 }
287 
288 static void __exit crypto_pcbc_module_exit(void)
289 {
290         crypto_unregister_template(&crypto_pcbc_tmpl);
291 }
292 
293 module_init(crypto_pcbc_module_init);
294 module_exit(crypto_pcbc_module_exit);
295 
296 MODULE_LICENSE("GPL");
297 MODULE_DESCRIPTION("PCBC block cipher algorithm");
298 MODULE_ALIAS_CRYPTO("pcbc");
299 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp