projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[package] base-files, ppp: fix interface shutdown
[openwrt.git] / target / linux / generic-2.6 / files / crypto / ocf / cryptosoft.c
1 /*
2 * An OCF module that uses the linux kernel cryptoapi, based on the
3 * original cryptosoft for BSD by Angelos D. Keromytis (angelos@cis.upenn.edu)
4 * but is mostly unrecognisable,
5 *
6 * Written by David McCullough <david_mccullough@mcafee.com>
7 * Copyright (C) 2004-2010 David McCullough
8 * Copyright (C) 2004-2005 Intel Corporation.
9 *
10 * LICENSE TERMS
11 *
12 * The free distribution and use of this software in both source and binary
13 * form is allowed (with or without changes) provided that:
14 *
15 * 1. distributions of this source code include the above copyright
16 * notice, this list of conditions and the following disclaimer;
17 *
18 * 2. distributions in binary form include the above copyright
19 * notice, this list of conditions and the following disclaimer
20 * in the documentation and/or other associated materials;
21 *
22 * 3. the copyright holder's name is not used to endorse products
23 * built using this software without specific written permission.
24 *
25 * ALTERNATIVELY, provided that this notice is retained in full, this product
26 * may be distributed under the terms of the GNU General Public License (GPL),
27 * in which case the provisions of the GPL apply INSTEAD OF those given above.
28 *
29 * DISCLAIMER
30 *
31 * This software is provided 'as is' with no explicit or implied warranties
32 * in respect of its properties, including, but not limited to, correctness
33 * and/or fitness for purpose.
34 * ---------------------------------------------------------------------------
35 */
36
37 #ifndef AUTOCONF_INCLUDED
38 #include <linux/config.h>
39 #endif
40 #include <linux/module.h>
41 #include <linux/init.h>
42 #include <linux/list.h>
43 #include <linux/slab.h>
44 #include <linux/sched.h>
45 #include <linux/wait.h>
46 #include <linux/crypto.h>
47 #include <linux/mm.h>
48 #include <linux/skbuff.h>
49 #include <linux/random.h>
50 #include <linux/version.h>
51 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
52 #include <linux/scatterlist.h>
53 #endif
54 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
55 #include <crypto/hash.h>
56 #endif
57
58 #include <cryptodev.h>
59 #include <uio.h>
60
61 struct {
62 softc_device_decl sc_dev;
63 } swcr_softc;
64
65 #define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)
66
67 #define SW_TYPE_CIPHER 0x01
68 #define SW_TYPE_HMAC 0x02
69 #define SW_TYPE_HASH 0x04
70 #define SW_TYPE_COMP 0x08
71 #define SW_TYPE_BLKCIPHER 0x10
72 #define SW_TYPE_ALG_MASK 0x1f
73
74 #define SW_TYPE_ASYNC 0x8000
75
76 /* We change some of the above if we have an async interface */
77
78 #define SW_TYPE_ALG_AMASK (SW_TYPE_ALG_MASK | SW_TYPE_ASYNC)
79
80 #define SW_TYPE_ABLKCIPHER (SW_TYPE_BLKCIPHER | SW_TYPE_ASYNC)
81 #define SW_TYPE_AHASH (SW_TYPE_HASH | SW_TYPE_ASYNC)
82 #define SW_TYPE_AHMAC (SW_TYPE_HMAC | SW_TYPE_ASYNC)
83
84 #define SCATTERLIST_MAX 16
85
86 struct swcr_data {
87 int sw_type;
88 int sw_alg;
89 struct crypto_tfm *sw_tfm;
90 union {
91 struct {
92 char *sw_key;
93 int sw_klen;
94 int sw_mlen;
95 } hmac;
96 void *sw_comp_buf;
97 } u;
98 struct swcr_data *sw_next;
99 };
100
101 struct swcr_req {
102 struct swcr_data *sw_head;
103 struct swcr_data *sw;
104 struct cryptop *crp;
105 struct cryptodesc *crd;
106 struct scatterlist sg[SCATTERLIST_MAX];
107 unsigned char iv[EALG_MAX_BLOCK_LEN];
108 char result[HASH_MAX_LEN];
109 void *crypto_req;
110 };
111
112 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
113 static kmem_cache_t *swcr_req_cache;
114 #else
115 static struct kmem_cache *swcr_req_cache;
116 #endif
117
118 #ifndef CRYPTO_TFM_MODE_CBC
119 /*
120 * As of linux-2.6.21 this is no longer defined, and presumably no longer
121 * needed to be passed into the crypto core code.
122 */
123 #define CRYPTO_TFM_MODE_CBC 0
124 #define CRYPTO_TFM_MODE_ECB 0
125 #endif
126
127 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
128 /*
129 * Linux 2.6.19 introduced a new Crypto API, setup macro's to convert new
130 * API into old API.
131 */
132
133 /* Symmetric/Block Cipher */
134 struct blkcipher_desc
135 {
136 struct crypto_tfm *tfm;
137 void *info;
138 };
139 #define ecb(X) #X , CRYPTO_TFM_MODE_ECB
140 #define cbc(X) #X , CRYPTO_TFM_MODE_CBC
141 #define crypto_has_blkcipher(X, Y, Z) crypto_alg_available(X, 0)
142 #define crypto_blkcipher_cast(X) X
143 #define crypto_blkcipher_tfm(X) X
144 #define crypto_alloc_blkcipher(X, Y, Z) crypto_alloc_tfm(X, mode)
145 #define crypto_blkcipher_ivsize(X) crypto_tfm_alg_ivsize(X)
146 #define crypto_blkcipher_blocksize(X) crypto_tfm_alg_blocksize(X)
147 #define crypto_blkcipher_setkey(X, Y, Z) crypto_cipher_setkey(X, Y, Z)
148 #define crypto_blkcipher_encrypt_iv(W, X, Y, Z) \
149 crypto_cipher_encrypt_iv((W)->tfm, X, Y, Z, (u8 *)((W)->info))
150 #define crypto_blkcipher_decrypt_iv(W, X, Y, Z) \
151 crypto_cipher_decrypt_iv((W)->tfm, X, Y, Z, (u8 *)((W)->info))
152 #define crypto_blkcipher_set_flags(x, y) /* nop */
153
154 /* Hash/HMAC/Digest */
155 struct hash_desc
156 {
157 struct crypto_tfm *tfm;
158 };
159 #define hmac(X) #X , 0
160 #define crypto_has_hash(X, Y, Z) crypto_alg_available(X, 0)
161 #define crypto_hash_cast(X) X
162 #define crypto_hash_tfm(X) X
163 #define crypto_alloc_hash(X, Y, Z) crypto_alloc_tfm(X, mode)
164 #define crypto_hash_digestsize(X) crypto_tfm_alg_digestsize(X)
165 #define crypto_hash_digest(W, X, Y, Z) \
166 crypto_digest_digest((W)->tfm, X, sg_num, Z)
167
168 /* Asymmetric Cipher */
169 #define crypto_has_cipher(X, Y, Z) crypto_alg_available(X, 0)
170
171 /* Compression */
172 #define crypto_has_comp(X, Y, Z) crypto_alg_available(X, 0)
173 #define crypto_comp_tfm(X) X
174 #define crypto_comp_cast(X) X
175 #define crypto_alloc_comp(X, Y, Z) crypto_alloc_tfm(X, mode)
176 #define plain(X) #X , 0
177 #else
178 #define ecb(X) "ecb(" #X ")" , 0
179 #define cbc(X) "cbc(" #X ")" , 0
180 #define hmac(X) "hmac(" #X ")" , 0
181 #define plain(X) #X , 0
182 #endif /* if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) */
183
184 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
185 /* no ablkcipher in older kernels */
186 #define crypto_alloc_ablkcipher(a,b,c) (NULL)
187 #define crypto_ablkcipher_tfm(x) ((struct crypto_tfm *)(x))
188 #define crypto_ablkcipher_set_flags(a, b) /* nop */
189 #define crypto_ablkcipher_setkey(x, y, z) (-EINVAL)
190 #define crypto_has_ablkcipher(a,b,c) (0)
191 #else
192 #define HAVE_ABLKCIPHER
193 #endif
194
195 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
196 /* no ahash in older kernels */
197 #define crypto_ahash_tfm(x) ((struct crypto_tfm *)(x))
198 #define crypto_alloc_ahash(a,b,c) (NULL)
199 #define crypto_ahash_digestsize(x) 0
200 #else
201 #define HAVE_AHASH
202 #endif
203
204 struct crypto_details {
205 char *alg_name;
206 int mode;
207 int sw_type;
208 };
209
210 static struct crypto_details crypto_details[] = {
211 [CRYPTO_DES_CBC] = { cbc(des), SW_TYPE_BLKCIPHER, },
212 [CRYPTO_3DES_CBC] = { cbc(des3_ede), SW_TYPE_BLKCIPHER, },
213 [CRYPTO_BLF_CBC] = { cbc(blowfish), SW_TYPE_BLKCIPHER, },
214 [CRYPTO_CAST_CBC] = { cbc(cast5), SW_TYPE_BLKCIPHER, },
215 [CRYPTO_SKIPJACK_CBC] = { cbc(skipjack), SW_TYPE_BLKCIPHER, },
216 [CRYPTO_MD5_HMAC] = { hmac(md5), SW_TYPE_HMAC, },
217 [CRYPTO_SHA1_HMAC] = { hmac(sha1), SW_TYPE_HMAC, },
218 [CRYPTO_RIPEMD160_HMAC] = { hmac(ripemd160), SW_TYPE_HMAC, },
219 [CRYPTO_MD5_KPDK] = { plain(md5-kpdk), SW_TYPE_HASH, },
220 [CRYPTO_SHA1_KPDK] = { plain(sha1-kpdk), SW_TYPE_HASH, },
221 [CRYPTO_AES_CBC] = { cbc(aes), SW_TYPE_BLKCIPHER, },
222 [CRYPTO_ARC4] = { ecb(arc4), SW_TYPE_BLKCIPHER, },
223 [CRYPTO_MD5] = { plain(md5), SW_TYPE_HASH, },
224 [CRYPTO_SHA1] = { plain(sha1), SW_TYPE_HASH, },
225 [CRYPTO_NULL_HMAC] = { hmac(digest_null), SW_TYPE_HMAC, },
226 [CRYPTO_NULL_CBC] = { cbc(cipher_null), SW_TYPE_BLKCIPHER, },
227 [CRYPTO_DEFLATE_COMP] = { plain(deflate), SW_TYPE_COMP, },
228 [CRYPTO_SHA2_256_HMAC] = { hmac(sha256), SW_TYPE_HMAC, },
229 [CRYPTO_SHA2_384_HMAC] = { hmac(sha384), SW_TYPE_HMAC, },
230 [CRYPTO_SHA2_512_HMAC] = { hmac(sha512), SW_TYPE_HMAC, },
231 [CRYPTO_CAMELLIA_CBC] = { cbc(camellia), SW_TYPE_BLKCIPHER, },
232 [CRYPTO_SHA2_256] = { plain(sha256), SW_TYPE_HASH, },
233 [CRYPTO_SHA2_384] = { plain(sha384), SW_TYPE_HASH, },
234 [CRYPTO_SHA2_512] = { plain(sha512), SW_TYPE_HASH, },
235 [CRYPTO_RIPEMD160] = { plain(ripemd160), SW_TYPE_HASH, },
236 };
237
238 int32_t swcr_id = -1;
239 module_param(swcr_id, int, 0444);
240 MODULE_PARM_DESC(swcr_id, "Read-Only OCF ID for cryptosoft driver");
241
242 int swcr_fail_if_compression_grows = 1;
243 module_param(swcr_fail_if_compression_grows, int, 0644);
244 MODULE_PARM_DESC(swcr_fail_if_compression_grows,
245 "Treat compression that results in more data as a failure");
246
247 int swcr_no_ahash = 0;
248 module_param(swcr_no_ahash, int, 0644);
249 MODULE_PARM_DESC(swcr_no_ahash,
250 "Do not use async hash/hmac even if available");
251
252 int swcr_no_ablk = 0;
253 module_param(swcr_no_ablk, int, 0644);
254 MODULE_PARM_DESC(swcr_no_ablk,
255 "Do not use async blk ciphers even if available");
256
257 static struct swcr_data **swcr_sessions = NULL;
258 static u_int32_t swcr_sesnum = 0;
259
260 static int swcr_process(device_t, struct cryptop *, int);
261 static int swcr_newsession(device_t, u_int32_t *, struct cryptoini *);
262 static int swcr_freesession(device_t, u_int64_t);
263
264 static device_method_t swcr_methods = {
265 /* crypto device methods */
266 DEVMETHOD(cryptodev_newsession, swcr_newsession),
267 DEVMETHOD(cryptodev_freesession,swcr_freesession),
268 DEVMETHOD(cryptodev_process, swcr_process),
269 };
270
271 #define debug swcr_debug
272 int swcr_debug = 0;
273 module_param(swcr_debug, int, 0644);
274 MODULE_PARM_DESC(swcr_debug, "Enable debug");
275
276 static void swcr_process_req(struct swcr_req *req);
277
278 /*
279 * Generate a new software session.
280 */
281 static int
282 swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri)
283 {
284 struct swcr_data **swd;
285 u_int32_t i;
286 int error;
287 char *algo;
288 int mode;
289
290 dprintk("%s()\n", __FUNCTION__);
291 if (sid == NULL || cri == NULL) {
292 dprintk("%s,%d - EINVAL\n", __FILE__, __LINE__);
293 return EINVAL;
294 }
295
296 if (swcr_sessions) {
297 for (i = 1; i < swcr_sesnum; i++)
298 if (swcr_sessions[i] == NULL)
299 break;
300 } else
301 i = 1; /* NB: to silence compiler warning */
302
303 if (swcr_sessions == NULL || i == swcr_sesnum) {
304 if (swcr_sessions == NULL) {
305 i = 1; /* We leave swcr_sessions[0] empty */
306 swcr_sesnum = CRYPTO_SW_SESSIONS;
307 } else
308 swcr_sesnum *= 2;
309
310 swd = kmalloc(swcr_sesnum * sizeof(struct swcr_data *), SLAB_ATOMIC);
311 if (swd == NULL) {
312 /* Reset session number */
313 if (swcr_sesnum == CRYPTO_SW_SESSIONS)
314 swcr_sesnum = 0;
315 else
316 swcr_sesnum /= 2;
317 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
318 return ENOBUFS;
319 }
320 memset(swd, 0, swcr_sesnum * sizeof(struct swcr_data *));
321
322 /* Copy existing sessions */
323 if (swcr_sessions) {
324 memcpy(swd, swcr_sessions,
325 (swcr_sesnum / 2) * sizeof(struct swcr_data *));
326 kfree(swcr_sessions);
327 }
328
329 swcr_sessions = swd;
330 }
331
332 swd = &swcr_sessions[i];
333 *sid = i;
334
335 while (cri) {
336 *swd = (struct swcr_data *) kmalloc(sizeof(struct swcr_data),
337 SLAB_ATOMIC);
338 if (*swd == NULL) {
339 swcr_freesession(NULL, i);
340 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
341 return ENOBUFS;
342 }
343 memset(*swd, 0, sizeof(struct swcr_data));
344
345 if (cri->cri_alg < 0 ||
346 cri->cri_alg>=sizeof(crypto_details)/sizeof(crypto_details[0])){
347 printk("cryptosoft: Unknown algorithm 0x%x\n", cri->cri_alg);
348 swcr_freesession(NULL, i);
349 return EINVAL;
350 }
351
352 algo = crypto_details[cri->cri_alg].alg_name;
353 if (!algo || !*algo) {
354 printk("cryptosoft: Unsupported algorithm 0x%x\n", cri->cri_alg);
355 swcr_freesession(NULL, i);
356 return EINVAL;
357 }
358
359 mode = crypto_details[cri->cri_alg].mode;
360 (*swd)->sw_type = crypto_details[cri->cri_alg].sw_type;
361 (*swd)->sw_alg = cri->cri_alg;
362
363 /* Algorithm specific configuration */
364 switch (cri->cri_alg) {
365 case CRYPTO_NULL_CBC:
366 cri->cri_klen = 0; /* make it work with crypto API */
367 break;
368 default:
369 break;
370 }
371
372 if ((*swd)->sw_type & SW_TYPE_BLKCIPHER) {
373 dprintk("%s crypto_alloc_*blkcipher(%s, 0x%x)\n", __FUNCTION__,
374 algo, mode);
375
376 /* try async first */
377 (*swd)->sw_tfm = swcr_no_ablk ? NULL :
378 crypto_ablkcipher_tfm(crypto_alloc_ablkcipher(algo, 0, 0));
379 if ((*swd)->sw_tfm) {
380 dprintk("%s %s cipher is async\n", __FUNCTION__, algo);
381 (*swd)->sw_type |= SW_TYPE_ASYNC;
382 } else {
383 dprintk("%s %s cipher is sync\n", __FUNCTION__, algo);
384 (*swd)->sw_tfm = crypto_blkcipher_tfm(
385 crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC));
386 }
387 if (!(*swd)->sw_tfm) {
388 dprintk("cryptosoft: crypto_alloc_blkcipher failed(%s, 0x%x)\n",
389 algo,mode);
390 swcr_freesession(NULL, i);
391 return EINVAL;
392 }
393
394 if (debug) {
395 dprintk("%s key:cri->cri_klen=%d,(cri->cri_klen + 7)/8=%d",
396 __FUNCTION__, cri->cri_klen, (cri->cri_klen + 7) / 8);
397 for (i = 0; i < (cri->cri_klen + 7) / 8; i++)
398 dprintk("%s0x%x", (i % 8) ? " " : "\n ",
399 cri->cri_key[i] & 0xff);
400 dprintk("\n");
401 }
402 if ((*swd)->sw_type & SW_TYPE_ASYNC) {
403 /* OCF doesn't enforce keys */
404 crypto_ablkcipher_set_flags(
405 __crypto_ablkcipher_cast((*swd)->sw_tfm),
406 CRYPTO_TFM_REQ_WEAK_KEY);
407 error = crypto_ablkcipher_setkey(
408 __crypto_ablkcipher_cast((*swd)->sw_tfm),
409 cri->cri_key, (cri->cri_klen + 7) / 8);
410 } else {
411 /* OCF doesn't enforce keys */
412 crypto_blkcipher_set_flags(
413 crypto_blkcipher_cast((*swd)->sw_tfm),
414 CRYPTO_TFM_REQ_WEAK_KEY);
415 error = crypto_blkcipher_setkey(
416 crypto_blkcipher_cast((*swd)->sw_tfm),
417 cri->cri_key, (cri->cri_klen + 7) / 8);
418 }
419 if (error) {
420 printk("cryptosoft: setkey failed %d (crt_flags=0x%x)\n", error,
421 (*swd)->sw_tfm->crt_flags);
422 swcr_freesession(NULL, i);
423 return error;
424 }
425 } else if ((*swd)->sw_type & (SW_TYPE_HMAC | SW_TYPE_HASH)) {
426 dprintk("%s crypto_alloc_*hash(%s, 0x%x)\n", __FUNCTION__,
427 algo, mode);
428
429 /* try async first */
430 (*swd)->sw_tfm = swcr_no_ahash ? NULL :
431 crypto_ahash_tfm(crypto_alloc_ahash(algo, 0, 0));
432 if ((*swd)->sw_tfm) {
433 dprintk("%s %s hash is async\n", __FUNCTION__, algo);
434 (*swd)->sw_type |= SW_TYPE_ASYNC;
435 } else {
436 dprintk("%s %s hash is sync\n", __FUNCTION__, algo);
437 (*swd)->sw_tfm = crypto_hash_tfm(
438 crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC));
439 }
440
441 if (!(*swd)->sw_tfm) {
442 dprintk("cryptosoft: crypto_alloc_hash failed(%s,0x%x)\n",
443 algo, mode);
444 swcr_freesession(NULL, i);
445 return EINVAL;
446 }
447
448 (*swd)->u.hmac.sw_klen = (cri->cri_klen + 7) / 8;
449 (*swd)->u.hmac.sw_key = (char *)kmalloc((*swd)->u.hmac.sw_klen,
450 SLAB_ATOMIC);
451 if ((*swd)->u.hmac.sw_key == NULL) {
452 swcr_freesession(NULL, i);
453 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
454 return ENOBUFS;
455 }
456 memcpy((*swd)->u.hmac.sw_key, cri->cri_key, (*swd)->u.hmac.sw_klen);
457 if (cri->cri_mlen) {
458 (*swd)->u.hmac.sw_mlen = cri->cri_mlen;
459 } else if ((*swd)->sw_type & SW_TYPE_ASYNC) {
460 (*swd)->u.hmac.sw_mlen = crypto_ahash_digestsize(
461 __crypto_ahash_cast((*swd)->sw_tfm));
462 } else {
463 (*swd)->u.hmac.sw_mlen = crypto_hash_digestsize(
464 crypto_hash_cast((*swd)->sw_tfm));
465 }
466 } else if ((*swd)->sw_type & SW_TYPE_COMP) {
467 (*swd)->sw_tfm = crypto_comp_tfm(
468 crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC));
469 if (!(*swd)->sw_tfm) {
470 dprintk("cryptosoft: crypto_alloc_comp failed(%s,0x%x)\n",
471 algo, mode);
472 swcr_freesession(NULL, i);
473 return EINVAL;
474 }
475 (*swd)->u.sw_comp_buf = kmalloc(CRYPTO_MAX_DATA_LEN, SLAB_ATOMIC);
476 if ((*swd)->u.sw_comp_buf == NULL) {
477 swcr_freesession(NULL, i);
478 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
479 return ENOBUFS;
480 }
481 } else {
482 printk("cryptosoft: Unhandled sw_type %d\n", (*swd)->sw_type);
483 swcr_freesession(NULL, i);
484 return EINVAL;
485 }
486
487 cri = cri->cri_next;
488 swd = &((*swd)->sw_next);
489 }
490 return 0;
491 }
492
493 /*
494 * Free a session.
495 */
496 static int
497 swcr_freesession(device_t dev, u_int64_t tid)
498 {
499 struct swcr_data *swd;
500 u_int32_t sid = CRYPTO_SESID2LID(tid);
501
502 dprintk("%s()\n", __FUNCTION__);
503 if (sid > swcr_sesnum || swcr_sessions == NULL ||
504 swcr_sessions[sid] == NULL) {
505 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
506 return(EINVAL);
507 }
508
509 /* Silently accept and return */
510 if (sid == 0)
511 return(0);
512
513 while ((swd = swcr_sessions[sid]) != NULL) {
514 swcr_sessions[sid] = swd->sw_next;
515 if (swd->sw_tfm) {
516 switch (swd->sw_type & SW_TYPE_ALG_AMASK) {
517 #ifdef HAVE_AHASH
518 case SW_TYPE_AHMAC:
519 case SW_TYPE_AHASH:
520 crypto_free_ahash(__crypto_ahash_cast(swd->sw_tfm));
521 break;
522 #endif
523 #ifdef HAVE_ABLKCIPHER
524 case SW_TYPE_ABLKCIPHER:
525 crypto_free_ablkcipher(__crypto_ablkcipher_cast(swd->sw_tfm));
526 break;
527 #endif
528 case SW_TYPE_BLKCIPHER:
529 crypto_free_blkcipher(crypto_blkcipher_cast(swd->sw_tfm));
530 break;
531 case SW_TYPE_HMAC:
532 case SW_TYPE_HASH:
533 crypto_free_hash(crypto_hash_cast(swd->sw_tfm));
534 break;
535 case SW_TYPE_COMP:
536 crypto_free_comp(crypto_comp_cast(swd->sw_tfm));
537 default:
538 crypto_free_tfm(swd->sw_tfm);
539 break;
540 }
541 swd->sw_tfm = NULL;
542 }
543 if (swd->sw_type & SW_TYPE_COMP) {
544 if (swd->u.sw_comp_buf)
545 kfree(swd->u.sw_comp_buf);
546 } else {
547 if (swd->u.hmac.sw_key)
548 kfree(swd->u.hmac.sw_key);
549 }
550 kfree(swd);
551 }
552 return 0;
553 }
554
555 #if defined(HAVE_ABLKCIPHER) || defined(HAVE_AHASH)
556 /* older kernels had no async interface */
557
558 static void swcr_process_callback(struct crypto_async_request *creq, int err)
559 {
560 struct swcr_req *req = creq->data;
561
562 dprintk("%s()\n", __FUNCTION__);
563 if (err) {
564 if (err == -EINPROGRESS)
565 return;
566 dprintk("%s() fail %d\n", __FUNCTION__, -err);
567 req->crp->crp_etype = -err;
568 goto done;
569 }
570
571 switch (req->sw->sw_type & SW_TYPE_ALG_AMASK) {
572 case SW_TYPE_AHMAC:
573 case SW_TYPE_AHASH:
574 crypto_copyback(req->crp->crp_flags, req->crp->crp_buf,
575 req->crd->crd_inject, req->sw->u.hmac.sw_mlen, req->result);
576 ahash_request_free(req->crypto_req);
577 break;
578 case SW_TYPE_ABLKCIPHER:
579 ablkcipher_request_free(req->crypto_req);
580 break;
581 default:
582 req->crp->crp_etype = EINVAL;
583 goto done;
584 }
585
586 req->crd = req->crd->crd_next;
587 if (req->crd) {
588 swcr_process_req(req);
589 return;
590 }
591
592 done:
593 dprintk("%s crypto_done %p\n", __FUNCTION__, req);
594 crypto_done(req->crp);
595 kmem_cache_free(swcr_req_cache, req);
596 }
597 #endif /* defined(HAVE_ABLKCIPHER) || defined(HAVE_AHASH) */
598
599
600 static void swcr_process_req(struct swcr_req *req)
601 {
602 struct swcr_data *sw;
603 struct cryptop *crp = req->crp;
604 struct cryptodesc *crd = req->crd;
605 struct sk_buff *skb = (struct sk_buff *) crp->crp_buf;
606 struct uio *uiop = (struct uio *) crp->crp_buf;
607 int sg_num, sg_len, skip;
608
609 dprintk("%s()\n", __FUNCTION__);
610
611 /*
612 * Find the crypto context.
613 *
614 * XXX Note that the logic here prevents us from having
615 * XXX the same algorithm multiple times in a session
616 * XXX (or rather, we can but it won't give us the right
617 * XXX results). To do that, we'd need some way of differentiating
618 * XXX between the various instances of an algorithm (so we can
619 * XXX locate the correct crypto context).
620 */
621 for (sw = req->sw_head; sw && sw->sw_alg != crd->crd_alg; sw = sw->sw_next)
622 ;
623
624 /* No such context ? */
625 if (sw == NULL) {
626 crp->crp_etype = EINVAL;
627 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
628 goto done;
629 }
630
631 req->sw = sw;
632 skip = crd->crd_skip;
633
634 /*
635 * setup the SG list skip from the start of the buffer
636 */
637 memset(req->sg, 0, sizeof(req->sg));
638 sg_init_table(req->sg, SCATTERLIST_MAX);
639 if (crp->crp_flags & CRYPTO_F_SKBUF) {
640 int i, len;
641
642 sg_num = 0;
643 sg_len = 0;
644
645 if (skip < skb_headlen(skb)) {
646 len = skb_headlen(skb) - skip;
647 if (len + sg_len > crd->crd_len)
648 len = crd->crd_len - sg_len;
649 sg_set_page(&req->sg[sg_num],
650 virt_to_page(skb->data + skip), len,
651 offset_in_page(skb->data + skip));
652 sg_len += len;
653 sg_num++;
654 skip = 0;
655 } else
656 skip -= skb_headlen(skb);
657
658 for (i = 0; sg_len < crd->crd_len &&
659 i < skb_shinfo(skb)->nr_frags &&
660 sg_num < SCATTERLIST_MAX; i++) {
661 if (skip < skb_shinfo(skb)->frags[i].size) {
662 len = skb_shinfo(skb)->frags[i].size - skip;
663 if (len + sg_len > crd->crd_len)
664 len = crd->crd_len - sg_len;
665 sg_set_page(&req->sg[sg_num],
666 skb_shinfo(skb)->frags[i].page,
667 len,
668 skb_shinfo(skb)->frags[i].page_offset + skip);
669 sg_len += len;
670 sg_num++;
671 skip = 0;
672 } else
673 skip -= skb_shinfo(skb)->frags[i].size;
674 }
675 } else if (crp->crp_flags & CRYPTO_F_IOV) {
676 int len;
677
678 sg_len = 0;
679 for (sg_num = 0; sg_len < crd->crd_len &&
680 sg_num < uiop->uio_iovcnt &&
681 sg_num < SCATTERLIST_MAX; sg_num++) {
682 if (skip <= uiop->uio_iov[sg_num].iov_len) {
683 len = uiop->uio_iov[sg_num].iov_len - skip;
684 if (len + sg_len > crd->crd_len)
685 len = crd->crd_len - sg_len;
686 sg_set_page(&req->sg[sg_num],
687 virt_to_page(uiop->uio_iov[sg_num].iov_base+skip),
688 len,
689 offset_in_page(uiop->uio_iov[sg_num].iov_base+skip));
690 sg_len += len;
691 skip = 0;
692 } else
693 skip -= uiop->uio_iov[sg_num].iov_len;
694 }
695 } else {
696 sg_len = (crp->crp_ilen - skip);
697 if (sg_len > crd->crd_len)
698 sg_len = crd->crd_len;
699 sg_set_page(&req->sg[0], virt_to_page(crp->crp_buf + skip),
700 sg_len, offset_in_page(crp->crp_buf + skip));
701 sg_num = 1;
702 }
703
704 switch (sw->sw_type & SW_TYPE_ALG_AMASK) {
705
706 #ifdef HAVE_AHASH
707 case SW_TYPE_AHMAC:
708 case SW_TYPE_AHASH:
709 {
710 int ret;
711
712 /* check we have room for the result */
713 if (crp->crp_ilen - crd->crd_inject < sw->u.hmac.sw_mlen) {
714 dprintk("cryptosoft: EINVAL crp_ilen=%d, len=%d, inject=%d "
715 "digestsize=%d\n", crp->crp_ilen, crd->crd_skip + sg_len,
716 crd->crd_inject, sw->u.hmac.sw_mlen);
717 crp->crp_etype = EINVAL;
718 goto done;
719 }
720
721 req->crypto_req =
722 ahash_request_alloc(__crypto_ahash_cast(sw->sw_tfm),GFP_KERNEL);
723 if (!req->crypto_req) {
724 crp->crp_etype = ENOMEM;
725 dprintk("%s,%d: ENOMEM ahash_request_alloc", __FILE__, __LINE__);
726 goto done;
727 }
728
729 ahash_request_set_callback(req->crypto_req,
730 CRYPTO_TFM_REQ_MAY_BACKLOG, swcr_process_callback, req);
731
732 memset(req->result, 0, sizeof(req->result));
733
734 if (sw->sw_type & SW_TYPE_AHMAC)
735 crypto_ahash_setkey(__crypto_ahash_cast(sw->sw_tfm),
736 sw->u.hmac.sw_key, sw->u.hmac.sw_klen);
737 ahash_request_set_crypt(req->crypto_req, req->sg, req->result, sg_len);
738 ret = crypto_ahash_digest(req->crypto_req);
739 switch (ret) {
740 case -EINPROGRESS:
741 case -EBUSY:
742 return;
743 default:
744 case 0:
745 dprintk("hash OP %s %d\n", ret ? "failed" : "success", ret);
746 crp->crp_etype = ret;
747 ahash_request_free(req->crypto_req);
748 goto done;
749 }
750 } break;
751 #endif /* HAVE_AHASH */
752
753 #ifdef HAVE_ABLKCIPHER
754 case SW_TYPE_ABLKCIPHER: {
755 int ret;
756 unsigned char *ivp = req->iv;
757 int ivsize =
758 crypto_ablkcipher_ivsize(__crypto_ablkcipher_cast(sw->sw_tfm));
759
760 if (sg_len < crypto_ablkcipher_blocksize(
761 __crypto_ablkcipher_cast(sw->sw_tfm))) {
762 crp->crp_etype = EINVAL;
763 dprintk("%s,%d: EINVAL len %d < %d\n", __FILE__, __LINE__,
764 sg_len, crypto_ablkcipher_blocksize(
765 __crypto_ablkcipher_cast(sw->sw_tfm)));
766 goto done;
767 }
768
769 if (ivsize > sizeof(req->iv)) {
770 crp->crp_etype = EINVAL;
771 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
772 goto done;
773 }
774
775 req->crypto_req = ablkcipher_request_alloc(
776 __crypto_ablkcipher_cast(sw->sw_tfm), GFP_KERNEL);
777 if (!req->crypto_req) {
778 crp->crp_etype = ENOMEM;
779 dprintk("%s,%d: ENOMEM ablkcipher_request_alloc",
780 __FILE__, __LINE__);
781 goto done;
782 }
783
784 ablkcipher_request_set_callback(req->crypto_req,
785 CRYPTO_TFM_REQ_MAY_BACKLOG, swcr_process_callback, req);
786
787 if (crd->crd_flags & CRD_F_KEY_EXPLICIT) {
788 int i, error;
789
790 if (debug) {
791 dprintk("%s key:", __FUNCTION__);
792 for (i = 0; i < (crd->crd_klen + 7) / 8; i++)
793 dprintk("%s0x%x", (i % 8) ? " " : "\n ",
794 crd->crd_key[i] & 0xff);
795 dprintk("\n");
796 }
797 /* OCF doesn't enforce keys */
798 crypto_ablkcipher_set_flags(__crypto_ablkcipher_cast(sw->sw_tfm),
799 CRYPTO_TFM_REQ_WEAK_KEY);
800 error = crypto_ablkcipher_setkey(
801 __crypto_ablkcipher_cast(sw->sw_tfm), crd->crd_key,
802 (crd->crd_klen + 7) / 8);
803 if (error) {
804 dprintk("cryptosoft: setkey failed %d (crt_flags=0x%x)\n",
805 error, sw->sw_tfm->crt_flags);
806 crp->crp_etype = -error;
807 }
808 }
809
810 if (crd->crd_flags & CRD_F_ENCRYPT) { /* encrypt */
811
812 if (crd->crd_flags & CRD_F_IV_EXPLICIT)
813 ivp = crd->crd_iv;
814 else
815 get_random_bytes(ivp, ivsize);
816 /*
817 * do we have to copy the IV back to the buffer ?
818 */
819 if ((crd->crd_flags & CRD_F_IV_PRESENT) == 0) {
820 crypto_copyback(crp->crp_flags, crp->crp_buf,
821 crd->crd_inject, ivsize, (caddr_t)ivp);
822 }
823 ablkcipher_request_set_crypt(req->crypto_req, req->sg, req->sg,
824 sg_len, ivp);
825 ret = crypto_ablkcipher_encrypt(req->crypto_req);
826
827 } else { /*decrypt */
828
829 if (crd->crd_flags & CRD_F_IV_EXPLICIT)
830 ivp = crd->crd_iv;
831 else
832 crypto_copydata(crp->crp_flags, crp->crp_buf,
833 crd->crd_inject, ivsize, (caddr_t)ivp);
834 ablkcipher_request_set_crypt(req->crypto_req, req->sg, req->sg,
835 sg_len, ivp);
836 ret = crypto_ablkcipher_decrypt(req->crypto_req);
837 }
838
839 switch (ret) {
840 case -EINPROGRESS:
841 case -EBUSY:
842 return;
843 default:
844 case 0:
845 dprintk("crypto OP %s %d\n", ret ? "failed" : "success", ret);
846 crp->crp_etype = ret;
847 goto done;
848 }
849 } break;
850 #endif /* HAVE_ABLKCIPHER */
851
852 case SW_TYPE_BLKCIPHER: {
853 unsigned char iv[EALG_MAX_BLOCK_LEN];
854 unsigned char *ivp = iv;
855 struct blkcipher_desc desc;
856 int ivsize = crypto_blkcipher_ivsize(crypto_blkcipher_cast(sw->sw_tfm));
857
858 if (sg_len < crypto_blkcipher_blocksize(
859 crypto_blkcipher_cast(sw->sw_tfm))) {
860 crp->crp_etype = EINVAL;
861 dprintk("%s,%d: EINVAL len %d < %d\n", __FILE__, __LINE__,
862 sg_len, crypto_blkcipher_blocksize(
863 crypto_blkcipher_cast(sw->sw_tfm)));
864 goto done;
865 }
866
867 if (ivsize > sizeof(iv)) {
868 crp->crp_etype = EINVAL;
869 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
870 goto done;
871 }
872
873 if (crd->crd_flags & CRD_F_KEY_EXPLICIT) {
874 int i, error;
875
876 if (debug) {
877 dprintk("%s key:", __FUNCTION__);
878 for (i = 0; i < (crd->crd_klen + 7) / 8; i++)
879 dprintk("%s0x%x", (i % 8) ? " " : "\n ",
880 crd->crd_key[i] & 0xff);
881 dprintk("\n");
882 }
883 /* OCF doesn't enforce keys */
884 crypto_blkcipher_set_flags(crypto_blkcipher_cast(sw->sw_tfm),
885 CRYPTO_TFM_REQ_WEAK_KEY);
886 error = crypto_blkcipher_setkey(
887 crypto_blkcipher_cast(sw->sw_tfm), crd->crd_key,
888 (crd->crd_klen + 7) / 8);
889 if (error) {
890 dprintk("cryptosoft: setkey failed %d (crt_flags=0x%x)\n",
891 error, sw->sw_tfm->crt_flags);
892 crp->crp_etype = -error;
893 }
894 }
895
896 memset(&desc, 0, sizeof(desc));
897 desc.tfm = crypto_blkcipher_cast(sw->sw_tfm);
898
899 if (crd->crd_flags & CRD_F_ENCRYPT) { /* encrypt */
900
901 if (crd->crd_flags & CRD_F_IV_EXPLICIT) {
902 ivp = crd->crd_iv;
903 } else {
904 get_random_bytes(ivp, ivsize);
905 }
906 /*
907 * do we have to copy the IV back to the buffer ?
908 */
909 if ((crd->crd_flags & CRD_F_IV_PRESENT) == 0) {
910 crypto_copyback(crp->crp_flags, crp->crp_buf,
911 crd->crd_inject, ivsize, (caddr_t)ivp);
912 }
913 desc.info = ivp;
914 crypto_blkcipher_encrypt_iv(&desc, req->sg, req->sg, sg_len);
915
916 } else { /*decrypt */
917
918 if (crd->crd_flags & CRD_F_IV_EXPLICIT) {
919 ivp = crd->crd_iv;
920 } else {
921 crypto_copydata(crp->crp_flags, crp->crp_buf,
922 crd->crd_inject, ivsize, (caddr_t)ivp);
923 }
924 desc.info = ivp;
925 crypto_blkcipher_decrypt_iv(&desc, req->sg, req->sg, sg_len);
926 }
927 } break;
928
929 case SW_TYPE_HMAC:
930 case SW_TYPE_HASH:
931 {
932 char result[HASH_MAX_LEN];
933 struct hash_desc desc;
934
935 /* check we have room for the result */
936 if (crp->crp_ilen - crd->crd_inject < sw->u.hmac.sw_mlen) {
937 dprintk("cryptosoft: EINVAL crp_ilen=%d, len=%d, inject=%d "
938 "digestsize=%d\n", crp->crp_ilen, crd->crd_skip + sg_len,
939 crd->crd_inject, sw->u.hmac.sw_mlen);
940 crp->crp_etype = EINVAL;
941 goto done;
942 }
943
944 memset(&desc, 0, sizeof(desc));
945 desc.tfm = crypto_hash_cast(sw->sw_tfm);
946
947 memset(result, 0, sizeof(result));
948
949 if (sw->sw_type & SW_TYPE_HMAC) {
950 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
951 crypto_hmac(sw->sw_tfm, sw->u.hmac.sw_key, &sw->u.hmac.sw_klen,
952 req->sg, sg_num, result);
953 #else
954 crypto_hash_setkey(desc.tfm, sw->u.hmac.sw_key,
955 sw->u.hmac.sw_klen);
956 crypto_hash_digest(&desc, req->sg, sg_len, result);
957 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) */
958
959 } else { /* SW_TYPE_HASH */
960 crypto_hash_digest(&desc, req->sg, sg_len, result);
961 }
962
963 crypto_copyback(crp->crp_flags, crp->crp_buf,
964 crd->crd_inject, sw->u.hmac.sw_mlen, result);
965 }
966 break;
967
968 case SW_TYPE_COMP: {
969 void *ibuf = NULL;
970 void *obuf = sw->u.sw_comp_buf;
971 int ilen = sg_len, olen = CRYPTO_MAX_DATA_LEN;
972 int ret = 0;
973
974 /*
975 * we need to use an additional copy if there is more than one
976 * input chunk since the kernel comp routines do not handle
977 * SG yet. Otherwise we just use the input buffer as is.
978 * Rather than allocate another buffer we just split the tmp
979 * buffer we already have.
980 * Perhaps we should just use zlib directly ?
981 */
982 if (sg_num > 1) {
983 int blk;
984
985 ibuf = obuf;
986 for (blk = 0; blk < sg_num; blk++) {
987 memcpy(obuf, sg_virt(&req->sg[blk]),
988 req->sg[blk].length);
989 obuf += req->sg[blk].length;
990 }
991 olen -= sg_len;
992 } else
993 ibuf = sg_virt(&req->sg[0]);
994
995 if (crd->crd_flags & CRD_F_ENCRYPT) { /* compress */
996 ret = crypto_comp_compress(crypto_comp_cast(sw->sw_tfm),
997 ibuf, ilen, obuf, &olen);
998 if (!ret && olen > crd->crd_len) {
999 dprintk("cryptosoft: ERANGE compress %d into %d\n",
1000 crd->crd_len, olen);
1001 if (swcr_fail_if_compression_grows)
1002 ret = ERANGE;
1003 }
1004 } else { /* decompress */
1005 ret = crypto_comp_decompress(crypto_comp_cast(sw->sw_tfm),
1006 ibuf, ilen, obuf, &olen);
1007 if (!ret && (olen + crd->crd_inject) > crp->crp_olen) {
1008 dprintk("cryptosoft: ETOOSMALL decompress %d into %d, "
1009 "space for %d,at offset %d\n",
1010 crd->crd_len, olen, crp->crp_olen, crd->crd_inject);
1011 ret = ETOOSMALL;
1012 }
1013 }
1014 if (ret)
1015 dprintk("%s,%d: ret = %d\n", __FILE__, __LINE__, ret);
1016
1017 /*
1018 * on success copy result back,
1019 * linux crpyto API returns -errno, we need to fix that
1020 */
1021 crp->crp_etype = ret < 0 ? -ret : ret;
1022 if (ret == 0) {
1023 /* copy back the result and return it's size */
1024 crypto_copyback(crp->crp_flags, crp->crp_buf,
1025 crd->crd_inject, olen, obuf);
1026 crp->crp_olen = olen;
1027 }
1028
1029
1030 } break;
1031
1032 default:
1033 /* Unknown/unsupported algorithm */
1034 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
1035 crp->crp_etype = EINVAL;
1036 goto done;
1037 }
1038
1039 done:
1040 crypto_done(crp);
1041 kmem_cache_free(swcr_req_cache, req);
1042 }
1043
1044
1045 /*
1046 * Process a crypto request.
1047 */
1048 static int
1049 swcr_process(device_t dev, struct cryptop *crp, int hint)
1050 {
1051 struct swcr_req *req = NULL;
1052 u_int32_t lid;
1053
1054 dprintk("%s()\n", __FUNCTION__);
1055 /* Sanity check */
1056 if (crp == NULL) {
1057 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
1058 return EINVAL;
1059 }
1060
1061 crp->crp_etype = 0;
1062
1063 if (crp->crp_desc == NULL || crp->crp_buf == NULL) {
1064 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
1065 crp->crp_etype = EINVAL;
1066 goto done;
1067 }
1068
1069 lid = crp->crp_sid & 0xffffffff;
1070 if (lid >= swcr_sesnum || lid == 0 || swcr_sessions == NULL ||
1071 swcr_sessions[lid] == NULL) {
1072 crp->crp_etype = ENOENT;
1073 dprintk("%s,%d: ENOENT\n", __FILE__, __LINE__);
1074 goto done;
1075 }
1076
1077 /*
1078 * do some error checking outside of the loop for SKB and IOV processing
1079 * this leaves us with valid skb or uiop pointers for later
1080 */
1081 if (crp->crp_flags & CRYPTO_F_SKBUF) {
1082 struct sk_buff *skb = (struct sk_buff *) crp->crp_buf;
1083 if (skb_shinfo(skb)->nr_frags >= SCATTERLIST_MAX) {
1084 printk("%s,%d: %d nr_frags > SCATTERLIST_MAX", __FILE__, __LINE__,
1085 skb_shinfo(skb)->nr_frags);
1086 goto done;
1087 }
1088 } else if (crp->crp_flags & CRYPTO_F_IOV) {
1089 struct uio *uiop = (struct uio *) crp->crp_buf;
1090 if (uiop->uio_iovcnt > SCATTERLIST_MAX) {
1091 printk("%s,%d: %d uio_iovcnt > SCATTERLIST_MAX", __FILE__, __LINE__,
1092 uiop->uio_iovcnt);
1093 goto done;
1094 }
1095 }
1096
1097 /*
1098 * setup a new request ready for queuing
1099 */
1100 req = kmem_cache_alloc(swcr_req_cache, SLAB_ATOMIC);
1101 if (req == NULL) {
1102 dprintk("%s,%d: ENOMEM\n", __FILE__, __LINE__);
1103 crp->crp_etype = ENOMEM;
1104 goto done;
1105 }
1106 memset(req, 0, sizeof(*req));
1107
1108 req->sw_head = swcr_sessions[lid];
1109 req->crp = crp;
1110 req->crd = crp->crp_desc;
1111
1112 swcr_process_req(req);
1113 return 0;
1114
1115 done:
1116 crypto_done(crp);
1117 if (req)
1118 kmem_cache_free(swcr_req_cache, req);
1119 return 0;
1120 }
1121
1122
1123 static int
1124 cryptosoft_init(void)
1125 {
1126 int i, sw_type, mode;
1127 char *algo;
1128
1129 dprintk("%s(%p)\n", __FUNCTION__, cryptosoft_init);
1130
1131 swcr_req_cache = kmem_cache_create("cryptosoft_req",
1132 sizeof(struct swcr_req), 0, SLAB_HWCACHE_ALIGN, NULL
1133 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
1134 , NULL
1135 #endif
1136 );
1137 if (!swcr_req_cache) {
1138 printk("cryptosoft: failed to create request cache\n");
1139 return -ENOENT;
1140 }
1141
1142 softc_device_init(&swcr_softc, "cryptosoft", 0, swcr_methods);
1143
1144 swcr_id = crypto_get_driverid(softc_get_device(&swcr_softc),
1145 CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_SYNC);
1146 if (swcr_id < 0) {
1147 printk("cryptosoft: Software crypto device cannot initialize!");
1148 return -ENODEV;
1149 }
1150
1151 #define REGISTER(alg) \
1152 crypto_register(swcr_id, alg, 0,0)
1153
1154 for (i = 0; i < sizeof(crypto_details)/sizeof(crypto_details[0]); i++) {
1155 int found;
1156
1157 algo = crypto_details[i].alg_name;
1158 if (!algo || !*algo) {
1159 dprintk("%s:Algorithm %d not supported\n", __FUNCTION__, i);
1160 continue;
1161 }
1162
1163 mode = crypto_details[i].mode;
1164 sw_type = crypto_details[i].sw_type;
1165
1166 found = 0;
1167 switch (sw_type & SW_TYPE_ALG_MASK) {
1168 case SW_TYPE_CIPHER:
1169 found = crypto_has_cipher(algo, 0, CRYPTO_ALG_ASYNC);
1170 break;
1171 case SW_TYPE_HMAC:
1172 found = crypto_has_hash(algo, 0, swcr_no_ahash?CRYPTO_ALG_ASYNC:0);
1173 break;
1174 case SW_TYPE_HASH:
1175 found = crypto_has_hash(algo, 0, swcr_no_ahash?CRYPTO_ALG_ASYNC:0);
1176 break;
1177 case SW_TYPE_COMP:
1178 found = crypto_has_comp(algo, 0, CRYPTO_ALG_ASYNC);
1179 break;
1180 case SW_TYPE_BLKCIPHER:
1181 found = crypto_has_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
1182 if (!found && !swcr_no_ablk)
1183 found = crypto_has_ablkcipher(algo, 0, 0);
1184 break;
1185 }
1186 if (found) {
1187 REGISTER(i);
1188 } else {
1189 dprintk("%s:Algorithm Type %d not supported (algorithm %d:'%s')\n",
1190 __FUNCTION__, sw_type, i, algo);
1191 }
1192 }
1193 return 0;
1194 }
1195
1196 static void
1197 cryptosoft_exit(void)
1198 {
1199 dprintk("%s()\n", __FUNCTION__);
1200 crypto_unregister_all(swcr_id);
1201 swcr_id = -1;
1202 kmem_cache_destroy(swcr_req_cache);
1203 }
1204
1205 late_initcall(cryptosoft_init);
1206 module_exit(cryptosoft_exit);
1207
1208 MODULE_LICENSE("Dual BSD/GPL");
1209 MODULE_AUTHOR("David McCullough <david_mccullough@securecomputing.com>");
1210 MODULE_DESCRIPTION("Cryptosoft (OCF module for kernel crypto)");
Personal OpenWRT clone
This page took 0.140854 seconds and 5 git commands to generate.