[CRYPTO] seqiv: Add AEAD support
[linux-2.6.git] / crypto / aead.c
1 /*
2  * AEAD: Authenticated Encryption with Associated Data
3  * 
4  * This file provides API support for AEAD algorithms.
5  *
6  * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the Free
10  * Software Foundation; either version 2 of the License, or (at your option) 
11  * any later version.
12  *
13  */
14
15 #include <crypto/internal/aead.h>
16 #include <linux/err.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
21 #include <linux/seq_file.h>
22
23 #include "internal.h"
24
25 static int setkey_unaligned(struct crypto_aead *tfm, const u8 *key,
26                             unsigned int keylen)
27 {
28         struct aead_alg *aead = crypto_aead_alg(tfm);
29         unsigned long alignmask = crypto_aead_alignmask(tfm);
30         int ret;
31         u8 *buffer, *alignbuffer;
32         unsigned long absize;
33
34         absize = keylen + alignmask;
35         buffer = kmalloc(absize, GFP_ATOMIC);
36         if (!buffer)
37                 return -ENOMEM;
38
39         alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
40         memcpy(alignbuffer, key, keylen);
41         ret = aead->setkey(tfm, alignbuffer, keylen);
42         memset(alignbuffer, 0, keylen);
43         kfree(buffer);
44         return ret;
45 }
46
47 static int setkey(struct crypto_aead *tfm, const u8 *key, unsigned int keylen)
48 {
49         struct aead_alg *aead = crypto_aead_alg(tfm);
50         unsigned long alignmask = crypto_aead_alignmask(tfm);
51
52         if ((unsigned long)key & alignmask)
53                 return setkey_unaligned(tfm, key, keylen);
54
55         return aead->setkey(tfm, key, keylen);
56 }
57
58 int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
59 {
60         struct aead_tfm *crt = crypto_aead_crt(tfm);
61         int err;
62
63         if (authsize > crypto_aead_alg(tfm)->maxauthsize)
64                 return -EINVAL;
65
66         if (crypto_aead_alg(tfm)->setauthsize) {
67                 err = crypto_aead_alg(tfm)->setauthsize(crt->base, authsize);
68                 if (err)
69                         return err;
70         }
71
72         crypto_aead_crt(crt->base)->authsize = authsize;
73         crt->authsize = authsize;
74         return 0;
75 }
76 EXPORT_SYMBOL_GPL(crypto_aead_setauthsize);
77
78 static unsigned int crypto_aead_ctxsize(struct crypto_alg *alg, u32 type,
79                                         u32 mask)
80 {
81         return alg->cra_ctxsize;
82 }
83
84 static int no_givcrypt(struct aead_givcrypt_request *req)
85 {
86         return -ENOSYS;
87 }
88
89 static int crypto_init_aead_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
90 {
91         struct aead_alg *alg = &tfm->__crt_alg->cra_aead;
92         struct aead_tfm *crt = &tfm->crt_aead;
93
94         if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8)
95                 return -EINVAL;
96
97         crt->setkey = tfm->__crt_alg->cra_flags & CRYPTO_ALG_GENIV ?
98                       alg->setkey : setkey;
99         crt->encrypt = alg->encrypt;
100         crt->decrypt = alg->decrypt;
101         crt->givencrypt = alg->givencrypt ?: no_givcrypt;
102         crt->givdecrypt = alg->givdecrypt ?: no_givcrypt;
103         crt->base = __crypto_aead_cast(tfm);
104         crt->ivsize = alg->ivsize;
105         crt->authsize = alg->maxauthsize;
106
107         return 0;
108 }
109
110 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
111         __attribute__ ((unused));
112 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
113 {
114         struct aead_alg *aead = &alg->cra_aead;
115
116         seq_printf(m, "type         : aead\n");
117         seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
118         seq_printf(m, "ivsize       : %u\n", aead->ivsize);
119         seq_printf(m, "maxauthsize  : %u\n", aead->maxauthsize);
120         seq_printf(m, "geniv        : %s\n", aead->geniv ?: "<built-in>");
121 }
122
123 const struct crypto_type crypto_aead_type = {
124         .ctxsize = crypto_aead_ctxsize,
125         .init = crypto_init_aead_ops,
126 #ifdef CONFIG_PROC_FS
127         .show = crypto_aead_show,
128 #endif
129 };
130 EXPORT_SYMBOL_GPL(crypto_aead_type);
131
132 static int aead_null_givencrypt(struct aead_givcrypt_request *req)
133 {
134         return crypto_aead_encrypt(&req->areq);
135 }
136
137 static int aead_null_givdecrypt(struct aead_givcrypt_request *req)
138 {
139         return crypto_aead_decrypt(&req->areq);
140 }
141
142 static int crypto_init_nivaead_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
143 {
144         struct aead_alg *alg = &tfm->__crt_alg->cra_aead;
145         struct aead_tfm *crt = &tfm->crt_aead;
146
147         if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8)
148                 return -EINVAL;
149
150         crt->setkey = setkey;
151         crt->encrypt = alg->encrypt;
152         crt->decrypt = alg->decrypt;
153         if (!alg->ivsize) {
154                 crt->givencrypt = aead_null_givencrypt;
155                 crt->givdecrypt = aead_null_givdecrypt;
156         }
157         crt->base = __crypto_aead_cast(tfm);
158         crt->ivsize = alg->ivsize;
159         crt->authsize = alg->maxauthsize;
160
161         return 0;
162 }
163
164 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg)
165         __attribute__ ((unused));
166 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg)
167 {
168         struct aead_alg *aead = &alg->cra_aead;
169
170         seq_printf(m, "type         : nivaead\n");
171         seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
172         seq_printf(m, "ivsize       : %u\n", aead->ivsize);
173         seq_printf(m, "maxauthsize  : %u\n", aead->maxauthsize);
174         seq_printf(m, "geniv        : %s\n", aead->geniv);
175 }
176
177 const struct crypto_type crypto_nivaead_type = {
178         .ctxsize = crypto_aead_ctxsize,
179         .init = crypto_init_nivaead_ops,
180 #ifdef CONFIG_PROC_FS
181         .show = crypto_nivaead_show,
182 #endif
183 };
184 EXPORT_SYMBOL_GPL(crypto_nivaead_type);
185
186 static int crypto_grab_nivaead(struct crypto_aead_spawn *spawn,
187                                const char *name, u32 type, u32 mask)
188 {
189         struct crypto_alg *alg;
190         int err;
191
192         type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
193         type |= CRYPTO_ALG_TYPE_AEAD;
194         mask |= CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV;
195
196         alg = crypto_alg_mod_lookup(name, type, mask);
197         if (IS_ERR(alg))
198                 return PTR_ERR(alg);
199
200         err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask);
201         crypto_mod_put(alg);
202         return err;
203 }
204
205 struct crypto_instance *aead_geniv_alloc(struct crypto_template *tmpl,
206                                          struct rtattr **tb, u32 type,
207                                          u32 mask)
208 {
209         const char *name;
210         struct crypto_aead_spawn *spawn;
211         struct crypto_attr_type *algt;
212         struct crypto_instance *inst;
213         struct crypto_alg *alg;
214         int err;
215
216         algt = crypto_get_attr_type(tb);
217         err = PTR_ERR(algt);
218         if (IS_ERR(algt))
219                 return ERR_PTR(err);
220
221         if ((algt->type ^ (CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_GENIV)) &
222             algt->mask)
223                 return ERR_PTR(-EINVAL);
224
225         name = crypto_attr_alg_name(tb[1]);
226         err = PTR_ERR(name);
227         if (IS_ERR(name))
228                 return ERR_PTR(err);
229
230         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
231         if (!inst)
232                 return ERR_PTR(-ENOMEM);
233
234         spawn = crypto_instance_ctx(inst);
235
236         /* Ignore async algorithms if necessary. */
237         mask |= crypto_requires_sync(algt->type, algt->mask);
238
239         crypto_set_aead_spawn(spawn, inst);
240         err = crypto_grab_nivaead(spawn, name, type, mask);
241         if (err)
242                 goto err_free_inst;
243
244         alg = crypto_aead_spawn_alg(spawn);
245
246         err = -EINVAL;
247         if (!alg->cra_aead.ivsize)
248                 goto err_drop_alg;
249
250         /*
251          * This is only true if we're constructing an algorithm with its
252          * default IV generator.  For the default generator we elide the
253          * template name and double-check the IV generator.
254          */
255         if (algt->mask & CRYPTO_ALG_GENIV) {
256                 if (strcmp(tmpl->name, alg->cra_aead.geniv))
257                         goto err_drop_alg;
258
259                 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
260                 memcpy(inst->alg.cra_driver_name, alg->cra_driver_name,
261                        CRYPTO_MAX_ALG_NAME);
262         } else {
263                 err = -ENAMETOOLONG;
264                 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME,
265                              "%s(%s)", tmpl->name, alg->cra_name) >=
266                     CRYPTO_MAX_ALG_NAME)
267                         goto err_drop_alg;
268                 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
269                              "%s(%s)", tmpl->name, alg->cra_driver_name) >=
270                     CRYPTO_MAX_ALG_NAME)
271                         goto err_drop_alg;
272         }
273
274         inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_GENIV;
275         inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC;
276         inst->alg.cra_priority = alg->cra_priority;
277         inst->alg.cra_blocksize = alg->cra_blocksize;
278         inst->alg.cra_alignmask = alg->cra_alignmask;
279         inst->alg.cra_type = &crypto_aead_type;
280
281         inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize;
282         inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize;
283         inst->alg.cra_aead.geniv = alg->cra_aead.geniv;
284
285         inst->alg.cra_aead.setkey = alg->cra_aead.setkey;
286         inst->alg.cra_aead.setauthsize = alg->cra_aead.setauthsize;
287         inst->alg.cra_aead.encrypt = alg->cra_aead.encrypt;
288         inst->alg.cra_aead.decrypt = alg->cra_aead.decrypt;
289
290 out:
291         return inst;
292
293 err_drop_alg:
294         crypto_drop_aead(spawn);
295 err_free_inst:
296         kfree(inst);
297         inst = ERR_PTR(err);
298         goto out;
299 }
300 EXPORT_SYMBOL_GPL(aead_geniv_alloc);
301
302 void aead_geniv_free(struct crypto_instance *inst)
303 {
304         crypto_drop_aead(crypto_instance_ctx(inst));
305         kfree(inst);
306 }
307 EXPORT_SYMBOL_GPL(aead_geniv_free);
308
309 int aead_geniv_init(struct crypto_tfm *tfm)
310 {
311         struct crypto_instance *inst = (void *)tfm->__crt_alg;
312         struct crypto_aead *aead;
313
314         aead = crypto_spawn_aead(crypto_instance_ctx(inst));
315         if (IS_ERR(aead))
316                 return PTR_ERR(aead);
317
318         tfm->crt_aead.base = aead;
319         tfm->crt_aead.reqsize += crypto_aead_reqsize(aead);
320
321         return 0;
322 }
323 EXPORT_SYMBOL_GPL(aead_geniv_init);
324
325 void aead_geniv_exit(struct crypto_tfm *tfm)
326 {
327         crypto_free_aead(tfm->crt_aead.base);
328 }
329 EXPORT_SYMBOL_GPL(aead_geniv_exit);
330
331 MODULE_LICENSE("GPL");
332 MODULE_DESCRIPTION("Authenticated Encryption with Associated Data (AEAD)");