Remove the requirement that redistributions in binary form reproduce
[ppp.git] / pppd / chap-new.c
1 /*
2  * chap-new.c - New CHAP implementation.
3  *
4  * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to
14  *    endorse or promote products derived from this software without
15  *    prior written permission.
16  *
17  * 3. Redistributions of any form whatsoever must retain the following
18  *    acknowledgment:
19  *    "This product includes software developed by Paul Mackerras
20  *     <paulus@samba.org>".
21  *
22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29  */
30
31 #define RCSID   "$Id: chap-new.c,v 1.6 2004/11/04 10:02:26 paulus Exp $"
32
33 #include <stdlib.h>
34 #include <string.h>
35 #include "pppd.h"
36 #include "chap-new.h"
37 #include "chap-md5.h"
38
39 #ifdef CHAPMS
40 #include "chap_ms.h"
41 #define MDTYPE_ALL (MDTYPE_MICROSOFT_V2 | MDTYPE_MICROSOFT | MDTYPE_MD5)
42 #else
43 #define MDTYPE_ALL (MDTYPE_MD5)
44 #endif
45
46 int chap_mdtype_all = MDTYPE_ALL;
47
48 /* Hook for a plugin to validate CHAP challenge */
49 int (*chap_verify_hook)(char *name, char *ourname, int id,
50                         struct chap_digest_type *digest,
51                         unsigned char *challenge, unsigned char *response,
52                         char *message, int message_space) = NULL;
53
54 /*
55  * Option variables.
56  */
57 int chap_timeout_time = 3;
58 int chap_max_transmits = 10;
59 int chap_rechallenge_time = 0;
60
61 /*
62  * Command-line options.
63  */
64 static option_t chap_option_list[] = {
65         { "chap-restart", o_int, &chap_timeout_time,
66           "Set timeout for CHAP", OPT_PRIO },
67         { "chap-max-challenge", o_int, &chap_max_transmits,
68           "Set max #xmits for challenge", OPT_PRIO },
69         { "chap-interval", o_int, &chap_rechallenge_time,
70           "Set interval for rechallenge", OPT_PRIO },
71         { NULL }
72 };
73
74 /*
75  * Internal state.
76  */
77 static struct chap_client_state {
78         int flags;
79         char *name;
80         struct chap_digest_type *digest;
81         unsigned char priv[64];         /* private area for digest's use */
82 } client;
83
84 /*
85  * These limits apply to challenge and response packets we send.
86  * The +4 is the +1 that we actually need rounded up.
87  */
88 #define CHAL_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_CHALLENGE_LEN + MAXNAMELEN)
89 #define RESP_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_RESPONSE_LEN + MAXNAMELEN)
90
91 static struct chap_server_state {
92         int flags;
93         int id;
94         char *name;
95         struct chap_digest_type *digest;
96         int challenge_xmits;
97         int challenge_pktlen;
98         unsigned char challenge[CHAL_MAX_PKTLEN];
99 } server;
100
101 /* Values for flags in chap_client_state and chap_server_state */
102 #define LOWERUP                 1
103 #define AUTH_STARTED            2
104 #define AUTH_DONE               4
105 #define AUTH_FAILED             8
106 #define TIMEOUT_PENDING         0x10
107 #define CHALLENGE_VALID         0x20
108
109 /*
110  * Prototypes.
111  */
112 static void chap_init(int unit);
113 static void chap_lowerup(int unit);
114 static void chap_lowerdown(int unit);
115 static void chap_timeout(void *arg);
116 static void chap_generate_challenge(struct chap_server_state *ss);
117 static void chap_handle_response(struct chap_server_state *ss, int code,
118                 unsigned char *pkt, int len);
119 static int chap_verify_response(char *name, char *ourname, int id,
120                 struct chap_digest_type *digest,
121                 unsigned char *challenge, unsigned char *response,
122                 char *message, int message_space);
123 static void chap_respond(struct chap_client_state *cs, int id,
124                 unsigned char *pkt, int len);
125 static void chap_handle_status(struct chap_client_state *cs, int code, int id,
126                 unsigned char *pkt, int len);
127 static void chap_protrej(int unit);
128 static void chap_input(int unit, unsigned char *pkt, int pktlen);
129 static int chap_print_pkt(unsigned char *p, int plen,
130                 void (*printer) __P((void *, char *, ...)), void *arg);
131
132 /* List of digest types that we know about */
133 static struct chap_digest_type *chap_digests;
134
135 /*
136  * chap_init - reset to initial state.
137  */
138 static void
139 chap_init(int unit)
140 {
141         memset(&client, 0, sizeof(client));
142         memset(&server, 0, sizeof(server));
143
144         chap_md5_init();
145 #ifdef CHAPMS
146         chapms_init();
147 #endif
148 }
149
150 /*
151  * Add a new digest type to the list.
152  */
153 void
154 chap_register_digest(struct chap_digest_type *dp)
155 {
156         dp->next = chap_digests;
157         chap_digests = dp;
158 }
159
160 /*
161  * chap_lowerup - we can start doing stuff now.
162  */
163 static void
164 chap_lowerup(int unit)
165 {
166         struct chap_client_state *cs = &client;
167         struct chap_server_state *ss = &server;
168
169         cs->flags |= LOWERUP;
170         ss->flags |= LOWERUP;
171         if (ss->flags & AUTH_STARTED)
172                 chap_timeout(ss);
173 }
174
175 static void
176 chap_lowerdown(int unit)
177 {
178         struct chap_client_state *cs = &client;
179         struct chap_server_state *ss = &server;
180
181         cs->flags = 0;
182         if (ss->flags & TIMEOUT_PENDING)
183                 UNTIMEOUT(chap_timeout, ss);
184         ss->flags = 0;
185 }
186
187 /*
188  * chap_auth_peer - Start authenticating the peer.
189  * If the lower layer is already up, we start sending challenges,
190  * otherwise we wait for the lower layer to come up.
191  */
192 void
193 chap_auth_peer(int unit, char *our_name, int digest_code)
194 {
195         struct chap_server_state *ss = &server;
196         struct chap_digest_type *dp;
197
198         if (ss->flags & AUTH_STARTED) {
199                 error("CHAP: peer authentication already started!");
200                 return;
201         }
202         for (dp = chap_digests; dp != NULL; dp = dp->next)
203                 if (dp->code == digest_code)
204                         break;
205         if (dp == NULL)
206                 fatal("CHAP digest 0x%x requested but not available",
207                       digest_code);
208
209         ss->digest = dp;
210         ss->name = our_name;
211         /* Start with a random ID value */
212         ss->id = (unsigned char)(drand48() * 256);
213         ss->flags |= AUTH_STARTED;
214         if (ss->flags & LOWERUP)
215                 chap_timeout(ss);
216 }
217
218 /*
219  * chap_auth_with_peer - Prepare to authenticate ourselves to the peer.
220  * There isn't much to do until we receive a challenge.
221  */
222 void
223 chap_auth_with_peer(int unit, char *our_name, int digest_code)
224 {
225         struct chap_client_state *cs = &client;
226         struct chap_digest_type *dp;
227
228         if (cs->flags & AUTH_STARTED) {
229                 error("CHAP: authentication with peer already started!");
230                 return;
231         }
232         for (dp = chap_digests; dp != NULL; dp = dp->next)
233                 if (dp->code == digest_code)
234                         break;
235         if (dp == NULL)
236                 fatal("CHAP digest 0x%x requested but not available",
237                       digest_code);
238
239         cs->digest = dp;
240         cs->name = our_name;
241         cs->flags |= AUTH_STARTED;
242 }
243
244 /*
245  * chap_timeout - It's time to send another challenge to the peer.
246  * This could be either a retransmission of a previous challenge,
247  * or a new challenge to start re-authentication.
248  */
249 static void
250 chap_timeout(void *arg)
251 {
252         struct chap_server_state *ss = arg;
253
254         ss->flags &= ~TIMEOUT_PENDING;
255         if ((ss->flags & CHALLENGE_VALID) == 0) {
256                 ss->challenge_xmits = 0;
257                 chap_generate_challenge(ss);
258                 ss->flags |= CHALLENGE_VALID;
259         } else if (ss->challenge_xmits >= chap_max_transmits) {
260                 ss->flags &= ~CHALLENGE_VALID;
261                 ss->flags |= AUTH_DONE | AUTH_FAILED;
262                 auth_peer_fail(0, PPP_CHAP);
263                 return;
264         }
265
266         output(0, ss->challenge, ss->challenge_pktlen);
267         ++ss->challenge_xmits;
268         ss->flags |= TIMEOUT_PENDING;
269         TIMEOUT(chap_timeout, arg, chap_timeout_time);
270 }
271
272 /*
273  * chap_generate_challenge - generate a challenge string and format
274  * the challenge packet in ss->challenge_pkt.
275  */
276 static void
277 chap_generate_challenge(struct chap_server_state *ss)
278 {
279         int clen = 1, nlen, len;
280         unsigned char *p;
281
282         p = ss->challenge;
283         MAKEHEADER(p, PPP_CHAP);
284         p += CHAP_HDRLEN;
285         ss->digest->generate_challenge(p);
286         clen = *p;
287         nlen = strlen(ss->name);
288         memcpy(p + 1 + clen, ss->name, nlen);
289
290         len = CHAP_HDRLEN + 1 + clen + nlen;
291         ss->challenge_pktlen = PPP_HDRLEN + len;
292
293         p = ss->challenge + PPP_HDRLEN;
294         p[0] = CHAP_CHALLENGE;
295         p[1] = ++ss->id;
296         p[2] = len >> 8;
297         p[3] = len;
298 }
299
300 /*
301  * chap_handle_response - check the response to our challenge.
302  */
303 static void
304 chap_handle_response(struct chap_server_state *ss, int id,
305                      unsigned char *pkt, int len)
306 {
307         int response_len, ok, mlen;
308         unsigned char *response, *p;
309         char *name = NULL;      /* initialized to shut gcc up */
310         int (*verifier)(char *, char *, int, struct chap_digest_type *,
311                 unsigned char *, unsigned char *, char *, int);
312         char rname[MAXNAMELEN+1];
313         char message[256];
314
315         if ((ss->flags & LOWERUP) == 0)
316                 return;
317         if (id != ss->challenge[PPP_HDRLEN+1] || len < 2)
318                 return;
319         if ((ss->flags & AUTH_DONE) == 0) {
320                 if ((ss->flags & CHALLENGE_VALID) == 0)
321                         return;
322                 response = pkt;
323                 GETCHAR(response_len, pkt);
324                 len -= response_len + 1;        /* length of name */
325                 name = (char *)pkt + response_len;
326                 if (len < 0)
327                         return;
328
329                 ss->flags &= ~CHALLENGE_VALID;
330                 if (ss->flags & TIMEOUT_PENDING) {
331                         ss->flags &= ~TIMEOUT_PENDING;
332                         UNTIMEOUT(chap_timeout, ss);
333                 }
334
335                 if (explicit_remote) {
336                         name = remote_name;
337                 } else {
338                         /* Null terminate and clean remote name. */
339                         slprintf(rname, sizeof(rname), "%.*v", len, name);
340                         name = rname;
341                 }
342
343                 if (chap_verify_hook)
344                         verifier = chap_verify_hook;
345                 else
346                         verifier = chap_verify_response;
347                 ok = (*verifier)(name, ss->name, id, ss->digest,
348                                  ss->challenge + PPP_HDRLEN + CHAP_HDRLEN,
349                                  response, message, sizeof(message));
350                 if (!ok || !auth_number()) {
351                         ss->flags |= AUTH_FAILED;
352                         warn("Peer %q failed CHAP authentication", name);
353                 }
354         }
355
356         /* send the response */
357         p = outpacket_buf;
358         MAKEHEADER(p, PPP_CHAP);
359         mlen = strlen(message);
360         len = CHAP_HDRLEN + mlen;
361         p[0] = (ss->flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS;
362         p[1] = id;
363         p[2] = len >> 8;
364         p[3] = len;
365         if (mlen > 0)
366                 memcpy(p + CHAP_HDRLEN, message, mlen);
367         output(0, outpacket_buf, PPP_HDRLEN + len);
368
369         if ((ss->flags & AUTH_DONE) == 0) {
370                 ss->flags |= AUTH_DONE;
371                 if (ss->flags & AUTH_FAILED) {
372                         auth_peer_fail(0, PPP_CHAP);
373                 } else {
374                         auth_peer_success(0, PPP_CHAP, ss->digest->code,
375                                           name, strlen(name));
376                         if (chap_rechallenge_time) {
377                                 ss->flags |= TIMEOUT_PENDING;
378                                 TIMEOUT(chap_timeout, ss,
379                                         chap_rechallenge_time);
380                         }
381                 }
382         }
383 }
384
385 /*
386  * chap_verify_response - check whether the peer's response matches
387  * what we think it should be.  Returns 1 if it does (authentication
388  * succeeded), or 0 if it doesn't.
389  */
390 static int
391 chap_verify_response(char *name, char *ourname, int id,
392                      struct chap_digest_type *digest,
393                      unsigned char *challenge, unsigned char *response,
394                      char *message, int message_space)
395 {
396         int ok;
397         unsigned char secret[MAXSECRETLEN];
398         int secret_len;
399
400         /* Get the secret that the peer is supposed to know */
401         if (!get_secret(0, name, ourname, (char *)secret, &secret_len, 1)) {
402                 error("No CHAP secret found for authenticating %q", name);
403                 return 0;
404         }
405
406         ok = digest->verify_response(id, name, secret, secret_len, challenge,
407                                      response, message, message_space);
408         memset(secret, 0, sizeof(secret));
409
410         return ok;
411 }
412
413 /*
414  * chap_respond - Generate and send a response to a challenge.
415  */
416 static void
417 chap_respond(struct chap_client_state *cs, int id,
418              unsigned char *pkt, int len)
419 {
420         int clen, nlen;
421         int secret_len;
422         unsigned char *p;
423         unsigned char response[RESP_MAX_PKTLEN];
424         char rname[MAXNAMELEN+1];
425         char secret[MAXSECRETLEN+1];
426
427         if ((cs->flags & (LOWERUP | AUTH_STARTED)) != (LOWERUP | AUTH_STARTED))
428                 return;         /* not ready */
429         if (len < 2 || len < pkt[0] + 1)
430                 return;         /* too short */
431         clen = pkt[0];
432         nlen = len - (clen + 1);
433
434         /* Null terminate and clean remote name. */
435         slprintf(rname, sizeof(rname), "%.*v", nlen, pkt + clen + 1);
436
437         /* Microsoft doesn't send their name back in the PPP packet */
438         if (explicit_remote || (remote_name[0] != 0 && rname[0] == 0))
439                 strlcpy(rname, remote_name, sizeof(rname));
440
441         /* get secret for authenticating ourselves with the specified host */
442         if (!get_secret(0, cs->name, rname, secret, &secret_len, 0)) {
443                 secret_len = 0; /* assume null secret if can't find one */
444                 warn("No CHAP secret found for authenticating us to %q", rname);
445         }
446
447         p = response;
448         MAKEHEADER(p, PPP_CHAP);
449         p += CHAP_HDRLEN;
450
451         cs->digest->make_response(p, id, cs->name, pkt,
452                                   secret, secret_len, cs->priv);
453         memset(secret, 0, secret_len);
454
455         clen = *p;
456         nlen = strlen(cs->name);
457         memcpy(p + clen + 1, cs->name, nlen);
458
459         p = response + PPP_HDRLEN;
460         len = CHAP_HDRLEN + clen + 1 + nlen;
461         p[0] = CHAP_RESPONSE;
462         p[1] = id;
463         p[2] = len >> 8;
464         p[3] = len;
465
466         output(0, response, PPP_HDRLEN + len);
467 }
468
469 static void
470 chap_handle_status(struct chap_client_state *cs, int code, int id,
471                    unsigned char *pkt, int len)
472 {
473         const char *msg = NULL;
474
475         if ((cs->flags & (AUTH_DONE|AUTH_STARTED|LOWERUP))
476             != (AUTH_STARTED|LOWERUP))
477                 return;
478         cs->flags |= AUTH_DONE;
479
480         if (code == CHAP_SUCCESS) {
481                 /* used for MS-CHAP v2 mutual auth, yuck */
482                 if (cs->digest->check_success != NULL) {
483                         if (!(*cs->digest->check_success)(pkt, len, cs->priv))
484                                 code = CHAP_FAILURE;
485                 } else
486                         msg = "CHAP authentication succeeded";
487         } else {
488                 if (cs->digest->handle_failure != NULL)
489                         (*cs->digest->handle_failure)(pkt, len);
490                 else
491                         msg = "CHAP authentication failed";
492         }
493         if (msg) {
494                 if (len > 0)
495                         info("%s: %.*v", msg, len, pkt);
496                 else
497                         info("%s", msg);
498         }
499         if (code == CHAP_SUCCESS)
500                 auth_withpeer_success(0, PPP_CHAP, cs->digest->code);
501         else {
502                 cs->flags |= AUTH_FAILED;
503                 auth_withpeer_fail(0, PPP_CHAP);
504         }
505 }
506
507 static void
508 chap_input(int unit, unsigned char *pkt, int pktlen)
509 {
510         struct chap_client_state *cs = &client;
511         struct chap_server_state *ss = &server;
512         unsigned char code, id;
513         int len;
514
515         if (pktlen < CHAP_HDRLEN)
516                 return;
517         GETCHAR(code, pkt);
518         GETCHAR(id, pkt);
519         GETSHORT(len, pkt);
520         if (len < CHAP_HDRLEN || len > pktlen)
521                 return;
522         len -= CHAP_HDRLEN;
523
524         switch (code) {
525         case CHAP_CHALLENGE:
526                 chap_respond(cs, id, pkt, len);
527                 break;
528         case CHAP_RESPONSE:
529                 chap_handle_response(ss, id, pkt, len);
530                 break;
531         case CHAP_FAILURE:
532         case CHAP_SUCCESS:
533                 chap_handle_status(cs, code, id, pkt, len);
534                 break;
535         }
536 }
537
538 static void
539 chap_protrej(int unit)
540 {
541         struct chap_client_state *cs = &client;
542         struct chap_server_state *ss = &server;
543
544         if (ss->flags & TIMEOUT_PENDING) {
545                 ss->flags &= ~TIMEOUT_PENDING;
546                 UNTIMEOUT(chap_timeout, ss);
547         }
548         if (ss->flags & AUTH_STARTED) {
549                 ss->flags = 0;
550                 auth_peer_fail(0, PPP_CHAP);
551         }
552         if ((cs->flags & (AUTH_STARTED|AUTH_DONE)) == AUTH_STARTED) {
553                 cs->flags &= ~AUTH_STARTED;
554                 auth_withpeer_fail(0, PPP_CHAP);
555         }
556 }
557
558 /*
559  * chap_print_pkt - print the contents of a CHAP packet.
560  */
561 static char *chap_code_names[] = {
562         "Challenge", "Response", "Success", "Failure"
563 };
564
565 static int
566 chap_print_pkt(unsigned char *p, int plen,
567                void (*printer) __P((void *, char *, ...)), void *arg)
568 {
569         int code, id, len;
570         int clen, nlen;
571         unsigned char x;
572
573         if (plen < CHAP_HDRLEN)
574                 return 0;
575         GETCHAR(code, p);
576         GETCHAR(id, p);
577         GETSHORT(len, p);
578         if (len < CHAP_HDRLEN || len > plen)
579                 return 0;
580
581         if (code >= 1 && code <= sizeof(chap_code_names) / sizeof(char *))
582                 printer(arg, " %s", chap_code_names[code-1]);
583         else
584                 printer(arg, " code=0x%x", code);
585         printer(arg, " id=0x%x", id);
586         len -= CHAP_HDRLEN;
587         switch (code) {
588         case CHAP_CHALLENGE:
589         case CHAP_RESPONSE:
590                 if (len < 1)
591                         break;
592                 clen = p[0];
593                 if (len < clen + 1)
594                         break;
595                 ++p;
596                 nlen = len - clen - 1;
597                 printer(arg, " <");
598                 for (; clen > 0; --clen) {
599                         GETCHAR(x, p);
600                         printer(arg, "%.2x", x);
601                 }
602                 printer(arg, ">, name = ");
603                 print_string((char *)p, nlen, printer, arg);
604                 break;
605         case CHAP_FAILURE:
606         case CHAP_SUCCESS:
607                 printer(arg, " ");
608                 print_string((char *)p, len, printer, arg);
609                 break;
610         default:
611                 for (clen = len; clen > 0; --clen) {
612                         GETCHAR(x, p);
613                         printer(arg, " %.2x", x);
614                 }
615         }
616
617         return len + CHAP_HDRLEN;
618 }
619
620 struct protent chap_protent = {
621         PPP_CHAP,
622         chap_init,
623         chap_input,
624         chap_protrej,
625         chap_lowerup,
626         chap_lowerdown,
627         NULL,           /* open */
628         NULL,           /* close */
629         chap_print_pkt,
630         NULL,           /* datainput */
631         1,              /* enabled_flag */
632         "CHAP",         /* name */
633         NULL,           /* data_name */
634         chap_option_list,
635         NULL,           /* check_options */
636 };