pppd/chap-new.c

   1 /*
   2  * chap-new.c - New CHAP implementation.
   3  *
   4  * Copyright (c) 2003 Paul Mackerras. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. The name(s) of the authors of this software must not be used to
  14  *    endorse or promote products derived from this software without
  15  *    prior written permission.
  16  *
  17  * 3. Redistributions of any form whatsoever must retain the following
  18  *    acknowledgment:
  19  *    "This product includes software developed by Paul Mackerras
  20  *     <paulus@samba.org>".
  21  *
  22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29  */
  30
  31 #define RCSID   "$Id: chap-new.c,v 1.6 2004/11/04 10:02:26 paulus Exp $"
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include "pppd.h"
  36 #include "chap-new.h"
  37 #include "chap-md5.h"
  38
  39 #ifdef CHAPMS
  40 #include "chap_ms.h"
  41 #define MDTYPE_ALL (MDTYPE_MICROSOFT_V2 | MDTYPE_MICROSOFT | MDTYPE_MD5)
  42 #else
  43 #define MDTYPE_ALL (MDTYPE_MD5)
  44 #endif
  45
  46 int chap_mdtype_all = MDTYPE_ALL;
  47
  48 /* Hook for a plugin to validate CHAP challenge */
  49 int (*chap_verify_hook)(char *name, char *ourname, int id,
  50                         struct chap_digest_type *digest,
  51                         unsigned char *challenge, unsigned char *response,
  52                         char *message, int message_space) = NULL;
  53
  54 /*
  55  * Option variables.
  56  */
  57 int chap_timeout_time = 3;
  58 int chap_max_transmits = 10;
  59 int chap_rechallenge_time = 0;
  60
  61 /*
  62  * Command-line options.
  63  */
  64 static option_t chap_option_list[] = {
  65         { "chap-restart", o_int, &chap_timeout_time,
  66           "Set timeout for CHAP", OPT_PRIO },
  67         { "chap-max-challenge", o_int, &chap_max_transmits,
  68           "Set max #xmits for challenge", OPT_PRIO },
  69         { "chap-interval", o_int, &chap_rechallenge_time,
  70           "Set interval for rechallenge", OPT_PRIO },
  71         { NULL }
  72 };
  73
  74 /*
  75  * Internal state.
  76  */
  77 static struct chap_client_state {
  78         int flags;
  79         char *name;
  80         struct chap_digest_type *digest;
  81         unsigned char priv[64];         /* private area for digest's use */
  82 } client;
  83
  84 /*
  85  * These limits apply to challenge and response packets we send.
  86  * The +4 is the +1 that we actually need rounded up.
  87  */
  88 #define CHAL_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_CHALLENGE_LEN + MAXNAMELEN)
  89 #define RESP_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_RESPONSE_LEN + MAXNAMELEN)
  90
  91 static struct chap_server_state {
  92         int flags;
  93         int id;
  94         char *name;
  95         struct chap_digest_type *digest;
  96         int challenge_xmits;
  97         int challenge_pktlen;
  98         unsigned char challenge[CHAL_MAX_PKTLEN];
  99 } server;
 100
 101 /* Values for flags in chap_client_state and chap_server_state */
 102 #define LOWERUP                 1
 103 #define AUTH_STARTED            2
 104 #define AUTH_DONE               4
 105 #define AUTH_FAILED             8
 106 #define TIMEOUT_PENDING         0x10
 107 #define CHALLENGE_VALID         0x20
 108
 109 /*
 110  * Prototypes.
 111  */
 112 static void chap_init(int unit);
 113 static void chap_lowerup(int unit);
 114 static void chap_lowerdown(int unit);
 115 static void chap_timeout(void *arg);
 116 static void chap_generate_challenge(struct chap_server_state *ss);
 117 static void chap_handle_response(struct chap_server_state *ss, int code,
 118                 unsigned char *pkt, int len);
 119 static int chap_verify_response(char *name, char *ourname, int id,
 120                 struct chap_digest_type *digest,
 121                 unsigned char *challenge, unsigned char *response,
 122                 char *message, int message_space);
 123 static void chap_respond(struct chap_client_state *cs, int id,
 124                 unsigned char *pkt, int len);
 125 static void chap_handle_status(struct chap_client_state *cs, int code, int id,
 126                 unsigned char *pkt, int len);
 127 static void chap_protrej(int unit);
 128 static void chap_input(int unit, unsigned char *pkt, int pktlen);
 129 static int chap_print_pkt(unsigned char *p, int plen,
 130                 void (*printer) __P((void *, char *, ...)), void *arg);
 131
 132 /* List of digest types that we know about */
 133 static struct chap_digest_type *chap_digests;
 134
 135 /*
 136  * chap_init - reset to initial state.
 137  */
 138 static void
 139 chap_init(int unit)
 140 {
 141         memset(&client, 0, sizeof(client));
 142         memset(&server, 0, sizeof(server));
 143
 144         chap_md5_init();
 145 #ifdef CHAPMS
 146         chapms_init();
 147 #endif
 148 }
 149
 150 /*
 151  * Add a new digest type to the list.
 152  */
 153 void
 154 chap_register_digest(struct chap_digest_type *dp)
 155 {
 156         dp->next = chap_digests;
 157         chap_digests = dp;
 158 }
 159
 160 /*
 161  * chap_lowerup - we can start doing stuff now.
 162  */
 163 static void
 164 chap_lowerup(int unit)
 165 {
 166         struct chap_client_state *cs = &client;
 167         struct chap_server_state *ss = &server;
 168
 169         cs->flags |= LOWERUP;
 170         ss->flags |= LOWERUP;
 171         if (ss->flags & AUTH_STARTED)
 172                 chap_timeout(ss);
 173 }
 174
 175 static void
 176 chap_lowerdown(int unit)
 177 {
 178         struct chap_client_state *cs = &client;
 179         struct chap_server_state *ss = &server;
 180
 181         cs->flags = 0;
 182         if (ss->flags & TIMEOUT_PENDING)
 183                 UNTIMEOUT(chap_timeout, ss);
 184         ss->flags = 0;
 185 }
 186
 187 /*
 188  * chap_auth_peer - Start authenticating the peer.
 189  * If the lower layer is already up, we start sending challenges,
 190  * otherwise we wait for the lower layer to come up.
 191  */
 192 void
 193 chap_auth_peer(int unit, char *our_name, int digest_code)
 194 {
 195         struct chap_server_state *ss = &server;
 196         struct chap_digest_type *dp;
 197
 198         if (ss->flags & AUTH_STARTED) {
 199                 error("CHAP: peer authentication already started!");
 200                 return;
 201         }
 202         for (dp = chap_digests; dp != NULL; dp = dp->next)
 203                 if (dp->code == digest_code)
 204                         break;
 205         if (dp == NULL)
 206                 fatal("CHAP digest 0x%x requested but not available",
 207                       digest_code);
 208
 209         ss->digest = dp;
 210         ss->name = our_name;
 211         /* Start with a random ID value */
 212         ss->id = (unsigned char)(drand48() * 256);
 213         ss->flags |= AUTH_STARTED;
 214         if (ss->flags & LOWERUP)
 215                 chap_timeout(ss);
 216 }
 217
 218 /*
 219  * chap_auth_with_peer - Prepare to authenticate ourselves to the peer.
 220  * There isn't much to do until we receive a challenge.
 221  */
 222 void
 223 chap_auth_with_peer(int unit, char *our_name, int digest_code)
 224 {
 225         struct chap_client_state *cs = &client;
 226         struct chap_digest_type *dp;
 227
 228         if (cs->flags & AUTH_STARTED) {
 229                 error("CHAP: authentication with peer already started!");
 230                 return;
 231         }
 232         for (dp = chap_digests; dp != NULL; dp = dp->next)
 233                 if (dp->code == digest_code)
 234                         break;
 235         if (dp == NULL)
 236                 fatal("CHAP digest 0x%x requested but not available",
 237                       digest_code);
 238
 239         cs->digest = dp;
 240         cs->name = our_name;
 241         cs->flags |= AUTH_STARTED;
 242 }
 243
 244 /*
 245  * chap_timeout - It's time to send another challenge to the peer.
 246  * This could be either a retransmission of a previous challenge,
 247  * or a new challenge to start re-authentication.
 248  */
 249 static void
 250 chap_timeout(void *arg)
 251 {
 252         struct chap_server_state *ss = arg;
 253
 254         ss->flags &= ~TIMEOUT_PENDING;
 255         if ((ss->flags & CHALLENGE_VALID) == 0) {
 256                 ss->challenge_xmits = 0;
 257                 chap_generate_challenge(ss);
 258                 ss->flags |= CHALLENGE_VALID;
 259         } else if (ss->challenge_xmits >= chap_max_transmits) {
 260                 ss->flags &= ~CHALLENGE_VALID;
 261                 ss->flags |= AUTH_DONE | AUTH_FAILED;
 262                 auth_peer_fail(0, PPP_CHAP);
 263                 return;
 264         }
 265
 266         output(0, ss->challenge, ss->challenge_pktlen);
 267         ++ss->challenge_xmits;
 268         ss->flags |= TIMEOUT_PENDING;
 269         TIMEOUT(chap_timeout, arg, chap_timeout_time);
 270 }
 271
 272 /*
 273  * chap_generate_challenge - generate a challenge string and format
 274  * the challenge packet in ss->challenge_pkt.
 275  */
 276 static void
 277 chap_generate_challenge(struct chap_server_state *ss)
 278 {
 279         int clen = 1, nlen, len;
 280         unsigned char *p;
 281
 282         p = ss->challenge;
 283         MAKEHEADER(p, PPP_CHAP);
 284         p += CHAP_HDRLEN;
 285         ss->digest->generate_challenge(p);
 286         clen = *p;
 287         nlen = strlen(ss->name);
 288         memcpy(p + 1 + clen, ss->name, nlen);
 289
 290         len = CHAP_HDRLEN + 1 + clen + nlen;
 291         ss->challenge_pktlen = PPP_HDRLEN + len;
 292
 293         p = ss->challenge + PPP_HDRLEN;
 294         p[0] = CHAP_CHALLENGE;
 295         p[1] = ++ss->id;
 296         p[2] = len >> 8;
 297         p[3] = len;
 298 }
 299
 300 /*
 301  * chap_handle_response - check the response to our challenge.
 302  */
 303 static void
 304 chap_handle_response(struct chap_server_state *ss, int id,
 305                      unsigned char *pkt, int len)
 306 {
 307         int response_len, ok, mlen;
 308         unsigned char *response, *p;
 309         char *name = NULL;      /* initialized to shut gcc up */
 310         int (*verifier)(char *, char *, int, struct chap_digest_type *,
 311                 unsigned char *, unsigned char *, char *, int);
 312         char rname[MAXNAMELEN+1];
 313         char message[256];
 314
 315         if ((ss->flags & LOWERUP) == 0)
 316                 return;
 317         if (id != ss->challenge[PPP_HDRLEN+1] || len < 2)
 318                 return;
 319         if ((ss->flags & AUTH_DONE) == 0) {
 320                 if ((ss->flags & CHALLENGE_VALID) == 0)
 321                         return;
 322                 response = pkt;
 323                 GETCHAR(response_len, pkt);
 324                 len -= response_len + 1;        /* length of name */
 325                 name = (char *)pkt + response_len;
 326                 if (len < 0)
 327                         return;
 328
 329                 ss->flags &= ~CHALLENGE_VALID;
 330                 if (ss->flags & TIMEOUT_PENDING) {
 331                         ss->flags &= ~TIMEOUT_PENDING;
 332                         UNTIMEOUT(chap_timeout, ss);
 333                 }
 334
 335                 if (explicit_remote) {
 336                         name = remote_name;
 337                 } else {
 338                         /* Null terminate and clean remote name. */
 339                         slprintf(rname, sizeof(rname), "%.*v", len, name);
 340                         name = rname;
 341                 }
 342
 343                 if (chap_verify_hook)
 344                         verifier = chap_verify_hook;
 345                 else
 346                         verifier = chap_verify_response;
 347                 ok = (*verifier)(name, ss->name, id, ss->digest,
 348                                  ss->challenge + PPP_HDRLEN + CHAP_HDRLEN,
 349                                  response, message, sizeof(message));
 350                 if (!ok || !auth_number()) {
 351                         ss->flags |= AUTH_FAILED;
 352                         warn("Peer %q failed CHAP authentication", name);
 353                 }
 354         }
 355
 356         /* send the response */
 357         p = outpacket_buf;
 358         MAKEHEADER(p, PPP_CHAP);
 359         mlen = strlen(message);
 360         len = CHAP_HDRLEN + mlen;
 361         p[0] = (ss->flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS;
 362         p[1] = id;
 363         p[2] = len >> 8;
 364         p[3] = len;
 365         if (mlen > 0)
 366                 memcpy(p + CHAP_HDRLEN, message, mlen);
 367         output(0, outpacket_buf, PPP_HDRLEN + len);
 368
 369         if ((ss->flags & AUTH_DONE) == 0) {
 370                 ss->flags |= AUTH_DONE;
 371                 if (ss->flags & AUTH_FAILED) {
 372                         auth_peer_fail(0, PPP_CHAP);
 373                 } else {
 374                         auth_peer_success(0, PPP_CHAP, ss->digest->code,
 375                                           name, strlen(name));
 376                         if (chap_rechallenge_time) {
 377                                 ss->flags |= TIMEOUT_PENDING;
 378                                 TIMEOUT(chap_timeout, ss,
 379                                         chap_rechallenge_time);
 380                         }
 381                 }
 382         }
 383 }
 384
 385 /*
 386  * chap_verify_response - check whether the peer's response matches
 387  * what we think it should be.  Returns 1 if it does (authentication
 388  * succeeded), or 0 if it doesn't.
 389  */
 390 static int
 391 chap_verify_response(char *name, char *ourname, int id,
 392                      struct chap_digest_type *digest,
 393                      unsigned char *challenge, unsigned char *response,
 394                      char *message, int message_space)
 395 {
 396         int ok;
 397         unsigned char secret[MAXSECRETLEN];
 398         int secret_len;
 399
 400         /* Get the secret that the peer is supposed to know */
 401         if (!get_secret(0, name, ourname, (char *)secret, &secret_len, 1)) {
 402                 error("No CHAP secret found for authenticating %q", name);
 403                 return 0;
 404         }
 405
 406         ok = digest->verify_response(id, name, secret, secret_len, challenge,
 407                                      response, message, message_space);
 408         memset(secret, 0, sizeof(secret));
 409
 410         return ok;
 411 }
 412
 413 /*
 414  * chap_respond - Generate and send a response to a challenge.
 415  */
 416 static void
 417 chap_respond(struct chap_client_state *cs, int id,
 418              unsigned char *pkt, int len)
 419 {
 420         int clen, nlen;
 421         int secret_len;
 422         unsigned char *p;
 423         unsigned char response[RESP_MAX_PKTLEN];
 424         char rname[MAXNAMELEN+1];
 425         char secret[MAXSECRETLEN+1];
 426
 427         if ((cs->flags & (LOWERUP | AUTH_STARTED)) != (LOWERUP | AUTH_STARTED))
 428                 return;         /* not ready */
 429         if (len < 2 || len < pkt[0] + 1)
 430                 return;         /* too short */
 431         clen = pkt[0];
 432         nlen = len - (clen + 1);
 433
 434         /* Null terminate and clean remote name. */
 435         slprintf(rname, sizeof(rname), "%.*v", nlen, pkt + clen + 1);
 436
 437         /* Microsoft doesn't send their name back in the PPP packet */
 438         if (explicit_remote || (remote_name[0] != 0 && rname[0] == 0))
 439                 strlcpy(rname, remote_name, sizeof(rname));
 440
 441         /* get secret for authenticating ourselves with the specified host */
 442         if (!get_secret(0, cs->name, rname, secret, &secret_len, 0)) {
 443                 secret_len = 0; /* assume null secret if can't find one */
 444                 warn("No CHAP secret found for authenticating us to %q", rname);
 445         }
 446
 447         p = response;
 448         MAKEHEADER(p, PPP_CHAP);
 449         p += CHAP_HDRLEN;
 450
 451         cs->digest->make_response(p, id, cs->name, pkt,
 452                                   secret, secret_len, cs->priv);
 453         memset(secret, 0, secret_len);
 454
 455         clen = *p;
 456         nlen = strlen(cs->name);
 457         memcpy(p + clen + 1, cs->name, nlen);
 458
 459         p = response + PPP_HDRLEN;
 460         len = CHAP_HDRLEN + clen + 1 + nlen;
 461         p[0] = CHAP_RESPONSE;
 462         p[1] = id;
 463         p[2] = len >> 8;
 464         p[3] = len;
 465
 466         output(0, response, PPP_HDRLEN + len);
 467 }
 468
 469 static void
 470 chap_handle_status(struct chap_client_state *cs, int code, int id,
 471                    unsigned char *pkt, int len)
 472 {
 473         const char *msg = NULL;
 474
 475         if ((cs->flags & (AUTH_DONE|AUTH_STARTED|LOWERUP))
 476             != (AUTH_STARTED|LOWERUP))
 477                 return;
 478         cs->flags |= AUTH_DONE;
 479
 480         if (code == CHAP_SUCCESS) {
 481                 /* used for MS-CHAP v2 mutual auth, yuck */
 482                 if (cs->digest->check_success != NULL) {
 483                         if (!(*cs->digest->check_success)(pkt, len, cs->priv))
 484                                 code = CHAP_FAILURE;
 485                 } else
 486                         msg = "CHAP authentication succeeded";
 487         } else {
 488                 if (cs->digest->handle_failure != NULL)
 489                         (*cs->digest->handle_failure)(pkt, len);
 490                 else
 491                         msg = "CHAP authentication failed";
 492         }
 493         if (msg) {
 494                 if (len > 0)
 495                         info("%s: %.*v", msg, len, pkt);
 496                 else
 497                         info("%s", msg);
 498         }
 499         if (code == CHAP_SUCCESS)
 500                 auth_withpeer_success(0, PPP_CHAP, cs->digest->code);
 501         else {
 502                 cs->flags |= AUTH_FAILED;
 503                 auth_withpeer_fail(0, PPP_CHAP);
 504         }
 505 }
 506
 507 static void
 508 chap_input(int unit, unsigned char *pkt, int pktlen)
 509 {
 510         struct chap_client_state *cs = &client;
 511         struct chap_server_state *ss = &server;
 512         unsigned char code, id;
 513         int len;
 514
 515         if (pktlen < CHAP_HDRLEN)
 516                 return;
 517         GETCHAR(code, pkt);
 518         GETCHAR(id, pkt);
 519         GETSHORT(len, pkt);
 520         if (len < CHAP_HDRLEN || len > pktlen)
 521                 return;
 522         len -= CHAP_HDRLEN;
 523
 524         switch (code) {
 525         case CHAP_CHALLENGE:
 526                 chap_respond(cs, id, pkt, len);
 527                 break;
 528         case CHAP_RESPONSE:
 529                 chap_handle_response(ss, id, pkt, len);
 530                 break;
 531         case CHAP_FAILURE:
 532         case CHAP_SUCCESS:
 533                 chap_handle_status(cs, code, id, pkt, len);
 534                 break;
 535         }
 536 }
 537
 538 static void
 539 chap_protrej(int unit)
 540 {
 541         struct chap_client_state *cs = &client;
 542         struct chap_server_state *ss = &server;
 543
 544         if (ss->flags & TIMEOUT_PENDING) {
 545                 ss->flags &= ~TIMEOUT_PENDING;
 546                 UNTIMEOUT(chap_timeout, ss);
 547         }
 548         if (ss->flags & AUTH_STARTED) {
 549                 ss->flags = 0;
 550                 auth_peer_fail(0, PPP_CHAP);
 551         }
 552         if ((cs->flags & (AUTH_STARTED|AUTH_DONE)) == AUTH_STARTED) {
 553                 cs->flags &= ~AUTH_STARTED;
 554                 auth_withpeer_fail(0, PPP_CHAP);
 555         }
 556 }
 557
 558 /*
 559  * chap_print_pkt - print the contents of a CHAP packet.
 560  */
 561 static char *chap_code_names[] = {
 562         "Challenge", "Response", "Success", "Failure"
 563 };
 564
 565 static int
 566 chap_print_pkt(unsigned char *p, int plen,
 567                void (*printer) __P((void *, char *, ...)), void *arg)
 568 {
 569         int code, id, len;
 570         int clen, nlen;
 571         unsigned char x;
 572
 573         if (plen < CHAP_HDRLEN)
 574                 return 0;
 575         GETCHAR(code, p);
 576         GETCHAR(id, p);
 577         GETSHORT(len, p);
 578         if (len < CHAP_HDRLEN || len > plen)
 579                 return 0;
 580
 581         if (code >= 1 && code <= sizeof(chap_code_names) / sizeof(char *))
 582                 printer(arg, " %s", chap_code_names[code-1]);
 583         else
 584                 printer(arg, " code=0x%x", code);
 585         printer(arg, " id=0x%x", id);
 586         len -= CHAP_HDRLEN;
 587         switch (code) {
 588         case CHAP_CHALLENGE:
 589         case CHAP_RESPONSE:
 590                 if (len < 1)
 591                         break;
 592                 clen = p[0];
 593                 if (len < clen + 1)
 594                         break;
 595                 ++p;
 596                 nlen = len - clen - 1;
 597                 printer(arg, " <");
 598                 for (; clen > 0; --clen) {
 599                         GETCHAR(x, p);
 600                         printer(arg, "%.2x", x);
 601                 }
 602                 printer(arg, ">, name = ");
 603                 print_string((char *)p, nlen, printer, arg);
 604                 break;
 605         case CHAP_FAILURE:
 606         case CHAP_SUCCESS:
 607                 printer(arg, " ");
 608                 print_string((char *)p, len, printer, arg);
 609                 break;
 610         default:
 611                 for (clen = len; clen > 0; --clen) {
 612                         GETCHAR(x, p);
 613                         printer(arg, " %.2x", x);
 614                 }
 615         }
 616
 617         return len + CHAP_HDRLEN;
 618 }
 619
 620 struct protent chap_protent = {
 621         PPP_CHAP,
 622         chap_init,
 623         chap_input,
 624         chap_protrej,
 625         chap_lowerup,
 626         chap_lowerdown,
 627         NULL,           /* open */
 628         NULL,           /* close */
 629         chap_print_pkt,
 630         NULL,           /* datainput */
 631         1,              /* enabled_flag */
 632         "CHAP",         /* name */
 633         NULL,           /* data_name */
 634         chap_option_list,
 635         NULL,           /* check_options */
 636 };