[CRYPTO] Add alignmask for low-level cipher implementations
[linux-3.10.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/rwsem.h>
20 #include <linux/slab.h>
21 #include "internal.h"
22
23 LIST_HEAD(crypto_alg_list);
24 DECLARE_RWSEM(crypto_alg_sem);
25
26 static inline int crypto_alg_get(struct crypto_alg *alg)
27 {
28         return try_module_get(alg->cra_module);
29 }
30
31 static inline void crypto_alg_put(struct crypto_alg *alg)
32 {
33         module_put(alg->cra_module);
34 }
35
36 struct crypto_alg *crypto_alg_lookup(const char *name)
37 {
38         struct crypto_alg *q, *alg = NULL;
39
40         if (!name)
41                 return NULL;
42         
43         down_read(&crypto_alg_sem);
44         
45         list_for_each_entry(q, &crypto_alg_list, cra_list) {
46                 if (!(strcmp(q->cra_name, name))) {
47                         if (crypto_alg_get(q))
48                                 alg = q;
49                         break;
50                 }
51         }
52         
53         up_read(&crypto_alg_sem);
54         return alg;
55 }
56
57 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
58 {
59         tfm->crt_flags = 0;
60         
61         switch (crypto_tfm_alg_type(tfm)) {
62         case CRYPTO_ALG_TYPE_CIPHER:
63                 return crypto_init_cipher_flags(tfm, flags);
64                 
65         case CRYPTO_ALG_TYPE_DIGEST:
66                 return crypto_init_digest_flags(tfm, flags);
67                 
68         case CRYPTO_ALG_TYPE_COMPRESS:
69                 return crypto_init_compress_flags(tfm, flags);
70         
71         default:
72                 break;
73         }
74         
75         BUG();
76         return -EINVAL;
77 }
78
79 static int crypto_init_ops(struct crypto_tfm *tfm)
80 {
81         switch (crypto_tfm_alg_type(tfm)) {
82         case CRYPTO_ALG_TYPE_CIPHER:
83                 return crypto_init_cipher_ops(tfm);
84                 
85         case CRYPTO_ALG_TYPE_DIGEST:
86                 return crypto_init_digest_ops(tfm);
87                 
88         case CRYPTO_ALG_TYPE_COMPRESS:
89                 return crypto_init_compress_ops(tfm);
90         
91         default:
92                 break;
93         }
94         
95         BUG();
96         return -EINVAL;
97 }
98
99 static void crypto_exit_ops(struct crypto_tfm *tfm)
100 {
101         switch (crypto_tfm_alg_type(tfm)) {
102         case CRYPTO_ALG_TYPE_CIPHER:
103                 crypto_exit_cipher_ops(tfm);
104                 break;
105                 
106         case CRYPTO_ALG_TYPE_DIGEST:
107                 crypto_exit_digest_ops(tfm);
108                 break;
109                 
110         case CRYPTO_ALG_TYPE_COMPRESS:
111                 crypto_exit_compress_ops(tfm);
112                 break;
113         
114         default:
115                 BUG();
116                 
117         }
118 }
119
120 struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
121 {
122         struct crypto_tfm *tfm = NULL;
123         struct crypto_alg *alg;
124
125         alg = crypto_alg_mod_lookup(name);
126         if (alg == NULL)
127                 goto out;
128         
129         tfm = kmalloc(sizeof(*tfm) + alg->cra_ctxsize, GFP_KERNEL);
130         if (tfm == NULL)
131                 goto out_put;
132
133         memset(tfm, 0, sizeof(*tfm) + alg->cra_ctxsize);
134         
135         tfm->__crt_alg = alg;
136         
137         if (crypto_init_flags(tfm, flags))
138                 goto out_free_tfm;
139                 
140         if (crypto_init_ops(tfm)) {
141                 crypto_exit_ops(tfm);
142                 goto out_free_tfm;
143         }
144
145         goto out;
146
147 out_free_tfm:
148         kfree(tfm);
149         tfm = NULL;
150 out_put:
151         crypto_alg_put(alg);
152 out:
153         return tfm;
154 }
155
156 void crypto_free_tfm(struct crypto_tfm *tfm)
157 {
158         struct crypto_alg *alg = tfm->__crt_alg;
159         int size = sizeof(*tfm) + alg->cra_ctxsize;
160
161         crypto_exit_ops(tfm);
162         crypto_alg_put(alg);
163         memset(tfm, 0, size);
164         kfree(tfm);
165 }
166
167 int crypto_register_alg(struct crypto_alg *alg)
168 {
169         int ret = 0;
170         struct crypto_alg *q;
171
172         if (alg->cra_alignmask & (alg->cra_alignmask + 1))
173                 return -EINVAL;
174
175         if (alg->cra_alignmask > PAGE_SIZE)
176                 return -EINVAL;
177         
178         down_write(&crypto_alg_sem);
179         
180         list_for_each_entry(q, &crypto_alg_list, cra_list) {
181                 if (!(strcmp(q->cra_name, alg->cra_name))) {
182                         ret = -EEXIST;
183                         goto out;
184                 }
185         }
186         
187         list_add_tail(&alg->cra_list, &crypto_alg_list);
188 out:    
189         up_write(&crypto_alg_sem);
190         return ret;
191 }
192
193 int crypto_unregister_alg(struct crypto_alg *alg)
194 {
195         int ret = -ENOENT;
196         struct crypto_alg *q;
197         
198         BUG_ON(!alg->cra_module);
199         
200         down_write(&crypto_alg_sem);
201         list_for_each_entry(q, &crypto_alg_list, cra_list) {
202                 if (alg == q) {
203                         list_del(&alg->cra_list);
204                         ret = 0;
205                         goto out;
206                 }
207         }
208 out:    
209         up_write(&crypto_alg_sem);
210         return ret;
211 }
212
213 int crypto_alg_available(const char *name, u32 flags)
214 {
215         int ret = 0;
216         struct crypto_alg *alg = crypto_alg_mod_lookup(name);
217         
218         if (alg) {
219                 crypto_alg_put(alg);
220                 ret = 1;
221         }
222         
223         return ret;
224 }
225
226 static int __init init_crypto(void)
227 {
228         printk(KERN_INFO "Initializing Cryptographic API\n");
229         crypto_init_proc();
230         return 0;
231 }
232
233 __initcall(init_crypto);
234
235 EXPORT_SYMBOL_GPL(crypto_register_alg);
236 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
237 EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
238 EXPORT_SYMBOL_GPL(crypto_free_tfm);
239 EXPORT_SYMBOL_GPL(crypto_alg_available);