Annotation of embedaddon/mpd/src/chap.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * chap.c
4: *
5: * Written by Toshiharu OHNO <tony-o@iij.ad.jp>
6: * Copyright (c) 1993, Internet Initiative Japan, Inc. All rights reserved.
7: * See ``COPYRIGHT.iij''
8: *
9: * Rewritten by Archie Cobbs <archie@freebsd.org>
10: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
11: * See ``COPYRIGHT.whistle''
12: */
13:
14: #include "ppp.h"
15: #include "auth.h"
16: #include "msoft.h"
17: #include "util.h"
18: #include <openssl/md5.h>
19:
20: /*
21: * INTERNAL FUNCTIONS
22: */
23:
24: static int ChapHash(Link l, int alg, u_char *hash_value, u_char id,
25: const char *username, const char *secret,
26: const u_char *challenge, int clen, int local);
27: static int ChapHashAgree(int alg, const u_char *self, int slen,
28: const u_char *peer, int plen);
29: static int ChapParsePkt(const char *pref, const u_char *pkt, const int pkt_len,
30: char *peer_name, u_char *chap_value,
31: int *chap_value_size);
32: static char *ChapGetSecret(Link l, int alg, char *password);
33: static void ChapGenRandom(Link l, u_char *buf, int len);
34:
35: /*
36: * INTERNAL VARIABLES
37: */
38:
39: static const u_char gIdBytes[] = { 0x3b, 0x1e, 0x68 };
40:
41: /*
42: * ChapStart()
43: */
44:
45: void
46: ChapStart(Link l, int which)
47: {
48: Auth a = &l->lcp.auth;
49: ChapInfo chap = &l->lcp.auth.chap;
50: ChapParams cp = &l->lcp.auth.params.chap;
51:
52: chap->proto = PROTO_CHAP;
53:
54: if (l->originate == LINK_ORIGINATE_LOCAL)
55: a->params.msoft.chap_alg = a->self_to_peer_alg;
56: else
57: a->params.msoft.chap_alg = a->peer_to_self_alg;
58:
59: switch (which)
60: {
61: case AUTH_SELF_TO_PEER: /* Just wait for peer's challenge */
62: break;
63:
64: case AUTH_PEER_TO_SELF:
65:
66: /* Invalidate any old challenge data */
67: cp->chal_len = 0;
68:
69: /* Initialize retry counter and timer */
70: chap->next_id = 1;
71: chap->retry = AUTH_RETRIES;
72:
73: TimerInit(&chap->chalTimer, "ChalTimer",
74: l->conf.retry_timeout * SECONDS, ChapChalTimeout, l);
75: TimerStart(&chap->chalTimer);
76:
77: /* Send first challenge */
78: ChapSendChallenge(l);
79: break;
80:
81: default:
82: assert(0);
83: }
84: }
85:
86: /*
87: * ChapStop()
88: */
89:
90: void
91: ChapStop(ChapInfo chap)
92: {
93: TimerStop(&chap->chalTimer);
94: TimerStop(&chap->respTimer);
95: if (chap->resp) {
96: Freee(chap->resp);
97: chap->resp = NULL;
98: }
99: }
100:
101: /*
102: * ChapSendChallenge()
103: */
104:
105: void
106: ChapSendChallenge(Link l)
107: {
108: Auth const a = &l->lcp.auth;
109: ChapInfo chap = &a->chap;
110: ChapParams cp = &a->params.chap;
111: u_char *pkt;
112:
113: /* don't generate new challenges on re-transmit */
114: if (cp->chal_len)
115: goto send_pkt;
116:
117: /* Put random challenge data in buffer (only once for Microsoft CHAP) */
118: switch (a->peer_to_self_alg) {
119: case CHAP_ALG_MSOFT: {
120: cp->chal_len = CHAP_MSOFT_CHAL_LEN;
121: ChapGenRandom(l, cp->chal_data, cp->chal_len);
122: if (l->originate == LINK_ORIGINATE_REMOTE) {
123: memcpy(a->params.msoft.msChal, cp->chal_data, cp->chal_len);
124: }
125: }
126: break;
127: case CHAP_ALG_MSOFTv2:
128: cp->chal_len = CHAP_MSOFTv2_CHAL_LEN;
129: ChapGenRandom(l, cp->chal_data, cp->chal_len);
130: if (l->originate == LINK_ORIGINATE_REMOTE) {
131: memcpy(a->params.msoft.msChal, cp->chal_data, cp->chal_len);
132: }
133: break;
134: case CHAP_ALG_MD5:
135: cp->chal_len = random() % 32 + 16;
136: ChapGenRandom(l, cp->chal_data, cp->chal_len);
137: break;
138: default:
139: assert(0);
140: }
141: assert(cp->chal_len <= sizeof(cp->chal_data));
142:
143: send_pkt:
144: /* Build a challenge packet */
145: pkt = Malloc(MB_AUTH, 1 + cp->chal_len + strlen(a->conf.authname) + 1);
146: pkt[0] = cp->chal_len;
147: memcpy(pkt + 1, cp->chal_data, cp->chal_len);
148: memcpy(pkt + 1 + cp->chal_len,
149: a->conf.authname, strlen(a->conf.authname));
150:
151: /* Send it off */
152: AuthOutput(l, chap->proto,
153: chap->proto == PROTO_CHAP ? CHAP_CHALLENGE : EAP_REQUEST,
154: chap->next_id++, pkt,
155: 1 + cp->chal_len + strlen(a->conf.authname), 0,
156: EAP_TYPE_MD5CHAL);
157: Freee(pkt);
158: }
159:
160: /*
161: * ChapSendResponse()
162: */
163:
164: static void
165: ChapSendResponse(Link l)
166: {
167: ChapInfo chap = &l->lcp.auth.chap;
168:
169: /* Stop response timer */
170: TimerStop(&chap->respTimer);
171:
172: /* Send response (possibly again) */
173: assert(chap->resp);
174: AuthOutput(l, chap->proto,
175: chap->proto == PROTO_CHAP ? CHAP_RESPONSE : EAP_RESPONSE,
176: chap->resp_id, chap->resp, chap->resp_len, 0, EAP_TYPE_MD5CHAL);
177:
178: /* Start re-send timer (only during authenticate phase where the
179: authentication timer is still running) */
180: if (l->lcp.phase == PHASE_AUTHENTICATE) {
181: TimerInit(&chap->respTimer, "RespTimer",
182: l->conf.retry_timeout * SECONDS,
183: (void (*)(void *)) ChapSendResponse, (void *) l);
184: TimerStart(&chap->respTimer);
185: }
186: }
187:
188: /*
189: * ChapParsePkt()
190: *
191: */
192:
193: static int
194: ChapParsePkt(const char *pref, const u_char *pkt, const int pkt_len,
195: char *peer_name, u_char *chap_value, int *chap_value_size)
196: {
197: int val_len, name_len;
198:
199: /* Compute and check lengths */
200: if (pkt == NULL
201: || pkt_len < 1
202: || (val_len = pkt[0]) < 1
203: || val_len > CHAP_MAX_VAL
204: || (name_len = (pkt_len - val_len - 1)) < 0
205: || name_len > CHAP_MAX_NAME) {
206: Log(LG_AUTH, ("[%s] Bogus packet", pref));
207: return(-1);
208: }
209:
210: /* Extract stuff */
211: memcpy(peer_name, pkt + 1 + val_len, name_len);
212: peer_name[name_len] = 0;
213: memcpy(chap_value, pkt + 1, val_len);
214: *chap_value_size = val_len;
215: Log(LG_AUTH, ("[%s] Name: \"%s\"", pref, peer_name));
216: #if 0
217: Log(LG_AUTH, ("[%s] Value: %d bytes", pref, *chap_value_size));
218: #endif
219: return(0);
220: }
221:
222: /*
223: * ChapChalTimeout()
224: *
225: * Timer expired for reply to challenge packet
226: */
227:
228: void
229: ChapChalTimeout(void *ptr)
230: {
231: Link const l = (Link) ptr;
232: ChapInfo const chap = &l->lcp.auth.chap;
233:
234: if (--chap->retry > 0) {
235: TimerStart(&chap->chalTimer);
236: ChapSendChallenge(l);
237: }
238: }
239:
240: /*
241: * ChapInput()
242: */
243:
244: void
245: ChapInput(Link l, AuthData auth, const u_char *pkt, u_short len)
246: {
247: Auth const a = &l->lcp.auth;
248: ChapInfo const chap = &a->chap;
249: char peer_name[CHAP_MAX_NAME + 1];
250: char password[AUTH_MAX_PASSWORD];
251: u_char hash_value[CHAP_MAX_VAL];
252: int hash_value_size;
253:
254: chap->proto = auth->proto;
255:
256: switch (auth->code) {
257: case CHAP_CHALLENGE:
258: {
259: u_char value[CHAP_MAX_VAL]; /* Chap packet */
260: int value_len; /* Packet length */
261: char *name, *secret;
262: int name_len, idFail;
263:
264: auth->alg = a->self_to_peer_alg;
265:
266: /* Check packet */
267: if ((a->self_to_peer != PROTO_CHAP && a->self_to_peer != PROTO_EAP)
268: || l->lcp.phase != PHASE_AUTHENTICATE)
269: Log(LG_AUTH, ("[%s] CHAP: Not expected, but that's OK", l->name));
270: if (ChapParsePkt(l->name, pkt, len, peer_name, value, &value_len) < 0)
271: break;
272:
273: /* Never respond to our own outstanding challenge */
274: if (value_len == auth->params.chap.chal_len
275: && !memcmp(value, auth->params.chap.chal_data, auth->params.chap.chal_len)) {
276: Log(LG_AUTH, ("[%s] CHAP: SECURITY: peer sent same challenge! Ignoring.", l->name));
277: break;
278: }
279:
280: /* Don't respond to a challenge that looks like it came from
281: us and has the wrong origination value embedded in it. This
282: avoids a security hole associated with using the same CHAP
283: password to authenticate in both directions on a link. */
284: idFail = 0;
285: do {
286: char buf[sizeof(gIdBytes)];
287: int chalOrig;
288:
289: /* Check challenge length */
290: if (value_len < sizeof(buf))
291: break;
292:
293: /* Copy challenge bits and extract origination value */
294: memcpy(buf, value, sizeof(buf));
295: chalOrig = (buf[0] >> 6) & 0x03;
296: buf[0] &= 0x3f;
297:
298: /* Check for same ID bytes in the challenge */
299: if (memcmp(buf, gIdBytes, sizeof(gIdBytes)) != 0)
300: break;
301:
302: /* ID bytes match; origination value must be opposite. Note this
303: assumes that if we can tell the origination direction of a link,
304: then so can the peer. */
305: switch (l->originate) {
306: case LINK_ORIGINATE_LOCAL:
307: idFail = (chalOrig != LINK_ORIGINATE_REMOTE);
308: break;
309: case LINK_ORIGINATE_REMOTE:
310: idFail = (chalOrig != LINK_ORIGINATE_LOCAL);
311: break;
312: case LINK_ORIGINATE_UNKNOWN:
313: default:
314: idFail = 0; /* XXX assumes leased line, etc is secure */
315: break;
316: }
317:
318: /* Log failure */
319: if (idFail) {
320: Log(LG_AUTH,
321: ("[%s] CHAP: SECURITY: origination value check failed (%s,%s). Ignoring.",
322: l->name,
323: LINK_ORIGINATION(l->originate),
324: LINK_ORIGINATION(chalOrig)));
325: break;
326: }
327: } while (0);
328: if (idFail)
329: break;
330:
331: /*
332: * Name we use to authenticate ourselves:
333: *
334: * 1. The manually configured authname ("set authname ...")
335: * 2. The peer's supplied name
336: */
337: if (*auth->conf.authname)
338: name = auth->conf.authname;
339: else
340: name = peer_name;
341: name_len = strlen(name);
342: Log(LG_AUTH, ("[%s] CHAP: Using authname \"%s\"", l->name, name));
343:
344: strlcpy(auth->params.authname, name, sizeof(auth->params.authname));
345:
346: /* Get the corresponding secret */
347: if ((strcmp(auth->conf.authname, auth->params.authname) == 0) &&
348: auth->conf.password[0] != 0) {
349: strlcpy(password, auth->conf.password, sizeof(password));
350: } else if (AuthGetData(auth->params.authname, password,
351: sizeof(password), NULL, NULL) < 0) {
352: Log(LG_AUTH, ("[%s] CHAP: Warning: no secret for \"%s\" found",
353: l->name,
354: auth->params.authname));
355: break;
356: }
357:
358: secret = ChapGetSecret(l, a->self_to_peer_alg, password);
359:
360: /* Get hash value */
361: if ((hash_value_size = ChapHash(l, a->self_to_peer_alg, hash_value,
362: auth->id, name, secret, value, value_len, 1)) < 0) {
363: Log(LG_AUTH, ("[%s] CHAP: Hash failure", l->name));
364: break;
365: }
366:
367: /* Need to remember MS-CHAP stuff for use with MPPE encryption */
368: switch (a->self_to_peer_alg) {
369: case CHAP_ALG_MSOFT:
370: if (l->originate == LINK_ORIGINATE_LOCAL)
371: memcpy(a->params.msoft.msChal, value, CHAP_MSOFT_CHAL_LEN);
372: break;
373: case CHAP_ALG_MSOFTv2:
374: if (l->originate == LINK_ORIGINATE_LOCAL) {
375: memcpy(a->params.msoft.msChal, value, CHAP_MSOFTv2_CHAL_LEN);
376: memcpy(a->params.msoft.ntResp,
377: hash_value + offsetof(struct mschapv2value, ntHash),
378: CHAP_MSOFTv2_RESP_LEN);
379: }
380: break;
381: }
382:
383: /* Build response packet */
384: if (chap->resp)
385: Freee(chap->resp);
386: chap->resp = Malloc(MB_AUTH, 1 + hash_value_size + name_len);
387: chap->resp[0] = hash_value_size;
388: memcpy(&chap->resp[1], hash_value, hash_value_size);
389: memcpy(&chap->resp[1 + hash_value_size], name, name_len);
390: chap->resp_len = 1 + hash_value_size + name_len;
391: chap->resp_id = auth->id;
392:
393: /* Send response to peer */
394: ChapSendResponse(l);
395: }
396: break;
397:
398: case CHAP_RESPONSE:
399: auth->alg = a->peer_to_self_alg;
400:
401: /* Stop challenge timer */
402: TimerStop(&chap->chalTimer);
403:
404: /* Check response */
405: if ((a->peer_to_self != PROTO_CHAP && a->peer_to_self != PROTO_EAP)
406: || l->lcp.phase != PHASE_AUTHENTICATE)
407: Log(LG_AUTH, ("[%s] CHAP: Not expected, but that's OK", l->name));
408: if (ChapParsePkt(l->name, pkt, len,
409: peer_name, auth->params.chap.value, &auth->params.chap.value_len) < 0) {
410: auth->why_fail = AUTH_FAIL_INVALID_PACKET;
411: ChapInputFinish(l, auth);
412: return;
413: }
414:
415: /* Strip MS domain if any */
416: if (!Enabled(&l->conf.options, LINK_CONF_MSDOMAIN))
417: if (a->peer_to_self_alg == CHAP_ALG_MSOFT
418: || a->peer_to_self_alg == CHAP_ALG_MSOFTv2) {
419: char *s;
420:
421: if ((s = strrchr(peer_name, '\\')))
422: memmove(peer_name, s + 1, strlen(s) + 1);
423: }
424:
425: strlcpy(auth->params.authname, peer_name, sizeof(auth->params.authname));
426:
427: auth->finish = ChapInputFinish;
428: AuthAsyncStart(l, auth);
429: return;
430:
431: case CHAP_SUCCESS:
432: case CHAP_FAILURE:
433:
434: auth->alg = a->self_to_peer_alg;
435:
436: /* Stop response timer */
437: TimerStop(&chap->respTimer);
438: if (chap->resp) {
439: Freee(chap->resp);
440: chap->resp = NULL;
441: }
442:
443: /* Appropriate? */
444: if (a->self_to_peer != PROTO_CHAP
445: || l->lcp.phase != PHASE_AUTHENTICATE) {
446: Log(LG_AUTH, ("[%s] CHAP: Not expected, but that's OK", l->name));
447: break;
448: }
449:
450: /* Log message */
451: ShowMesg(LG_AUTH, l->name, (char *) pkt, len);
452: AuthFinish(l, AUTH_SELF_TO_PEER, auth->code == CHAP_SUCCESS);
453: break;
454:
455: case CHAP_MS_V1_CHANGE_PW:
456: Log(LG_AUTH, ("[%s] CHAP: Sorry changing passwords using MS-CHAPv1 is not yet implemented",
457: l->name));
458: goto badResponse;
459:
460: case CHAP_MS_V2_CHANGE_PW:
461: Log(LG_AUTH, ("[%s] CHAP: Sorry changing passwords using MS-CHAPv2 is not yet implemented",
462: l->name));
463: goto badResponse;
464:
465: default:
466: Log(LG_AUTH, ("[%s] CHAP: unknown code %d", l->name, auth->code));
467: break;
468: }
469: AuthDataDestroy(auth);
470: return;
471:
472: badResponse:
473: {
474: char failMesg[64];
475:
476: auth->why_fail = AUTH_FAIL_NOT_EXPECTED;
477: AuthFailMsg(auth, failMesg, sizeof(failMesg));
478: AuthOutput(l, auth->proto, auth->proto == PROTO_CHAP ? CHAP_FAILURE : EAP_FAILURE,
479: auth->id, (u_char *)failMesg, strlen(failMesg), 0, EAP_TYPE_MD5CHAL);
480: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
481: AuthDataDestroy(auth);
482: }
483: }
484:
485: /*
486: * ChapInputFinish()
487: *
488: * Possible return point from the asynch auth handler.
489: *
490: */
491:
492: void
493: ChapInputFinish(Link l, AuthData auth)
494: {
495: Auth a = &l->lcp.auth;
496: ChapInfo chap = &a->chap;
497: u_char hash_value[CHAP_MAX_VAL];
498: int hash_value_size;
499: char ackMesg[128], *secret;
500:
501: Log(LG_AUTH, ("[%s] CHAP: Auth return status: %s",
502: l->name, AuthStatusText(auth->status)));
503:
504: if (auth->status == AUTH_STATUS_BUSY) {
505: AuthDataDestroy(auth);
506: return;
507: }
508:
509: if (a->peer_to_self_alg == CHAP_ALG_MSOFTv2 &&
510: auth->mschapv2resp != NULL) {
511: strlcpy(ackMesg, auth->mschapv2resp, sizeof(ackMesg));
512: } else if (auth->reply_message != NULL) {
513: strlcpy(ackMesg, auth->reply_message, sizeof(ackMesg));
514: } else {
515: strlcpy(ackMesg, AUTH_MSG_WELCOME, sizeof(ackMesg));
516: }
517:
518: if (auth->status == AUTH_STATUS_FAIL)
519: goto badResponse;
520: else if (auth->status == AUTH_STATUS_SUCCESS)
521: goto goodResponse;
522:
523: /* Copy in peer challenge for MS-CHAPv2 */
524: if (a->peer_to_self_alg == CHAP_ALG_MSOFTv2)
525: memcpy(hash_value, a->params.chap.value, 16);
526:
527: secret = ChapGetSecret(l, a->peer_to_self_alg, a->params.password);
528:
529: /* Get expected hash value */
530: if ((hash_value_size = ChapHash(l, a->peer_to_self_alg, hash_value, auth->id,
531: a->params.authname, secret, a->params.chap.chal_data, a->params.chap.chal_len,
532: 0)) < 0) {
533: Log(LG_AUTH, ("[%s] CHAP: Hash failure", l->name));
534: auth->why_fail = AUTH_FAIL_INVALID_PACKET;
535: goto badResponse;
536: }
537:
538: /* Compare with peer's response */
539: if (a->params.chap.chal_len == 0
540: || !ChapHashAgree(a->peer_to_self_alg, hash_value, hash_value_size,
541: a->params.chap.value, a->params.chap.value_len)) {
542: Log(LG_AUTH, ("[%s] CHAP: Invalid response", l->name));
543: auth->why_fail = AUTH_FAIL_INVALID_LOGIN;
544: goto badResponse;
545: }
546:
547: /* Response is good */
548: Log(LG_AUTH, ("[%s] CHAP: Response is valid", l->name));
549:
550: if (a->peer_to_self_alg == CHAP_ALG_MSOFTv2) {
551: struct mschapv2value *const pv = (struct mschapv2value *)a->params.chap.value;
552: char hex[41];
553: u_char authresp[20];
554: int i;
555:
556: /* Generate MS-CHAPv2 'authenticator response' */
557: GenerateAuthenticatorResponse(a->params.msoft.nt_hash, pv->ntHash,
558: pv->peerChal, a->params.chap.chal_data, a->params.authname, authresp);
559: for (i = 0; i < 20; i++)
560: sprintf(hex + (i * 2), "%02X", authresp[i]);
561: /* If we have reply message, send it. */
562: if (auth->reply_message != NULL) {
563: snprintf(ackMesg, sizeof(ackMesg), "S=%s M=%s",
564: hex, auth->reply_message);
565: } else
566: snprintf(ackMesg, sizeof(ackMesg), "S=%s", hex);
567: }
568:
569: goodResponse:
570: #ifdef USE_OPIE
571: /* make a dummy verify to force an update of the opiekeys database */
572: if (a->params.authentic == AUTH_CONF_OPIE)
573: opieverify(&auth->opie.data, a->params.password);
574: #endif
575:
576: /* Need to remember MS-CHAP stuff for use with MPPE encryption */
577: if (l->originate == LINK_ORIGINATE_REMOTE &&
578: a->peer_to_self_alg == CHAP_ALG_MSOFTv2 &&
579: !memcmp(a->params.msoft.ntResp, gMsoftZeros, CHAP_MSOFTv2_RESP_LEN)) {
580: memcpy(a->params.msoft.ntResp,
581: a->params.chap.value + offsetof(struct mschapv2value, ntHash),
582: CHAP_MSOFTv2_RESP_LEN);
583: }
584:
585: Log(LG_AUTH, ("[%s] CHAP: Reply message: %s", l->name, ackMesg));
586: AuthOutput(l, chap->proto, chap->proto == PROTO_CHAP ? CHAP_SUCCESS : EAP_SUCCESS,
587: auth->id, (u_char *)ackMesg, strlen(ackMesg), 0, EAP_TYPE_MD5CHAL);
588: AuthFinish(l, AUTH_PEER_TO_SELF, TRUE);
589: AuthDataDestroy(auth);
590: return;
591:
592: badResponse:
593: {
594: char failMesg[64];
595:
596: AuthFailMsg(auth, failMesg, sizeof(failMesg));
597: Log(LG_AUTH, ("[%s] CHAP: Reply message: %s", l->name, failMesg));
598: AuthOutput(l, chap->proto, chap->proto == PROTO_CHAP ? CHAP_FAILURE : EAP_FAILURE,
599: auth->id, (u_char *)failMesg, strlen(failMesg), 0, EAP_TYPE_MD5CHAL);
600: AuthFinish(l, AUTH_PEER_TO_SELF, FALSE);
601: AuthDataDestroy(auth);
602: }
603: }
604:
605: /*
606: * ChapGetSecret()
607: *
608: * returns either the plaintext pass for CHAP-MD5
609: * or the NT-Hash for MS-CHAP. Set's credentials for
610: * MPPE-Key derivation
611: */
612:
613: static char *
614: ChapGetSecret(Link l, int alg, char *password)
615: {
616: Auth a = &l->lcp.auth;
617: char *pw;
618:
619: if (alg == CHAP_ALG_MD5)
620: pw = password;
621: else {
622: if (!a->params.msoft.has_nt_hash)
623: {
624: NTPasswordHash(password, a->params.msoft.nt_hash);
625: NTPasswordHashHash(a->params.msoft.nt_hash, a->params.msoft.nt_hash_hash);
626: LMPasswordHash(password, a->params.msoft.lm_hash);
627: a->params.msoft.has_nt_hash = TRUE;
628: a->params.msoft.has_lm_hash = TRUE;
629: }
630:
631: pw = (char *) a->params.msoft.nt_hash;
632: }
633:
634: return pw;
635: }
636:
637: /*
638: * ChapGenRandom()
639: */
640:
641: static void
642: ChapGenRandom(Link l, u_char *buf, int len)
643: {
644: int k;
645:
646: /* Prefix with our unique ID plus origination value */
647: for (k = 0; k < sizeof(gIdBytes) && k < len; k++)
648: buf[k] = gIdBytes[k];
649: buf[0] |= (l->originate & 0x03) << 6;
650:
651: /* Fill the rest with semi-random bytes */
652: for (; k < len; k++)
653: buf[k] = random() & 0xff;
654: }
655:
656: /*
657: * ChapHash()
658: */
659:
660: static int
661: ChapHash(Link l, int alg, u_char *hash_value, u_char id, const char *username,
662: const char *secret, const u_char *challenge, int clen, int local)
663: {
664: int hash_size;
665:
666: switch (alg) {
667: case CHAP_ALG_MD5:
668: {
669: MD5_CTX md5ctx;
670:
671: MD5_Init(&md5ctx);
672: MD5_Update(&md5ctx, &id, 1);
673: MD5_Update(&md5ctx, secret, strlen(secret));
674: MD5_Update(&md5ctx, challenge, clen);
675: MD5_Final(hash_value, &md5ctx);
676: hash_size = 16;
677: }
678: break;
679:
680: case CHAP_ALG_MSOFT:
681: {
682: struct mschapvalue *const val = (struct mschapvalue *) hash_value;
683:
684: /* We don't generate the LANManager hash because it's too insecure */
685: memset(val->lmHash, 0, sizeof(val->lmHash));
686: NTChallengeResponse(challenge, secret, val->ntHash);
687: val->useNT = 1;
688: hash_size = 49;
689: }
690: break;
691: case CHAP_ALG_MSOFTv2:
692: {
693: struct mschapv2value *const val = (struct mschapv2value *) hash_value;
694: const char *s;
695:
696: if ((s = strrchr(username, '\\')) != NULL)
697: username = s + 1;
698: if (local) { /* generate reverse 'peer challenge' */
699: ChapGenRandom(l, val->peerChal, sizeof(val->peerChal));
700: memset(val->reserved, 0, sizeof(val->reserved));
701: }
702: GenerateNTResponse(challenge,
703: val->peerChal, username, secret, val->ntHash);
704:
705: hash_size = 49;
706: }
707: break;
708:
709: default:
710: return(-1);
711: }
712:
713: /* Done */
714: return(hash_size);
715: }
716:
717: /*
718: * ChapHashAgree()
719: */
720:
721: static int
722: ChapHashAgree(int alg, const u_char *self, int slen,
723: const u_char *peer, int plen)
724: {
725: switch (alg)
726: {
727: case CHAP_ALG_MD5:
728: return(slen == plen && !memcmp(self, peer, slen));
729:
730: case CHAP_ALG_MSOFT:
731: {
732: struct mschapvalue *const sv = (struct mschapvalue *) self;
733: struct mschapvalue *const pv = (struct mschapvalue *) peer;
734:
735: if (slen != 49 || plen != 49)
736: return(0);
737: if (sv->useNT != 1 || pv->useNT != 1)
738: return(0);
739: return(!memcmp(&sv->ntHash, &pv->ntHash, sizeof(sv->ntHash)));
740: }
741: case CHAP_ALG_MSOFTv2:
742: {
743: struct mschapv2value *const sv =(struct mschapv2value *) self;
744: struct mschapv2value *const pv =(struct mschapv2value *) peer;
745:
746: if (slen != 49 || plen != 49)
747: return(0);
748: return(!memcmp(&sv->ntHash, &pv->ntHash, sizeof(sv->ntHash)));
749: }
750:
751: default:
752: return(0);
753: }
754: }
755:
756: /*
757: * ChapCode()
758: */
759:
760: const char *
761: ChapCode(int code, char *buf, size_t len)
762: {
763: switch (code) {
764: case CHAP_CHALLENGE:
765: strlcpy(buf, "CHALLENGE", len);
766: break;
767: case CHAP_RESPONSE:
768: strlcpy(buf, "RESPONSE", len);
769: break;
770: case CHAP_SUCCESS:
771: strlcpy(buf, "SUCCESS", len);
772: break;
773: case CHAP_FAILURE:
774: strlcpy(buf, "FAILURE", len);
775: break;
776: default:
777: snprintf(buf, len, "code%d", code);
778: }
779: return(buf);
780: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to chap.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