pppd/upap.c

   1 /*
   2  * upap.c - User/Password Authentication Protocol.
   3  *
   4  * Copyright (c) 1989 Carnegie Mellon University.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms are permitted
   8  * provided that the above copyright notice and this paragraph are
   9  * duplicated in all such forms and that any documentation,
  10  * advertising materials, and other materials related to such
  11  * distribution and use acknowledge that the software was developed
  12  * by Carnegie Mellon University.  The name of the
  13  * University may not be used to endorse or promote products derived
  14  * from this software without specific prior written permission.
  15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18  */
  19
  20 #define RCSID   "$Id: upap.c,v 1.25 2002/04/02 13:54:59 dfs Exp $"
  21
  22 /*
  23  * TODO:
  24  */
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "pppd.h"
  30 #include "upap.h"
  31
  32 static const char rcsid[] = RCSID;
  33
  34 static bool hide_password = 1;
  35
  36 /*
  37  * Command-line options.
  38  */
  39 static option_t pap_option_list[] = {
  40     { "hide-password", o_bool, &hide_password,
  41       "Don't output passwords to log", OPT_PRIO | 1 },
  42     { "show-password", o_bool, &hide_password,
  43       "Show password string in debug log messages", OPT_PRIOSUB | 0 },
  44
  45     { "pap-restart", o_int, &upap[0].us_timeouttime,
  46       "Set retransmit timeout for PAP", OPT_PRIO },
  47     { "pap-max-authreq", o_int, &upap[0].us_maxtransmits,
  48       "Set max number of transmissions for auth-reqs", OPT_PRIO },
  49     { "pap-timeout", o_int, &upap[0].us_reqtimeout,
  50       "Set time limit for peer PAP authentication", OPT_PRIO },
  51
  52     { NULL }
  53 };
  54
  55 /*
  56  * Protocol entry points.
  57  */
  58 static void upap_init __P((int));
  59 static void upap_lowerup __P((int));
  60 static void upap_lowerdown __P((int));
  61 static void upap_input __P((int, u_char *, int));
  62 static void upap_protrej __P((int));
  63 static int  upap_printpkt __P((u_char *, int,
  64                                void (*) __P((void *, char *, ...)), void *));
  65
  66 struct protent pap_protent = {
  67     PPP_PAP,
  68     upap_init,
  69     upap_input,
  70     upap_protrej,
  71     upap_lowerup,
  72     upap_lowerdown,
  73     NULL,
  74     NULL,
  75     upap_printpkt,
  76     NULL,
  77     1,
  78     "PAP",
  79     NULL,
  80     pap_option_list,
  81     NULL,
  82     NULL,
  83     NULL
  84 };
  85
  86 upap_state upap[NUM_PPP];               /* UPAP state; one for each unit */
  87
  88 static void upap_timeout __P((void *));
  89 static void upap_reqtimeout __P((void *));
  90 static void upap_rauthreq __P((upap_state *, u_char *, int, int));
  91 static void upap_rauthack __P((upap_state *, u_char *, int, int));
  92 static void upap_rauthnak __P((upap_state *, u_char *, int, int));
  93 static void upap_sauthreq __P((upap_state *));
  94 static void upap_sresp __P((upap_state *, int, int, char *, int));
  95
  96
  97 /*
  98  * upap_init - Initialize a UPAP unit.
  99  */
 100 static void
 101 upap_init(unit)
 102     int unit;
 103 {
 104     upap_state *u = &upap[unit];
 105
 106     u->us_unit = unit;
 107     u->us_user = NULL;
 108     u->us_userlen = 0;
 109     u->us_passwd = NULL;
 110     u->us_passwdlen = 0;
 111     u->us_clientstate = UPAPCS_INITIAL;
 112     u->us_serverstate = UPAPSS_INITIAL;
 113     u->us_id = 0;
 114     u->us_timeouttime = UPAP_DEFTIMEOUT;
 115     u->us_maxtransmits = 10;
 116     u->us_reqtimeout = UPAP_DEFREQTIME;
 117 }
 118
 119
 120 /*
 121  * upap_authwithpeer - Authenticate us with our peer (start client).
 122  *
 123  * Set new state and send authenticate's.
 124  */
 125 void
 126 upap_authwithpeer(unit, user, password)
 127     int unit;
 128     char *user, *password;
 129 {
 130     upap_state *u = &upap[unit];
 131
 132     /* Save the username and password we're given */
 133     u->us_user = user;
 134     u->us_userlen = strlen(user);
 135     u->us_passwd = password;
 136     u->us_passwdlen = strlen(password);
 137     u->us_transmits = 0;
 138
 139     /* Lower layer up yet? */
 140     if (u->us_clientstate == UPAPCS_INITIAL ||
 141         u->us_clientstate == UPAPCS_PENDING) {
 142         u->us_clientstate = UPAPCS_PENDING;
 143         return;
 144     }
 145
 146     upap_sauthreq(u);                   /* Start protocol */
 147 }
 148
 149
 150 /*
 151  * upap_authpeer - Authenticate our peer (start server).
 152  *
 153  * Set new state.
 154  */
 155 void
 156 upap_authpeer(unit)
 157     int unit;
 158 {
 159     upap_state *u = &upap[unit];
 160
 161     /* Lower layer up yet? */
 162     if (u->us_serverstate == UPAPSS_INITIAL ||
 163         u->us_serverstate == UPAPSS_PENDING) {
 164         u->us_serverstate = UPAPSS_PENDING;
 165         return;
 166     }
 167
 168     u->us_serverstate = UPAPSS_LISTEN;
 169     if (u->us_reqtimeout > 0)
 170         TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout);
 171 }
 172
 173
 174 /*
 175  * upap_timeout - Retransmission timer for sending auth-reqs expired.
 176  */
 177 static void
 178 upap_timeout(arg)
 179     void *arg;
 180 {
 181     upap_state *u = (upap_state *) arg;
 182
 183     if (u->us_clientstate != UPAPCS_AUTHREQ)
 184         return;
 185
 186     if (u->us_transmits >= u->us_maxtransmits) {
 187         /* give up in disgust */
 188         error("No response to PAP authenticate-requests");
 189         u->us_clientstate = UPAPCS_BADAUTH;
 190         auth_withpeer_fail(u->us_unit, PPP_PAP);
 191         return;
 192     }
 193
 194     upap_sauthreq(u);           /* Send Authenticate-Request */
 195 }
 196
 197
 198 /*
 199  * upap_reqtimeout - Give up waiting for the peer to send an auth-req.
 200  */
 201 static void
 202 upap_reqtimeout(arg)
 203     void *arg;
 204 {
 205     upap_state *u = (upap_state *) arg;
 206
 207     if (u->us_serverstate != UPAPSS_LISTEN)
 208         return;                 /* huh?? */
 209
 210     auth_peer_fail(u->us_unit, PPP_PAP);
 211     u->us_serverstate = UPAPSS_BADAUTH;
 212 }
 213
 214
 215 /*
 216  * upap_lowerup - The lower layer is up.
 217  *
 218  * Start authenticating if pending.
 219  */
 220 static void
 221 upap_lowerup(unit)
 222     int unit;
 223 {
 224     upap_state *u = &upap[unit];
 225
 226     if (u->us_clientstate == UPAPCS_INITIAL)
 227         u->us_clientstate = UPAPCS_CLOSED;
 228     else if (u->us_clientstate == UPAPCS_PENDING) {
 229         upap_sauthreq(u);       /* send an auth-request */
 230     }
 231
 232     if (u->us_serverstate == UPAPSS_INITIAL)
 233         u->us_serverstate = UPAPSS_CLOSED;
 234     else if (u->us_serverstate == UPAPSS_PENDING) {
 235         u->us_serverstate = UPAPSS_LISTEN;
 236         if (u->us_reqtimeout > 0)
 237             TIMEOUT(upap_reqtimeout, u, u->us_reqtimeout);
 238     }
 239 }
 240
 241
 242 /*
 243  * upap_lowerdown - The lower layer is down.
 244  *
 245  * Cancel all timeouts.
 246  */
 247 static void
 248 upap_lowerdown(unit)
 249     int unit;
 250 {
 251     upap_state *u = &upap[unit];
 252
 253     if (u->us_clientstate == UPAPCS_AUTHREQ)    /* Timeout pending? */
 254         UNTIMEOUT(upap_timeout, u);             /* Cancel timeout */
 255     if (u->us_serverstate == UPAPSS_LISTEN && u->us_reqtimeout > 0)
 256         UNTIMEOUT(upap_reqtimeout, u);
 257
 258     u->us_clientstate = UPAPCS_INITIAL;
 259     u->us_serverstate = UPAPSS_INITIAL;
 260 }
 261
 262
 263 /*
 264  * upap_protrej - Peer doesn't speak this protocol.
 265  *
 266  * This shouldn't happen.  In any case, pretend lower layer went down.
 267  */
 268 static void
 269 upap_protrej(unit)
 270     int unit;
 271 {
 272     upap_state *u = &upap[unit];
 273
 274     if (u->us_clientstate == UPAPCS_AUTHREQ) {
 275         error("PAP authentication failed due to protocol-reject");
 276         auth_withpeer_fail(unit, PPP_PAP);
 277     }
 278     if (u->us_serverstate == UPAPSS_LISTEN) {
 279         error("PAP authentication of peer failed (protocol-reject)");
 280         auth_peer_fail(unit, PPP_PAP);
 281     }
 282     upap_lowerdown(unit);
 283 }
 284
 285
 286 /*
 287  * upap_input - Input UPAP packet.
 288  */
 289 static void
 290 upap_input(unit, inpacket, l)
 291     int unit;
 292     u_char *inpacket;
 293     int l;
 294 {
 295     upap_state *u = &upap[unit];
 296     u_char *inp;
 297     u_char code, id;
 298     int len;
 299
 300     /*
 301      * Parse header (code, id and length).
 302      * If packet too short, drop it.
 303      */
 304     inp = inpacket;
 305     if (l < UPAP_HEADERLEN) {
 306         UPAPDEBUG(("pap_input: rcvd short header."));
 307         return;
 308     }
 309     GETCHAR(code, inp);
 310     GETCHAR(id, inp);
 311     GETSHORT(len, inp);
 312     if (len < UPAP_HEADERLEN) {
 313         UPAPDEBUG(("pap_input: rcvd illegal length."));
 314         return;
 315     }
 316     if (len > l) {
 317         UPAPDEBUG(("pap_input: rcvd short packet."));
 318         return;
 319     }
 320     len -= UPAP_HEADERLEN;
 321
 322     /*
 323      * Action depends on code.
 324      */
 325     switch (code) {
 326     case UPAP_AUTHREQ:
 327         upap_rauthreq(u, inp, id, len);
 328         break;
 329
 330     case UPAP_AUTHACK:
 331         upap_rauthack(u, inp, id, len);
 332         break;
 333
 334     case UPAP_AUTHNAK:
 335         upap_rauthnak(u, inp, id, len);
 336         break;
 337
 338     default:                            /* XXX Need code reject */
 339         break;
 340     }
 341 }
 342
 343
 344 /*
 345  * upap_rauth - Receive Authenticate.
 346  */
 347 static void
 348 upap_rauthreq(u, inp, id, len)
 349     upap_state *u;
 350     u_char *inp;
 351     int id;
 352     int len;
 353 {
 354     u_char ruserlen, rpasswdlen;
 355     char *ruser, *rpasswd;
 356     int retcode;
 357     char *msg;
 358     int msglen;
 359
 360     if (u->us_serverstate < UPAPSS_LISTEN)
 361         return;
 362
 363     /*
 364      * If we receive a duplicate authenticate-request, we are
 365      * supposed to return the same status as for the first request.
 366      */
 367     if (u->us_serverstate == UPAPSS_OPEN) {
 368         upap_sresp(u, UPAP_AUTHACK, id, "", 0); /* return auth-ack */
 369         return;
 370     }
 371     if (u->us_serverstate == UPAPSS_BADAUTH) {
 372         upap_sresp(u, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */
 373         return;
 374     }
 375
 376     /*
 377      * Parse user/passwd.
 378      */
 379     if (len < 1) {
 380         UPAPDEBUG(("pap_rauth: rcvd short packet."));
 381         return;
 382     }
 383     GETCHAR(ruserlen, inp);
 384     len -= sizeof (u_char) + ruserlen + sizeof (u_char);
 385     if (len < 0) {
 386         UPAPDEBUG(("pap_rauth: rcvd short packet."));
 387         return;
 388     }
 389     ruser = (char *) inp;
 390     INCPTR(ruserlen, inp);
 391     GETCHAR(rpasswdlen, inp);
 392     if (len < rpasswdlen) {
 393         UPAPDEBUG(("pap_rauth: rcvd short packet."));
 394         return;
 395     }
 396     rpasswd = (char *) inp;
 397
 398     /*
 399      * Check the username and password given.
 400      */
 401     retcode = check_passwd(u->us_unit, ruser, ruserlen, rpasswd,
 402                            rpasswdlen, &msg);
 403     BZERO(rpasswd, rpasswdlen);
 404     msglen = strlen(msg);
 405     if (msglen > 255)
 406         msglen = 255;
 407
 408     upap_sresp(u, retcode, id, msg, msglen);
 409
 410     if (retcode == UPAP_AUTHACK) {
 411         u->us_serverstate = UPAPSS_OPEN;
 412         auth_peer_success(u->us_unit, PPP_PAP, 0, ruser, ruserlen);
 413     } else {
 414         u->us_serverstate = UPAPSS_BADAUTH;
 415         auth_peer_fail(u->us_unit, PPP_PAP);
 416     }
 417
 418     if (u->us_reqtimeout > 0)
 419         UNTIMEOUT(upap_reqtimeout, u);
 420 }
 421
 422
 423 /*
 424  * upap_rauthack - Receive Authenticate-Ack.
 425  */
 426 static void
 427 upap_rauthack(u, inp, id, len)
 428     upap_state *u;
 429     u_char *inp;
 430     int id;
 431     int len;
 432 {
 433     u_char msglen;
 434     char *msg;
 435
 436     if (u->us_clientstate != UPAPCS_AUTHREQ) /* XXX */
 437         return;
 438
 439     /*
 440      * Parse message.
 441      */
 442     if (len < 1) {
 443         UPAPDEBUG(("pap_rauthack: ignoring missing msg-length."));
 444     } else {
 445         GETCHAR(msglen, inp);
 446         if (msglen > 0) {
 447             len -= sizeof (u_char);
 448             if (len < msglen) {
 449                 UPAPDEBUG(("pap_rauthack: rcvd short packet."));
 450                 return;
 451             }
 452             msg = (char *) inp;
 453             PRINTMSG(msg, msglen);
 454         }
 455     }
 456
 457     u->us_clientstate = UPAPCS_OPEN;
 458
 459     auth_withpeer_success(u->us_unit, PPP_PAP, 0);
 460 }
 461
 462
 463 /*
 464  * upap_rauthnak - Receive Authenticate-Nakk.
 465  */
 466 static void
 467 upap_rauthnak(u, inp, id, len)
 468     upap_state *u;
 469     u_char *inp;
 470     int id;
 471     int len;
 472 {
 473     u_char msglen;
 474     char *msg;
 475
 476     if (u->us_clientstate != UPAPCS_AUTHREQ) /* XXX */
 477         return;
 478
 479     /*
 480      * Parse message.
 481      */
 482     if (len < 1) {
 483         UPAPDEBUG(("pap_rauthnak: ignoring missing msg-length."));
 484     } else {
 485         GETCHAR(msglen, inp);
 486         if (msglen > 0) {
 487             len -= sizeof (u_char);
 488             if (len < msglen) {
 489                 UPAPDEBUG(("pap_rauthnak: rcvd short packet."));
 490                 return;
 491             }
 492             msg = (char *) inp;
 493             PRINTMSG(msg, msglen);
 494         }
 495     }
 496
 497     u->us_clientstate = UPAPCS_BADAUTH;
 498
 499     error("PAP authentication failed");
 500     auth_withpeer_fail(u->us_unit, PPP_PAP);
 501 }
 502
 503
 504 /*
 505  * upap_sauthreq - Send an Authenticate-Request.
 506  */
 507 static void
 508 upap_sauthreq(u)
 509     upap_state *u;
 510 {
 511     u_char *outp;
 512     int outlen;
 513
 514     outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) +
 515         u->us_userlen + u->us_passwdlen;
 516     outp = outpacket_buf;
 517
 518     MAKEHEADER(outp, PPP_PAP);
 519
 520     PUTCHAR(UPAP_AUTHREQ, outp);
 521     PUTCHAR(++u->us_id, outp);
 522     PUTSHORT(outlen, outp);
 523     PUTCHAR(u->us_userlen, outp);
 524     BCOPY(u->us_user, outp, u->us_userlen);
 525     INCPTR(u->us_userlen, outp);
 526     PUTCHAR(u->us_passwdlen, outp);
 527     BCOPY(u->us_passwd, outp, u->us_passwdlen);
 528
 529     output(u->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
 530
 531     TIMEOUT(upap_timeout, u, u->us_timeouttime);
 532     ++u->us_transmits;
 533     u->us_clientstate = UPAPCS_AUTHREQ;
 534 }
 535
 536
 537 /*
 538  * upap_sresp - Send a response (ack or nak).
 539  */
 540 static void
 541 upap_sresp(u, code, id, msg, msglen)
 542     upap_state *u;
 543     u_char code, id;
 544     char *msg;
 545     int msglen;
 546 {
 547     u_char *outp;
 548     int outlen;
 549
 550     outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen;
 551     outp = outpacket_buf;
 552     MAKEHEADER(outp, PPP_PAP);
 553
 554     PUTCHAR(code, outp);
 555     PUTCHAR(id, outp);
 556     PUTSHORT(outlen, outp);
 557     PUTCHAR(msglen, outp);
 558     BCOPY(msg, outp, msglen);
 559     output(u->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
 560 }
 561
 562 /*
 563  * upap_printpkt - print the contents of a PAP packet.
 564  */
 565 static char *upap_codenames[] = {
 566     "AuthReq", "AuthAck", "AuthNak"
 567 };
 568
 569 static int
 570 upap_printpkt(p, plen, printer, arg)
 571     u_char *p;
 572     int plen;
 573     void (*printer) __P((void *, char *, ...));
 574     void *arg;
 575 {
 576     int code, id, len;
 577     int mlen, ulen, wlen;
 578     char *user, *pwd, *msg;
 579     u_char *pstart;
 580
 581     if (plen < UPAP_HEADERLEN)
 582         return 0;
 583     pstart = p;
 584     GETCHAR(code, p);
 585     GETCHAR(id, p);
 586     GETSHORT(len, p);
 587     if (len < UPAP_HEADERLEN || len > plen)
 588         return 0;
 589
 590     if (code >= 1 && code <= sizeof(upap_codenames) / sizeof(char *))
 591         printer(arg, " %s", upap_codenames[code-1]);
 592     else
 593         printer(arg, " code=0x%x", code);
 594     printer(arg, " id=0x%x", id);
 595     len -= UPAP_HEADERLEN;
 596     switch (code) {
 597     case UPAP_AUTHREQ:
 598         if (len < 1)
 599             break;
 600         ulen = p[0];
 601         if (len < ulen + 2)
 602             break;
 603         wlen = p[ulen + 1];
 604         if (len < ulen + wlen + 2)
 605             break;
 606         user = (char *) (p + 1);
 607         pwd = (char *) (p + ulen + 2);
 608         p += ulen + wlen + 2;
 609         len -= ulen + wlen + 2;
 610         printer(arg, " user=");
 611         print_string(user, ulen, printer, arg);
 612         printer(arg, " password=");
 613         if (!hide_password)
 614             print_string(pwd, wlen, printer, arg);
 615         else
 616             printer(arg, "<hidden>");
 617         break;
 618     case UPAP_AUTHACK:
 619     case UPAP_AUTHNAK:
 620         if (len < 1)
 621             break;
 622         mlen = p[0];
 623         if (len < mlen + 1)
 624             break;
 625         msg = (char *) (p + 1);
 626         p += mlen + 1;
 627         len -= mlen + 1;
 628         printer(arg, " ");
 629         print_string(msg, mlen, printer, arg);
 630         break;
 631     }
 632
 633     /* print the rest of the bytes in the packet */
 634     for (; len > 0; --len) {
 635         GETCHAR(code, p);
 636         printer(arg, " %.2x", code);
 637     }
 638
 639     return p - pstart;
 640 }