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