projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ixp4xx: sync 2.6.32 kernel config
[openwrt.git] / target / linux / generic / files / crypto / ocf / cryptocteon / cryptocteon.c
1 /*
2 * Octeon Crypto for OCF
3 *
4 * Written by David McCullough <david_mccullough@mcafee.com>
5 * Copyright (C) 2009-2010 David McCullough
6 *
7 * LICENSE TERMS
8 *
9 * The free distribution and use of this software in both source and binary
10 * form is allowed (with or without changes) provided that:
11 *
12 * 1. distributions of this source code include the above copyright
13 * notice, this list of conditions and the following disclaimer;
14 *
15 * 2. distributions in binary form include the above copyright
16 * notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other associated materials;
18 *
19 * 3. the copyright holder's name is not used to endorse products
20 * built using this software without specific written permission.
21 *
22 * DISCLAIMER
23 *
24 * This software is provided 'as is' with no explicit or implied warranties
25 * in respect of its properties, including, but not limited to, correctness
26 * and/or fitness for purpose.
27 * ---------------------------------------------------------------------------
28 */
29
30 #ifndef AUTOCONF_INCLUDED
31 #include <linux/config.h>
32 #endif
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/list.h>
36 #include <linux/slab.h>
37 #include <linux/sched.h>
38 #include <linux/wait.h>
39 #include <linux/crypto.h>
40 #include <linux/mm.h>
41 #include <linux/skbuff.h>
42 #include <linux/random.h>
43 #include <linux/scatterlist.h>
44
45 #include <cryptodev.h>
46 #include <uio.h>
47
48 struct {
49 softc_device_decl sc_dev;
50 } octo_softc;
51
52 #define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)
53
54 struct octo_sess {
55 int octo_encalg;
56 #define MAX_CIPHER_KEYLEN 64
57 char octo_enckey[MAX_CIPHER_KEYLEN];
58 int octo_encklen;
59
60 int octo_macalg;
61 #define MAX_HASH_KEYLEN 64
62 char octo_mackey[MAX_HASH_KEYLEN];
63 int octo_macklen;
64 int octo_mackey_set;
65
66 int octo_mlen;
67 int octo_ivsize;
68
69 #if 0
70 int (*octo_decrypt)(struct scatterlist *sg, int sg_len,
71 uint8_t *key, int key_len, uint8_t * iv,
72 uint64_t *hminner, uint64_t *hmouter);
73
74 int (*octo_encrypt)(struct scatterlist *sg, int sg_len,
75 uint8_t *key, int key_len, uint8_t * iv,
76 uint64_t *hminner, uint64_t *hmouter);
77 #else
78 int (*octo_encrypt)(struct octo_sess *od,
79 struct scatterlist *sg, int sg_len,
80 int auth_off, int auth_len,
81 int crypt_off, int crypt_len,
82 int icv_off, uint8_t *ivp);
83 int (*octo_decrypt)(struct octo_sess *od,
84 struct scatterlist *sg, int sg_len,
85 int auth_off, int auth_len,
86 int crypt_off, int crypt_len,
87 int icv_off, uint8_t *ivp);
88 #endif
89
90 uint64_t octo_hminner[3];
91 uint64_t octo_hmouter[3];
92 };
93
94 int32_t octo_id = -1;
95 module_param(octo_id, int, 0444);
96 MODULE_PARM_DESC(octo_id, "Read-Only OCF ID for cryptocteon driver");
97
98 static struct octo_sess **octo_sessions = NULL;
99 static u_int32_t octo_sesnum = 0;
100
101 static int octo_process(device_t, struct cryptop *, int);
102 static int octo_newsession(device_t, u_int32_t *, struct cryptoini *);
103 static int octo_freesession(device_t, u_int64_t);
104
105 static device_method_t octo_methods = {
106 /* crypto device methods */
107 DEVMETHOD(cryptodev_newsession, octo_newsession),
108 DEVMETHOD(cryptodev_freesession,octo_freesession),
109 DEVMETHOD(cryptodev_process, octo_process),
110 };
111
112 #define debug octo_debug
113 int octo_debug = 0;
114 module_param(octo_debug, int, 0644);
115 MODULE_PARM_DESC(octo_debug, "Enable debug");
116
117
118 #include "cavium_crypto.c"
119
120
121 /*
122 * Generate a new octo session. We artifically limit it to a single
123 * hash/cipher or hash-cipher combo just to make it easier, most callers
124 * do not expect more than this anyway.
125 */
126 static int
127 octo_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri)
128 {
129 struct cryptoini *c, *encini = NULL, *macini = NULL;
130 struct octo_sess **ocd;
131 int i;
132
133 dprintk("%s()\n", __FUNCTION__);
134 if (sid == NULL || cri == NULL) {
135 dprintk("%s,%d - EINVAL\n", __FILE__, __LINE__);
136 return EINVAL;
137 }
138
139 /*
140 * To keep it simple, we only handle hash, cipher or hash/cipher in a
141 * session, you cannot currently do multiple ciphers/hashes in one
142 * session even though it would be possibel to code this driver to
143 * handle it.
144 */
145 for (i = 0, c = cri; c && i < 2; i++) {
146 if (c->cri_alg == CRYPTO_MD5_HMAC ||
147 c->cri_alg == CRYPTO_SHA1_HMAC ||
148 c->cri_alg == CRYPTO_NULL_HMAC) {
149 if (macini) {
150 break;
151 }
152 macini = c;
153 }
154 if (c->cri_alg == CRYPTO_DES_CBC ||
155 c->cri_alg == CRYPTO_3DES_CBC ||
156 c->cri_alg == CRYPTO_AES_CBC ||
157 c->cri_alg == CRYPTO_NULL_CBC) {
158 if (encini) {
159 break;
160 }
161 encini = c;
162 }
163 c = c->cri_next;
164 }
165 if (!macini && !encini) {
166 dprintk("%s,%d - EINVAL bad cipher/hash or combination\n",
167 __FILE__, __LINE__);
168 return EINVAL;
169 }
170 if (c) {
171 dprintk("%s,%d - EINVAL cannot handle chained cipher/hash combos\n",
172 __FILE__, __LINE__);
173 return EINVAL;
174 }
175
176 /*
177 * So we have something we can do, lets setup the session
178 */
179
180 if (octo_sessions) {
181 for (i = 1; i < octo_sesnum; i++)
182 if (octo_sessions[i] == NULL)
183 break;
184 } else
185 i = 1; /* NB: to silence compiler warning */
186
187 if (octo_sessions == NULL || i == octo_sesnum) {
188 if (octo_sessions == NULL) {
189 i = 1; /* We leave octo_sessions[0] empty */
190 octo_sesnum = CRYPTO_SW_SESSIONS;
191 } else
192 octo_sesnum *= 2;
193
194 ocd = kmalloc(octo_sesnum * sizeof(struct octo_sess *), SLAB_ATOMIC);
195 if (ocd == NULL) {
196 /* Reset session number */
197 if (octo_sesnum == CRYPTO_SW_SESSIONS)
198 octo_sesnum = 0;
199 else
200 octo_sesnum /= 2;
201 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
202 return ENOBUFS;
203 }
204 memset(ocd, 0, octo_sesnum * sizeof(struct octo_sess *));
205
206 /* Copy existing sessions */
207 if (octo_sessions) {
208 memcpy(ocd, octo_sessions,
209 (octo_sesnum / 2) * sizeof(struct octo_sess *));
210 kfree(octo_sessions);
211 }
212
213 octo_sessions = ocd;
214 }
215
216 ocd = &octo_sessions[i];
217 *sid = i;
218
219
220 *ocd = (struct octo_sess *) kmalloc(sizeof(struct octo_sess), SLAB_ATOMIC);
221 if (*ocd == NULL) {
222 octo_freesession(NULL, i);
223 dprintk("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
224 return ENOBUFS;
225 }
226 memset(*ocd, 0, sizeof(struct octo_sess));
227
228 if (encini && encini->cri_key) {
229 (*ocd)->octo_encklen = (encini->cri_klen + 7) / 8;
230 memcpy((*ocd)->octo_enckey, encini->cri_key, (*ocd)->octo_encklen);
231 }
232
233 if (macini && macini->cri_key) {
234 (*ocd)->octo_macklen = (macini->cri_klen + 7) / 8;
235 memcpy((*ocd)->octo_mackey, macini->cri_key, (*ocd)->octo_macklen);
236 }
237
238 (*ocd)->octo_mlen = 0;
239 if (encini && encini->cri_mlen)
240 (*ocd)->octo_mlen = encini->cri_mlen;
241 else if (macini && macini->cri_mlen)
242 (*ocd)->octo_mlen = macini->cri_mlen;
243 else
244 (*ocd)->octo_mlen = 12;
245
246 /*
247 * point c at the enc if it exists, otherwise the mac
248 */
249 c = encini ? encini : macini;
250
251 switch (c->cri_alg) {
252 case CRYPTO_DES_CBC:
253 case CRYPTO_3DES_CBC:
254 (*ocd)->octo_ivsize = 8;
255 switch (macini ? macini->cri_alg : -1) {
256 case CRYPTO_MD5_HMAC:
257 (*ocd)->octo_encrypt = octo_des_cbc_md5_encrypt;
258 (*ocd)->octo_decrypt = octo_des_cbc_md5_decrypt;
259 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
260 (*ocd)->octo_hmouter);
261 break;
262 case CRYPTO_SHA1_HMAC:
263 (*ocd)->octo_encrypt = octo_des_cbc_sha1_encrypt;
264 (*ocd)->octo_decrypt = octo_des_cbc_sha1_encrypt;
265 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
266 (*ocd)->octo_hmouter);
267 break;
268 case -1:
269 (*ocd)->octo_encrypt = octo_des_cbc_encrypt;
270 (*ocd)->octo_decrypt = octo_des_cbc_decrypt;
271 break;
272 default:
273 octo_freesession(NULL, i);
274 dprintk("%s,%d: EINVALn", __FILE__, __LINE__);
275 return EINVAL;
276 }
277 break;
278 case CRYPTO_AES_CBC:
279 (*ocd)->octo_ivsize = 16;
280 switch (macini ? macini->cri_alg : -1) {
281 case CRYPTO_MD5_HMAC:
282 (*ocd)->octo_encrypt = octo_aes_cbc_md5_encrypt;
283 (*ocd)->octo_decrypt = octo_aes_cbc_md5_decrypt;
284 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
285 (*ocd)->octo_hmouter);
286 break;
287 case CRYPTO_SHA1_HMAC:
288 (*ocd)->octo_encrypt = octo_aes_cbc_sha1_encrypt;
289 (*ocd)->octo_decrypt = octo_aes_cbc_sha1_decrypt;
290 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
291 (*ocd)->octo_hmouter);
292 break;
293 case -1:
294 (*ocd)->octo_encrypt = octo_aes_cbc_encrypt;
295 (*ocd)->octo_decrypt = octo_aes_cbc_decrypt;
296 break;
297 default:
298 octo_freesession(NULL, i);
299 dprintk("%s,%d: EINVALn", __FILE__, __LINE__);
300 return EINVAL;
301 }
302 break;
303 case CRYPTO_MD5_HMAC:
304 (*ocd)->octo_encrypt = octo_null_md5_encrypt;
305 (*ocd)->octo_decrypt = octo_null_md5_encrypt;
306 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
307 (*ocd)->octo_hmouter);
308 break;
309 case CRYPTO_SHA1_HMAC:
310 (*ocd)->octo_encrypt = octo_null_sha1_encrypt;
311 (*ocd)->octo_decrypt = octo_null_sha1_encrypt;
312 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
313 (*ocd)->octo_hmouter);
314 break;
315 default:
316 octo_freesession(NULL, i);
317 dprintk("%s,%d: EINVALn", __FILE__, __LINE__);
318 return EINVAL;
319 }
320
321 (*ocd)->octo_encalg = encini ? encini->cri_alg : -1;
322 (*ocd)->octo_macalg = macini ? macini->cri_alg : -1;
323
324 return 0;
325 }
326
327 /*
328 * Free a session.
329 */
330 static int
331 octo_freesession(device_t dev, u_int64_t tid)
332 {
333 u_int32_t sid = CRYPTO_SESID2LID(tid);
334
335 dprintk("%s()\n", __FUNCTION__);
336 if (sid > octo_sesnum || octo_sessions == NULL ||
337 octo_sessions[sid] == NULL) {
338 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
339 return(EINVAL);
340 }
341
342 /* Silently accept and return */
343 if (sid == 0)
344 return(0);
345
346 if (octo_sessions[sid])
347 kfree(octo_sessions[sid]);
348 octo_sessions[sid] = NULL;
349 return 0;
350 }
351
352 /*
353 * Process a request.
354 */
355 static int
356 octo_process(device_t dev, struct cryptop *crp, int hint)
357 {
358 struct cryptodesc *crd;
359 struct octo_sess *od;
360 u_int32_t lid;
361 #define SCATTERLIST_MAX 16
362 struct scatterlist sg[SCATTERLIST_MAX];
363 int sg_num, sg_len;
364 struct sk_buff *skb = NULL;
365 struct uio *uiop = NULL;
366 struct cryptodesc *enccrd = NULL, *maccrd = NULL;
367 unsigned char *ivp = NULL;
368 unsigned char iv_data[HASH_MAX_LEN];
369 int auth_off = 0, auth_len = 0, crypt_off = 0, crypt_len = 0, icv_off = 0;
370
371 dprintk("%s()\n", __FUNCTION__);
372 /* Sanity check */
373 if (crp == NULL) {
374 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
375 return EINVAL;
376 }
377
378 crp->crp_etype = 0;
379
380 if (crp->crp_desc == NULL || crp->crp_buf == NULL) {
381 dprintk("%s,%d: EINVAL\n", __FILE__, __LINE__);
382 crp->crp_etype = EINVAL;
383 goto done;
384 }
385
386 lid = crp->crp_sid & 0xffffffff;
387 if (lid >= octo_sesnum || lid == 0 || octo_sessions == NULL ||
388 octo_sessions[lid] == NULL) {
389 crp->crp_etype = ENOENT;
390 dprintk("%s,%d: ENOENT\n", __FILE__, __LINE__);
391 goto done;
392 }
393 od = octo_sessions[lid];
394
395 /*
396 * do some error checking outside of the loop for SKB and IOV processing
397 * this leaves us with valid skb or uiop pointers for later
398 */
399 if (crp->crp_flags & CRYPTO_F_SKBUF) {
400 skb = (struct sk_buff *) crp->crp_buf;
401 if (skb_shinfo(skb)->nr_frags >= SCATTERLIST_MAX) {
402 printk("%s,%d: %d nr_frags > SCATTERLIST_MAX", __FILE__, __LINE__,
403 skb_shinfo(skb)->nr_frags);
404 goto done;
405 }
406 } else if (crp->crp_flags & CRYPTO_F_IOV) {
407 uiop = (struct uio *) crp->crp_buf;
408 if (uiop->uio_iovcnt > SCATTERLIST_MAX) {
409 printk("%s,%d: %d uio_iovcnt > SCATTERLIST_MAX", __FILE__, __LINE__,
410 uiop->uio_iovcnt);
411 goto done;
412 }
413 }
414
415 /* point our enccrd and maccrd appropriately */
416 crd = crp->crp_desc;
417 if (crd->crd_alg == od->octo_encalg) enccrd = crd;
418 if (crd->crd_alg == od->octo_macalg) maccrd = crd;
419 crd = crd->crd_next;
420 if (crd) {
421 if (crd->crd_alg == od->octo_encalg) enccrd = crd;
422 if (crd->crd_alg == od->octo_macalg) maccrd = crd;
423 crd = crd->crd_next;
424 }
425 if (crd) {
426 crp->crp_etype = EINVAL;
427 dprintk("%s,%d: ENOENT - descriptors do not match session\n",
428 __FILE__, __LINE__);
429 goto done;
430 }
431
432 if (enccrd) {
433 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) {
434 ivp = enccrd->crd_iv;
435 } else {
436 ivp = iv_data;
437 crypto_copydata(crp->crp_flags, crp->crp_buf,
438 enccrd->crd_inject, od->octo_ivsize, (caddr_t) ivp);
439 }
440
441 if (maccrd) {
442 auth_off = maccrd->crd_skip;
443 auth_len = maccrd->crd_len;
444 icv_off = maccrd->crd_inject;
445 }
446
447 crypt_off = enccrd->crd_skip;
448 crypt_len = enccrd->crd_len;
449 } else { /* if (maccrd) */
450 auth_off = maccrd->crd_skip;
451 auth_len = maccrd->crd_len;
452 icv_off = maccrd->crd_inject;
453 }
454
455
456 /*
457 * setup the SG list to cover the buffer
458 */
459 memset(sg, 0, sizeof(sg));
460 if (crp->crp_flags & CRYPTO_F_SKBUF) {
461 int i, len;
462
463 sg_num = 0;
464 sg_len = 0;
465
466 len = skb_headlen(skb);
467 sg_set_page(&sg[sg_num], virt_to_page(skb->data), len,
468 offset_in_page(skb->data));
469 sg_len += len;
470 sg_num++;
471
472 for (i = 0; i < skb_shinfo(skb)->nr_frags && sg_num < SCATTERLIST_MAX;
473 i++) {
474 len = skb_shinfo(skb)->frags[i].size;
475 sg_set_page(&sg[sg_num], skb_shinfo(skb)->frags[i].page,
476 len, skb_shinfo(skb)->frags[i].page_offset);
477 sg_len += len;
478 sg_num++;
479 }
480 } else if (crp->crp_flags & CRYPTO_F_IOV) {
481 int len;
482
483 sg_len = 0;
484 for (sg_num = 0; sg_len < crp->crp_ilen &&
485 sg_num < uiop->uio_iovcnt &&
486 sg_num < SCATTERLIST_MAX; sg_num++) {
487 len = uiop->uio_iov[sg_num].iov_len;
488 sg_set_page(&sg[sg_num],
489 virt_to_page(uiop->uio_iov[sg_num].iov_base), len,
490 offset_in_page(uiop->uio_iov[sg_num].iov_base));
491 sg_len += len;
492 }
493 } else {
494 sg_len = crp->crp_ilen;
495 sg_set_page(&sg[0], virt_to_page(crp->crp_buf), sg_len,
496 offset_in_page(crp->crp_buf));
497 sg_num = 1;
498 }
499
500
501 /*
502 * setup a new explicit key
503 */
504 if (enccrd) {
505 if (enccrd->crd_flags & CRD_F_KEY_EXPLICIT) {
506 od->octo_encklen = (enccrd->crd_klen + 7) / 8;
507 memcpy(od->octo_enckey, enccrd->crd_key, od->octo_encklen);
508 }
509 }
510 if (maccrd) {
511 if (maccrd->crd_flags & CRD_F_KEY_EXPLICIT) {
512 od->octo_macklen = (maccrd->crd_klen + 7) / 8;
513 memcpy(od->octo_mackey, maccrd->crd_key, od->octo_macklen);
514 od->octo_mackey_set = 0;
515 }
516 if (!od->octo_mackey_set) {
517 octo_calc_hash(maccrd->crd_alg == CRYPTO_MD5_HMAC ? 0 : 1,
518 maccrd->crd_key, od->octo_hminner, od->octo_hmouter);
519 od->octo_mackey_set = 1;
520 }
521 }
522
523
524 if (!enccrd || (enccrd->crd_flags & CRD_F_ENCRYPT))
525 (*od->octo_encrypt)(od, sg, sg_len,
526 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
527 else
528 (*od->octo_decrypt)(od, sg, sg_len,
529 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
530
531 done:
532 crypto_done(crp);
533 return 0;
534 }
535
536 static int
537 cryptocteon_init(void)
538 {
539 dprintk("%s(%p)\n", __FUNCTION__, cryptocteon_init);
540
541 softc_device_init(&octo_softc, "cryptocteon", 0, octo_methods);
542
543 octo_id = crypto_get_driverid(softc_get_device(&octo_softc),
544 CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC);
545 if (octo_id < 0) {
546 printk("Cryptocteon device cannot initialize!");
547 return -ENODEV;
548 }
549
550 crypto_register(octo_id, CRYPTO_MD5_HMAC, 0,0);
551 crypto_register(octo_id, CRYPTO_SHA1_HMAC, 0,0);
552 //crypto_register(octo_id, CRYPTO_MD5, 0,0);
553 //crypto_register(octo_id, CRYPTO_SHA1, 0,0);
554 crypto_register(octo_id, CRYPTO_DES_CBC, 0,0);
555 crypto_register(octo_id, CRYPTO_3DES_CBC, 0,0);
556 crypto_register(octo_id, CRYPTO_AES_CBC, 0,0);
557
558 return(0);
559 }
560
561 static void
562 cryptocteon_exit(void)
563 {
564 dprintk("%s()\n", __FUNCTION__);
565 crypto_unregister_all(octo_id);
566 octo_id = -1;
567 }
568
569 module_init(cryptocteon_init);
570 module_exit(cryptocteon_exit);
571
572 MODULE_LICENSE("BSD");
573 MODULE_AUTHOR("David McCullough <david_mccullough@mcafee.com>");
574 MODULE_DESCRIPTION("Cryptocteon (OCF module for Cavium OCTEON crypto)");
Personal OpenWRT clone
This page took 0.07651 seconds and 5 git commands to generate.