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