![[BACK]](/icons/back.gif){kind=icon}
Return to cryptosoft.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / crypto|
Return to cryptosoft.c CVS log | Up to [local] / sys / crypto |
1.1 nbrk 1: /* $OpenBSD: cryptosoft.c,v 1.46 2006/12/29 13:04:37 pedro Exp $ */
2:
3: /*
4: * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu)
5: *
6: * This code was written by Angelos D. Keromytis in Athens, Greece, in
7: * February 2000. Network Security Technologies Inc. (NSTI) kindly
8: * supported the development of this code.
9: *
10: * Copyright (c) 2000, 2001 Angelos D. Keromytis
11: *
12: * Permission to use, copy, and modify this software with or without fee
13: * is hereby granted, provided that this entire notice is included in
14: * all source code copies of any software which is or includes a copy or
15: * modification of this software.
16: *
17: * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
18: * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
19: * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
20: * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
21: * PURPOSE.
22: */
23:
24: #include <sys/param.h>
25: #include <sys/systm.h>
26: #include <sys/malloc.h>
27: #include <sys/mbuf.h>
28: #include <sys/sysctl.h>
29: #include <sys/errno.h>
30: #include <dev/rndvar.h>
31: #include <crypto/md5.h>
32: #include <crypto/sha1.h>
33: #include <crypto/rmd160.h>
34: #include <crypto/cast.h>
35: #include <crypto/skipjack.h>
36: #include <crypto/blf.h>
37: #include <crypto/cryptodev.h>
38: #include <crypto/cryptosoft.h>
39: #include <crypto/xform.h>
40:
41: u_int8_t hmac_ipad_buffer[64] = {
42: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
43: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
44: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
45: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
46: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
47: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
48: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
49: 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36
50: };
51:
52: u_int8_t hmac_opad_buffer[64] = {
53: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
54: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
55: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
56: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
57: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
58: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
59: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C,
60: 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C, 0x5C
61: };
62:
63:
64: struct swcr_data **swcr_sessions = NULL;
65: u_int32_t swcr_sesnum = 0;
66: int32_t swcr_id = -1;
67:
68: #define COPYBACK(x, a, b, c, d) \
69: (x) == CRYPTO_BUF_MBUF ? m_copyback((struct mbuf *)a,b,c,d) \
70: : cuio_copyback((struct uio *)a,b,c,d)
71: #define COPYDATA(x, a, b, c, d) \
72: (x) == CRYPTO_BUF_MBUF ? m_copydata((struct mbuf *)a,b,c,d) \
73: : cuio_copydata((struct uio *)a,b,c,d)
74:
75: /*
76: * Apply a symmetric encryption/decryption algorithm.
77: */
78: int
79: swcr_encdec(struct cryptodesc *crd, struct swcr_data *sw, caddr_t buf,
80: int outtype)
81: {
82: unsigned char iv[EALG_MAX_BLOCK_LEN], blk[EALG_MAX_BLOCK_LEN], *idat;
83: unsigned char *ivp, piv[EALG_MAX_BLOCK_LEN];
84: struct enc_xform *exf;
85: int i, k, j, blks, ind, count, ivlen;
86: struct mbuf *m = NULL;
87: struct uio *uio = NULL;
88:
89: exf = sw->sw_exf;
90: blks = exf->blocksize;
91: ivlen = exf->ivsize;
92:
93: /* Check for non-padded data */
94: if (crd->crd_len % blks)
95: return EINVAL;
96:
97: if (outtype == CRYPTO_BUF_MBUF)
98: m = (struct mbuf *) buf;
99: else
100: uio = (struct uio *) buf;
101:
102: /* Initialize the IV */
103: if (crd->crd_flags & CRD_F_ENCRYPT) {
104: /* IV explicitly provided ? */
105: if (crd->crd_flags & CRD_F_IV_EXPLICIT)
106: bcopy(crd->crd_iv, iv, ivlen);
107: else
108: arc4random_bytes(iv, ivlen);
109:
110: /* Do we need to write the IV */
111: if (!(crd->crd_flags & CRD_F_IV_PRESENT)) {
112: COPYBACK(outtype, buf, crd->crd_inject, ivlen, iv);
113: }
114:
115: } else { /* Decryption */
116: /* IV explicitly provided ? */
117: if (crd->crd_flags & CRD_F_IV_EXPLICIT)
118: bcopy(crd->crd_iv, iv, ivlen);
119: else {
120: /* Get IV off buf */
121: COPYDATA(outtype, buf, crd->crd_inject, ivlen, iv);
122: }
123: }
124:
125: ivp = iv;
126:
127: if (exf->reinit)
128: exf->reinit(sw->sw_kschedule, iv);
129:
130: if (outtype == CRYPTO_BUF_MBUF) {
131: /* Find beginning of data */
132: m = m_getptr(m, crd->crd_skip, &k);
133: if (m == NULL)
134: return EINVAL;
135:
136: i = crd->crd_len;
137:
138: while (i > 0) {
139: /*
140: * If there's insufficient data at the end of
141: * an mbuf, we have to do some copying.
142: */
143: if (m->m_len < k + blks && m->m_len != k) {
144: m_copydata(m, k, blks, blk);
145:
146: /* Actual encryption/decryption */
147: if (exf->reinit) {
148: exf->encrypt(sw->sw_kschedule, blk);
149: } else if (crd->crd_flags & CRD_F_ENCRYPT) {
150: /* XOR with previous block */
151: for (j = 0; j < blks; j++)
152: blk[j] ^= ivp[j];
153:
154: exf->encrypt(sw->sw_kschedule, blk);
155:
156: /*
157: * Keep encrypted block for XOR'ing
158: * with next block
159: */
160: bcopy(blk, iv, blks);
161: ivp = iv;
162: } else { /* decrypt */
163: /*
164: * Keep encrypted block for XOR'ing
165: * with next block
166: */
167: if (ivp == iv)
168: bcopy(blk, piv, blks);
169: else
170: bcopy(blk, iv, blks);
171:
172: exf->decrypt(sw->sw_kschedule, blk);
173:
174: /* XOR with previous block */
175: for (j = 0; j < blks; j++)
176: blk[j] ^= ivp[j];
177:
178: if (ivp == iv)
179: bcopy(piv, iv, blks);
180: else
181: ivp = iv;
182: }
183:
184: /* Copy back decrypted block */
185: m_copyback(m, k, blks, blk);
186:
187: /* Advance pointer */
188: m = m_getptr(m, k + blks, &k);
189: if (m == NULL)
190: return EINVAL;
191:
192: i -= blks;
193:
194: /* Could be done... */
195: if (i == 0)
196: break;
197: }
198:
199: /* Skip possibly empty mbufs */
200: if (k == m->m_len) {
201: for (m = m->m_next; m && m->m_len == 0;
202: m = m->m_next)
203: ;
204: k = 0;
205: }
206:
207: /* Sanity check */
208: if (m == NULL)
209: return EINVAL;
210:
211: /*
212: * Warning: idat may point to garbage here, but
213: * we only use it in the while() loop, only if
214: * there are indeed enough data.
215: */
216: idat = mtod(m, unsigned char *) + k;
217:
218: while (m->m_len >= k + blks && i > 0) {
219: if (exf->reinit) {
220: exf->encrypt(sw->sw_kschedule, idat);
221: } else if (crd->crd_flags & CRD_F_ENCRYPT) {
222: /* XOR with previous block/IV */
223: for (j = 0; j < blks; j++)
224: idat[j] ^= ivp[j];
225:
226: exf->encrypt(sw->sw_kschedule, idat);
227: ivp = idat;
228: } else { /* decrypt */
229: /*
230: * Keep encrypted block to be used
231: * in next block's processing.
232: */
233: if (ivp == iv)
234: bcopy(idat, piv, blks);
235: else
236: bcopy(idat, iv, blks);
237:
238: exf->decrypt(sw->sw_kschedule, idat);
239:
240: /* XOR with previous block/IV */
241: for (j = 0; j < blks; j++)
242: idat[j] ^= ivp[j];
243:
244: if (ivp == iv)
245: bcopy(piv, iv, blks);
246: else
247: ivp = iv;
248: }
249:
250: idat += blks;
251: k += blks;
252: i -= blks;
253: }
254: }
255: } else {
256: /* Find beginning of data */
257: count = crd->crd_skip;
258: ind = cuio_getptr(uio, count, &k);
259: if (ind == -1)
260: return EINVAL;
261:
262: i = crd->crd_len;
263:
264: while (i > 0) {
265: /*
266: * If there's insufficient data at the end,
267: * we have to do some copying.
268: */
269: if (uio->uio_iov[ind].iov_len < k + blks &&
270: uio->uio_iov[ind].iov_len != k) {
271: cuio_copydata(uio, k, blks, blk);
272:
273: /* Actual encryption/decryption */
274: if (exf->reinit) {
275: exf->encrypt(sw->sw_kschedule, blk);
276: } else if (crd->crd_flags & CRD_F_ENCRYPT) {
277: /* XOR with previous block */
278: for (j = 0; j < blks; j++)
279: blk[j] ^= ivp[j];
280:
281: exf->encrypt(sw->sw_kschedule, blk);
282:
283: /*
284: * Keep encrypted block for XOR'ing
285: * with next block
286: */
287: bcopy(blk, iv, blks);
288: ivp = iv;
289: } else { /* decrypt */
290: /*
291: * Keep encrypted block for XOR'ing
292: * with next block
293: */
294: if (ivp == iv)
295: bcopy(blk, piv, blks);
296: else
297: bcopy(blk, iv, blks);
298:
299: exf->decrypt(sw->sw_kschedule, blk);
300:
301: /* XOR with previous block */
302: for (j = 0; j < blks; j++)
303: blk[j] ^= ivp[j];
304:
305: if (ivp == iv)
306: bcopy(piv, iv, blks);
307: else
308: ivp = iv;
309: }
310:
311: /* Copy back decrypted block */
312: cuio_copyback(uio, k, blks, blk);
313:
314: count += blks;
315:
316: /* Advance pointer */
317: ind = cuio_getptr(uio, count, &k);
318: if (ind == -1)
319: return (EINVAL);
320:
321: i -= blks;
322:
323: /* Could be done... */
324: if (i == 0)
325: break;
326: }
327:
328: /*
329: * Warning: idat may point to garbage here, but
330: * we only use it in the while() loop, only if
331: * there are indeed enough data.
332: */
333: idat = (char *)uio->uio_iov[ind].iov_base + k;
334:
335: while (uio->uio_iov[ind].iov_len >= k + blks &&
336: i > 0) {
337: if (exf->reinit) {
338: exf->encrypt(sw->sw_kschedule, idat);
339: } else if (crd->crd_flags & CRD_F_ENCRYPT) {
340: /* XOR with previous block/IV */
341: for (j = 0; j < blks; j++)
342: idat[j] ^= ivp[j];
343:
344: exf->encrypt(sw->sw_kschedule, idat);
345: ivp = idat;
346: } else { /* decrypt */
347: /*
348: * Keep encrypted block to be used
349: * in next block's processing.
350: */
351: if (ivp == iv)
352: bcopy(idat, piv, blks);
353: else
354: bcopy(idat, iv, blks);
355:
356: exf->decrypt(sw->sw_kschedule, idat);
357:
358: /* XOR with previous block/IV */
359: for (j = 0; j < blks; j++)
360: idat[j] ^= ivp[j];
361:
362: if (ivp == iv)
363: bcopy(piv, iv, blks);
364: else
365: ivp = iv;
366: }
367:
368: idat += blks;
369: count += blks;
370: k += blks;
371: i -= blks;
372: }
373: }
374: }
375:
376: return 0; /* Done with encryption/decryption */
377: }
378:
379: /*
380: * Compute keyed-hash authenticator.
381: */
382: int
383: swcr_authcompute(struct cryptop *crp, struct cryptodesc *crd,
384: struct swcr_data *sw, caddr_t buf, int outtype)
385: {
386: unsigned char aalg[AALG_MAX_RESULT_LEN];
387: struct auth_hash *axf;
388: union authctx ctx;
389: int err;
390:
391: if (sw->sw_ictx == 0)
392: return EINVAL;
393:
394: axf = sw->sw_axf;
395:
396: bcopy(sw->sw_ictx, &ctx, axf->ctxsize);
397:
398: if (outtype == CRYPTO_BUF_MBUF)
399: err = m_apply((struct mbuf *) buf, crd->crd_skip, crd->crd_len,
400: (int (*)(caddr_t, caddr_t, unsigned int)) axf->Update,
401: (caddr_t) &ctx);
402: else
403: err = cuio_apply((struct uio *) buf, crd->crd_skip,
404: crd->crd_len,
405: (int (*)(caddr_t, caddr_t, unsigned int)) axf->Update,
406: (caddr_t) &ctx);
407:
408: if (err)
409: return err;
410:
411: switch (sw->sw_alg) {
412: case CRYPTO_MD5_HMAC:
413: case CRYPTO_SHA1_HMAC:
414: case CRYPTO_RIPEMD160_HMAC:
415: case CRYPTO_SHA2_256_HMAC:
416: case CRYPTO_SHA2_384_HMAC:
417: case CRYPTO_SHA2_512_HMAC:
418: if (sw->sw_octx == NULL)
419: return EINVAL;
420:
421: axf->Final(aalg, &ctx);
422: bcopy(sw->sw_octx, &ctx, axf->ctxsize);
423: axf->Update(&ctx, aalg, axf->hashsize);
424: axf->Final(aalg, &ctx);
425: break;
426:
427: case CRYPTO_MD5_KPDK:
428: case CRYPTO_SHA1_KPDK:
429: if (sw->sw_octx == NULL)
430: return EINVAL;
431:
432: axf->Update(&ctx, sw->sw_octx, sw->sw_klen);
433: axf->Final(aalg, &ctx);
434: break;
435:
436: case CRYPTO_MD5:
437: case CRYPTO_SHA1:
438: axf->Final(aalg, &ctx);
439: break;
440: }
441:
442: /* Inject the authentication data */
443: if (outtype == CRYPTO_BUF_MBUF)
444: COPYBACK(outtype, buf, crd->crd_inject, axf->authsize, aalg);
445: else
446: bcopy(aalg, crp->crp_mac, axf->authsize);
447:
448: return 0;
449: }
450:
451: /*
452: * Apply a compression/decompression algorithm
453: */
454: int
455: swcr_compdec(struct cryptodesc *crd, struct swcr_data *sw,
456: caddr_t buf, int outtype)
457: {
458: u_int8_t *data, *out;
459: struct comp_algo *cxf;
460: int adj;
461: u_int32_t result;
462:
463: cxf = sw->sw_cxf;
464:
465: /* We must handle the whole buffer of data in one time
466: * then if there is not all the data in the mbuf, we must
467: * copy in a buffer.
468: */
469:
470: MALLOC(data, u_int8_t *, crd->crd_len, M_CRYPTO_DATA, M_NOWAIT);
471: if (data == NULL)
472: return (EINVAL);
473: COPYDATA(outtype, buf, crd->crd_skip, crd->crd_len, data);
474:
475: if (crd->crd_flags & CRD_F_COMP)
476: result = cxf->compress(data, crd->crd_len, &out);
477: else
478: result = cxf->decompress(data, crd->crd_len, &out);
479:
480: FREE(data, M_CRYPTO_DATA);
481: if (result == 0)
482: return EINVAL;
483:
484: /* Copy back the (de)compressed data. m_copyback is
485: * extending the mbuf as necessary.
486: */
487: sw->sw_size = result;
488: /* Check the compressed size when doing compression */
489: if (crd->crd_flags & CRD_F_COMP) {
490: if (result > crd->crd_len) {
491: /* Compression was useless, we lost time */
492: FREE(out, M_CRYPTO_DATA);
493: return 0;
494: }
495: }
496:
497: COPYBACK(outtype, buf, crd->crd_skip, result, out);
498: if (result < crd->crd_len) {
499: adj = result - crd->crd_len;
500: if (outtype == CRYPTO_BUF_MBUF) {
501: adj = result - crd->crd_len;
502: m_adj((struct mbuf *)buf, adj);
503: } else {
504: struct uio *uio = (struct uio *)buf;
505: int ind;
506:
507: adj = crd->crd_len - result;
508: ind = uio->uio_iovcnt - 1;
509:
510: while (adj > 0 && ind >= 0) {
511: if (adj < uio->uio_iov[ind].iov_len) {
512: uio->uio_iov[ind].iov_len -= adj;
513: break;
514: }
515:
516: adj -= uio->uio_iov[ind].iov_len;
517: uio->uio_iov[ind].iov_len = 0;
518: ind--;
519: uio->uio_iovcnt--;
520: }
521: }
522: }
523: FREE(out, M_CRYPTO_DATA);
524: return 0;
525: }
526:
527: /*
528: * Generate a new software session.
529: */
530: int
531: swcr_newsession(u_int32_t *sid, struct cryptoini *cri)
532: {
533: struct swcr_data **swd;
534: struct auth_hash *axf;
535: struct enc_xform *txf;
536: struct comp_algo *cxf;
537: u_int32_t i;
538: int k;
539:
540: if (sid == NULL || cri == NULL)
541: return EINVAL;
542:
543: if (swcr_sessions) {
544: for (i = 1; i < swcr_sesnum; i++)
545: if (swcr_sessions[i] == NULL)
546: break;
547: }
548:
549: if (swcr_sessions == NULL || i == swcr_sesnum) {
550: if (swcr_sessions == NULL) {
551: i = 1; /* We leave swcr_sessions[0] empty */
552: swcr_sesnum = CRYPTO_SW_SESSIONS;
553: } else
554: swcr_sesnum *= 2;
555:
556: swd = malloc(swcr_sesnum * sizeof(struct swcr_data *),
557: M_CRYPTO_DATA, M_NOWAIT);
558: if (swd == NULL) {
559: /* Reset session number */
560: if (swcr_sesnum == CRYPTO_SW_SESSIONS)
561: swcr_sesnum = 0;
562: else
563: swcr_sesnum /= 2;
564: return ENOBUFS;
565: }
566:
567: bzero(swd, swcr_sesnum * sizeof(struct swcr_data *));
568:
569: /* Copy existing sessions */
570: if (swcr_sessions) {
571: bcopy(swcr_sessions, swd,
572: (swcr_sesnum / 2) * sizeof(struct swcr_data *));
573: free(swcr_sessions, M_CRYPTO_DATA);
574: }
575:
576: swcr_sessions = swd;
577: }
578:
579: swd = &swcr_sessions[i];
580: *sid = i;
581:
582: while (cri) {
583: MALLOC(*swd, struct swcr_data *, sizeof(struct swcr_data),
584: M_CRYPTO_DATA, M_NOWAIT);
585: if (*swd == NULL) {
586: swcr_freesession(i);
587: return ENOBUFS;
588: }
589: bzero(*swd, sizeof(struct swcr_data));
590:
591: switch (cri->cri_alg) {
592: case CRYPTO_DES_CBC:
593: txf = &enc_xform_des;
594: goto enccommon;
595: case CRYPTO_3DES_CBC:
596: txf = &enc_xform_3des;
597: goto enccommon;
598: case CRYPTO_BLF_CBC:
599: txf = &enc_xform_blf;
600: goto enccommon;
601: case CRYPTO_CAST_CBC:
602: txf = &enc_xform_cast5;
603: goto enccommon;
604: case CRYPTO_SKIPJACK_CBC:
605: txf = &enc_xform_skipjack;
606: goto enccommon;
607: case CRYPTO_RIJNDAEL128_CBC:
608: txf = &enc_xform_rijndael128;
609: goto enccommon;
610: case CRYPTO_AES_CTR:
611: txf = &enc_xform_aes_ctr;
612: goto enccommon;
613: case CRYPTO_NULL:
614: txf = &enc_xform_null;
615: goto enccommon;
616: enccommon:
617: if (txf->setkey(&((*swd)->sw_kschedule), cri->cri_key,
618: cri->cri_klen / 8) < 0) {
619: swcr_freesession(i);
620: return EINVAL;
621: }
622: (*swd)->sw_exf = txf;
623: break;
624:
625: case CRYPTO_MD5_HMAC:
626: axf = &auth_hash_hmac_md5_96;
627: goto authcommon;
628: case CRYPTO_SHA1_HMAC:
629: axf = &auth_hash_hmac_sha1_96;
630: goto authcommon;
631: case CRYPTO_RIPEMD160_HMAC:
632: axf = &auth_hash_hmac_ripemd_160_96;
633: goto authcommon;
634: case CRYPTO_SHA2_256_HMAC:
635: axf = &auth_hash_hmac_sha2_256_96;
636: goto authcommon;
637: case CRYPTO_SHA2_384_HMAC:
638: axf = &auth_hash_hmac_sha2_384_96;
639: goto authcommon;
640: case CRYPTO_SHA2_512_HMAC:
641: axf = &auth_hash_hmac_sha2_512_96;
642: authcommon:
643: (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
644: M_NOWAIT);
645: if ((*swd)->sw_ictx == NULL) {
646: swcr_freesession(i);
647: return ENOBUFS;
648: }
649:
650: (*swd)->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA,
651: M_NOWAIT);
652: if ((*swd)->sw_octx == NULL) {
653: swcr_freesession(i);
654: return ENOBUFS;
655: }
656:
657: for (k = 0; k < cri->cri_klen / 8; k++)
658: cri->cri_key[k] ^= HMAC_IPAD_VAL;
659:
660: axf->Init((*swd)->sw_ictx);
661: axf->Update((*swd)->sw_ictx, cri->cri_key,
662: cri->cri_klen / 8);
663: axf->Update((*swd)->sw_ictx, hmac_ipad_buffer,
664: HMAC_BLOCK_LEN - (cri->cri_klen / 8));
665:
666: for (k = 0; k < cri->cri_klen / 8; k++)
667: cri->cri_key[k] ^= (HMAC_IPAD_VAL ^ HMAC_OPAD_VAL);
668:
669: axf->Init((*swd)->sw_octx);
670: axf->Update((*swd)->sw_octx, cri->cri_key,
671: cri->cri_klen / 8);
672: axf->Update((*swd)->sw_octx, hmac_opad_buffer,
673: HMAC_BLOCK_LEN - (cri->cri_klen / 8));
674:
675: for (k = 0; k < cri->cri_klen / 8; k++)
676: cri->cri_key[k] ^= HMAC_OPAD_VAL;
677: (*swd)->sw_axf = axf;
678: break;
679:
680: case CRYPTO_MD5_KPDK:
681: axf = &auth_hash_key_md5;
682: goto auth2common;
683:
684: case CRYPTO_SHA1_KPDK:
685: axf = &auth_hash_key_sha1;
686: auth2common:
687: (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
688: M_NOWAIT);
689: if ((*swd)->sw_ictx == NULL) {
690: swcr_freesession(i);
691: return ENOBUFS;
692: }
693:
694: /* Store the key so we can "append" it to the payload */
695: (*swd)->sw_octx = malloc(cri->cri_klen / 8, M_CRYPTO_DATA,
696: M_NOWAIT);
697: if ((*swd)->sw_octx == NULL) {
698: swcr_freesession(i);
699: return ENOBUFS;
700: }
701:
702: (*swd)->sw_klen = cri->cri_klen / 8;
703: bcopy(cri->cri_key, (*swd)->sw_octx, cri->cri_klen / 8);
704: axf->Init((*swd)->sw_ictx);
705: axf->Update((*swd)->sw_ictx, cri->cri_key,
706: cri->cri_klen / 8);
707: axf->Final(NULL, (*swd)->sw_ictx);
708: (*swd)->sw_axf = axf;
709: break;
710:
711: case CRYPTO_MD5:
712: axf = &auth_hash_md5;
713: goto auth3common;
714:
715: case CRYPTO_SHA1:
716: axf = &auth_hash_sha1;
717: auth3common:
718: (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
719: M_NOWAIT);
720: if ((*swd)->sw_ictx == NULL) {
721: swcr_freesession(i);
722: return ENOBUFS;
723: }
724:
725: axf->Init((*swd)->sw_ictx);
726: (*swd)->sw_axf = axf;
727: break;
728:
729: case CRYPTO_DEFLATE_COMP:
730: cxf = &comp_algo_deflate;
731: (*swd)->sw_cxf = cxf;
732: break;
733: default:
734: swcr_freesession(i);
735: return EINVAL;
736: }
737:
738: (*swd)->sw_alg = cri->cri_alg;
739: cri = cri->cri_next;
740: swd = &((*swd)->sw_next);
741: }
742: return 0;
743: }
744:
745: /*
746: * Free a session.
747: */
748: int
749: swcr_freesession(u_int64_t tid)
750: {
751: struct swcr_data *swd;
752: struct enc_xform *txf;
753: struct auth_hash *axf;
754: u_int32_t sid = ((u_int32_t) tid) & 0xffffffff;
755:
756: if (sid > swcr_sesnum || swcr_sessions == NULL ||
757: swcr_sessions[sid] == NULL)
758: return EINVAL;
759:
760: /* Silently accept and return */
761: if (sid == 0)
762: return 0;
763:
764: while ((swd = swcr_sessions[sid]) != NULL) {
765: swcr_sessions[sid] = swd->sw_next;
766:
767: switch (swd->sw_alg) {
768: case CRYPTO_DES_CBC:
769: case CRYPTO_3DES_CBC:
770: case CRYPTO_BLF_CBC:
771: case CRYPTO_CAST_CBC:
772: case CRYPTO_SKIPJACK_CBC:
773: case CRYPTO_RIJNDAEL128_CBC:
774: case CRYPTO_AES_CTR:
775: case CRYPTO_NULL:
776: txf = swd->sw_exf;
777:
778: if (swd->sw_kschedule)
779: txf->zerokey(&(swd->sw_kschedule));
780: break;
781:
782: case CRYPTO_MD5_HMAC:
783: case CRYPTO_SHA1_HMAC:
784: case CRYPTO_RIPEMD160_HMAC:
785: case CRYPTO_SHA2_256_HMAC:
786: case CRYPTO_SHA2_384_HMAC:
787: case CRYPTO_SHA2_512_HMAC:
788: axf = swd->sw_axf;
789:
790: if (swd->sw_ictx) {
791: bzero(swd->sw_ictx, axf->ctxsize);
792: free(swd->sw_ictx, M_CRYPTO_DATA);
793: }
794: if (swd->sw_octx) {
795: bzero(swd->sw_octx, axf->ctxsize);
796: free(swd->sw_octx, M_CRYPTO_DATA);
797: }
798: break;
799:
800: case CRYPTO_MD5_KPDK:
801: case CRYPTO_SHA1_KPDK:
802: axf = swd->sw_axf;
803:
804: if (swd->sw_ictx) {
805: bzero(swd->sw_ictx, axf->ctxsize);
806: free(swd->sw_ictx, M_CRYPTO_DATA);
807: }
808: if (swd->sw_octx) {
809: bzero(swd->sw_octx, swd->sw_klen);
810: free(swd->sw_octx, M_CRYPTO_DATA);
811: }
812: break;
813:
814: case CRYPTO_MD5:
815: case CRYPTO_SHA1:
816: axf = swd->sw_axf;
817:
818: if (swd->sw_ictx)
819: free(swd->sw_ictx, M_CRYPTO_DATA);
820: break;
821: }
822:
823: FREE(swd, M_CRYPTO_DATA);
824: }
825: return 0;
826: }
827:
828: /*
829: * Process a software request.
830: */
831: int
832: swcr_process(struct cryptop *crp)
833: {
834: struct cryptodesc *crd;
835: struct swcr_data *sw;
836: u_int32_t lid;
837: int type;
838:
839: /* Sanity check */
840: if (crp == NULL)
841: return EINVAL;
842:
843: if (crp->crp_desc == NULL || crp->crp_buf == NULL) {
844: crp->crp_etype = EINVAL;
845: goto done;
846: }
847:
848: lid = crp->crp_sid & 0xffffffff;
849: if (lid >= swcr_sesnum || lid == 0 || swcr_sessions[lid] == NULL) {
850: crp->crp_etype = ENOENT;
851: goto done;
852: }
853:
854: if (crp->crp_flags & CRYPTO_F_IMBUF)
855: type = CRYPTO_BUF_MBUF;
856: else
857: type = CRYPTO_BUF_IOV;
858:
859: /* Go through crypto descriptors, processing as we go */
860: for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
861: /*
862: * Find the crypto context.
863: *
864: * XXX Note that the logic here prevents us from having
865: * XXX the same algorithm multiple times in a session
866: * XXX (or rather, we can but it won't give us the right
867: * XXX results). To do that, we'd need some way of differentiating
868: * XXX between the various instances of an algorithm (so we can
869: * XXX locate the correct crypto context).
870: */
871: for (sw = swcr_sessions[lid];
872: sw && sw->sw_alg != crd->crd_alg;
873: sw = sw->sw_next)
874: ;
875:
876: /* No such context ? */
877: if (sw == NULL) {
878: crp->crp_etype = EINVAL;
879: goto done;
880: }
881:
882: switch (sw->sw_alg) {
883: case CRYPTO_NULL:
884: break;
885: case CRYPTO_DES_CBC:
886: case CRYPTO_3DES_CBC:
887: case CRYPTO_BLF_CBC:
888: case CRYPTO_CAST_CBC:
889: case CRYPTO_SKIPJACK_CBC:
890: case CRYPTO_RIJNDAEL128_CBC:
891: case CRYPTO_AES_CTR:
892: if ((crp->crp_etype = swcr_encdec(crd, sw,
893: crp->crp_buf, type)) != 0)
894: goto done;
895: break;
896: case CRYPTO_MD5_HMAC:
897: case CRYPTO_SHA1_HMAC:
898: case CRYPTO_RIPEMD160_HMAC:
899: case CRYPTO_SHA2_256_HMAC:
900: case CRYPTO_SHA2_384_HMAC:
901: case CRYPTO_SHA2_512_HMAC:
902: case CRYPTO_MD5_KPDK:
903: case CRYPTO_SHA1_KPDK:
904: case CRYPTO_MD5:
905: case CRYPTO_SHA1:
906: if ((crp->crp_etype = swcr_authcompute(crp, crd, sw,
907: crp->crp_buf, type)) != 0)
908: goto done;
909: break;
910:
911: case CRYPTO_DEFLATE_COMP:
912: if ((crp->crp_etype = swcr_compdec(crd, sw,
913: crp->crp_buf, type)) != 0)
914: goto done;
915: else
916: crp->crp_olen = (int)sw->sw_size;
917: break;
918:
919: default:
920: /* Unknown/unsupported algorithm */
921: crp->crp_etype = EINVAL;
922: goto done;
923: }
924: }
925:
926: done:
927: crypto_done(crp);
928: return 0;
929: }
930:
931: /*
932: * Initialize the driver, called from the kernel main().
933: */
934: void
935: swcr_init(void)
936: {
937: int algs[CRYPTO_ALGORITHM_MAX + 1];
938: int flags = CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_ENCRYPT_MAC |
939: CRYPTOCAP_F_MAC_ENCRYPT;
940:
941: swcr_id = crypto_get_driverid(flags);
942: if (swcr_id < 0) {
943: /* This should never happen */
944: panic("Software crypto device cannot initialize!");
945: }
946:
947: bzero(algs, sizeof(algs));
948:
949: algs[CRYPTO_DES_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
950: algs[CRYPTO_3DES_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
951: algs[CRYPTO_BLF_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
952: algs[CRYPTO_CAST_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
953: algs[CRYPTO_SKIPJACK_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
954: algs[CRYPTO_MD5_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
955: algs[CRYPTO_SHA1_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
956: algs[CRYPTO_RIPEMD160_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
957: algs[CRYPTO_MD5_KPDK] = CRYPTO_ALG_FLAG_SUPPORTED;
958: algs[CRYPTO_SHA1_KPDK] = CRYPTO_ALG_FLAG_SUPPORTED;
959: algs[CRYPTO_MD5] = CRYPTO_ALG_FLAG_SUPPORTED;
960: algs[CRYPTO_SHA1] = CRYPTO_ALG_FLAG_SUPPORTED;
961: algs[CRYPTO_RIJNDAEL128_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
962: algs[CRYPTO_AES_CTR] = CRYPTO_ALG_FLAG_SUPPORTED;
963: algs[CRYPTO_DEFLATE_COMP] = CRYPTO_ALG_FLAG_SUPPORTED;
964: algs[CRYPTO_NULL] = CRYPTO_ALG_FLAG_SUPPORTED;
965: algs[CRYPTO_SHA2_256_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
966: algs[CRYPTO_SHA2_384_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
967: algs[CRYPTO_SHA2_512_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
968:
969: crypto_register(swcr_id, algs, swcr_newsession,
970: swcr_freesession, swcr_process);
971: }