1 /*- 2 * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org> 3 * based on work by Toshiharu OHNO <tony-o@iij.ad.jp> 4 * Internet Initiative Japan, Inc (IIJ) 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD: src/usr.sbin/ppp/chap.c,v 1.61.2.7 2002/09/01 02:12:23 brian Exp $ 29 */ 30 31 #include <sys/param.h> 32 #include <netinet/in.h> 33 #include <netinet/in_systm.h> 34 #include <netinet/ip.h> 35 #include <sys/socket.h> 36 #include <sys/un.h> 37 38 #include <ctype.h> 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <paths.h> 42 #include <signal.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <sys/wait.h> 47 #include <termios.h> 48 #include <unistd.h> 49 #ifndef NODES 50 #include <openssl/md4.h> 51 #endif 52 #include <openssl/md5.h> 53 54 #include "layer.h" 55 #include "mbuf.h" 56 #include "log.h" 57 #include "defs.h" 58 #include "timer.h" 59 #include "fsm.h" 60 #include "proto.h" 61 #include "lqr.h" 62 #include "hdlc.h" 63 #include "lcp.h" 64 #include "auth.h" 65 #include "async.h" 66 #include "throughput.h" 67 #include "descriptor.h" 68 #include "chap.h" 69 #include "iplist.h" 70 #include "slcompress.h" 71 #include "ncpaddr.h" 72 #include "ipcp.h" 73 #include "filter.h" 74 #include "ccp.h" 75 #include "link.h" 76 #include "physical.h" 77 #include "mp.h" 78 #ifndef NORADIUS 79 #include "radius.h" 80 #endif 81 #include "ipv6cp.h" 82 #include "ncp.h" 83 #include "bundle.h" 84 #include "chat.h" 85 #include "cbcp.h" 86 #include "command.h" 87 #include "datalink.h" 88 #ifndef NODES 89 #include "chap_ms.h" 90 #include "mppe.h" 91 #endif 92 #include "id.h" 93 94 static const char * const chapcodes[] = { 95 "???", "CHALLENGE", "RESPONSE", "SUCCESS", "FAILURE" 96 }; 97 #define MAXCHAPCODE (NELEM(chapcodes) - 1) 98 99 static void 100 ChapOutput(struct physical *physical, u_int code, u_int id, 101 const u_char *ptr, int count, const char *text) 102 { 103 int plen; 104 struct fsmheader lh; 105 struct mbuf *bp; 106 107 plen = sizeof(struct fsmheader) + count; 108 lh.code = code; 109 lh.id = id; 110 lh.length = htons(plen); 111 bp = m_get(plen, MB_CHAPOUT); 112 memcpy(MBUF_CTOP(bp), &lh, sizeof(struct fsmheader)); 113 if (count) 114 memcpy(MBUF_CTOP(bp) + sizeof(struct fsmheader), ptr, count); 115 log_DumpBp(LogDEBUG, "ChapOutput", bp); 116 if (text == NULL) 117 log_Printf(LogPHASE, "Chap Output: %s\n", chapcodes[code]); 118 else 119 log_Printf(LogPHASE, "Chap Output: %s (%s)\n", chapcodes[code], text); 120 link_PushPacket(&physical->link, bp, physical->dl->bundle, 121 LINK_QUEUES(&physical->link) - 1, PROTO_CHAP); 122 } 123 124 static char * 125 chap_BuildAnswer(char *name, char *key, u_char id, char *challenge 126 #ifndef NODES 127 , u_char type, char *peerchallenge, char *authresponse, 128 int lanman 129 #endif 130 ) 131 { 132 char *result, *digest; 133 size_t nlen, klen; 134 135 nlen = strlen(name); 136 klen = strlen(key); 137 138 #ifndef NODES 139 if (type == 0x80) { 140 char expkey[AUTHLEN << 2]; 141 MD4_CTX MD4context; 142 size_t f; 143 144 if ((result = malloc(1 + nlen + MS_CHAP_RESPONSE_LEN)) == NULL) 145 return result; 146 147 digest = result; /* the response */ 148 *digest++ = MS_CHAP_RESPONSE_LEN; /* 49 */ 149 memcpy(digest + MS_CHAP_RESPONSE_LEN, name, nlen); 150 if (lanman) { 151 memset(digest + 24, '\0', 25); 152 mschap_LANMan(digest, challenge + 1, key); /* LANMan response */ 153 } else { 154 memset(digest, '\0', 25); 155 digest += 24; 156 157 for (f = 0; f < klen; f++) { 158 expkey[2*f] = key[f]; 159 expkey[2*f+1] = '\0'; 160 } 161 /* 162 * ----------- 163 * expkey = | k\0e\0y\0 | 164 * ----------- 165 */ 166 MD4_Init(&MD4context); 167 MD4_Update(&MD4context, expkey, klen << 1); 168 MD4_Final(digest, &MD4context); 169 170 /* 171 * ---- -------- ---------------- ------- ------ 172 * result = | 49 | LANMan | 16 byte digest | 9 * ? | name | 173 * ---- -------- ---------------- ------- ------ 174 */ 175 mschap_NT(digest, challenge + 1); 176 } 177 /* 178 * ---- -------- ------------- ----- ------ 179 * | | struct MS_ChapResponse24 | | 180 * result = | 49 | LANMan | NT digest | 0/1 | name | 181 * ---- -------- ------------- ----- ------ 182 * where only one of LANMan & NT digest are set. 183 */ 184 } else if (type == 0x81) { 185 char expkey[AUTHLEN << 2]; 186 char pwdhash[CHAP81_HASH_LEN]; 187 char pwdhashhash[CHAP81_HASH_LEN]; 188 char *ntresponse; 189 size_t f; 190 191 if ((result = malloc(1 + nlen + CHAP81_RESPONSE_LEN)) == NULL) 192 return result; 193 194 memset(result, 0, 1 + nlen + CHAP81_RESPONSE_LEN); 195 196 digest = result; 197 *digest++ = CHAP81_RESPONSE_LEN; /* value size */ 198 199 /* Copy our challenge */ 200 memcpy(digest, peerchallenge + 1, CHAP81_CHALLENGE_LEN); 201 202 /* Expand password to Unicode XXX */ 203 for (f = 0; f < klen; f++) { 204 expkey[2*f] = key[f]; 205 expkey[2*f+1] = '\0'; 206 } 207 208 ntresponse = digest + CHAP81_NTRESPONSE_OFF; 209 210 /* Get some needed hashes */ 211 NtPasswordHash(expkey, klen * 2, pwdhash); 212 HashNtPasswordHash(pwdhash, pwdhashhash); 213 214 /* Generate NTRESPONSE to respond on challenge call */ 215 GenerateNTResponse(challenge + 1, peerchallenge + 1, name, 216 expkey, klen * 2, ntresponse); 217 218 /* Generate MPPE MASTERKEY */ 219 GetMasterKey(pwdhashhash, ntresponse, MPPE_MasterKey); /* XXX Global ! */ 220 221 /* Generate AUTHRESPONSE to verify on auth success */ 222 GenerateAuthenticatorResponse(expkey, klen * 2, ntresponse, 223 peerchallenge + 1, challenge + 1, name, 224 authresponse); 225 226 authresponse[CHAP81_AUTHRESPONSE_LEN] = 0; 227 228 memcpy(digest + CHAP81_RESPONSE_LEN, name, nlen); 229 } else 230 #endif 231 if ((result = malloc(nlen + 17)) != NULL) { 232 /* Normal MD5 stuff */ 233 MD5_CTX MD5context; 234 235 digest = result; 236 *digest++ = 16; /* value size */ 237 238 MD5_Init(&MD5context); 239 MD5_Update(&MD5context, &id, 1); 240 MD5_Update(&MD5context, key, klen); 241 MD5_Update(&MD5context, challenge + 1, *challenge); 242 MD5_Final(digest, &MD5context); 243 244 memcpy(digest + 16, name, nlen); 245 /* 246 * ---- -------- ------ 247 * result = | 16 | digest | name | 248 * ---- -------- ------ 249 */ 250 } 251 252 return result; 253 } 254 255 static void 256 chap_StartChild(struct chap *chap, char *prog, const char *name) 257 { 258 char *argv[MAXARGS], *nargv[MAXARGS]; 259 int argc, fd; 260 int in[2], out[2]; 261 pid_t pid; 262 263 if (chap->child.fd != -1) { 264 log_Printf(LogWARN, "Chap: %s: Program already running\n", prog); 265 return; 266 } 267 268 if (pipe(in) == -1) { 269 log_Printf(LogERROR, "Chap: pipe: %s\n", strerror(errno)); 270 return; 271 } 272 273 if (pipe(out) == -1) { 274 log_Printf(LogERROR, "Chap: pipe: %s\n", strerror(errno)); 275 close(in[0]); 276 close(in[1]); 277 return; 278 } 279 280 pid = getpid(); 281 switch ((chap->child.pid = fork())) { 282 case -1: 283 log_Printf(LogERROR, "Chap: fork: %s\n", strerror(errno)); 284 close(in[0]); 285 close(in[1]); 286 close(out[0]); 287 close(out[1]); 288 chap->child.pid = 0; 289 return; 290 291 case 0: 292 timer_TermService(); 293 294 if ((argc = command_Interpret(prog, strlen(prog), argv)) <= 0) { 295 if (argc < 0) { 296 log_Printf(LogWARN, "CHAP: Invalid command syntax\n"); 297 _exit(255); 298 } 299 _exit(0); 300 } 301 302 close(in[1]); 303 close(out[0]); 304 if (out[1] == STDIN_FILENO) 305 out[1] = dup(out[1]); 306 dup2(in[0], STDIN_FILENO); 307 dup2(out[1], STDOUT_FILENO); 308 close(STDERR_FILENO); 309 if (open(_PATH_DEVNULL, O_RDWR) != STDERR_FILENO) { 310 log_Printf(LogALERT, "Chap: Failed to open %s: %s\n", 311 _PATH_DEVNULL, strerror(errno)); 312 exit(1); 313 } 314 for (fd = getdtablesize(); fd > STDERR_FILENO; fd--) 315 fcntl(fd, F_SETFD, 1); 316 #ifndef NOSUID 317 setuid(ID0realuid()); 318 #endif 319 command_Expand(nargv, argc, (char const *const *)argv, 320 chap->auth.physical->dl->bundle, 0, pid); 321 execvp(nargv[0], nargv); 322 printf("exec() of %s failed: %s\n", nargv[0], strerror(errno)); 323 _exit(255); 324 325 default: 326 close(in[0]); 327 close(out[1]); 328 chap->child.fd = out[0]; 329 chap->child.buf.len = 0; 330 write(in[1], chap->auth.in.name, strlen(chap->auth.in.name)); 331 write(in[1], "\n", 1); 332 write(in[1], chap->challenge.peer + 1, *chap->challenge.peer); 333 write(in[1], "\n", 1); 334 write(in[1], name, strlen(name)); 335 write(in[1], "\n", 1); 336 close(in[1]); 337 break; 338 } 339 } 340 341 static void 342 chap_Cleanup(struct chap *chap, int sig) 343 { 344 if (chap->child.pid) { 345 int status; 346 347 close(chap->child.fd); 348 chap->child.fd = -1; 349 if (sig) 350 kill(chap->child.pid, SIGTERM); 351 chap->child.pid = 0; 352 chap->child.buf.len = 0; 353 354 if (wait(&status) == -1) 355 log_Printf(LogERROR, "Chap: wait: %s\n", strerror(errno)); 356 else if (WIFSIGNALED(status)) 357 log_Printf(LogWARN, "Chap: Child received signal %d\n", WTERMSIG(status)); 358 else if (WIFEXITED(status) && WEXITSTATUS(status)) 359 log_Printf(LogERROR, "Chap: Child exited %d\n", WEXITSTATUS(status)); 360 } 361 *chap->challenge.local = *chap->challenge.peer = '\0'; 362 #ifndef NODES 363 chap->peertries = 0; 364 #endif 365 } 366 367 static void 368 chap_Respond(struct chap *chap, char *name, char *key 369 #ifndef NODES 370 , u_char type, int lm 371 #endif 372 ) 373 { 374 u_char *ans; 375 376 ans = chap_BuildAnswer(name, key, chap->auth.id, chap->challenge.peer 377 #ifndef NODES 378 , type, chap->challenge.local, chap->authresponse, lm 379 #endif 380 ); 381 382 if (ans) { 383 ChapOutput(chap->auth.physical, CHAP_RESPONSE, chap->auth.id, 384 ans, *ans + 1 + strlen(name), name); 385 #ifndef NODES 386 chap->NTRespSent = !lm; 387 MPPE_IsServer = 0; /* XXX Global ! */ 388 #endif 389 free(ans); 390 } else 391 ChapOutput(chap->auth.physical, CHAP_FAILURE, chap->auth.id, 392 "Out of memory!", 14, NULL); 393 } 394 395 static int 396 chap_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w __unused, 397 fd_set *e __unused, int *n) 398 { 399 struct chap *chap = descriptor2chap(d); 400 401 if (r && chap && chap->child.fd != -1) { 402 FD_SET(chap->child.fd, r); 403 if (*n < chap->child.fd + 1) 404 *n = chap->child.fd + 1; 405 log_Printf(LogTIMER, "Chap: fdset(r) %d\n", chap->child.fd); 406 return 1; 407 } 408 409 return 0; 410 } 411 412 static int 413 chap_IsSet(struct fdescriptor *d, const fd_set *fdset) 414 { 415 struct chap *chap = descriptor2chap(d); 416 417 return chap && chap->child.fd != -1 && FD_ISSET(chap->child.fd, fdset); 418 } 419 420 static void 421 chap_Read(struct fdescriptor *d, struct bundle *bundle __unused, 422 const fd_set *fdset __unused) 423 { 424 struct chap *chap = descriptor2chap(d); 425 int got; 426 427 got = read(chap->child.fd, chap->child.buf.ptr + chap->child.buf.len, 428 sizeof chap->child.buf.ptr - chap->child.buf.len - 1); 429 if (got == -1) { 430 log_Printf(LogERROR, "Chap: Read: %s\n", strerror(errno)); 431 chap_Cleanup(chap, SIGTERM); 432 } else if (got == 0) { 433 log_Printf(LogWARN, "Chap: Read: Child terminated connection\n"); 434 chap_Cleanup(chap, SIGTERM); 435 } else { 436 char *name, *key, *end; 437 438 chap->child.buf.len += got; 439 chap->child.buf.ptr[chap->child.buf.len] = '\0'; 440 name = chap->child.buf.ptr; 441 name += strspn(name, " \t"); 442 if ((key = strchr(name, '\n')) == NULL) 443 end = NULL; 444 else 445 end = strchr(++key, '\n'); 446 447 if (end == NULL) { 448 if (chap->child.buf.len == sizeof chap->child.buf.ptr - 1) { 449 log_Printf(LogWARN, "Chap: Read: Input buffer overflow\n"); 450 chap_Cleanup(chap, SIGTERM); 451 } 452 } else { 453 #ifndef NODES 454 int lanman = chap->auth.physical->link.lcp.his_authtype == 0x80 && 455 ((chap->NTRespSent && 456 IsAccepted(chap->auth.physical->link.lcp.cfg.chap80lm)) || 457 !IsAccepted(chap->auth.physical->link.lcp.cfg.chap80nt)); 458 #endif 459 460 while (end >= name && strchr(" \t\r\n", *end)) 461 *end-- = '\0'; 462 end = key - 1; 463 while (end >= name && strchr(" \t\r\n", *end)) 464 *end-- = '\0'; 465 key += strspn(key, " \t"); 466 467 chap_Respond(chap, name, key 468 #ifndef NODES 469 , chap->auth.physical->link.lcp.his_authtype, lanman 470 #endif 471 ); 472 chap_Cleanup(chap, 0); 473 } 474 } 475 } 476 477 static int 478 chap_Write(struct fdescriptor *d __unused, struct bundle *bundle __unused, 479 const fd_set *fdset __unused) 480 { 481 /* We never want to write here ! */ 482 log_Printf(LogALERT, "chap_Write: Internal error: Bad call !\n"); 483 return 0; 484 } 485 486 static void 487 chap_ChallengeInit(struct authinfo *authp) 488 { 489 struct chap *chap = auth2chap(authp); 490 int len, i; 491 char *cp; 492 493 len = strlen(authp->physical->dl->bundle->cfg.auth.name); 494 495 if (!*chap->challenge.local) { 496 randinit(); 497 cp = chap->challenge.local; 498 499 #ifndef NORADIUS 500 if (*authp->physical->dl->bundle->radius.cfg.file) { 501 /* For radius, our challenge is 16 readable NUL terminated bytes :*/ 502 *cp++ = 16; 503 for (i = 0; i < 16; i++) 504 *cp++ = (random() % 10) + '0'; 505 } else 506 #endif 507 { 508 #ifndef NODES 509 if (authp->physical->link.lcp.want_authtype == 0x80) 510 *cp++ = 8; /* MS does 8 byte callenges :-/ */ 511 else if (authp->physical->link.lcp.want_authtype == 0x81) 512 *cp++ = 16; /* MS-CHAP-V2 does 16 bytes challenges */ 513 else 514 #endif 515 *cp++ = random() % (CHAPCHALLENGELEN-16) + 16; 516 for (i = 0; i < *chap->challenge.local; i++) 517 *cp++ = random() & 0xff; 518 } 519 memcpy(cp, authp->physical->dl->bundle->cfg.auth.name, len); 520 } 521 } 522 523 static void 524 chap_Challenge(struct authinfo *authp) 525 { 526 struct chap *chap = auth2chap(authp); 527 int len; 528 529 log_Printf(LogDEBUG, "CHAP%02X: Challenge\n", 530 authp->physical->link.lcp.want_authtype); 531 532 len = strlen(authp->physical->dl->bundle->cfg.auth.name); 533 534 /* Generate new local challenge value */ 535 if (!*chap->challenge.local) 536 chap_ChallengeInit(authp); 537 538 #ifndef NODES 539 if (authp->physical->link.lcp.want_authtype == 0x81) 540 ChapOutput(authp->physical, CHAP_CHALLENGE, authp->id, 541 chap->challenge.local, 1 + *chap->challenge.local, NULL); 542 else 543 #endif 544 ChapOutput(authp->physical, CHAP_CHALLENGE, authp->id, 545 chap->challenge.local, 1 + *chap->challenge.local + len, NULL); 546 } 547 548 static void 549 chap_Success(struct authinfo *authp) 550 { 551 struct bundle *bundle = authp->physical->dl->bundle; 552 const char *msg; 553 554 datalink_GotAuthname(authp->physical->dl, authp->in.name); 555 #ifndef NODES 556 if (authp->physical->link.lcp.want_authtype == 0x81) { 557 #ifndef NORADIUS 558 if (*bundle->radius.cfg.file && bundle->radius.msrepstr) 559 msg = bundle->radius.msrepstr; 560 else 561 #endif 562 msg = auth2chap(authp)->authresponse; 563 MPPE_MasterKeyValid = 1; /* XXX Global ! */ 564 } else 565 #endif 566 #ifndef NORADIUS 567 if (*bundle->radius.cfg.file && bundle->radius.repstr) 568 msg = bundle->radius.repstr; 569 else 570 #endif 571 msg = "Welcome!!"; 572 573 ChapOutput(authp->physical, CHAP_SUCCESS, authp->id, msg, strlen(msg), 574 NULL); 575 576 authp->physical->link.lcp.auth_ineed = 0; 577 if (Enabled(bundle, OPT_UTMP)) 578 physical_Login(authp->physical, authp->in.name); 579 580 if (authp->physical->link.lcp.auth_iwait == 0) 581 /* 582 * Either I didn't need to authenticate, or I've already been 583 * told that I got the answer right. 584 */ 585 datalink_AuthOk(authp->physical->dl); 586 } 587 588 static void 589 chap_Failure(struct authinfo *authp) 590 { 591 #ifndef NODES 592 char buf[1024], *ptr; 593 #endif 594 const char *msg; 595 596 #ifndef NORADIUS 597 struct bundle *bundle = authp->physical->link.lcp.fsm.bundle; 598 if (*bundle->radius.cfg.file && bundle->radius.errstr) 599 msg = bundle->radius.errstr; 600 else 601 #endif 602 #ifndef NODES 603 if (authp->physical->link.lcp.want_authtype == 0x80) { 604 sprintf(buf, "E=691 R=1 M=Invalid!"); 605 msg = buf; 606 } else if (authp->physical->link.lcp.want_authtype == 0x81) { 607 int i; 608 609 ptr = buf; 610 ptr += sprintf(buf, "E=691 R=0 C="); 611 for (i=0; i<16; i++) 612 ptr += sprintf(ptr, "%02X", *(auth2chap(authp)->challenge.local+1+i)); 613 614 sprintf(ptr, " V=3 M=Invalid!"); 615 msg = buf; 616 } else 617 #endif 618 msg = "Invalid!!"; 619 620 ChapOutput(authp->physical, CHAP_FAILURE, authp->id, msg, strlen(msg) + 1, 621 NULL); 622 datalink_AuthNotOk(authp->physical->dl); 623 } 624 625 static int 626 chap_Cmp(char *myans, int mylen, char *hisans, int hislen 627 #ifndef NODES 628 , u_char type, int lm 629 #endif 630 ) 631 { 632 if (mylen != hislen) 633 return 0; 634 #ifndef NODES 635 else if (type == 0x80) { 636 int off = lm ? 0 : 24; 637 638 if (memcmp(myans + off, hisans + off, 24)) 639 return 0; 640 } 641 #endif 642 else if (memcmp(myans, hisans, mylen)) 643 return 0; 644 645 return 1; 646 } 647 648 #ifndef NODES 649 static int 650 chap_HaveAnotherGo(struct chap *chap) 651 { 652 if (++chap->peertries < 3) { 653 /* Give the peer another shot */ 654 *chap->challenge.local = '\0'; 655 chap_Challenge(&chap->auth); 656 return 1; 657 } 658 659 return 0; 660 } 661 #endif 662 663 void 664 chap_Init(struct chap *chap, struct physical *p) 665 { 666 chap->desc.type = CHAP_DESCRIPTOR; 667 chap->desc.UpdateSet = chap_UpdateSet; 668 chap->desc.IsSet = chap_IsSet; 669 chap->desc.Read = chap_Read; 670 chap->desc.Write = chap_Write; 671 chap->child.pid = 0; 672 chap->child.fd = -1; 673 auth_Init(&chap->auth, p, chap_Challenge, chap_Success, chap_Failure); 674 *chap->challenge.local = *chap->challenge.peer = '\0'; 675 #ifndef NODES 676 chap->NTRespSent = 0; 677 chap->peertries = 0; 678 #endif 679 } 680 681 void 682 chap_ReInit(struct chap *chap) 683 { 684 chap_Cleanup(chap, SIGTERM); 685 } 686 687 struct mbuf * 688 chap_Input(struct bundle *bundle, struct link *l, struct mbuf *bp) 689 { 690 struct physical *p = link2physical(l); 691 struct chap *chap = &p->dl->chap; 692 char *name, *key, *ans; 693 int len; 694 size_t nlen; 695 u_char alen; 696 #ifndef NODES 697 int lanman; 698 #endif 699 700 if (p == NULL) { 701 log_Printf(LogERROR, "chap_Input: Not a physical link - dropped\n"); 702 m_freem(bp); 703 return NULL; 704 } 705 706 if (bundle_Phase(bundle) != PHASE_NETWORK && 707 bundle_Phase(bundle) != PHASE_AUTHENTICATE) { 708 log_Printf(LogPHASE, "Unexpected chap input - dropped !\n"); 709 m_freem(bp); 710 return NULL; 711 } 712 713 m_settype(bp, MB_CHAPIN); 714 if ((bp = auth_ReadHeader(&chap->auth, bp)) == NULL && 715 ntohs(chap->auth.in.hdr.length) == 0) 716 log_Printf(LogWARN, "Chap Input: Truncated header !\n"); 717 else if (chap->auth.in.hdr.code == 0 || chap->auth.in.hdr.code > MAXCHAPCODE) 718 log_Printf(LogPHASE, "Chap Input: %d: Bad CHAP code !\n", 719 chap->auth.in.hdr.code); 720 else { 721 len = m_length(bp); 722 ans = NULL; 723 724 if (chap->auth.in.hdr.code != CHAP_CHALLENGE && 725 chap->auth.id != chap->auth.in.hdr.id && 726 Enabled(bundle, OPT_IDCHECK)) { 727 /* Wrong conversation dude ! */ 728 log_Printf(LogPHASE, "Chap Input: %s dropped (got id %d, not %d)\n", 729 chapcodes[chap->auth.in.hdr.code], chap->auth.in.hdr.id, 730 chap->auth.id); 731 m_freem(bp); 732 return NULL; 733 } 734 chap->auth.id = chap->auth.in.hdr.id; /* We respond with this id */ 735 736 #ifndef NODES 737 lanman = 0; 738 #endif 739 switch (chap->auth.in.hdr.code) { 740 case CHAP_CHALLENGE: 741 bp = mbuf_Read(bp, &alen, 1); 742 len -= alen + 1; 743 if (len < 0) { 744 log_Printf(LogERROR, "Chap Input: Truncated challenge !\n"); 745 m_freem(bp); 746 return NULL; 747 } 748 *chap->challenge.peer = alen; 749 bp = mbuf_Read(bp, chap->challenge.peer + 1, alen); 750 bp = auth_ReadName(&chap->auth, bp, len); 751 #ifndef NODES 752 lanman = p->link.lcp.his_authtype == 0x80 && 753 ((chap->NTRespSent && IsAccepted(p->link.lcp.cfg.chap80lm)) || 754 !IsAccepted(p->link.lcp.cfg.chap80nt)); 755 756 /* Generate local challenge value */ 757 chap_ChallengeInit(&chap->auth); 758 #endif 759 break; 760 761 case CHAP_RESPONSE: 762 auth_StopTimer(&chap->auth); 763 bp = mbuf_Read(bp, &alen, 1); 764 len -= alen + 1; 765 if (len < 0) { 766 log_Printf(LogERROR, "Chap Input: Truncated response !\n"); 767 m_freem(bp); 768 return NULL; 769 } 770 if ((ans = malloc(alen + 1)) == NULL) { 771 log_Printf(LogERROR, "Chap Input: Out of memory !\n"); 772 m_freem(bp); 773 return NULL; 774 } 775 *ans = chap->auth.id; 776 bp = mbuf_Read(bp, ans + 1, alen); 777 bp = auth_ReadName(&chap->auth, bp, len); 778 #ifndef NODES 779 lanman = p->link.lcp.want_authtype == 0x80 && 780 alen == 49 && ans[alen] == 0; 781 #endif 782 break; 783 784 case CHAP_SUCCESS: 785 case CHAP_FAILURE: 786 /* chap->auth.in.name is already set up at CHALLENGE time */ 787 if ((ans = malloc(len + 1)) == NULL) { 788 log_Printf(LogERROR, "Chap Input: Out of memory !\n"); 789 m_freem(bp); 790 return NULL; 791 } 792 bp = mbuf_Read(bp, ans, len); 793 ans[len] = '\0'; 794 break; 795 } 796 797 switch (chap->auth.in.hdr.code) { 798 case CHAP_CHALLENGE: 799 case CHAP_RESPONSE: 800 if (*chap->auth.in.name) 801 log_Printf(LogPHASE, "Chap Input: %s (%d bytes from %s%s)\n", 802 chapcodes[chap->auth.in.hdr.code], alen, 803 chap->auth.in.name, 804 #ifndef NODES 805 lanman && chap->auth.in.hdr.code == CHAP_RESPONSE ? 806 " - lanman" : 807 #endif 808 ""); 809 else 810 log_Printf(LogPHASE, "Chap Input: %s (%d bytes%s)\n", 811 chapcodes[chap->auth.in.hdr.code], alen, 812 #ifndef NODES 813 lanman && chap->auth.in.hdr.code == CHAP_RESPONSE ? 814 " - lanman" : 815 #endif 816 ""); 817 break; 818 819 case CHAP_SUCCESS: 820 case CHAP_FAILURE: 821 if (*ans) 822 log_Printf(LogPHASE, "Chap Input: %s (%s)\n", 823 chapcodes[chap->auth.in.hdr.code], ans); 824 else 825 log_Printf(LogPHASE, "Chap Input: %s\n", 826 chapcodes[chap->auth.in.hdr.code]); 827 break; 828 } 829 830 switch (chap->auth.in.hdr.code) { 831 case CHAP_CHALLENGE: 832 if (*bundle->cfg.auth.key == '!' && bundle->cfg.auth.key[1] != '!') 833 chap_StartChild(chap, bundle->cfg.auth.key + 1, 834 bundle->cfg.auth.name); 835 else 836 chap_Respond(chap, bundle->cfg.auth.name, bundle->cfg.auth.key + 837 (*bundle->cfg.auth.key == '!' ? 1 : 0) 838 839 #ifndef NODES 840 , p->link.lcp.his_authtype, lanman 841 #endif 842 ); 843 break; 844 845 case CHAP_RESPONSE: 846 name = chap->auth.in.name; 847 nlen = strlen(name); 848 #ifndef NODES 849 if (p->link.lcp.want_authtype == 0x81) { 850 struct MSCHAPv2_resp *resp = (struct MSCHAPv2_resp *)(ans + 1); 851 852 chap->challenge.peer[0] = sizeof resp->PeerChallenge; 853 memcpy(chap->challenge.peer + 1, resp->PeerChallenge, 854 sizeof resp->PeerChallenge); 855 } 856 #endif 857 858 #ifndef NORADIUS 859 if (*bundle->radius.cfg.file) { 860 if (!radius_Authenticate(&bundle->radius, &chap->auth, 861 chap->auth.in.name, ans, alen + 1, 862 chap->challenge.local + 1, 863 *chap->challenge.local)) 864 chap_Failure(&chap->auth); 865 } else 866 #endif 867 { 868 if (p->link.lcp.want_authtype == 0x81 && ans[alen] != '\0' && 869 alen == sizeof(struct MSCHAPv2_resp)) { 870 struct MSCHAPv2_resp *resp = (struct MSCHAPv2_resp *)(ans + 1); 871 872 log_Printf(LogWARN, "%s: Compensating for corrupt (Win98/WinME?) " 873 "CHAP81 RESPONSE\n", l->name); 874 resp->Flags = '\0'; /* rfc2759 says it *MUST* be zero */ 875 } 876 key = auth_GetSecret(name, nlen); 877 if (key) { 878 #ifndef NODES 879 if (p->link.lcp.want_authtype == 0x80 && 880 lanman && !IsEnabled(p->link.lcp.cfg.chap80lm)) { 881 log_Printf(LogPHASE, "Auth failure: LANMan not enabled\n"); 882 if (chap_HaveAnotherGo(chap)) 883 break; 884 key = NULL; 885 } else if (p->link.lcp.want_authtype == 0x80 && 886 !lanman && !IsEnabled(p->link.lcp.cfg.chap80nt)) { 887 log_Printf(LogPHASE, "Auth failure: mschap not enabled\n"); 888 if (chap_HaveAnotherGo(chap)) 889 break; 890 key = NULL; 891 } else if (p->link.lcp.want_authtype == 0x81 && 892 !IsEnabled(p->link.lcp.cfg.chap81)) { 893 log_Printf(LogPHASE, "Auth failure: CHAP81 not enabled\n"); 894 key = NULL; 895 } else 896 #endif 897 { 898 char *myans = chap_BuildAnswer(name, key, chap->auth.id, 899 chap->challenge.local 900 #ifndef NODES 901 , p->link.lcp.want_authtype, 902 chap->challenge.peer, 903 chap->authresponse, lanman); 904 MPPE_IsServer = 1; /* XXX Global ! */ 905 #else 906 ); 907 #endif 908 if (myans == NULL) 909 key = NULL; 910 else { 911 if (!chap_Cmp(myans + 1, *myans, ans + 1, alen 912 #ifndef NODES 913 , p->link.lcp.want_authtype, lanman 914 #endif 915 )) 916 key = NULL; 917 free(myans); 918 } 919 } 920 } 921 922 if (key) 923 chap_Success(&chap->auth); 924 else 925 chap_Failure(&chap->auth); 926 } 927 928 break; 929 930 case CHAP_SUCCESS: 931 if (p->link.lcp.auth_iwait == PROTO_CHAP) { 932 p->link.lcp.auth_iwait = 0; 933 if (p->link.lcp.auth_ineed == 0) { 934 #ifndef NODES 935 if (p->link.lcp.his_authtype == 0x81) { 936 if (strncasecmp(ans, chap->authresponse, 42)) { 937 datalink_AuthNotOk(p->dl); 938 log_Printf(LogWARN, "CHAP81: AuthenticatorResponse: (%.42s)" 939 " != ans: (%.42s)\n", chap->authresponse, ans); 940 941 } else { 942 /* Successful login */ 943 MPPE_MasterKeyValid = 1; /* XXX Global ! */ 944 datalink_AuthOk(p->dl); 945 } 946 } else 947 #endif 948 /* 949 * We've succeeded in our ``login'' 950 * If we're not expecting the peer to authenticate (or he already 951 * has), proceed to network phase. 952 */ 953 datalink_AuthOk(p->dl); 954 } 955 } 956 break; 957 958 case CHAP_FAILURE: 959 datalink_AuthNotOk(p->dl); 960 break; 961 } 962 free(ans); 963 } 964 965 m_freem(bp); 966 return NULL; 967 } 968