![[BACK]](/icons/back.gif){kind=icon}
Return to awi_wep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to awi_wep.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: awi_wep.c,v 1.13 2005/02/21 11:16:00 dlg Exp $ */
2: /* $NetBSD: awi_wep.c,v 1.2 2000/07/04 14:47:58 onoe Exp $ */
3:
4: /*
5: * Copyright (c) 2000 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Atsushi Onoe.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: /*
41: * WEP support framework for the awi driver.
42: *
43: * No actual encryption capability is provided here, but any can be added
44: * to awi_wep_algo table below.
45: *
46: * Note that IEEE802.11 specification states WEP uses RC4 with 40bit key,
47: * which is a proprietary encryption algorithm available under license
48: * from RSA Data Security Inc. Using another algorithm, includes null
49: * encryption provided here, the awi driver cannot be able to communicate
50: * with other stations.
51: */
52:
53: #include <sys/param.h>
54: #include <sys/systm.h>
55: #include <sys/kernel.h>
56: #include <sys/mbuf.h>
57: #include <sys/malloc.h>
58: #include <sys/proc.h>
59: #include <sys/socket.h>
60: #include <sys/errno.h>
61: #include <sys/sockio.h>
62: #if defined(__FreeBSD__) && __FreeBSD__ >= 4
63: #include <sys/bus.h>
64: #else
65: #include <sys/device.h>
66: #endif
67:
68: #include <net/if.h>
69: #include <net/if_dl.h>
70: #ifdef __FreeBSD__
71: #include <net/ethernet.h>
72: #include <net/if_arp.h>
73: #elif defined(__OpenBSD__)
74: #include <netinet/in.h>
75: #include <netinet/if_ether.h>
76: #else
77: #include <net/if_ether.h>
78: #endif
79: #include <net/if_media.h>
80: #include <net80211/ieee80211.h>
81: #include <net80211/ieee80211_ioctl.h>
82:
83: #include <machine/cpu.h>
84: #include <machine/bus.h>
85: #ifdef __FreeBSD__
86: #include <machine/clock.h>
87: #endif
88:
89: #if defined(__NetBSD__) || defined(__OpenBSD__)
90: #include <dev/ic/am79c930reg.h>
91: #include <dev/ic/am79c930var.h>
92: #include <dev/ic/awireg.h>
93: #include <dev/ic/awivar.h>
94: #include <dev/rndvar.h>
95: #endif
96:
97: #ifdef __OpenBSD__
98: #include <dev/rndvar.h>
99: #endif
100:
101: #ifdef __OpenBSD__
102: #include <dev/rndvar.h>
103: #endif
104:
105: #ifdef __NetBSD__
106: #include <crypto/arc4/arc4.h>
107: #endif
108:
109: #ifdef __FreeBSD__
110: #include <dev/awi/am79c930reg.h>
111: #include <dev/awi/am79c930var.h>
112: #include <dev/awi/awireg.h>
113: #include <dev/awi/awivar.h>
114:
115: #include <crypto/rc4/rc4.h>
116: static __inline int
117: arc4_ctxlen(void)
118: {
119: return sizeof(struct rc4_state);
120: }
121:
122: static __inline void
123: arc4_setkey(void *ctx, u_int8_t *key, int keylen)
124: {
125: rc4_init(ctx, key, keylen);
126: }
127:
128: static __inline void
129: arc4_encrypt(void *ctx, u_int8_t *dst, u_int8_t *src, int len)
130: {
131: rc4_crypt(ctx, dst, src, len);
132: }
133: #endif
134:
135: static void awi_crc_init(void);
136: static u_int32_t awi_crc_update(u_int32_t crc, u_int8_t *buf, int len);
137:
138: static int awi_null_ctxlen(void);
139: static void awi_null_setkey(void *ctx, u_int8_t *key, int keylen);
140: static void awi_null_copy(void *ctx, u_int8_t *dst, u_int8_t *src, int len);
141:
142: /* XXX: the order should be known to wiconfig/user */
143:
144: static struct awi_wep_algo awi_wep_algo[] = {
145: /* 0: no wep */
146: { "no" }, /* dummy for no wep */
147:
148: #if 0
149: /* 1: normal wep (arc4) */
150: { "arc4", arc4_ctxlen, arc4_setkey,
151: arc4_encrypt, arc4_encrypt },
152: #endif
153: /* 2: debug wep (null) */
154: { "null", awi_null_ctxlen, awi_null_setkey,
155: awi_null_copy, awi_null_copy },
156: /* dummy for wep without encryption */
157: };
158:
159: int
160: awi_wep_setnwkey(sc, nwkey)
161: struct awi_softc *sc;
162: struct ieee80211_nwkey *nwkey;
163: {
164: int i, len, error;
165: u_int8_t keybuf[AWI_MAX_KEYLEN];
166:
167: if (nwkey->i_defkid <= 0 ||
168: nwkey->i_defkid > IEEE80211_WEP_NKID)
169: return EINVAL;
170: error = 0;
171: for (i = 0; i < IEEE80211_WEP_NKID; i++) {
172: if (nwkey->i_key[i].i_keydat == NULL)
173: continue;
174: len = nwkey->i_key[i].i_keylen;
175: if (len > sizeof(keybuf)) {
176: error = EINVAL;
177: break;
178: }
179: error = copyin(nwkey->i_key[i].i_keydat, keybuf, len);
180: if (error)
181: break;
182: error = awi_wep_setkey(sc, i, keybuf, len);
183: if (error)
184: break;
185: }
186: if (error == 0) {
187: sc->sc_wep_defkid = nwkey->i_defkid - 1;
188: error = awi_wep_setalgo(sc, nwkey->i_wepon);
189: if (error == 0 && sc->sc_enabled) {
190: awi_stop(sc);
191: error = awi_init(sc);
192: }
193: }
194: return error;
195: }
196:
197: int
198: awi_wep_getnwkey(sc, nwkey)
199: struct awi_softc *sc;
200: struct ieee80211_nwkey *nwkey;
201: {
202: int i, len, error, suerr;
203: u_int8_t keybuf[AWI_MAX_KEYLEN];
204:
205: nwkey->i_wepon = awi_wep_getalgo(sc);
206: nwkey->i_defkid = sc->sc_wep_defkid + 1;
207: /* do not show any keys to non-root user */
208: #ifdef __FreeBSD__
209: suerr = suser(curproc);
210: #else
211: #ifdef __OpenBSD__
212: suerr = suser(curproc, 0);
213: #else
214: suerr = suser(curproc->p_ucred, &curproc->p_acflag);
215: #endif
216: #endif
217: error = 0;
218: for (i = 0; i < IEEE80211_WEP_NKID; i++) {
219: if (nwkey->i_key[i].i_keydat == NULL)
220: continue;
221: if (suerr) {
222: error = suerr;
223: break;
224: }
225: len = sizeof(keybuf);
226: error = awi_wep_getkey(sc, i, keybuf, &len);
227: if (error)
228: break;
229: if (nwkey->i_key[i].i_keylen < len) {
230: error = ENOSPC;
231: break;
232: }
233: nwkey->i_key[i].i_keylen = len;
234: error = copyout(keybuf, nwkey->i_key[i].i_keydat, len);
235: if (error)
236: break;
237: }
238: return error;
239: }
240:
241: int
242: awi_wep_getalgo(sc)
243: struct awi_softc *sc;
244: {
245:
246: if (sc->sc_wep_algo == NULL)
247: return 0;
248: return sc->sc_wep_algo - awi_wep_algo;
249: }
250:
251: int
252: awi_wep_setalgo(sc, algo)
253: struct awi_softc *sc;
254: int algo;
255: {
256: struct awi_wep_algo *awa;
257: int ctxlen;
258:
259: awi_crc_init(); /* XXX: not belongs here */
260: if (algo < 0 || algo >= sizeof(awi_wep_algo)/sizeof(awi_wep_algo[0]))
261: return EINVAL;
262: awa = &awi_wep_algo[algo];
263: if (awa->awa_name == NULL)
264: return EINVAL;
265: if (awa->awa_ctxlen == NULL) {
266: awa = NULL;
267: ctxlen = 0;
268: } else
269: ctxlen = awa->awa_ctxlen();
270: if (sc->sc_wep_ctx != NULL) {
271: free(sc->sc_wep_ctx, M_DEVBUF);
272: sc->sc_wep_ctx = NULL;
273: }
274: if (ctxlen) {
275: sc->sc_wep_ctx = malloc(ctxlen, M_DEVBUF, M_NOWAIT);
276: if (sc->sc_wep_ctx == NULL)
277: return ENOMEM;
278: }
279: sc->sc_wep_algo = awa;
280: return 0;
281: }
282:
283: int
284: awi_wep_setkey(sc, kid, key, keylen)
285: struct awi_softc *sc;
286: int kid;
287: unsigned char *key;
288: int keylen;
289: {
290:
291: if (kid < 0 || kid >= IEEE80211_WEP_NKID)
292: return EINVAL;
293: if (keylen < 0 || keylen + IEEE80211_WEP_IVLEN > AWI_MAX_KEYLEN)
294: return EINVAL;
295: sc->sc_wep_keylen[kid] = keylen;
296: if (keylen > 0)
297: memcpy(sc->sc_wep_key[kid] + IEEE80211_WEP_IVLEN, key, keylen);
298: return 0;
299: }
300:
301: int
302: awi_wep_getkey(sc, kid, key, keylen)
303: struct awi_softc *sc;
304: int kid;
305: unsigned char *key;
306: int *keylen;
307: {
308:
309: if (kid < 0 || kid >= IEEE80211_WEP_NKID)
310: return EINVAL;
311: if (*keylen < sc->sc_wep_keylen[kid])
312: return ENOSPC;
313: *keylen = sc->sc_wep_keylen[kid];
314: if (*keylen > 0)
315: memcpy(key, sc->sc_wep_key[kid] + IEEE80211_WEP_IVLEN, *keylen);
316: return 0;
317: }
318:
319: struct mbuf *
320: awi_wep_encrypt(sc, m0, txflag)
321: struct awi_softc *sc;
322: struct mbuf *m0;
323: int txflag;
324: {
325: struct mbuf *m, *n, *n0;
326: struct ieee80211_frame *wh;
327: struct awi_wep_algo *awa;
328: int left, len, moff, noff, keylen, kid;
329: u_int32_t iv, crc;
330: u_int8_t *key, *ivp;
331: void *ctx;
332: u_int8_t crcbuf[IEEE80211_WEP_CRCLEN];
333:
334: n0 = NULL;
335: awa = sc->sc_wep_algo;
336: if (awa == NULL)
337: goto fail;
338: ctx = sc->sc_wep_ctx;
339: m = m0;
340: left = m->m_pkthdr.len;
341: MGET(n, M_DONTWAIT, m->m_type);
342: n0 = n;
343: if (n == NULL)
344: goto fail;
345: M_DUP_PKTHDR(n, m);
346: len = IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN +
347: IEEE80211_WEP_CRCLEN;
348: if (txflag) {
349: n->m_pkthdr.len += len;
350: } else {
351: wh = mtod(n, struct ieee80211_frame *);
352: n->m_pkthdr.len -= len;
353: left -= len;
354: }
355: n->m_len = MHLEN;
356: if (n->m_pkthdr.len >= MINCLSIZE) {
357: MCLGET(n, M_DONTWAIT);
358: if (n->m_flags & M_EXT)
359: n->m_len = n->m_ext.ext_size;
360: }
361: len = sizeof(struct ieee80211_frame);
362: memcpy(mtod(n, caddr_t), mtod(m, caddr_t), len);
363: left -= len;
364: moff = len;
365: noff = len;
366: if (txflag) {
367: kid = sc->sc_wep_defkid;
368: wh = mtod(n, struct ieee80211_frame *);
369: wh->i_fc[1] |= IEEE80211_FC1_WEP;
370: iv = arc4random();
371: /*
372: * store IV, byte order is not the matter since it's random.
373: * assuming IEEE80211_WEP_IVLEN is 3
374: */
375: ivp = mtod(n, u_int8_t *) + noff;
376: ivp[0] = (iv >> 16) & 0xff;
377: ivp[1] = (iv >> 8) & 0xff;
378: ivp[2] = iv & 0xff;
379: ivp[3] = kid & 0x03; /* clear pad and keyid */
380: noff += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
381: } else {
382: ivp = mtod(m, u_int8_t *) + moff;
383: moff += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
384: kid = ivp[IEEE80211_WEP_IVLEN] & 0x03;
385: }
386: key = sc->sc_wep_key[kid];
387: keylen = sc->sc_wep_keylen[kid];
388: /* assuming IEEE80211_WEP_IVLEN is 3 */
389: key[0] = ivp[0];
390: key[1] = ivp[1];
391: key[2] = ivp[2];
392: awa->awa_setkey(ctx, key, IEEE80211_WEP_IVLEN + keylen);
393:
394: /* encrypt with calculating CRC */
395: crc = ~0;
396: while (left > 0) {
397: len = m->m_len - moff;
398: if (len == 0) {
399: m = m->m_next;
400: moff = 0;
401: continue;
402: }
403: if (len > n->m_len - noff) {
404: len = n->m_len - noff;
405: if (len == 0) {
406: MGET(n->m_next, M_DONTWAIT, n->m_type);
407: if (n->m_next == NULL)
408: goto fail;
409: n = n->m_next;
410: n->m_len = MLEN;
411: if (left >= MINCLSIZE) {
412: MCLGET(n, M_DONTWAIT);
413: if (n->m_flags & M_EXT)
414: n->m_len = n->m_ext.ext_size;
415: }
416: noff = 0;
417: continue;
418: }
419: }
420: if (len > left)
421: len = left;
422: if (txflag) {
423: awa->awa_encrypt(ctx, mtod(n, caddr_t) + noff,
424: mtod(m, caddr_t) + moff, len);
425: crc = awi_crc_update(crc, mtod(m, caddr_t) + moff, len);
426: } else {
427: awa->awa_decrypt(ctx, mtod(n, caddr_t) + noff,
428: mtod(m, caddr_t) + moff, len);
429: crc = awi_crc_update(crc, mtod(n, caddr_t) + noff, len);
430: }
431: left -= len;
432: moff += len;
433: noff += len;
434: }
435: crc = ~crc;
436: if (txflag) {
437: LE_WRITE_4(crcbuf, crc);
438: if (n->m_len >= noff + sizeof(crcbuf))
439: n->m_len = noff + sizeof(crcbuf);
440: else {
441: n->m_len = noff;
442: MGET(n->m_next, M_DONTWAIT, n->m_type);
443: if (n->m_next == NULL)
444: goto fail;
445: n = n->m_next;
446: n->m_len = sizeof(crcbuf);
447: noff = 0;
448: }
449: awa->awa_encrypt(ctx, mtod(n, caddr_t) + noff, crcbuf,
450: sizeof(crcbuf));
451: } else {
452: n->m_len = noff;
453: noff = 0;
454: for (; noff < sizeof(crcbuf); noff += len, m = m->m_next) {
455: if (m->m_len < moff + len)
456: len = m->m_len - moff;
457: if (len == 0)
458: continue;
459: awa->awa_decrypt(ctx, crcbuf + noff,
460: mtod(m, caddr_t) + moff, len);
461: }
462: if (crc != LE_READ_4(crcbuf))
463: goto fail;
464: }
465: m_freem(m0);
466: return n0;
467:
468: fail:
469: m_freem(m0);
470: m_freem(n0);
471: return NULL;
472: }
473:
474: /*
475: * CRC 32 -- routine from RFC 2083
476: */
477:
478: /* Table of CRCs of all 8-bit messages */
479: static u_int32_t awi_crc_table[256];
480: static int awi_crc_table_computed = 0;
481:
482: /* Make the table for a fast CRC. */
483: static void
484: awi_crc_init()
485: {
486: u_int32_t c;
487: int n, k;
488:
489: if (awi_crc_table_computed)
490: return;
491: for (n = 0; n < 256; n++) {
492: c = (u_int32_t)n;
493: for (k = 0; k < 8; k++) {
494: if (c & 1)
495: c = 0xedb88320UL ^ (c >> 1);
496: else
497: c = c >> 1;
498: }
499: awi_crc_table[n] = c;
500: }
501: awi_crc_table_computed = 1;
502: }
503:
504: /*
505: * Update a running CRC with the bytes buf[0..len-1]--the CRC
506: * should be initialized to all 1's, and the transmitted value
507: * is the 1's complement of the final running CRC
508: */
509:
510: static u_int32_t
511: awi_crc_update(crc, buf, len)
512: u_int32_t crc;
513: u_int8_t *buf;
514: int len;
515: {
516: u_int8_t *endbuf;
517:
518: for (endbuf = buf + len; buf < endbuf; buf++)
519: crc = awi_crc_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
520: return crc;
521: }
522:
523: /*
524: * Null -- do nothing but copy.
525: */
526:
527: static int
528: awi_null_ctxlen()
529: {
530:
531: return 0;
532: }
533:
534: static void
535: awi_null_setkey(ctx, key, keylen)
536: void *ctx;
537: u_char *key;
538: int keylen;
539: {
540: }
541:
542: static void
543: awi_null_copy(ctx, dst, src, len)
544: void *ctx;
545: u_char *dst;
546: u_char *src;
547: int len;
548: {
549:
550: memcpy(dst, src, len);
551: }