50a78a2d221657c2e6e15bb3cb314835de203b5b
[ppp.git] / 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.27 2002/10/12 01:28:05 fcusack 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     char rhostname[256];
357     int retcode;
358     char *msg;
359     int msglen;
360
361     if (u->us_serverstate < UPAPSS_LISTEN)
362         return;
363
364     /*
365      * If we receive a duplicate authenticate-request, we are
366      * supposed to return the same status as for the first request.
367      */
368     if (u->us_serverstate == UPAPSS_OPEN) {
369         upap_sresp(u, UPAP_AUTHACK, id, "", 0); /* return auth-ack */
370         return;
371     }
372     if (u->us_serverstate == UPAPSS_BADAUTH) {
373         upap_sresp(u, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */
374         return;
375     }
376
377     /*
378      * Parse user/passwd.
379      */
380     if (len < 1) {
381         UPAPDEBUG(("pap_rauth: rcvd short packet."));
382         return;
383     }
384     GETCHAR(ruserlen, inp);
385     len -= sizeof (u_char) + ruserlen + sizeof (u_char);
386     if (len < 0) {
387         UPAPDEBUG(("pap_rauth: rcvd short packet."));
388         return;
389     }
390     ruser = (char *) inp;
391     INCPTR(ruserlen, inp);
392     GETCHAR(rpasswdlen, inp);
393     if (len < rpasswdlen) {
394         UPAPDEBUG(("pap_rauth: rcvd short packet."));
395         return;
396     }
397     rpasswd = (char *) inp;
398
399     /*
400      * Check the username and password given.
401      */
402     retcode = check_passwd(u->us_unit, ruser, ruserlen, rpasswd,
403                            rpasswdlen, &msg);
404     BZERO(rpasswd, rpasswdlen);
405
406     /*
407      * Check remote number authorization.  A plugin may have filled in
408      * the remote number or added an allowed number, and rather than
409      * return an authenticate failure, is leaving it for us to verify.
410      */
411     if (retcode == UPAP_AUTHACK) {
412         if (!auth_number()) {
413             /* We do not want to leak info about the pap result. */
414             retcode = UPAP_AUTHNAK; /* XXX exit value will be "wrong" */
415             error("calling number %q is not authorized", remote_number);
416         }
417     }
418
419     msglen = strlen(msg);
420     if (msglen > 255)
421         msglen = 255;
422     upap_sresp(u, retcode, id, msg, msglen);
423
424     /* Null terminate and clean remote name. */
425     slprintf(rhostname, sizeof(rhostname), "%.*v", ruserlen, ruser);
426
427     if (retcode == UPAP_AUTHACK) {
428         u->us_serverstate = UPAPSS_OPEN;
429         notice("PAP peer authentication succeeded for %q", rhostname);
430         auth_peer_success(u->us_unit, PPP_PAP, 0, ruser, ruserlen);
431     } else {
432         u->us_serverstate = UPAPSS_BADAUTH;
433         warn("PAP peer authentication failed for %q", rhostname);
434         auth_peer_fail(u->us_unit, PPP_PAP);
435     }
436
437     if (u->us_reqtimeout > 0)
438         UNTIMEOUT(upap_reqtimeout, u);
439 }
440
441
442 /*
443  * upap_rauthack - Receive Authenticate-Ack.
444  */
445 static void
446 upap_rauthack(u, inp, id, len)
447     upap_state *u;
448     u_char *inp;
449     int id;
450     int len;
451 {
452     u_char msglen;
453     char *msg;
454
455     if (u->us_clientstate != UPAPCS_AUTHREQ) /* XXX */
456         return;
457
458     /*
459      * Parse message.
460      */
461     if (len < 1) {
462         UPAPDEBUG(("pap_rauthack: ignoring missing msg-length."));
463     } else {
464         GETCHAR(msglen, inp);
465         if (msglen > 0) {
466             len -= sizeof (u_char);
467             if (len < msglen) {
468                 UPAPDEBUG(("pap_rauthack: rcvd short packet."));
469                 return;
470             }
471             msg = (char *) inp;
472             PRINTMSG(msg, msglen);
473         }
474     }
475
476     u->us_clientstate = UPAPCS_OPEN;
477
478     notice("PAP authentication succeeded");
479     auth_withpeer_success(u->us_unit, PPP_PAP, 0);
480 }
481
482
483 /*
484  * upap_rauthnak - Receive Authenticate-Nak.
485  */
486 static void
487 upap_rauthnak(u, inp, id, len)
488     upap_state *u;
489     u_char *inp;
490     int id;
491     int len;
492 {
493     u_char msglen;
494     char *msg;
495
496     if (u->us_clientstate != UPAPCS_AUTHREQ) /* XXX */
497         return;
498
499     /*
500      * Parse message.
501      */
502     if (len < 1) {
503         UPAPDEBUG(("pap_rauthnak: ignoring missing msg-length."));
504     } else {
505         GETCHAR(msglen, inp);
506         if (msglen > 0) {
507             len -= sizeof (u_char);
508             if (len < msglen) {
509                 UPAPDEBUG(("pap_rauthnak: rcvd short packet."));
510                 return;
511             }
512             msg = (char *) inp;
513             PRINTMSG(msg, msglen);
514         }
515     }
516
517     u->us_clientstate = UPAPCS_BADAUTH;
518
519     error("PAP authentication failed");
520     auth_withpeer_fail(u->us_unit, PPP_PAP);
521 }
522
523
524 /*
525  * upap_sauthreq - Send an Authenticate-Request.
526  */
527 static void
528 upap_sauthreq(u)
529     upap_state *u;
530 {
531     u_char *outp;
532     int outlen;
533
534     outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) +
535         u->us_userlen + u->us_passwdlen;
536     outp = outpacket_buf;
537     
538     MAKEHEADER(outp, PPP_PAP);
539
540     PUTCHAR(UPAP_AUTHREQ, outp);
541     PUTCHAR(++u->us_id, outp);
542     PUTSHORT(outlen, outp);
543     PUTCHAR(u->us_userlen, outp);
544     BCOPY(u->us_user, outp, u->us_userlen);
545     INCPTR(u->us_userlen, outp);
546     PUTCHAR(u->us_passwdlen, outp);
547     BCOPY(u->us_passwd, outp, u->us_passwdlen);
548
549     output(u->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
550
551     TIMEOUT(upap_timeout, u, u->us_timeouttime);
552     ++u->us_transmits;
553     u->us_clientstate = UPAPCS_AUTHREQ;
554 }
555
556
557 /*
558  * upap_sresp - Send a response (ack or nak).
559  */
560 static void
561 upap_sresp(u, code, id, msg, msglen)
562     upap_state *u;
563     u_char code, id;
564     char *msg;
565     int msglen;
566 {
567     u_char *outp;
568     int outlen;
569
570     outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen;
571     outp = outpacket_buf;
572     MAKEHEADER(outp, PPP_PAP);
573
574     PUTCHAR(code, outp);
575     PUTCHAR(id, outp);
576     PUTSHORT(outlen, outp);
577     PUTCHAR(msglen, outp);
578     BCOPY(msg, outp, msglen);
579     output(u->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
580 }
581
582 /*
583  * upap_printpkt - print the contents of a PAP packet.
584  */
585 static char *upap_codenames[] = {
586     "AuthReq", "AuthAck", "AuthNak"
587 };
588
589 static int
590 upap_printpkt(p, plen, printer, arg)
591     u_char *p;
592     int plen;
593     void (*printer) __P((void *, char *, ...));
594     void *arg;
595 {
596     int code, id, len;
597     int mlen, ulen, wlen;
598     char *user, *pwd, *msg;
599     u_char *pstart;
600
601     if (plen < UPAP_HEADERLEN)
602         return 0;
603     pstart = p;
604     GETCHAR(code, p);
605     GETCHAR(id, p);
606     GETSHORT(len, p);
607     if (len < UPAP_HEADERLEN || len > plen)
608         return 0;
609
610     if (code >= 1 && code <= sizeof(upap_codenames) / sizeof(char *))
611         printer(arg, " %s", upap_codenames[code-1]);
612     else
613         printer(arg, " code=0x%x", code);
614     printer(arg, " id=0x%x", id);
615     len -= UPAP_HEADERLEN;
616     switch (code) {
617     case UPAP_AUTHREQ:
618         if (len < 1)
619             break;
620         ulen = p[0];
621         if (len < ulen + 2)
622             break;
623         wlen = p[ulen + 1];
624         if (len < ulen + wlen + 2)
625             break;
626         user = (char *) (p + 1);
627         pwd = (char *) (p + ulen + 2);
628         p += ulen + wlen + 2;
629         len -= ulen + wlen + 2;
630         printer(arg, " user=");
631         print_string(user, ulen, printer, arg);
632         printer(arg, " password=");
633         if (!hide_password)
634             print_string(pwd, wlen, printer, arg);
635         else
636             printer(arg, "<hidden>");
637         break;
638     case UPAP_AUTHACK:
639     case UPAP_AUTHNAK:
640         if (len < 1)
641             break;
642         mlen = p[0];
643         if (len < mlen + 1)
644             break;
645         msg = (char *) (p + 1);
646         p += mlen + 1;
647         len -= mlen + 1;
648         printer(arg, " ");
649         print_string(msg, mlen, printer, arg);
650         break;
651     }
652
653     /* print the rest of the bytes in the packet */
654     for (; len > 0; --len) {
655         GETCHAR(code, p);
656         printer(arg, " %.2x", code);
657     }
658
659     return p - pstart;
660 }