![[BACK]](/icons/back.gif){kind=icon}
Return to via.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / i386 / i386|
Return to via.c CVS log | Up to [local] / sys / arch / i386 / i386 |
1.1 nbrk 1: /* $OpenBSD: via.c,v 1.12 2007/08/14 20:10:05 henric Exp $ */
2: /* $NetBSD: machdep.c,v 1.214 1996/11/10 03:16:17 thorpej Exp $ */
3:
4: /*-
5: * Copyright (c) 2003 Jason Wright
6: * Copyright (c) 2003, 2004 Theo de Raadt
7: * All rights reserved.
8: *
9: * Permission to use, copy, modify, and distribute this software for any
10: * purpose with or without fee is hereby granted, provided that the above
11: * copyright notice and this permission notice appear in all copies.
12: *
13: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20: */
21:
22: #include <sys/param.h>
23: #include <sys/systm.h>
24: #include <sys/signalvar.h>
25: #include <sys/kernel.h>
26: #include <sys/proc.h>
27: #include <sys/user.h>
28: #include <sys/exec.h>
29: #include <sys/buf.h>
30: #include <sys/reboot.h>
31: #include <sys/conf.h>
32: #include <sys/file.h>
33: #include <sys/timeout.h>
34: #include <sys/malloc.h>
35: #include <sys/mbuf.h>
36: #include <sys/extent.h>
37: #include <sys/sysctl.h>
38:
39: #ifdef CRYPTO
40: #include <crypto/cryptodev.h>
41: #include <crypto/rijndael.h>
42: #include <crypto/xform.h>
43: #include <crypto/cryptosoft.h>
44: #endif
45:
46: #include <uvm/uvm_extern.h>
47:
48: #include <machine/cpu.h>
49: #include <machine/cpufunc.h>
50: #include <machine/gdt.h>
51: #include <machine/pio.h>
52: #include <machine/bus.h>
53: #include <machine/psl.h>
54: #include <machine/reg.h>
55: #include <machine/specialreg.h>
56: #include <machine/biosvar.h>
57:
58: #include <dev/rndvar.h>
59:
60: void viac3_rnd(void *);
61:
62:
63: #ifdef CRYPTO
64:
65: struct viac3_session {
66: u_int32_t ses_ekey[4 * (AES_MAXROUNDS + 1) + 4]; /* 128 bit aligned */
67: u_int32_t ses_dkey[4 * (AES_MAXROUNDS + 1) + 4]; /* 128 bit aligned */
68: u_int8_t ses_iv[16]; /* 128 bit aligned */
69: u_int32_t ses_cw0;
70: struct swcr_data *swd;
71: int ses_klen;
72: int ses_used;
73: };
74:
75: struct viac3_softc {
76: u_int32_t op_cw[4]; /* 128 bit aligned */
77: u_int8_t op_iv[16]; /* 128 bit aligned */
78: void *op_buf;
79:
80: /* normal softc stuff */
81: int32_t sc_cid;
82: int sc_nsessions;
83: struct viac3_session *sc_sessions;
84: };
85:
86: #define VIAC3_SESSION(sid) ((sid) & 0x0fffffff)
87: #define VIAC3_SID(crd,ses) (((crd) << 28) | ((ses) & 0x0fffffff))
88:
89: static struct viac3_softc *vc3_sc;
90: extern int i386_has_xcrypt;
91:
92: extern u_int8_t hmac_ipad_buffer[64];
93: extern u_int8_t hmac_opad_buffer[64];
94:
95: void viac3_crypto_setup(void);
96: int viac3_crypto_newsession(u_int32_t *, struct cryptoini *);
97: int viac3_crypto_process(struct cryptop *);
98: int viac3_crypto_swauth(struct cryptop *, struct cryptodesc *,
99: struct swcr_data *, caddr_t);
100: int viac3_crypto_encdec(struct cryptop *, struct cryptodesc *,
101: struct viac3_session *, struct viac3_softc *, caddr_t);
102: int viac3_crypto_freesession(u_int64_t);
103: static __inline void viac3_cbc(void *, void *, void *, void *, int, void *);
104:
105: void
106: viac3_crypto_setup(void)
107: {
108: int algs[CRYPTO_ALGORITHM_MAX + 1];
109:
110: if ((vc3_sc = malloc(sizeof(*vc3_sc), M_DEVBUF, M_NOWAIT)) == NULL)
111: return; /* YYY bitch? */
112: bzero(vc3_sc, sizeof(*vc3_sc));
113:
114: bzero(algs, sizeof(algs));
115: algs[CRYPTO_AES_CBC] = CRYPTO_ALG_FLAG_SUPPORTED;
116: algs[CRYPTO_MD5_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
117: algs[CRYPTO_SHA1_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
118: algs[CRYPTO_RIPEMD160_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
119: algs[CRYPTO_SHA2_256_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
120: algs[CRYPTO_SHA2_384_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
121: algs[CRYPTO_SHA2_512_HMAC] = CRYPTO_ALG_FLAG_SUPPORTED;
122:
123: vc3_sc->sc_cid = crypto_get_driverid(0);
124: if (vc3_sc->sc_cid < 0)
125: return; /* YYY bitch? */
126:
127: crypto_register(vc3_sc->sc_cid, algs, viac3_crypto_newsession,
128: viac3_crypto_freesession, viac3_crypto_process);
129: }
130:
131: int
132: viac3_crypto_newsession(u_int32_t *sidp, struct cryptoini *cri)
133: {
134: struct cryptoini *c;
135: struct viac3_softc *sc = vc3_sc;
136: struct viac3_session *ses = NULL;
137: struct auth_hash *axf;
138: struct swcr_data *swd;
139: int sesn, i, cw0;
140:
141: if (sc == NULL || sidp == NULL || cri == NULL)
142: return (EINVAL);
143:
144: if (sc->sc_sessions == NULL) {
145: ses = sc->sc_sessions = malloc(sizeof(*ses), M_DEVBUF,
146: M_NOWAIT);
147: if (ses == NULL)
148: return (ENOMEM);
149: sesn = 0;
150: sc->sc_nsessions = 1;
151: } else {
152: for (sesn = 0; sesn < sc->sc_nsessions; sesn++) {
153: if (sc->sc_sessions[sesn].ses_used == 0) {
154: ses = &sc->sc_sessions[sesn];
155: break;
156: }
157: }
158:
159: if (ses == NULL) {
160: sesn = sc->sc_nsessions;
161: ses = malloc((sesn + 1) * sizeof(*ses), M_DEVBUF,
162: M_NOWAIT);
163: if (ses == NULL)
164: return (ENOMEM);
165: bcopy(sc->sc_sessions, ses, sesn * sizeof(*ses));
166: bzero(sc->sc_sessions, sesn * sizeof(*ses));
167: free(sc->sc_sessions, M_DEVBUF);
168: sc->sc_sessions = ses;
169: ses = &sc->sc_sessions[sesn];
170: sc->sc_nsessions++;
171: }
172: }
173:
174: bzero(ses, sizeof(*ses));
175: ses->ses_used = 1;
176:
177: for (c = cri; c != NULL; c = c->cri_next) {
178: switch (c->cri_alg) {
179: case CRYPTO_AES_CBC:
180: switch (c->cri_klen) {
181: case 128:
182: cw0 = C3_CRYPT_CWLO_KEY128;
183: break;
184: case 192:
185: cw0 = C3_CRYPT_CWLO_KEY192;
186: break;
187: case 256:
188: cw0 = C3_CRYPT_CWLO_KEY256;
189: break;
190: default:
191: viac3_crypto_freesession(sesn);
192: return (EINVAL);
193: }
194: cw0 |= C3_CRYPT_CWLO_ALG_AES | C3_CRYPT_CWLO_KEYGEN_SW |
195: C3_CRYPT_CWLO_NORMAL;
196:
197: get_random_bytes(ses->ses_iv, sizeof(ses->ses_iv));
198: ses->ses_klen = c->cri_klen;
199: ses->ses_cw0 = cw0;
200:
201: /* Build expanded keys for both directions */
202: rijndaelKeySetupEnc(ses->ses_ekey, c->cri_key,
203: c->cri_klen);
204: rijndaelKeySetupDec(ses->ses_dkey, c->cri_key,
205: c->cri_klen);
206: for (i = 0; i < 4 * (AES_MAXROUNDS + 1); i++) {
207: ses->ses_ekey[i] = ntohl(ses->ses_ekey[i]);
208: ses->ses_dkey[i] = ntohl(ses->ses_dkey[i]);
209: }
210:
211: break;
212:
213: case CRYPTO_MD5_HMAC:
214: axf = &auth_hash_hmac_md5_96;
215: goto authcommon;
216: case CRYPTO_SHA1_HMAC:
217: axf = &auth_hash_hmac_sha1_96;
218: goto authcommon;
219: case CRYPTO_RIPEMD160_HMAC:
220: axf = &auth_hash_hmac_ripemd_160_96;
221: goto authcommon;
222: case CRYPTO_SHA2_256_HMAC:
223: axf = &auth_hash_hmac_sha2_256_96;
224: goto authcommon;
225: case CRYPTO_SHA2_384_HMAC:
226: axf = &auth_hash_hmac_sha2_384_96;
227: goto authcommon;
228: case CRYPTO_SHA2_512_HMAC:
229: axf = &auth_hash_hmac_sha2_512_96;
230: authcommon:
231: MALLOC(swd, struct swcr_data *,
232: sizeof(struct swcr_data), M_CRYPTO_DATA,
233: M_NOWAIT);
234: if (swd == NULL) {
235: viac3_crypto_freesession(sesn);
236: return (ENOMEM);
237: }
238: bzero(swd, sizeof(struct swcr_data));
239: ses->swd = swd;
240:
241: swd->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA,
242: M_NOWAIT);
243: if (swd->sw_ictx == NULL) {
244: viac3_crypto_freesession(sesn);
245: return (ENOMEM);
246: }
247:
248: swd->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA,
249: M_NOWAIT);
250: if (swd->sw_octx == NULL) {
251: viac3_crypto_freesession(sesn);
252: return (ENOMEM);
253: }
254:
255: for (i = 0; i < c->cri_klen / 8; i++)
256: c->cri_key[i] ^= HMAC_IPAD_VAL;
257:
258: axf->Init(swd->sw_ictx);
259: axf->Update(swd->sw_ictx, c->cri_key, c->cri_klen / 8);
260: axf->Update(swd->sw_ictx, hmac_ipad_buffer,
261: HMAC_BLOCK_LEN - (c->cri_klen / 8));
262:
263: for (i = 0; i < c->cri_klen / 8; i++)
264: c->cri_key[i] ^= (HMAC_IPAD_VAL ^
265: HMAC_OPAD_VAL);
266:
267: axf->Init(swd->sw_octx);
268: axf->Update(swd->sw_octx, c->cri_key, c->cri_klen / 8);
269: axf->Update(swd->sw_octx, hmac_opad_buffer,
270: HMAC_BLOCK_LEN - (c->cri_klen / 8));
271:
272: for (i = 0; i < c->cri_klen / 8; i++)
273: c->cri_key[i] ^= HMAC_OPAD_VAL;
274:
275: swd->sw_axf = axf;
276: swd->sw_alg = c->cri_alg;
277:
278: break;
279: default:
280: viac3_crypto_freesession(sesn);
281: return (EINVAL);
282: }
283: }
284:
285: *sidp = VIAC3_SID(0, sesn);
286: return (0);
287: }
288:
289: int
290: viac3_crypto_freesession(u_int64_t tid)
291: {
292: struct viac3_softc *sc = vc3_sc;
293: struct swcr_data *swd;
294: struct auth_hash *axf;
295: int sesn;
296: u_int32_t sid = ((u_int32_t)tid) & 0xffffffff;
297:
298: if (sc == NULL)
299: return (EINVAL);
300: sesn = VIAC3_SESSION(sid);
301: if (sesn >= sc->sc_nsessions)
302: return (EINVAL);
303:
304: if (sc->sc_sessions[sesn].swd) {
305: swd = sc->sc_sessions[sesn].swd;
306: axf = swd->sw_axf;
307:
308: if (swd->sw_ictx) {
309: bzero(swd->sw_ictx, axf->ctxsize);
310: free(swd->sw_ictx, M_CRYPTO_DATA);
311: }
312: if (swd->sw_octx) {
313: bzero(swd->sw_octx, axf->ctxsize);
314: free(swd->sw_octx, M_CRYPTO_DATA);
315: }
316: FREE(swd, M_CRYPTO_DATA);
317: }
318:
319: bzero(&sc->sc_sessions[sesn], sizeof(sc->sc_sessions[sesn]));
320: return (0);
321: }
322:
323: static __inline void
324: viac3_cbc(void *cw, void *src, void *dst, void *key, int rep,
325: void *iv)
326: {
327: unsigned int creg0;
328:
329: creg0 = rcr0(); /* Permit access to SIMD/FPU path */
330: lcr0(creg0 & ~(CR0_EM|CR0_TS));
331:
332: /* Do the deed */
333: __asm __volatile("pushfl; popfl");
334: __asm __volatile("rep xcrypt-cbc" :
335: : "a" (iv), "b" (key), "c" (rep), "d" (cw), "S" (src), "D" (dst)
336: : "memory", "cc");
337:
338: lcr0(creg0);
339: }
340:
341: int
342: viac3_crypto_swauth(struct cryptop *crp, struct cryptodesc *crd,
343: struct swcr_data *sw, caddr_t buf)
344: {
345: int type;
346:
347: if (crp->crp_flags & CRYPTO_F_IMBUF)
348: type = CRYPTO_BUF_MBUF;
349: else
350: type= CRYPTO_BUF_IOV;
351:
352: return (swcr_authcompute(crp, crd, sw, buf, type));
353: }
354:
355: int
356: viac3_crypto_encdec(struct cryptop *crp, struct cryptodesc *crd,
357: struct viac3_session *ses, struct viac3_softc *sc, caddr_t buf)
358: {
359: u_int32_t *key;
360: int err = 0;
361:
362: if ((crd->crd_len % 16) != 0) {
363: err = EINVAL;
364: return (err);
365: }
366:
367: sc->op_buf = malloc(crd->crd_len, M_DEVBUF, M_NOWAIT);
368: if (sc->op_buf == NULL) {
369: err = ENOMEM;
370: return (err);
371: }
372:
373: if (crd->crd_flags & CRD_F_ENCRYPT) {
374: sc->op_cw[0] = ses->ses_cw0 | C3_CRYPT_CWLO_ENCRYPT;
375: key = ses->ses_ekey;
376: if (crd->crd_flags & CRD_F_IV_EXPLICIT)
377: bcopy(crd->crd_iv, sc->op_iv, 16);
378: else
379: bcopy(ses->ses_iv, sc->op_iv, 16);
380:
381: if ((crd->crd_flags & CRD_F_IV_PRESENT) == 0) {
382: if (crp->crp_flags & CRYPTO_F_IMBUF)
383: m_copyback((struct mbuf *)crp->crp_buf,
384: crd->crd_inject, 16, sc->op_iv);
385: else if (crp->crp_flags & CRYPTO_F_IOV)
386: cuio_copyback((struct uio *)crp->crp_buf,
387: crd->crd_inject, 16, sc->op_iv);
388: else
389: bcopy(sc->op_iv,
390: crp->crp_buf + crd->crd_inject, 16);
391: }
392: } else {
393: sc->op_cw[0] = ses->ses_cw0 | C3_CRYPT_CWLO_DECRYPT;
394: key = ses->ses_dkey;
395: if (crd->crd_flags & CRD_F_IV_EXPLICIT)
396: bcopy(crd->crd_iv, sc->op_iv, 16);
397: else {
398: if (crp->crp_flags & CRYPTO_F_IMBUF)
399: m_copydata((struct mbuf *)crp->crp_buf,
400: crd->crd_inject, 16, sc->op_iv);
401: else if (crp->crp_flags & CRYPTO_F_IOV)
402: cuio_copydata((struct uio *)crp->crp_buf,
403: crd->crd_inject, 16, sc->op_iv);
404: else
405: bcopy(crp->crp_buf + crd->crd_inject,
406: sc->op_iv, 16);
407: }
408: }
409:
410: if (crp->crp_flags & CRYPTO_F_IMBUF)
411: m_copydata((struct mbuf *)crp->crp_buf,
412: crd->crd_skip, crd->crd_len, sc->op_buf);
413: else if (crp->crp_flags & CRYPTO_F_IOV)
414: cuio_copydata((struct uio *)crp->crp_buf,
415: crd->crd_skip, crd->crd_len, sc->op_buf);
416: else
417: bcopy(crp->crp_buf + crd->crd_skip, sc->op_buf, crd->crd_len);
418:
419: sc->op_cw[1] = sc->op_cw[2] = sc->op_cw[3] = 0;
420: viac3_cbc(&sc->op_cw, sc->op_buf, sc->op_buf, key,
421: crd->crd_len / 16, sc->op_iv);
422:
423: if (crp->crp_flags & CRYPTO_F_IMBUF)
424: m_copyback((struct mbuf *)crp->crp_buf,
425: crd->crd_skip, crd->crd_len, sc->op_buf);
426: else if (crp->crp_flags & CRYPTO_F_IOV)
427: cuio_copyback((struct uio *)crp->crp_buf,
428: crd->crd_skip, crd->crd_len, sc->op_buf);
429: else
430: bcopy(sc->op_buf, crp->crp_buf + crd->crd_skip,
431: crd->crd_len);
432:
433: /* copy out last block for use as next session IV */
434: if (crd->crd_flags & CRD_F_ENCRYPT) {
435: if (crp->crp_flags & CRYPTO_F_IMBUF)
436: m_copydata((struct mbuf *)crp->crp_buf,
437: crd->crd_skip + crd->crd_len - 16, 16,
438: ses->ses_iv);
439: else if (crp->crp_flags & CRYPTO_F_IOV)
440: cuio_copydata((struct uio *)crp->crp_buf,
441: crd->crd_skip + crd->crd_len - 16, 16,
442: ses->ses_iv);
443: else
444: bcopy(crp->crp_buf + crd->crd_skip +
445: crd->crd_len - 16, ses->ses_iv, 16);
446: }
447:
448: if (sc->op_buf != NULL) {
449: bzero(sc->op_buf, crd->crd_len);
450: free(sc->op_buf, M_DEVBUF);
451: sc->op_buf = NULL;
452: }
453:
454: return (err);
455: }
456:
457: int
458: viac3_crypto_process(struct cryptop *crp)
459: {
460: struct viac3_softc *sc = vc3_sc;
461: struct viac3_session *ses;
462: struct cryptodesc *crd;
463: int sesn, err = 0;
464:
465: if (crp == NULL || crp->crp_callback == NULL) {
466: err = EINVAL;
467: goto out;
468: }
469:
470: sesn = VIAC3_SESSION(crp->crp_sid);
471: if (sesn >= sc->sc_nsessions) {
472: err = EINVAL;
473: goto out;
474: }
475: ses = &sc->sc_sessions[sesn];
476:
477: for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
478: switch (crd->crd_alg) {
479: case CRYPTO_AES_CBC:
480: if ((err = viac3_crypto_encdec(crp, crd, ses, sc,
481: crp->crp_buf)) != 0)
482: goto out;
483: break;
484:
485: case CRYPTO_MD5_HMAC:
486: case CRYPTO_SHA1_HMAC:
487: case CRYPTO_RIPEMD160_HMAC:
488: case CRYPTO_SHA2_256_HMAC:
489: case CRYPTO_SHA2_384_HMAC:
490: case CRYPTO_SHA2_512_HMAC:
491: if ((err = viac3_crypto_swauth(crp, crd, ses->swd,
492: crp->crp_buf)) != 0)
493: goto out;
494: break;
495:
496: default:
497: err = EINVAL;
498: goto out;
499: }
500: }
501: out:
502: crp->crp_etype = err;
503: crypto_done(crp);
504: return (err);
505: }
506:
507: #endif /* CRYPTO */
508:
509: #if defined(I686_CPU)
510: /*
511: * Note, the VIA C3 Nehemiah provides 4 internal 8-byte buffers, which
512: * store random data, and can be accessed a lot quicker than waiting
513: * for new data to be generated. As we are using every 8th bit only
514: * due to whitening. Since the RNG generates in excess of 21KB/s at
515: * its worst, collecting 64 bytes worth of entropy should not affect
516: * things significantly.
517: *
518: * Note, due to some weirdness in the RNG, we need at least 7 bytes
519: * extra on the end of our buffer. Also, there is an outside chance
520: * that the VIA RNG can "wedge", as the generated bit-rate is variable.
521: * We could do all sorts of startup testing and things, but
522: * frankly, I don't really see the point. If the RNG wedges, then the
523: * chances of you having a defective CPU are very high. Let it wedge.
524: *
525: * Adding to the whole confusion, in order to access the RNG, we need
526: * to have FXSR support enabled, and the correct FPU enable bits must
527: * be there to enable the FPU in kernel. It would be nice if all this
528: * mumbo-jumbo was not needed in order to use the RNG. Oh well, life
529: * does go on...
530: */
531: #define VIAC3_RNG_BUFSIZ 16 /* 32bit words */
532: struct timeout viac3_rnd_tmo;
533: int viac3_rnd_present;
534:
535: void
536: viac3_rnd(void *v)
537: {
538: struct timeout *tmo = v;
539: unsigned int *p, i, rv, creg0, len = VIAC3_RNG_BUFSIZ;
540: static int buffer[VIAC3_RNG_BUFSIZ + 2]; /* XXX why + 2? */
541: #ifdef MULTIPROCESSOR
542: int s = splipi();
543: #endif
544:
545: creg0 = rcr0(); /* Permit access to SIMD/FPU path */
546: lcr0(creg0 & ~(CR0_EM|CR0_TS));
547:
548: /*
549: * Here we collect the random data from the VIA C3 RNG. We make
550: * sure that we turn on maximum whitening (%edx[0,1] == "11"), so
551: * that we get the best random data possible.
552: */
553: __asm __volatile("rep xstore-rng"
554: : "=a" (rv) : "d" (3), "D" (buffer), "c" (len*sizeof(int))
555: : "memory", "cc");
556:
557: lcr0(creg0);
558:
559: #ifdef MULTIPROCESSOR
560: splx(s);
561: #endif
562:
563: for (i = 0, p = buffer; i < VIAC3_RNG_BUFSIZ; i++, p++)
564: add_true_randomness(*p);
565:
566: timeout_add(tmo, (hz > 100) ? (hz / 100) : 1);
567: }
568:
569: #endif /* defined(I686_CPU) */