Make authentication success/failure messages uniform.
[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.26 2002/10/11 22:11:13 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     msglen = strlen(msg);
406     if (msglen > 255)
407         msglen = 255;
408
409     upap_sresp(u, retcode, id, msg, msglen);
410
411     if (ruserlen >= sizeof(rhostname))
412         ruserlen = sizeof(rhostname) - 1;
413     BCOPY(ruser, rhostname, ruserlen);
414     rhostname[ruserlen] = '\000';
415
416     if (retcode == UPAP_AUTHACK) {
417         u->us_serverstate = UPAPSS_OPEN;
418         notice("PAP peer authentication succeeded for %q", rhostname);
419         auth_peer_success(u->us_unit, PPP_PAP, 0, ruser, ruserlen);
420     } else {
421         u->us_serverstate = UPAPSS_BADAUTH;
422         error("PAP peer authentication failed for %q", rhostname);
423         auth_peer_fail(u->us_unit, PPP_PAP);
424     }
425
426     if (u->us_reqtimeout > 0)
427         UNTIMEOUT(upap_reqtimeout, u);
428 }
429
430
431 /*
432  * upap_rauthack - Receive Authenticate-Ack.
433  */
434 static void
435 upap_rauthack(u, inp, id, len)
436     upap_state *u;
437     u_char *inp;
438     int id;
439     int len;
440 {
441     u_char msglen;
442     char *msg;
443
444     if (u->us_clientstate != UPAPCS_AUTHREQ) /* XXX */
445         return;
446
447     /*
448      * Parse message.
449      */
450     if (len < 1) {
451         UPAPDEBUG(("pap_rauthack: ignoring missing msg-length."));
452     } else {
453         GETCHAR(msglen, inp);
454         if (msglen > 0) {
455             len -= sizeof (u_char);
456             if (len < msglen) {
457                 UPAPDEBUG(("pap_rauthack: rcvd short packet."));
458                 return;
459             }
460             msg = (char *) inp;
461             PRINTMSG(msg, msglen);
462         }
463     }
464
465     u->us_clientstate = UPAPCS_OPEN;
466
467     notice("PAP authentication succeeded");
468     auth_withpeer_success(u->us_unit, PPP_PAP, 0);
469 }
470
471
472 /*
473  * upap_rauthnak - Receive Authenticate-Nak.
474  */
475 static void
476 upap_rauthnak(u, inp, id, len)
477     upap_state *u;
478     u_char *inp;
479     int id;
480     int len;
481 {
482     u_char msglen;
483     char *msg;
484
485     if (u->us_clientstate != UPAPCS_AUTHREQ) /* XXX */
486         return;
487
488     /*
489      * Parse message.
490      */
491     if (len < 1) {
492         UPAPDEBUG(("pap_rauthnak: ignoring missing msg-length."));
493     } else {
494         GETCHAR(msglen, inp);
495         if (msglen > 0) {
496             len -= sizeof (u_char);
497             if (len < msglen) {
498                 UPAPDEBUG(("pap_rauthnak: rcvd short packet."));
499                 return;
500             }
501             msg = (char *) inp;
502             PRINTMSG(msg, msglen);
503         }
504     }
505
506     u->us_clientstate = UPAPCS_BADAUTH;
507
508     error("PAP authentication failed");
509     auth_withpeer_fail(u->us_unit, PPP_PAP);
510 }
511
512
513 /*
514  * upap_sauthreq - Send an Authenticate-Request.
515  */
516 static void
517 upap_sauthreq(u)
518     upap_state *u;
519 {
520     u_char *outp;
521     int outlen;
522
523     outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) +
524         u->us_userlen + u->us_passwdlen;
525     outp = outpacket_buf;
526     
527     MAKEHEADER(outp, PPP_PAP);
528
529     PUTCHAR(UPAP_AUTHREQ, outp);
530     PUTCHAR(++u->us_id, outp);
531     PUTSHORT(outlen, outp);
532     PUTCHAR(u->us_userlen, outp);
533     BCOPY(u->us_user, outp, u->us_userlen);
534     INCPTR(u->us_userlen, outp);
535     PUTCHAR(u->us_passwdlen, outp);
536     BCOPY(u->us_passwd, outp, u->us_passwdlen);
537
538     output(u->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
539
540     TIMEOUT(upap_timeout, u, u->us_timeouttime);
541     ++u->us_transmits;
542     u->us_clientstate = UPAPCS_AUTHREQ;
543 }
544
545
546 /*
547  * upap_sresp - Send a response (ack or nak).
548  */
549 static void
550 upap_sresp(u, code, id, msg, msglen)
551     upap_state *u;
552     u_char code, id;
553     char *msg;
554     int msglen;
555 {
556     u_char *outp;
557     int outlen;
558
559     outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen;
560     outp = outpacket_buf;
561     MAKEHEADER(outp, PPP_PAP);
562
563     PUTCHAR(code, outp);
564     PUTCHAR(id, outp);
565     PUTSHORT(outlen, outp);
566     PUTCHAR(msglen, outp);
567     BCOPY(msg, outp, msglen);
568     output(u->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
569 }
570
571 /*
572  * upap_printpkt - print the contents of a PAP packet.
573  */
574 static char *upap_codenames[] = {
575     "AuthReq", "AuthAck", "AuthNak"
576 };
577
578 static int
579 upap_printpkt(p, plen, printer, arg)
580     u_char *p;
581     int plen;
582     void (*printer) __P((void *, char *, ...));
583     void *arg;
584 {
585     int code, id, len;
586     int mlen, ulen, wlen;
587     char *user, *pwd, *msg;
588     u_char *pstart;
589
590     if (plen < UPAP_HEADERLEN)
591         return 0;
592     pstart = p;
593     GETCHAR(code, p);
594     GETCHAR(id, p);
595     GETSHORT(len, p);
596     if (len < UPAP_HEADERLEN || len > plen)
597         return 0;
598
599     if (code >= 1 && code <= sizeof(upap_codenames) / sizeof(char *))
600         printer(arg, " %s", upap_codenames[code-1]);
601     else
602         printer(arg, " code=0x%x", code);
603     printer(arg, " id=0x%x", id);
604     len -= UPAP_HEADERLEN;
605     switch (code) {
606     case UPAP_AUTHREQ:
607         if (len < 1)
608             break;
609         ulen = p[0];
610         if (len < ulen + 2)
611             break;
612         wlen = p[ulen + 1];
613         if (len < ulen + wlen + 2)
614             break;
615         user = (char *) (p + 1);
616         pwd = (char *) (p + ulen + 2);
617         p += ulen + wlen + 2;
618         len -= ulen + wlen + 2;
619         printer(arg, " user=");
620         print_string(user, ulen, printer, arg);
621         printer(arg, " password=");
622         if (!hide_password)
623             print_string(pwd, wlen, printer, arg);
624         else
625             printer(arg, "<hidden>");
626         break;
627     case UPAP_AUTHACK:
628     case UPAP_AUTHNAK:
629         if (len < 1)
630             break;
631         mlen = p[0];
632         if (len < mlen + 1)
633             break;
634         msg = (char *) (p + 1);
635         p += mlen + 1;
636         len -= mlen + 1;
637         printer(arg, " ");
638         print_string(msg, mlen, printer, arg);
639         break;
640     }
641
642     /* print the rest of the bytes in the packet */
643     for (; len > 0; --len) {
644         GETCHAR(code, p);
645         printer(arg, " %.2x", code);
646     }
647
648     return p - pstart;
649 }