crypto: fips - FIPS requires algorithm self-tests
[linux-2.6.git] / crypto / pcbc.c
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");