blob: 0906cedd452136dac25961afeaf846bd0133c4ba [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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)
Herbert Xu5cb14542005-11-05 16:58:14 +11006 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
John Anthony Kazos Jr991d1742007-10-19 23:06:17 +02009 * and Nettle, by Niels Möller.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
13 * Software Foundation; either version 2 of the License, or (at your option)
14 * any later version.
15 *
16 */
Jesper Juhla61cc442005-07-06 13:54:31 -070017
Herbert Xu6bfd4802006-09-21 11:39:29 +100018#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/errno.h>
Herbert Xu5cb14542005-11-05 16:58:14 +110020#include <linux/kernel.h>
Adrian Bunk176c3652005-07-06 13:53:09 -070021#include <linux/kmod.h>
Herbert Xu2b8c19d2006-09-21 11:31:44 +100022#include <linux/module.h>
Herbert Xu28259822006-08-06 21:23:26 +100023#include <linux/param.h>
Herbert Xu6bfd4802006-09-21 11:39:29 +100024#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/slab.h>
Herbert Xu5cb14542005-11-05 16:58:14 +110026#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "internal.h"
28
29LIST_HEAD(crypto_alg_list);
Herbert Xucce9e062006-08-21 21:08:13 +100030EXPORT_SYMBOL_GPL(crypto_alg_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070031DECLARE_RWSEM(crypto_alg_sem);
Herbert Xucce9e062006-08-21 21:08:13 +100032EXPORT_SYMBOL_GPL(crypto_alg_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Herbert Xu28259822006-08-06 21:23:26 +100034BLOCKING_NOTIFIER_HEAD(crypto_chain);
35EXPORT_SYMBOL_GPL(crypto_chain);
36
Herbert Xu6521f302006-08-06 20:28:44 +100037static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
Herbert Xu6521f302006-08-06 20:28:44 +100039 atomic_inc(&alg->cra_refcnt);
40 return alg;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041}
42
Herbert Xu28259822006-08-06 21:23:26 +100043struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
Herbert Xu6521f302006-08-06 20:28:44 +100044{
45 return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
46}
Herbert Xu28259822006-08-06 21:23:26 +100047EXPORT_SYMBOL_GPL(crypto_mod_get);
Herbert Xu6521f302006-08-06 20:28:44 +100048
Herbert Xu28259822006-08-06 21:23:26 +100049void crypto_mod_put(struct crypto_alg *alg)
Herbert Xu6521f302006-08-06 20:28:44 +100050{
Herbert Xuda7cd592007-05-19 14:51:00 +100051 struct module *module = alg->cra_module;
52
Herbert Xu6521f302006-08-06 20:28:44 +100053 crypto_alg_put(alg);
Herbert Xuda7cd592007-05-19 14:51:00 +100054 module_put(module);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
Herbert Xu28259822006-08-06 21:23:26 +100056EXPORT_SYMBOL_GPL(crypto_mod_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Herbert Xuc51b6c82008-08-04 11:44:59 +080058static struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type,
59 u32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
61 struct crypto_alg *q, *alg = NULL;
Herbert Xu28259822006-08-06 21:23:26 +100062 int best = -2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 list_for_each_entry(q, &crypto_alg_list, cra_list) {
Herbert Xu5cb14542005-11-05 16:58:14 +110065 int exact, fuzzy;
66
Herbert Xu6bfd4802006-09-21 11:39:29 +100067 if (crypto_is_moribund(q))
68 continue;
69
Herbert Xu492e2b62006-09-21 11:35:17 +100070 if ((q->cra_flags ^ type) & mask)
71 continue;
72
73 if (crypto_is_larval(q) &&
74 ((struct crypto_larval *)q)->mask != mask)
75 continue;
76
Herbert Xu5cb14542005-11-05 16:58:14 +110077 exact = !strcmp(q->cra_driver_name, name);
78 fuzzy = !strcmp(q->cra_name, name);
79 if (!exact && !(fuzzy && q->cra_priority > best))
80 continue;
81
Herbert Xu72fa4912006-05-28 09:05:24 +100082 if (unlikely(!crypto_mod_get(q)))
Herbert Xu5cb14542005-11-05 16:58:14 +110083 continue;
84
85 best = q->cra_priority;
86 if (alg)
Herbert Xu72fa4912006-05-28 09:05:24 +100087 crypto_mod_put(alg);
Herbert Xu5cb14542005-11-05 16:58:14 +110088 alg = q;
89
90 if (exact)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 }
Herbert Xu28259822006-08-06 21:23:26 +100093
94 return alg;
95}
Herbert Xu28259822006-08-06 21:23:26 +100096
97static void crypto_larval_destroy(struct crypto_alg *alg)
98{
99 struct crypto_larval *larval = (void *)alg;
100
101 BUG_ON(!crypto_is_larval(alg));
102 if (larval->adult)
103 crypto_mod_put(larval->adult);
104 kfree(larval);
105}
106
Herbert Xu492e2b62006-09-21 11:35:17 +1000107static struct crypto_alg *crypto_larval_alloc(const char *name, u32 type,
108 u32 mask)
Herbert Xu28259822006-08-06 21:23:26 +1000109{
110 struct crypto_alg *alg;
111 struct crypto_larval *larval;
112
113 larval = kzalloc(sizeof(*larval), GFP_KERNEL);
114 if (!larval)
Herbert Xu6bfd4802006-09-21 11:39:29 +1000115 return ERR_PTR(-ENOMEM);
Herbert Xu28259822006-08-06 21:23:26 +1000116
Herbert Xu492e2b62006-09-21 11:35:17 +1000117 larval->mask = mask;
118 larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
Herbert Xu28259822006-08-06 21:23:26 +1000119 larval->alg.cra_priority = -1;
120 larval->alg.cra_destroy = crypto_larval_destroy;
121
122 atomic_set(&larval->alg.cra_refcnt, 2);
123 strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
124 init_completion(&larval->completion);
125
126 down_write(&crypto_alg_sem);
Herbert Xu492e2b62006-09-21 11:35:17 +1000127 alg = __crypto_alg_lookup(name, type, mask);
Herbert Xu28259822006-08-06 21:23:26 +1000128 if (!alg) {
129 alg = &larval->alg;
130 list_add(&alg->cra_list, &crypto_alg_list);
131 }
132 up_write(&crypto_alg_sem);
133
134 if (alg != &larval->alg)
135 kfree(larval);
136
137 return alg;
138}
139
Herbert Xub9c55aa2007-12-04 12:46:48 +1100140void crypto_larval_kill(struct crypto_alg *alg)
Herbert Xu28259822006-08-06 21:23:26 +1000141{
142 struct crypto_larval *larval = (void *)alg;
143
144 down_write(&crypto_alg_sem);
145 list_del(&alg->cra_list);
146 up_write(&crypto_alg_sem);
Herbert Xufe3c5202007-05-19 17:51:40 +1000147 complete_all(&larval->completion);
Herbert Xu28259822006-08-06 21:23:26 +1000148 crypto_alg_put(alg);
149}
Herbert Xub9c55aa2007-12-04 12:46:48 +1100150EXPORT_SYMBOL_GPL(crypto_larval_kill);
Herbert Xu28259822006-08-06 21:23:26 +1000151
152static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
153{
154 struct crypto_larval *larval = (void *)alg;
155
156 wait_for_completion_interruptible_timeout(&larval->completion, 60 * HZ);
157 alg = larval->adult;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000158 if (alg) {
159 if (!crypto_mod_get(alg))
160 alg = ERR_PTR(-EAGAIN);
161 } else
162 alg = ERR_PTR(-ENOENT);
Herbert Xu28259822006-08-06 21:23:26 +1000163 crypto_mod_put(&larval->alg);
164
165 return alg;
166}
167
Herbert Xuc51b6c82008-08-04 11:44:59 +0800168struct crypto_alg *crypto_alg_lookup(const char *name, u32 type, u32 mask)
Herbert Xu28259822006-08-06 21:23:26 +1000169{
170 struct crypto_alg *alg;
171
Herbert Xu28259822006-08-06 21:23:26 +1000172 down_read(&crypto_alg_sem);
Herbert Xu492e2b62006-09-21 11:35:17 +1000173 alg = __crypto_alg_lookup(name, type, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 up_read(&crypto_alg_sem);
Herbert Xu28259822006-08-06 21:23:26 +1000175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return alg;
177}
Herbert Xuc51b6c82008-08-04 11:44:59 +0800178EXPORT_SYMBOL_GPL(crypto_alg_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Herbert Xub9c55aa2007-12-04 12:46:48 +1100180struct crypto_alg *crypto_larval_lookup(const char *name, u32 type, u32 mask)
Adrian Bunk176c3652005-07-06 13:53:09 -0700181{
Herbert Xu28259822006-08-06 21:23:26 +1000182 struct crypto_alg *alg;
Herbert Xu28259822006-08-06 21:23:26 +1000183
Herbert Xu6bfd4802006-09-21 11:39:29 +1000184 if (!name)
185 return ERR_PTR(-ENOENT);
186
187 mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
Herbert Xu492e2b62006-09-21 11:35:17 +1000188 type &= mask;
189
190 alg = try_then_request_module(crypto_alg_lookup(name, type, mask),
191 name);
Herbert Xu28259822006-08-06 21:23:26 +1000192 if (alg)
193 return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg;
194
Herbert Xub9c55aa2007-12-04 12:46:48 +1100195 return crypto_larval_alloc(name, type, mask);
196}
197EXPORT_SYMBOL_GPL(crypto_larval_lookup);
198
199struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
200{
201 struct crypto_alg *alg;
202 struct crypto_alg *larval;
203 int ok;
204
205 larval = crypto_larval_lookup(name, type, mask);
Herbert Xu6bfd4802006-09-21 11:39:29 +1000206 if (IS_ERR(larval) || !crypto_is_larval(larval))
Herbert Xu28259822006-08-06 21:23:26 +1000207 return larval;
208
Herbert Xu2b8c19d2006-09-21 11:31:44 +1000209 ok = crypto_notify(CRYPTO_MSG_ALG_REQUEST, larval);
210 if (ok == NOTIFY_DONE) {
211 request_module("cryptomgr");
212 ok = crypto_notify(CRYPTO_MSG_ALG_REQUEST, larval);
213 }
214
215 if (ok == NOTIFY_STOP)
Herbert Xu28259822006-08-06 21:23:26 +1000216 alg = crypto_larval_wait(larval);
217 else {
218 crypto_mod_put(larval);
Herbert Xu6bfd4802006-09-21 11:39:29 +1000219 alg = ERR_PTR(-ENOENT);
Herbert Xu28259822006-08-06 21:23:26 +1000220 }
221 crypto_larval_kill(larval);
222 return alg;
Adrian Bunk176c3652005-07-06 13:53:09 -0700223}
Herbert Xu492e2b62006-09-21 11:35:17 +1000224EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
Adrian Bunk176c3652005-07-06 13:53:09 -0700225
Herbert Xu27d2a332007-01-24 20:50:26 +1100226static int crypto_init_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
Herbert Xu27d2a332007-01-24 20:50:26 +1100228 const struct crypto_type *type_obj = tfm->__crt_alg->cra_type;
Herbert Xue853c3c2006-08-22 00:06:54 +1000229
Herbert Xu27d2a332007-01-24 20:50:26 +1100230 if (type_obj)
231 return type_obj->init(tfm, type, mask);
Herbert Xue853c3c2006-08-22 00:06:54 +1000232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 switch (crypto_tfm_alg_type(tfm)) {
234 case CRYPTO_ALG_TYPE_CIPHER:
235 return crypto_init_cipher_ops(tfm);
236
237 case CRYPTO_ALG_TYPE_DIGEST:
Loc Ho004a4032008-05-14 20:41:47 +0800238 if ((mask & CRYPTO_ALG_TYPE_HASH_MASK) !=
239 CRYPTO_ALG_TYPE_HASH_MASK)
240 return crypto_init_digest_ops_async(tfm);
241 else
242 return crypto_init_digest_ops(tfm);
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 case CRYPTO_ALG_TYPE_COMPRESS:
245 return crypto_init_compress_ops(tfm);
246
247 default:
248 break;
249 }
250
251 BUG();
252 return -EINVAL;
253}
254
255static void crypto_exit_ops(struct crypto_tfm *tfm)
256{
Herbert Xue853c3c2006-08-22 00:06:54 +1000257 const struct crypto_type *type = tfm->__crt_alg->cra_type;
258
259 if (type) {
260 if (type->exit)
261 type->exit(tfm);
262 return;
263 }
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 switch (crypto_tfm_alg_type(tfm)) {
266 case CRYPTO_ALG_TYPE_CIPHER:
267 crypto_exit_cipher_ops(tfm);
268 break;
269
270 case CRYPTO_ALG_TYPE_DIGEST:
271 crypto_exit_digest_ops(tfm);
272 break;
273
274 case CRYPTO_ALG_TYPE_COMPRESS:
275 crypto_exit_compress_ops(tfm);
276 break;
277
278 default:
279 BUG();
280
281 }
282}
283
Herbert Xu27d2a332007-01-24 20:50:26 +1100284static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
Herbert Xufbdae9f2005-07-06 13:53:29 -0700285{
Herbert Xu27d2a332007-01-24 20:50:26 +1100286 const struct crypto_type *type_obj = alg->cra_type;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700287 unsigned int len;
288
Herbert Xue853c3c2006-08-22 00:06:54 +1000289 len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
Herbert Xu27d2a332007-01-24 20:50:26 +1100290 if (type_obj)
291 return len + type_obj->ctxsize(alg, type, mask);
Herbert Xue853c3c2006-08-22 00:06:54 +1000292
Herbert Xufbdae9f2005-07-06 13:53:29 -0700293 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
294 default:
295 BUG();
296
297 case CRYPTO_ALG_TYPE_CIPHER:
Herbert Xuf1ddcaf2007-01-27 10:05:15 +1100298 len += crypto_cipher_ctxsize(alg);
Herbert Xufbdae9f2005-07-06 13:53:29 -0700299 break;
300
301 case CRYPTO_ALG_TYPE_DIGEST:
Herbert Xuf1ddcaf2007-01-27 10:05:15 +1100302 len += crypto_digest_ctxsize(alg);
Herbert Xufbdae9f2005-07-06 13:53:29 -0700303 break;
304
305 case CRYPTO_ALG_TYPE_COMPRESS:
Herbert Xuf1ddcaf2007-01-27 10:05:15 +1100306 len += crypto_compress_ctxsize(alg);
Herbert Xufbdae9f2005-07-06 13:53:29 -0700307 break;
308 }
309
Herbert Xue853c3c2006-08-22 00:06:54 +1000310 return len;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700311}
312
Herbert Xu6bfd4802006-09-21 11:39:29 +1000313void crypto_shoot_alg(struct crypto_alg *alg)
314{
315 down_write(&crypto_alg_sem);
316 alg->cra_flags |= CRYPTO_ALG_DYING;
317 up_write(&crypto_alg_sem);
318}
319EXPORT_SYMBOL_GPL(crypto_shoot_alg);
320
Herbert Xu27d2a332007-01-24 20:50:26 +1100321struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
322 u32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
324 struct crypto_tfm *tfm = NULL;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700325 unsigned int tfm_size;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000326 int err = -ENOMEM;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700327
Herbert Xu27d2a332007-01-24 20:50:26 +1100328 tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
Eric Sesterhennbbeb5632006-03-06 21:42:07 +1100329 tfm = kzalloc(tfm_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 if (tfm == NULL)
Akinobu Mita9765d262006-10-11 22:29:51 +1000331 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 tfm->__crt_alg = alg;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000334
Herbert Xu27d2a332007-01-24 20:50:26 +1100335 err = crypto_init_ops(tfm, type, mask);
Herbert Xu6bfd4802006-09-21 11:39:29 +1000336 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 goto out_free_tfm;
Herbert Xuc7fc0592006-05-24 13:02:26 +1000338
Herbert Xu6bfd4802006-09-21 11:39:29 +1000339 if (alg->cra_init && (err = alg->cra_init(tfm))) {
340 if (err == -EAGAIN)
341 crypto_shoot_alg(alg);
Herbert Xuc7fc0592006-05-24 13:02:26 +1000342 goto cra_init_failed;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000343 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 goto out;
346
Herbert Xuc7fc0592006-05-24 13:02:26 +1000347cra_init_failed:
348 crypto_exit_ops(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349out_free_tfm:
350 kfree(tfm);
Akinobu Mita9765d262006-10-11 22:29:51 +1000351out_err:
Herbert Xu6bfd4802006-09-21 11:39:29 +1000352 tfm = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353out:
354 return tfm;
355}
Herbert Xu6bfd4802006-09-21 11:39:29 +1000356EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
357
Herbert Xu6d7d6842006-07-30 11:53:01 +1000358/*
359 * crypto_alloc_base - Locate algorithm and allocate transform
360 * @alg_name: Name of algorithm
361 * @type: Type of algorithm
362 * @mask: Mask for type comparison
363 *
364 * crypto_alloc_base() will first attempt to locate an already loaded
365 * algorithm. If that fails and the kernel supports dynamically loadable
366 * modules, it will then attempt to load a module of the same name or
367 * alias. If that fails it will send a query to any loaded crypto manager
368 * to construct an algorithm on the fly. A refcount is grabbed on the
369 * algorithm which is then associated with the new transform.
370 *
371 * The returned transform is of a non-determinate type. Most people
372 * should use one of the more specific allocation functions such as
373 * crypto_alloc_blkcipher.
374 *
375 * In case of error the return value is an error pointer.
376 */
377struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
378{
379 struct crypto_tfm *tfm;
380 int err;
381
382 for (;;) {
383 struct crypto_alg *alg;
384
385 alg = crypto_alg_mod_lookup(alg_name, type, mask);
Akinobu Mita9765d262006-10-11 22:29:51 +1000386 if (IS_ERR(alg)) {
387 err = PTR_ERR(alg);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000388 goto err;
Akinobu Mita9765d262006-10-11 22:29:51 +1000389 }
Herbert Xu6d7d6842006-07-30 11:53:01 +1000390
Herbert Xu27d2a332007-01-24 20:50:26 +1100391 tfm = __crypto_alloc_tfm(alg, type, mask);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000392 if (!IS_ERR(tfm))
Akinobu Mita9765d262006-10-11 22:29:51 +1000393 return tfm;
Herbert Xu6d7d6842006-07-30 11:53:01 +1000394
395 crypto_mod_put(alg);
396 err = PTR_ERR(tfm);
397
398err:
399 if (err != -EAGAIN)
400 break;
401 if (signal_pending(current)) {
402 err = -EINTR;
403 break;
404 }
Akinobu Mita9765d262006-10-11 22:29:51 +1000405 }
Herbert Xu6d7d6842006-07-30 11:53:01 +1000406
Akinobu Mita9765d262006-10-11 22:29:51 +1000407 return ERR_PTR(err);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000408}
409EXPORT_SYMBOL_GPL(crypto_alloc_base);
410
411/*
412 * crypto_free_tfm - Free crypto transform
413 * @tfm: Transform to free
414 *
415 * crypto_free_tfm() frees up the transform and any associated resources,
416 * then drops the refcount on the associated algorithm.
417 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418void crypto_free_tfm(struct crypto_tfm *tfm)
419{
Jesper Juhla61cc442005-07-06 13:54:31 -0700420 struct crypto_alg *alg;
421 int size;
422
423 if (unlikely(!tfm))
424 return;
425
426 alg = tfm->__crt_alg;
427 size = sizeof(*tfm) + alg->cra_ctxsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Herbert Xuc7fc0592006-05-24 13:02:26 +1000429 if (alg->cra_exit)
430 alg->cra_exit(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 crypto_exit_ops(tfm);
Herbert Xu72fa4912006-05-28 09:05:24 +1000432 crypto_mod_put(alg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 memset(tfm, 0, size);
434 kfree(tfm);
435}
436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437EXPORT_SYMBOL_GPL(crypto_free_tfm);
Herbert Xufce32d72006-08-26 17:35:45 +1000438
439int crypto_has_alg(const char *name, u32 type, u32 mask)
440{
441 int ret = 0;
442 struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
443
444 if (!IS_ERR(alg)) {
445 crypto_mod_put(alg);
446 ret = 1;
447 }
448
449 return ret;
450}
451EXPORT_SYMBOL_GPL(crypto_has_alg);
Sebastian Siewiorc3715cb92008-03-30 16:36:09 +0800452
453MODULE_DESCRIPTION("Cryptographic core API");
454MODULE_LICENSE("GPL");