[CRYPTO] Ensure cit_iv is aligned correctly
[linux-2.6.git] / crypto / api.c
1 /*
2  * Scatterlist Cryptographic API.
3  *
4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5  * Copyright (c) 2002 David S. Miller (davem@redhat.com)
6  *
7  * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
8  * and Nettle, by Niels Möller.
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 #include <linux/init.h>
17 #include <linux/crypto.h>
18 #include <linux/errno.h>
19 #include <linux/kmod.h>
20 #include <linux/rwsem.h>
21 #include <linux/slab.h>
22 #include "internal.h"
23
24 LIST_HEAD(crypto_alg_list);
25 DECLARE_RWSEM(crypto_alg_sem);
26
27 static inline int crypto_alg_get(struct crypto_alg *alg)
28 {
29         return try_module_get(alg->cra_module);
30 }
31
32 static inline void crypto_alg_put(struct crypto_alg *alg)
33 {
34         module_put(alg->cra_module);
35 }
36
37 static struct crypto_alg *crypto_alg_lookup(const char *name)
38 {
39         struct crypto_alg *q, *alg = NULL;
40
41         if (!name)
42                 return NULL;
43         
44         down_read(&crypto_alg_sem);
45         
46         list_for_each_entry(q, &crypto_alg_list, cra_list) {
47                 if (!(strcmp(q->cra_name, name))) {
48                         if (crypto_alg_get(q))
49                                 alg = q;
50                         break;
51                 }
52         }
53         
54         up_read(&crypto_alg_sem);
55         return alg;
56 }
57
58 /* A far more intelligent version of this is planned.  For now, just
59  * try an exact match on the name of the algorithm. */
60 static inline struct crypto_alg *crypto_alg_mod_lookup(const char *name)
61 {
62         return try_then_request_module(crypto_alg_lookup(name), name);
63 }
64
65 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
66 {
67         tfm->crt_flags = 0;
68         
69         switch (crypto_tfm_alg_type(tfm)) {
70         case CRYPTO_ALG_TYPE_CIPHER:
71                 return crypto_init_cipher_flags(tfm, flags);
72                 
73         case CRYPTO_ALG_TYPE_DIGEST:
74                 return crypto_init_digest_flags(tfm, flags);
75                 
76         case CRYPTO_ALG_TYPE_COMPRESS:
77                 return crypto_init_compress_flags(tfm, flags);
78         
79         default:
80                 break;
81         }
82         
83         BUG();
84         return -EINVAL;
85 }
86
87 static int crypto_init_ops(struct crypto_tfm *tfm)
88 {
89         switch (crypto_tfm_alg_type(tfm)) {
90         case CRYPTO_ALG_TYPE_CIPHER:
91                 return crypto_init_cipher_ops(tfm);
92                 
93         case CRYPTO_ALG_TYPE_DIGEST:
94                 return crypto_init_digest_ops(tfm);
95                 
96         case CRYPTO_ALG_TYPE_COMPRESS:
97                 return crypto_init_compress_ops(tfm);
98         
99         default:
100                 break;
101         }
102         
103         BUG();
104         return -EINVAL;
105 }
106
107 static void crypto_exit_ops(struct crypto_tfm *tfm)
108 {
109         switch (crypto_tfm_alg_type(tfm)) {
110         case CRYPTO_ALG_TYPE_CIPHER:
111                 crypto_exit_cipher_ops(tfm);
112                 break;
113                 
114         case CRYPTO_ALG_TYPE_DIGEST:
115                 crypto_exit_digest_ops(tfm);
116                 break;
117                 
118         case CRYPTO_ALG_TYPE_COMPRESS:
119                 crypto_exit_compress_ops(tfm);
120                 break;
121         
122         default:
123                 BUG();
124                 
125         }
126 }
127
128 static unsigned int crypto_ctxsize(struct crypto_alg *alg, int flags)
129 {
130         unsigned int len;
131
132         switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
133         default:
134                 BUG();
135
136         case CRYPTO_ALG_TYPE_CIPHER:
137                 len = crypto_cipher_ctxsize(alg, flags);
138                 break;
139                 
140         case CRYPTO_ALG_TYPE_DIGEST:
141                 len = crypto_digest_ctxsize(alg, flags);
142                 break;
143                 
144         case CRYPTO_ALG_TYPE_COMPRESS:
145                 len = crypto_compress_ctxsize(alg, flags);
146                 break;
147         }
148
149         return len + alg->cra_alignmask;
150 }
151
152 struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
153 {
154         struct crypto_tfm *tfm = NULL;
155         struct crypto_alg *alg;
156         unsigned int tfm_size;
157
158         alg = crypto_alg_mod_lookup(name);
159         if (alg == NULL)
160                 goto out;
161
162         tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags);
163         tfm = kmalloc(tfm_size, GFP_KERNEL);
164         if (tfm == NULL)
165                 goto out_put;
166
167         memset(tfm, 0, tfm_size);
168         
169         tfm->__crt_alg = alg;
170         
171         if (crypto_init_flags(tfm, flags))
172                 goto out_free_tfm;
173                 
174         if (crypto_init_ops(tfm)) {
175                 crypto_exit_ops(tfm);
176                 goto out_free_tfm;
177         }
178
179         goto out;
180
181 out_free_tfm:
182         kfree(tfm);
183         tfm = NULL;
184 out_put:
185         crypto_alg_put(alg);
186 out:
187         return tfm;
188 }
189
190 void crypto_free_tfm(struct crypto_tfm *tfm)
191 {
192         struct crypto_alg *alg = tfm->__crt_alg;
193         int size = sizeof(*tfm) + alg->cra_ctxsize;
194
195         crypto_exit_ops(tfm);
196         crypto_alg_put(alg);
197         memset(tfm, 0, size);
198         kfree(tfm);
199 }
200
201 int crypto_register_alg(struct crypto_alg *alg)
202 {
203         int ret = 0;
204         struct crypto_alg *q;
205
206         if (alg->cra_alignmask & (alg->cra_alignmask + 1))
207                 return -EINVAL;
208
209         if (alg->cra_alignmask > PAGE_SIZE)
210                 return -EINVAL;
211         
212         down_write(&crypto_alg_sem);
213         
214         list_for_each_entry(q, &crypto_alg_list, cra_list) {
215                 if (!(strcmp(q->cra_name, alg->cra_name))) {
216                         ret = -EEXIST;
217                         goto out;
218                 }
219         }
220         
221         list_add_tail(&alg->cra_list, &crypto_alg_list);
222 out:    
223         up_write(&crypto_alg_sem);
224         return ret;
225 }
226
227 int crypto_unregister_alg(struct crypto_alg *alg)
228 {
229         int ret = -ENOENT;
230         struct crypto_alg *q;
231         
232         BUG_ON(!alg->cra_module);
233         
234         down_write(&crypto_alg_sem);
235         list_for_each_entry(q, &crypto_alg_list, cra_list) {
236                 if (alg == q) {
237                         list_del(&alg->cra_list);
238                         ret = 0;
239                         goto out;
240                 }
241         }
242 out:    
243         up_write(&crypto_alg_sem);
244         return ret;
245 }
246
247 int crypto_alg_available(const char *name, u32 flags)
248 {
249         int ret = 0;
250         struct crypto_alg *alg = crypto_alg_mod_lookup(name);
251         
252         if (alg) {
253                 crypto_alg_put(alg);
254                 ret = 1;
255         }
256         
257         return ret;
258 }
259
260 static int __init init_crypto(void)
261 {
262         printk(KERN_INFO "Initializing Cryptographic API\n");
263         crypto_init_proc();
264         return 0;
265 }
266
267 __initcall(init_crypto);
268
269 EXPORT_SYMBOL_GPL(crypto_register_alg);
270 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
271 EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
272 EXPORT_SYMBOL_GPL(crypto_free_tfm);
273 EXPORT_SYMBOL_GPL(crypto_alg_available);