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