Annotation of embedaddon/mpd/src/eap.c, revision 1.1.1.3
1.1 misho 1: /*
2: * See ``COPYRIGHT.mpd''
3: *
1.1.1.3 ! misho 4: * $Id: eap.c,v 1.34 2008/10/30 11:41:39 amotin Exp $
1.1 misho 5: *
6: */
7:
8: #include "ppp.h"
9: #include "radius.h"
10: #include "auth.h"
11: #include "ngfunc.h"
12:
13: /*
14: * INTERNAL FUNCTIONS
15: */
16:
17: static void EapSendRequest(Link l, u_char type);
18: static void EapSendNak(Link l, u_char id, u_char type);
19: static void EapSendIdentRequest(Link l);
20: static void EapIdentTimeout(void *ptr);
21: static char EapTypeSupported(u_char type);
22: static void EapRadiusProxy(Link l, AuthData auth, const u_char *pkt, u_short len);
23: static void EapRadiusProxyFinish(Link l, AuthData auth);
24: static void EapRadiusSendMsg(void *ptr);
25: static void EapRadiusSendMsgTimeout(void *ptr);
26: static int EapSetCommand(Context ctx, int ac, char *av[], void *arg);
27:
28: /* Set menu options */
29: enum {
30: SET_ACCEPT,
31: SET_DENY,
32: SET_ENABLE,
33: SET_DISABLE,
34: SET_YES,
35: SET_NO
36: };
37:
38: /*
39: * GLOBAL VARIABLES
40: */
41:
42: const struct cmdtab EapSetCmds[] = {
43: { "accept [opt ...]", "Accept option",
44: EapSetCommand, NULL, 2, (void *) SET_ACCEPT },
45: { "deny [opt ...]", "Deny option",
46: EapSetCommand, NULL, 2, (void *) SET_DENY },
47: { "enable [opt ...]", "Enable option",
48: EapSetCommand, NULL, 2, (void *) SET_ENABLE },
49: { "disable [opt ...]", "Disable option",
50: EapSetCommand, NULL, 2, (void *) SET_DISABLE },
51: { "yes [opt ...]", "Enable and accept option",
52: EapSetCommand, NULL, 2, (void *) SET_YES },
53: { "no [opt ...]", "Disable and deny option",
54: EapSetCommand, NULL, 2, (void *) SET_NO },
55: { NULL },
56: };
57:
58: /*
59: * INTERNAL VARIABLES
60: */
61:
62: static struct confinfo gConfList[] = {
63: { 0, EAP_CONF_RADIUS, "radius-proxy" },
64: { 1, EAP_CONF_MD5, "md5" },
65: { 0, 0, NULL },
66: };
67:
68:
69:
70: /*
71: * EapInit()
72: */
73:
74: void
75: EapInit(Link l)
76: {
77: EapInfo eap = &l->lcp.auth.eap;
78:
79: Disable(&eap->conf.options, EAP_CONF_MD5);
80: Accept(&eap->conf.options, EAP_CONF_MD5);
81: }
82:
83: /*
84: * EapStart()
85: */
86:
87: void
88: EapStart(Link l, int which)
89: {
90: Auth a = &l->lcp.auth;
91: EapInfo eap = &l->lcp.auth.eap;
92: int i;
93:
94: for (i = 0; i < EAP_NUM_TYPES; i++)
95: eap->peer_types[i] = eap->want_types[i] = 0;
96:
97: /* fill a list of requestable auth types */
98: if (Enabled(&eap->conf.options, EAP_CONF_MD5))
99: eap->want_types[0] = EAP_TYPE_MD5CHAL;
100:
101: /* fill a list of acceptable auth types */
102: if (Acceptable(&eap->conf.options, EAP_CONF_MD5))
103: eap->peer_types[0] = EAP_TYPE_MD5CHAL;
104:
105: if (l->originate == LINK_ORIGINATE_LOCAL)
106: a->params.msoft.chap_alg = a->self_to_peer_alg;
107: else
108: a->params.msoft.chap_alg = a->peer_to_self_alg;
109:
110: switch (which) {
111: case AUTH_PEER_TO_SELF:
112:
113: /* Initialize retry counter and timer */
114: eap->next_id = 1;
115: eap->retry = AUTH_RETRIES;
116:
117: TimerInit(&eap->reqTimer, "EapRadiusSendMsgTimer",
118: l->conf.retry_timeout * SECONDS, EapRadiusSendMsgTimeout, (void *) l);
119:
120: TimerInit(&eap->identTimer, "EapTimer",
121: l->conf.retry_timeout * SECONDS, EapIdentTimeout, (void *) l);
122: TimerStart(&eap->identTimer);
123:
124: /* Send first request
125: * Send the request even, if the Radius-Eap-Proxy feature is active,
126: * this saves on roundtrip.
127: */
128: EapSendIdentRequest(l);
129: break;
130:
131: case AUTH_SELF_TO_PEER: /* Just wait for authenitcaor's request */
132: break;
133:
134: default:
135: assert(0);
136: }
137: }
138:
139: /*
140: * EapStop()
141: */
142:
143: void
144: EapStop(EapInfo eap)
145: {
146: TimerStop(&eap->identTimer);
147: TimerStop(&eap->reqTimer);
148: }
149:
150: /*
151: * EapSendRequest()
152: *
153: * Send an EAP request to peer.
154: */
155:
156: static void
157: EapSendRequest(Link l, u_char type)
158: {
159: Auth const a = &l->lcp.auth;
160: EapInfo const eap = &a->eap;
161: ChapInfo const chap = &a->chap;
162: ChapParams const cp = &a->params.chap;
163: int i = 0;
164: u_char req_type = 0;
165:
166: if (type == 0) {
167: for (i = 0; i < EAP_NUM_TYPES; i++) {
168: if (eap->want_types[i] != 0) {
169: req_type = eap->want_types[i];
170: break;
171: }
172: }
173: } else {
174: req_type = type;
175: }
176:
177: if (req_type == 0) {
178: Log(LG_AUTH, ("[%s] EAP: ran out of EAP Types", l->name));
179: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
180: return;
181: }
182:
183: /* don't request this type again */
184: eap->want_types[i] = 0;
185:
186: switch (req_type) {
187: case EAP_TYPE_MD5CHAL:
188:
189: /* Invalidate any old challenge data */
190: cp->chal_len = 0;
191: /* Initialize retry counter and timer */
192: chap->next_id = 1;
193: chap->retry = AUTH_RETRIES;
194: chap->proto = PROTO_EAP;
195: a->peer_to_self_alg = CHAP_ALG_MD5;
196:
197: TimerInit(&chap->chalTimer, "ChalTimer",
198: l->conf.retry_timeout * SECONDS, ChapChalTimeout, l);
199: TimerStart(&chap->chalTimer);
200:
201: /* Send first challenge */
202: ChapSendChallenge(l);
203: break;
204:
205: default:
206: Log(LG_AUTH, ("[%s] EAP: Type %d is currently un-implemented",
207: l->name, eap->want_types[i]));
208: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
209: }
210:
211: return;
212: }
213:
214: /*
215: * EapSendNak()
216: *
217: * Send an EAP Nak to peer.
218: */
219:
220: static void
221: EapSendNak(Link l, u_char id, u_char type)
222: {
223: Auth const a = &l->lcp.auth;
224: EapInfo const eap = &a->eap;
225: int i = 0;
226: u_char nak_type = 0;
227:
228: for (i = 0; i < EAP_NUM_TYPES; i++) {
229: if (eap->peer_types[i] != 0) {
230: nak_type = eap->peer_types[i];
231: break;
232: }
233: }
234:
235: if (nak_type == 0) {
236: Log(LG_AUTH, ("[%s] EAP: ran out of EAP Types", l->name));
237: AuthFinish(l, AUTH_SELF_TO_PEER, FALSE);
238: return;
239: }
240:
241: /* don't nak this proto again */
242: eap->peer_types[i] = 0;
243:
244: AuthOutput(l, PROTO_EAP, EAP_RESPONSE, id, &nak_type, 1, 0, EAP_TYPE_NAK);
245: return;
246: }
247:
248: /*
249: * EapSendIdentRequest()
250: *
251: * Send an Ident Request to the peer.
252: */
253:
254: static void
255: EapSendIdentRequest(Link l)
256: {
257: EapInfo const eap = &l->lcp.auth.eap;
258:
259: /* Send the initial Identity request */
260: AuthOutput(l, PROTO_EAP, EAP_REQUEST, eap->next_id++, NULL, 0, 0, EAP_TYPE_IDENT);
261: }
262:
263: /*
264: * EapInput()
265: *
266: * Accept an incoming EAP packet
267: */
268:
269: void
270: EapInput(Link l, AuthData auth, const u_char *pkt, u_short len)
271: {
272: Auth const a = &l->lcp.auth;
273: EapInfo const eap = &a->eap;
274: int data_len = len - 1, i, acc_type;
275: u_char *data = NULL, type = 0;
276:
277: if (pkt != NULL) {
278: data = data_len > 0 ? (u_char *) &pkt[1] : NULL;
279: type = pkt[0];
280: }
281:
282: if (Enabled(&eap->conf.options, EAP_CONF_RADIUS)) {
283: EapRadiusProxy(l, auth, pkt, len);
284: return;
285: }
286:
287: switch (auth->code) {
288: case EAP_REQUEST:
289: switch (type) {
290: case EAP_TYPE_IDENT:
291: AuthOutput(l, PROTO_EAP, EAP_RESPONSE, auth->id, (u_char *) auth->conf.authname,
292: strlen(auth->conf.authname), 0, EAP_TYPE_IDENT);
293: break;
294:
295: case EAP_TYPE_NAK:
296: case EAP_TYPE_NOTIF:
297: Log(LG_AUTH, ("[%s] EAP: Type %s is invalid in Request messages",
298: l->name, EapType(type)));
299: AuthFinish(l, AUTH_SELF_TO_PEER, FALSE);
300: break;
301:
302: /* deal with Auth Types */
303: default:
304: acc_type = 0;
305: if (EapTypeSupported(type)) {
306: for (i = 0; i < EAP_NUM_TYPES; i++) {
307: if (eap->peer_types[i] == type) {
308: acc_type = eap->peer_types[i];
309: break;
310: }
311: }
312:
313: if (acc_type == 0) {
314: Log(LG_AUTH, ("[%s] EAP: Type %s not acceptable", l->name,
315: EapType(type)));
316: EapSendNak(l, auth->id, type);
317: break;
318: }
319:
320: switch (type) {
321: case EAP_TYPE_MD5CHAL:
322: a->self_to_peer_alg = CHAP_ALG_MD5;
323: auth->code = CHAP_CHALLENGE;
324: ChapInput(l, auth, &pkt[1], len - 1);
325: return;
326:
327: default:
328: assert(0);
329: }
330: } else {
331: Log(LG_AUTH, ("[%s] EAP: Type %s not supported", l->name, EapType(type)));
332: EapSendNak(l, auth->id, type);
333: }
334: }
335: break;
336:
337: case EAP_RESPONSE:
338: switch (type) {
339: case EAP_TYPE_IDENT:
340: TimerStop(&eap->identTimer);
341: Log(LG_AUTH, ("[%s] EAP: Identity:%*.*s",
342: l->name, data_len, data_len, data));
343: EapSendRequest(l, 0);
344: break;
345:
346: case EAP_TYPE_NOTIF:
347: Log(LG_AUTH, ("[%s] EAP: Notify:%*.*s ", l->name,
348: data_len, data_len, data));
349: break;
350:
351: case EAP_TYPE_NAK:
352: Log(LG_AUTH, ("[%s] EAP: Nak desired Type %s ", l->name,
353: EapType(data[0])));
354: if (EapTypeSupported(data[0]))
355: EapSendRequest(l, data[0]);
356: else
357: EapSendRequest(l, 0);
358: break;
359:
360: case EAP_TYPE_MD5CHAL:
361: auth->code = CHAP_RESPONSE;
362: ChapInput(l, auth, &pkt[1], len - 1);
363: return;
364:
365: default:
366: Log(LG_AUTH, ("[%s] EAP: unknown type %d", l->name, type));
367: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
368: }
369: break;
370:
371: case EAP_SUCCESS:
372: AuthFinish(l, AUTH_SELF_TO_PEER, TRUE);
373: break;
374:
375: case EAP_FAILURE:
376: AuthFinish(l, AUTH_SELF_TO_PEER, FALSE);
377: break;
378:
379: default:
380: Log(LG_AUTH, ("[%s] EAP: unknown code %d", l->name, auth->code));
381: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
382: }
383: AuthDataDestroy(auth);
384: }
385:
386: /*
387: * EapRadiusProxy()
388: *
389: * Proxy EAP Requests from/to the RADIUS server
390: */
391:
392: static void
393: EapRadiusProxy(Link l, AuthData auth, const u_char *pkt, u_short len)
394: {
395: int data_len = len - 1;
396: u_char *data = NULL, type = 0;
397: Auth const a = &l->lcp.auth;
398: EapInfo const eap = &a->eap;
399: struct fsmheader lh;
400:
401: Log(LG_AUTH, ("[%s] EAP: Proxying packet to RADIUS", l->name));
402:
403: if (pkt != NULL) {
404: data = data_len > 0 ? (u_char *) &pkt[1] : NULL;
405: type = pkt[0];
406: }
407:
408: if (auth->code == EAP_RESPONSE && type == EAP_TYPE_IDENT) {
409: TimerStop(&eap->identTimer);
410: if (data_len >= AUTH_MAX_AUTHNAME) {
411: Log(LG_AUTH, ("[%s] EAP: Identity to big (%d), truncating",
412: l->name, data_len));
413: data_len = AUTH_MAX_AUTHNAME - 1;
414: }
415: memset(eap->identity, 0, sizeof(eap->identity));
416: strncpy(eap->identity, (char *) data, data_len);
417: Log(LG_AUTH, ("[%s] EAP: Identity: %s", l->name, eap->identity));
418: }
419:
420: TimerStop(&eap->reqTimer);
421:
422: /* prepare packet */
423: lh.code = auth->code;
424: lh.id = auth->id;
425: lh.length = htons(len + sizeof(lh));
426:
427: auth->params.eapmsg = Malloc(MB_AUTH, len + sizeof(lh));
428: memcpy(auth->params.eapmsg, &lh, sizeof(lh));
429: memcpy(&auth->params.eapmsg[sizeof(lh)], pkt, len);
430:
431: auth->params.eapmsg_len = len + sizeof(lh);
432: strlcpy(auth->params.authname, eap->identity, sizeof(auth->params.authname));
433:
434: auth->eap_radius = TRUE;
435:
436: auth->finish = EapRadiusProxyFinish;
437: AuthAsyncStart(l, auth);
438:
439: }
440:
441: /*
442: * RadiusEapProxyFinish()
443: *
444: * Return point from the asynch RADIUS EAP Proxy Handler.
445: *
446: */
447:
448: static void
449: EapRadiusProxyFinish(Link l, AuthData auth)
450: {
451: Auth const a = &l->lcp.auth;
452: EapInfo eap = &a->eap;
453:
454: Log(LG_AUTH, ("[%s] EAP: RADIUS return status: %s",
455: l->name, AuthStatusText(auth->status)));
456:
457: /* this shouldn't happen normally, however be liberal */
458: if (a->params.eapmsg == NULL) {
459: struct fsmheader lh;
460:
461: Log(LG_AUTH, ("[%s] EAP: Warning, rec'd empty EAP-Message",
462: l->name));
463: /* prepare packet */
464: lh.code = auth->status == AUTH_STATUS_SUCCESS ? EAP_SUCCESS : EAP_FAILURE;
465: lh.id = auth->id;
466: lh.length = htons(sizeof(lh));
467:
468: a->params.eapmsg = Mdup(MB_AUTH, &lh, sizeof(lh));
469: a->params.eapmsg_len = sizeof(lh);
470: }
471:
472: if (a->params.eapmsg != NULL) {
473: eap->retry = AUTH_RETRIES;
474:
475: EapRadiusSendMsg(l);
476: if (auth->status == AUTH_STATUS_UNDEF)
477: TimerStart(&eap->reqTimer);
478: }
479:
480: if (auth->status == AUTH_STATUS_FAIL) {
481: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
482: } else if (auth->status == AUTH_STATUS_SUCCESS) {
483: AuthFinish(l, AUTH_PEER_TO_SELF, TRUE);
484: }
485:
486: AuthDataDestroy(auth);
487: }
488:
489: /*
490: * EapRadiusSendMsg()
491: *
492: * Send an EAP Message to the peer
493: */
494:
495: static void
496: EapRadiusSendMsg(void *ptr)
497: {
498: Mbuf bp;
499: Link l = (Link)ptr;
500: Auth const a = &l->lcp.auth;
501: FsmHeader const f = (FsmHeader)a->params.eapmsg;
502: char buf[32];
503:
504: if (a->params.eapmsg_len > 4) {
505: Log(LG_AUTH, ("[%s] EAP: send %s #%d len: %d, type: %s",
506: l->name, EapCode(f->code, buf, sizeof(buf)), f->id, htons(f->length),
507: EapType(a->params.eapmsg[4])));
508: } else {
509: Log(LG_AUTH, ("[%s] EAP: send %s #%d len: %d",
510: l->name, EapCode(f->code, buf, sizeof(buf)), f->id, htons(f->length)));
511: }
512:
513: bp = mbcopyback(NULL, 0, a->params.eapmsg, a->params.eapmsg_len);
514: NgFuncWritePppFrameLink(l, PROTO_EAP, bp);
515: }
516:
517: /*
518: * EapRadiusSendMsgTimeout()
519: *
520: * Timer expired for reply to our request
521: */
522:
523: static void
524: EapRadiusSendMsgTimeout(void *ptr)
525: {
526: Link l = (Link)ptr;
527: EapInfo const eap = &l->lcp.auth.eap;
528:
529: if (--eap->retry > 0) {
530: TimerStart(&eap->reqTimer);
531: EapRadiusSendMsg(l);
532: }
533: }
534:
535: /*
536: * EapIdentTimeout()
537: *
538: * Timer expired for reply to our request
539: */
540:
541: static void
542: EapIdentTimeout(void *ptr)
543: {
544: Link l = (Link)ptr;
545: EapInfo const eap = &l->lcp.auth.eap;
546:
547: if (--eap->retry > 0) {
548: TimerStart(&eap->identTimer);
549: EapSendIdentRequest(l);
550: }
551: }
552:
553: /*
554: * EapStat()
555: */
556:
557: int
558: EapStat(Context ctx, int ac, char *av[], void *arg)
559: {
560: EapInfo const eap = &ctx->lnk->lcp.auth.eap;
561:
562: Printf("\tIdentity : %s\r\n", eap->identity);
563: Printf("EAP options\r\n");
564: OptStat(ctx, &eap->conf.options, gConfList);
565:
566: return (0);
567: }
568:
569: /*
570: * EapCode()
571: */
572:
573: const char *
574: EapCode(u_char code, char *buf, size_t len)
575: {
576: switch (code) {
577: case EAP_REQUEST:
578: strlcpy(buf, "REQUEST", len);
579: break;
580: case EAP_RESPONSE:
581: strlcpy(buf, "RESPONSE", len);
582: break;
583: case EAP_SUCCESS:
584: strlcpy(buf, "SUCCESS", len);
585: break;
586: case EAP_FAILURE:
587: strlcpy(buf, "FAILURE", len);
588: break;
589: default:
590: snprintf(buf, len, "code%d", code);
591: }
592: return(buf);
593: }
594:
595: /*
596: * EapType()
597: */
598:
599: const char *
600: EapType(u_char type)
601: {
602: switch (type) {
603: case EAP_TYPE_IDENT:
604: return("Identity");
605: case EAP_TYPE_NOTIF:
606: return("Notification");
607: case EAP_TYPE_NAK:
608: return("Nak");
609: case EAP_TYPE_MD5CHAL:
610: return("MD5 Challenge");
611: case EAP_TYPE_OTP:
612: return("One Time Password");
613: case EAP_TYPE_GTC:
614: return("Generic Token Card");
615: case EAP_TYPE_EAP_TLS:
616: return("TLS");
617: case EAP_TYPE_MSCHAP_V2:
618: return("MS-CHAPv2");
619: case EAP_TYPE_EAP_TTLS:
620: return("TTLS");
621: default:
622: return("UNKNOWN");
623: }
624: }
625:
626: /*
627: * EapTypeSupported()
628: */
629:
630: static char
631: EapTypeSupported(u_char type)
632: {
633: switch (type) {
634: case EAP_TYPE_IDENT:
635: case EAP_TYPE_NOTIF:
636: case EAP_TYPE_NAK:
637: case EAP_TYPE_MD5CHAL:
638: return 1;
639:
640: default:
641: return 0;
642: }
643: }
644:
645: /*
646: * EapSetCommand()
647: */
648:
649: static int
650: EapSetCommand(Context ctx, int ac, char *av[], void *arg)
651: {
652: EapInfo const eap = &ctx->lnk->lcp.auth.eap;
653:
654: if (ac == 0)
655: return(-1);
656:
657: switch ((intptr_t)arg) {
658:
659: case SET_ACCEPT:
660: AcceptCommand(ac, av, &eap->conf.options, gConfList);
661: break;
662:
663: case SET_DENY:
664: DenyCommand(ac, av, &eap->conf.options, gConfList);
665: break;
666:
667: case SET_ENABLE:
668: EnableCommand(ac, av, &eap->conf.options, gConfList);
669: break;
670:
671: case SET_DISABLE:
672: DisableCommand(ac, av, &eap->conf.options, gConfList);
673: break;
674:
675: case SET_YES:
676: YesCommand(ac, av, &eap->conf.options, gConfList);
677: break;
678:
679: case SET_NO:
680: NoCommand(ac, av, &eap->conf.options, gConfList);
681: break;
682:
683: default:
684: assert(0);
685: }
686:
687: return(0);
688: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to eap.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src