]> git.ozlabs.org Git - ppp.git/blob - pppd/auth.c
pppd: Fix enforcing peer IP address (#235)
[ppp.git] / pppd / auth.c
1 /*
2  * auth.c - PPP authentication and phase control.
3  *
4  * Copyright (c) 1993-2002 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  * Derived from main.c, which is:
31  *
32  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
33  *
34  * Redistribution and use in source and binary forms, with or without
35  * modification, are permitted provided that the following conditions
36  * are met:
37  *
38  * 1. Redistributions of source code must retain the above copyright
39  *    notice, this list of conditions and the following disclaimer.
40  *
41  * 2. Redistributions in binary form must reproduce the above copyright
42  *    notice, this list of conditions and the following disclaimer in
43  *    the documentation and/or other materials provided with the
44  *    distribution.
45  *
46  * 3. The name "Carnegie Mellon University" must not be used to
47  *    endorse or promote products derived from this software without
48  *    prior written permission. For permission or any legal
49  *    details, please contact
50  *      Office of Technology Transfer
51  *      Carnegie Mellon University
52  *      5000 Forbes Avenue
53  *      Pittsburgh, PA  15213-3890
54  *      (412) 268-4387, fax: (412) 268-7395
55  *      tech-transfer@andrew.cmu.edu
56  *
57  * 4. Redistributions of any form whatsoever must retain the following
58  *    acknowledgment:
59  *    "This product includes software developed by Computing Services
60  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
61  *
62  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
63  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
64  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
65  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
66  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
67  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
68  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
69  */
70
71 #define RCSID   "$Id: auth.c,v 1.117 2008/07/01 12:27:56 paulus Exp $"
72
73 #include <stdio.h>
74 #include <stddef.h>
75 #include <stdlib.h>
76 #include <unistd.h>
77 #include <errno.h>
78 #include <pwd.h>
79 #include <grp.h>
80 #include <string.h>
81 #include <strings.h>
82 #include <sys/types.h>
83 #include <sys/stat.h>
84 #include <sys/socket.h>
85 #include <utmp.h>
86 #include <fcntl.h>
87 #if defined(_PATH_LASTLOG) && defined(__linux__)
88 #include <lastlog.h>
89 #endif
90
91 #include <netdb.h>
92 #include <netinet/in.h>
93 #include <arpa/inet.h>
94
95
96 #ifdef HAS_SHADOW
97 #include <shadow.h>
98 #ifndef PW_PPP
99 #define PW_PPP PW_LOGIN
100 #endif
101 #endif
102 #include <time.h>
103
104 #ifdef SYSTEMD
105 #include <systemd/sd-daemon.h>
106 #endif
107
108 #include "pppd.h"
109 #include "fsm.h"
110 #include "lcp.h"
111 #include "ccp.h"
112 #include "ecp.h"
113 #include "ipcp.h"
114 #include "upap.h"
115 #include "chap-new.h"
116 #include "eap.h"
117 #ifdef USE_EAPTLS
118 #include "eap-tls.h"
119 #endif
120 #ifdef CBCP_SUPPORT
121 #include "cbcp.h"
122 #endif
123 #include "pathnames.h"
124 #include "session.h"
125
126
127 /* Bits in scan_authfile return value */
128 #define NONWILD_SERVER  1
129 #define NONWILD_CLIENT  2
130
131 #define ISWILD(word)    (word[0] == '*' && word[1] == 0)
132
133 /* The name by which the peer authenticated itself to us. */
134 char peer_authname[MAXNAMELEN];
135
136 /* Records which authentication operations haven't completed yet. */
137 static int auth_pending[NUM_PPP];
138
139 /* Records which authentication operations have been completed. */
140 int auth_done[NUM_PPP];
141
142 /* List of addresses which the peer may use. */
143 static struct permitted_ip *addresses[NUM_PPP];
144
145 /* Wordlist giving addresses which the peer may use
146    without authenticating itself. */
147 static struct wordlist *noauth_addrs;
148
149 /* Remote telephone number, if available */
150 char remote_number[MAXNAMELEN];
151
152 /* Wordlist giving remote telephone numbers which may connect. */
153 static struct wordlist *permitted_numbers;
154
155 /* Extra options to apply, from the secrets file entry for the peer. */
156 static struct wordlist *extra_options;
157
158 /* Number of network protocols which we have opened. */
159 static int num_np_open;
160
161 /* Number of network protocols which have come up. */
162 static int num_np_up;
163
164 /* Set if we got the contents of passwd[] from the pap-secrets file. */
165 static int passwd_from_file;
166
167 /* Set if we require authentication only because we have a default route. */
168 static bool default_auth;
169
170 /* Hook to enable a plugin to control the idle time limit */
171 int (*idle_time_hook)(struct ppp_idle *) = NULL;
172
173 /* Hook for a plugin to say whether we can possibly authenticate any peer */
174 int (*pap_check_hook)(void) = NULL;
175
176 /* Hook for a plugin to check the PAP user and password */
177 int (*pap_auth_hook)(char *user, char *passwd, char **msgp,
178                      struct wordlist **paddrs,
179                      struct wordlist **popts) = NULL;
180
181 /* Hook for a plugin to know about the PAP user logout */
182 void (*pap_logout_hook)(void) = NULL;
183
184 /* Hook for a plugin to get the PAP password for authenticating us */
185 int (*pap_passwd_hook)(char *user, char *passwd) = NULL;
186
187 /* Hook for a plugin to say if we can possibly authenticate a peer using CHAP */
188 int (*chap_check_hook)(void) = NULL;
189
190 /* Hook for a plugin to get the CHAP password for authenticating us */
191 int (*chap_passwd_hook)(char *user, char *passwd) = NULL;
192
193 #ifdef USE_EAPTLS
194 /* Hook for a plugin to get the EAP-TLS password for authenticating us */
195 int (*eaptls_passwd_hook)(char *user, char *passwd) = NULL;
196 #endif
197
198 /* Hook for a plugin to say whether it is OK if the peer
199    refuses to authenticate. */
200 int (*null_auth_hook)(struct wordlist **paddrs,
201                       struct wordlist **popts) = NULL;
202
203 int (*allowed_address_hook)(u_int32_t addr) = NULL;
204
205 #ifdef HAVE_MULTILINK
206 /* Hook for plugin to hear when an interface joins a multilink bundle */
207 void (*multilink_join_hook)(void) = NULL;
208 #endif
209
210 /* A notifier for when the peer has authenticated itself,
211    and we are proceeding to the network phase. */
212 struct notifier *auth_up_notifier = NULL;
213
214 /* A notifier for when the link goes down. */
215 struct notifier *link_down_notifier = NULL;
216
217 /*
218  * This is used to ensure that we don't start an auth-up/down
219  * script while one is already running.
220  */
221 enum script_state {
222     s_down,
223     s_up
224 };
225
226 static enum script_state auth_state = s_down;
227 static enum script_state auth_script_state = s_down;
228 static pid_t auth_script_pid = 0;
229
230 /*
231  * Option variables.
232  */
233 bool uselogin = 0;              /* Use /etc/passwd for checking PAP */
234 bool session_mgmt = 0;          /* Do session management (login records) */
235 bool cryptpap = 0;              /* Passwords in pap-secrets are encrypted */
236 bool refuse_pap = 0;            /* Don't wanna auth. ourselves with PAP */
237 bool refuse_chap = 0;           /* Don't wanna auth. ourselves with CHAP */
238 bool refuse_eap = 0;            /* Don't wanna auth. ourselves with EAP */
239 #ifdef CHAPMS
240 bool refuse_mschap = 0;         /* Don't wanna auth. ourselves with MS-CHAP */
241 bool refuse_mschap_v2 = 0;      /* Don't wanna auth. ourselves with MS-CHAPv2 */
242 #else
243 bool refuse_mschap = 1;         /* Don't wanna auth. ourselves with MS-CHAP */
244 bool refuse_mschap_v2 = 1;      /* Don't wanna auth. ourselves with MS-CHAPv2 */
245 #endif
246 bool usehostname = 0;           /* Use hostname for our_name */
247 bool auth_required = 0;         /* Always require authentication from peer */
248 bool allow_any_ip = 0;          /* Allow peer to use any IP address */
249 bool explicit_remote = 0;       /* User specified explicit remote name */
250 bool explicit_user = 0;         /* Set if "user" option supplied */
251 bool explicit_passwd = 0;       /* Set if "password" option supplied */
252 char remote_name[MAXNAMELEN];   /* Peer's name for authentication */
253 #ifdef USE_EAPTLS
254 char *cacert_file  = NULL;      /* CA certificate file (pem format) */
255 char *ca_path      = NULL;      /* directory with CA certificates */
256 char *cert_file    = NULL;      /* client certificate file (pem format) */
257 char *privkey_file = NULL;      /* client private key file (pem format) */
258 char *crl_dir      = NULL;      /* directory containing CRL files */
259 char *crl_file     = NULL;      /* Certificate Revocation List (CRL) file (pem format) */
260 char *max_tls_version = NULL;   /* Maximum TLS protocol version (default=1.2) */
261 bool need_peer_eap = 0;                 /* Require peer to authenticate us */
262 #endif
263
264 static char *uafname;           /* name of most recent +ua file */
265
266 extern char *crypt (const char *, const char *);
267
268 /* Prototypes for procedures local to this file. */
269
270 static void network_phase (int);
271 static void check_idle (void *);
272 static void connect_time_expired (void *);
273 static int  null_login (int);
274 static int  get_pap_passwd (char *);
275 static int  have_pap_secret (int *);
276 static int  have_chap_secret (char *, char *, int, int *);
277 static int  have_srp_secret(char *client, char *server, int need_ip,
278     int *lacks_ipp);
279
280 #ifdef USE_EAPTLS
281 static int  have_eaptls_secret_server
282 (char *client, char *server, int need_ip, int *lacks_ipp);
283 static int  have_eaptls_secret_client (char *client, char *server);
284 static int  scan_authfile_eaptls(FILE * f, char *client, char *server,
285                                char *cli_cert, char *serv_cert,
286                                char *ca_cert, char *pk,
287                                struct wordlist ** addrs,
288                                struct wordlist ** opts,
289                                char *filename, int flags);
290 #endif
291
292 static int  ip_addr_check (u_int32_t, struct permitted_ip *);
293 static int  scan_authfile(FILE *, char *, char *, char *,
294                           struct wordlist **, struct wordlist **,
295                           char *, int);
296 static void free_wordlist (struct wordlist *);
297 static void auth_script (char *);
298 static void auth_script_done (void *);
299 static void set_allowed_addrs (int, struct wordlist *, struct wordlist *);
300 static int  some_ip_ok (struct wordlist *);
301 static int  setupapfile (char **);
302 static int  privgroup (char **);
303 static int  set_noauth_addr (char **);
304 static int  set_permitted_number (char **);
305 static void check_access (FILE *, char *);
306 static int  wordlist_count (struct wordlist *);
307
308 #ifdef MAXOCTETS
309 static void check_maxoctets (void *);
310 #endif
311
312 /*
313  * Authentication-related options.
314  */
315 option_t auth_options[] = {
316     { "auth", o_bool, &auth_required,
317       "Require authentication from peer", OPT_PRIO | 1 },
318     { "noauth", o_bool, &auth_required,
319       "Don't require peer to authenticate", OPT_PRIOSUB | OPT_PRIV,
320       &allow_any_ip },
321     { "require-pap", o_bool, &lcp_wantoptions[0].neg_upap,
322       "Require PAP authentication from peer",
323       OPT_PRIOSUB | 1, &auth_required },
324     { "+pap", o_bool, &lcp_wantoptions[0].neg_upap,
325       "Require PAP authentication from peer",
326       OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required },
327     { "require-chap", o_bool, &auth_required,
328       "Require CHAP authentication from peer",
329       OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5,
330       &lcp_wantoptions[0].chap_mdtype },
331     { "+chap", o_bool, &auth_required,
332       "Require CHAP authentication from peer",
333       OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5,
334       &lcp_wantoptions[0].chap_mdtype },
335 #ifdef CHAPMS
336     { "require-mschap", o_bool, &auth_required,
337       "Require MS-CHAP authentication from peer",
338       OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT,
339       &lcp_wantoptions[0].chap_mdtype },
340     { "+mschap", o_bool, &auth_required,
341       "Require MS-CHAP authentication from peer",
342       OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT,
343       &lcp_wantoptions[0].chap_mdtype },
344     { "require-mschap-v2", o_bool, &auth_required,
345       "Require MS-CHAPv2 authentication from peer",
346       OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2,
347       &lcp_wantoptions[0].chap_mdtype },
348     { "+mschap-v2", o_bool, &auth_required,
349       "Require MS-CHAPv2 authentication from peer",
350       OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2,
351       &lcp_wantoptions[0].chap_mdtype },
352 #endif
353
354     { "refuse-pap", o_bool, &refuse_pap,
355       "Don't agree to auth to peer with PAP", 1 },
356     { "-pap", o_bool, &refuse_pap,
357       "Don't allow PAP authentication with peer", OPT_ALIAS | 1 },
358     { "refuse-chap", o_bool, &refuse_chap,
359       "Don't agree to auth to peer with CHAP",
360       OPT_A2CLRB | MDTYPE_MD5,
361       &lcp_allowoptions[0].chap_mdtype },
362     { "-chap", o_bool, &refuse_chap,
363       "Don't allow CHAP authentication with peer",
364       OPT_ALIAS | OPT_A2CLRB | MDTYPE_MD5,
365       &lcp_allowoptions[0].chap_mdtype },
366 #ifdef CHAPMS
367     { "refuse-mschap", o_bool, &refuse_mschap,
368       "Don't agree to auth to peer with MS-CHAP",
369       OPT_A2CLRB | MDTYPE_MICROSOFT,
370       &lcp_allowoptions[0].chap_mdtype },
371     { "-mschap", o_bool, &refuse_mschap,
372       "Don't allow MS-CHAP authentication with peer",
373       OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT,
374       &lcp_allowoptions[0].chap_mdtype },
375     { "refuse-mschap-v2", o_bool, &refuse_mschap_v2,
376       "Don't agree to auth to peer with MS-CHAPv2",
377       OPT_A2CLRB | MDTYPE_MICROSOFT_V2,
378       &lcp_allowoptions[0].chap_mdtype },
379     { "-mschap-v2", o_bool, &refuse_mschap_v2,
380       "Don't allow MS-CHAPv2 authentication with peer",
381       OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT_V2,
382       &lcp_allowoptions[0].chap_mdtype },
383 #endif
384
385     { "require-eap", o_bool, &lcp_wantoptions[0].neg_eap,
386       "Require EAP authentication from peer", OPT_PRIOSUB | 1,
387       &auth_required },
388     { "refuse-eap", o_bool, &refuse_eap,
389       "Don't agree to authenticate to peer with EAP", 1 },
390
391     { "name", o_string, our_name,
392       "Set local name for authentication",
393       OPT_PRIO | OPT_PRIV | OPT_STATIC, NULL, MAXNAMELEN },
394
395     { "+ua", o_special, (void *)setupapfile,
396       "Get PAP user and password from file",
397       OPT_PRIO | OPT_A2STRVAL, &uafname },
398
399     { "user", o_string, user,
400       "Set name for auth with peer", OPT_PRIO | OPT_STATIC,
401       &explicit_user, MAXNAMELEN },
402
403     { "password", o_string, passwd,
404       "Password for authenticating us to the peer",
405       OPT_PRIO | OPT_STATIC | OPT_HIDE,
406       &explicit_passwd, MAXSECRETLEN },
407
408     { "usehostname", o_bool, &usehostname,
409       "Must use hostname for authentication", 1 },
410
411     { "remotename", o_string, remote_name,
412       "Set remote name for authentication", OPT_PRIO | OPT_STATIC,
413       &explicit_remote, MAXNAMELEN },
414
415     { "login", o_bool, &uselogin,
416       "Use system password database for PAP", OPT_A2COPY | 1 ,
417       &session_mgmt },
418     { "enable-session", o_bool, &session_mgmt,
419       "Enable session accounting for remote peers", OPT_PRIV | 1 },
420
421     { "papcrypt", o_bool, &cryptpap,
422       "PAP passwords are encrypted", 1 },
423
424     { "privgroup", o_special, (void *)privgroup,
425       "Allow group members to use privileged options", OPT_PRIV | OPT_A2LIST },
426
427     { "allow-ip", o_special, (void *)set_noauth_addr,
428       "Set IP address(es) which can be used without authentication",
429       OPT_PRIV | OPT_A2LIST },
430
431     { "remotenumber", o_string, remote_number,
432       "Set remote telephone number for authentication", OPT_PRIO | OPT_STATIC,
433       NULL, MAXNAMELEN },
434
435     { "allow-number", o_special, (void *)set_permitted_number,
436       "Set telephone number(s) which are allowed to connect",
437       OPT_PRIV | OPT_A2LIST },
438
439 #ifdef USE_EAPTLS
440     { "ca", o_string, &cacert_file,   "EAP-TLS CA certificate in PEM format" },
441     { "capath", o_string, &ca_path,   "EAP-TLS CA certificate directory" },
442     { "cert", o_string, &cert_file,   "EAP-TLS client certificate in PEM format" },
443     { "key", o_string, &privkey_file, "EAP-TLS client private key in PEM format" },
444     { "crl-dir", o_string, &crl_dir,  "Use CRLs in directory" },
445     { "crl", o_string, &crl_file,     "Use specific CRL file" },
446     { "max-tls-version", o_string, &max_tls_version,
447       "Maximum TLS version (1.0/1.1/1.2 (default)/1.3)" },
448     { "need-peer-eap", o_bool, &need_peer_eap,
449       "Require the peer to authenticate us", 1 },
450 #endif /* USE_EAPTLS */
451     { NULL }
452 };
453
454 /*
455  * setupapfile - specifies UPAP info for authenticating with peer.
456  */
457 static int
458 setupapfile(char **argv)
459 {
460     FILE *ufile;
461     int l;
462     uid_t euid;
463     char u[MAXNAMELEN], p[MAXSECRETLEN];
464     char *fname;
465
466     lcp_allowoptions[0].neg_upap = 1;
467
468     /* open user info file */
469     fname = strdup(*argv);
470     if (fname == NULL)
471         novm("+ua file name");
472     euid = geteuid();
473     if (seteuid(getuid()) == -1) {
474         option_error("unable to reset uid before opening %s: %m", fname);
475         free(fname);
476         return 0;
477     }
478     ufile = fopen(fname, "r");
479     if (seteuid(euid) == -1)
480         fatal("unable to regain privileges: %m");
481     if (ufile == NULL) {
482         option_error("unable to open user login data file %s", fname);
483         free(fname);
484         return 0;
485     }
486     check_access(ufile, fname);
487     uafname = fname;
488
489     /* get username */
490     if (fgets(u, MAXNAMELEN - 1, ufile) == NULL
491         || fgets(p, MAXSECRETLEN - 1, ufile) == NULL) {
492         fclose(ufile);
493         option_error("unable to read user login data file %s", fname);
494         free(fname);
495         return 0;
496     }
497     fclose(ufile);
498
499     /* get rid of newlines */
500     l = strlen(u);
501     if (l > 0 && u[l-1] == '\n')
502         u[l-1] = 0;
503     l = strlen(p);
504     if (l > 0 && p[l-1] == '\n')
505         p[l-1] = 0;
506
507     if (override_value("user", option_priority, fname)) {
508         strlcpy(user, u, sizeof(user));
509         explicit_user = 1;
510     }
511     if (override_value("passwd", option_priority, fname)) {
512         strlcpy(passwd, p, sizeof(passwd));
513         explicit_passwd = 1;
514     }
515
516     free(fname);
517     return (1);
518 }
519
520
521 /*
522  * privgroup - allow members of the group to have privileged access.
523  */
524 static int
525 privgroup(char **argv)
526 {
527     struct group *g;
528     int i;
529
530     g = getgrnam(*argv);
531     if (g == 0) {
532         option_error("group %s is unknown", *argv);
533         return 0;
534     }
535     for (i = 0; i < ngroups; ++i) {
536         if (groups[i] == g->gr_gid) {
537             privileged = 1;
538             break;
539         }
540     }
541     return 1;
542 }
543
544
545 /*
546  * set_noauth_addr - set address(es) that can be used without authentication.
547  * Equivalent to specifying an entry like `"" * "" addr' in pap-secrets.
548  */
549 static int
550 set_noauth_addr(char **argv)
551 {
552     char *addr = *argv;
553     int l = strlen(addr) + 1;
554     struct wordlist *wp;
555
556     wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l);
557     if (wp == NULL)
558         novm("allow-ip argument");
559     wp->word = (char *) (wp + 1);
560     wp->next = noauth_addrs;
561     BCOPY(addr, wp->word, l);
562     noauth_addrs = wp;
563     return 1;
564 }
565
566
567 /*
568  * set_permitted_number - set remote telephone number(s) that may connect.
569  */
570 static int
571 set_permitted_number(char **argv)
572 {
573     char *number = *argv;
574     int l = strlen(number) + 1;
575     struct wordlist *wp;
576
577     wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l);
578     if (wp == NULL)
579         novm("allow-number argument");
580     wp->word = (char *) (wp + 1);
581     wp->next = permitted_numbers;
582     BCOPY(number, wp->word, l);
583     permitted_numbers = wp;
584     return 1;
585 }
586
587
588 /*
589  * An Open on LCP has requested a change from Dead to Establish phase.
590  */
591 void
592 link_required(int unit)
593 {
594 }
595
596 /*
597  * Bring the link up to the point of being able to do ppp.
598  */
599 void start_link(int unit)
600 {
601     status = EXIT_CONNECT_FAILED;
602     new_phase(PHASE_SERIALCONN);
603
604     hungup = 0;
605     devfd = the_channel->connect();
606     if (devfd < 0)
607         goto fail;
608
609     /* set up the serial device as a ppp interface */
610     /*
611      * N.B. we used to do tdb_writelock/tdb_writeunlock around this
612      * (from establish_ppp to set_ifunit).  However, we won't be
613      * doing the set_ifunit in multilink mode, which is the only time
614      * we need the atomicity that the tdb_writelock/tdb_writeunlock
615      * gives us.  Thus we don't need the tdb_writelock/tdb_writeunlock.
616      */
617     fd_ppp = the_channel->establish_ppp(devfd);
618     if (fd_ppp < 0) {
619         status = EXIT_FATAL_ERROR;
620         goto disconnect;
621     }
622
623     if (!demand && ifunit >= 0)
624         set_ifunit(1);
625
626     /*
627      * Start opening the connection and wait for
628      * incoming events (reply, timeout, etc.).
629      */
630     if (ifunit >= 0)
631         notice("Connect: %s <--> %s", ifname, ppp_devnam);
632     else
633         notice("Starting negotiation on %s", ppp_devnam);
634     add_fd(fd_ppp);
635
636     status = EXIT_NEGOTIATION_FAILED;
637     new_phase(PHASE_ESTABLISH);
638
639     lcp_lowerup(0);
640     return;
641
642  disconnect:
643     new_phase(PHASE_DISCONNECT);
644     if (the_channel->disconnect)
645         the_channel->disconnect();
646
647  fail:
648     new_phase(PHASE_DEAD);
649     if (the_channel->cleanup)
650         (*the_channel->cleanup)();
651 }
652
653 /*
654  * LCP has terminated the link; go to the Dead phase and take the
655  * physical layer down.
656  */
657 void
658 link_terminated(int unit)
659 {
660     if (phase == PHASE_DEAD || phase == PHASE_MASTER)
661         return;
662     new_phase(PHASE_DISCONNECT);
663
664     if (pap_logout_hook) {
665         pap_logout_hook();
666     }
667     session_end(devnam);
668
669     if (!doing_multilink) {
670         notice("Connection terminated.");
671         print_link_stats();
672     } else
673         notice("Link terminated.");
674
675     /*
676      * Delete pid files before disestablishing ppp.  Otherwise it
677      * can happen that another pppd gets the same unit and then
678      * we delete its pid file.
679      */
680     if (!doing_multilink && !demand)
681         remove_pidfiles();
682
683     /*
684      * If we may want to bring the link up again, transfer
685      * the ppp unit back to the loopback.  Set the
686      * real serial device back to its normal mode of operation.
687      */
688     if (fd_ppp >= 0) {
689         remove_fd(fd_ppp);
690         clean_check();
691         the_channel->disestablish_ppp(devfd);
692         if (doing_multilink)
693             mp_exit_bundle();
694         fd_ppp = -1;
695     }
696     if (!hungup)
697         lcp_lowerdown(0);
698     if (!doing_multilink && !demand)
699         script_unsetenv("IFNAME");
700
701     /*
702      * Run disconnector script, if requested.
703      * XXX we may not be able to do this if the line has hung up!
704      */
705     if (devfd >= 0 && the_channel->disconnect) {
706         the_channel->disconnect();
707         devfd = -1;
708     }
709     if (the_channel->cleanup)
710         (*the_channel->cleanup)();
711
712     if (doing_multilink && multilink_master) {
713         if (!bundle_terminating) {
714             new_phase(PHASE_MASTER);
715             if (master_detach && !detached)
716                 detach();
717         } else
718             mp_bundle_terminated();
719     } else
720         new_phase(PHASE_DEAD);
721 }
722
723 /*
724  * LCP has gone down; it will either die or try to re-establish.
725  */
726 void
727 link_down(int unit)
728 {
729     if (auth_state != s_down) {
730         notify(link_down_notifier, 0);
731         auth_state = s_down;
732         if (auth_script_state == s_up && auth_script_pid == 0) {
733             update_link_stats(unit);
734             auth_script_state = s_down;
735             auth_script(_PATH_AUTHDOWN);
736         }
737     }
738     if (!doing_multilink) {
739         upper_layers_down(unit);
740         if (phase != PHASE_DEAD && phase != PHASE_MASTER)
741             new_phase(PHASE_ESTABLISH);
742     }
743     /* XXX if doing_multilink, should do something to stop
744        network-layer traffic on the link */
745 }
746
747 void upper_layers_down(int unit)
748 {
749     int i;
750     struct protent *protp;
751
752     for (i = 0; (protp = protocols[i]) != NULL; ++i) {
753         if (!protp->enabled_flag)
754             continue;
755         if (protp->protocol != PPP_LCP && protp->lowerdown != NULL)
756             (*protp->lowerdown)(unit);
757         if (protp->protocol < 0xC000 && protp->close != NULL)
758             (*protp->close)(unit, "LCP down");
759     }
760     num_np_open = 0;
761     num_np_up = 0;
762 }
763
764 /*
765  * The link is established.
766  * Proceed to the Dead, Authenticate or Network phase as appropriate.
767  */
768 void
769 link_established(int unit)
770 {
771     int auth;
772     lcp_options *wo = &lcp_wantoptions[unit];
773     lcp_options *go = &lcp_gotoptions[unit];
774     lcp_options *ho = &lcp_hisoptions[unit];
775 #ifdef USE_EAPTLS
776     lcp_options *ao = &lcp_allowoptions[unit];
777 #endif
778     int i;
779     struct protent *protp;
780
781     /*
782      * Tell higher-level protocols that LCP is up.
783      */
784     if (!doing_multilink) {
785         for (i = 0; (protp = protocols[i]) != NULL; ++i)
786             if (protp->protocol != PPP_LCP && protp->enabled_flag
787                 && protp->lowerup != NULL)
788                 (*protp->lowerup)(unit);
789     }
790
791     if (!auth_required && noauth_addrs != NULL)
792         set_allowed_addrs(unit, NULL, NULL);
793
794     if (auth_required && !(go->neg_upap || go->neg_chap || go->neg_eap)) {
795         /*
796          * We wanted the peer to authenticate itself, and it refused:
797          * if we have some address(es) it can use without auth, fine,
798          * otherwise treat it as though it authenticated with PAP using
799          * a username of "" and a password of "".  If that's not OK,
800          * boot it out.
801          */
802         if (noauth_addrs != NULL) {
803             set_allowed_addrs(unit, NULL, NULL);
804         } else if (!wo->neg_upap || uselogin || !null_login(unit)) {
805             warn("peer refused to authenticate: terminating link");
806             status = EXIT_PEER_AUTH_FAILED;
807             lcp_close(unit, "peer refused to authenticate");
808             return;
809         }
810     }
811
812 #ifdef USE_EAPTLS
813     if (need_peer_eap && !ao->neg_eap) {
814         warn("eap required to authenticate us but no suitable secrets");
815         lcp_close(unit, "couldn't negotiate eap");
816         status = EXIT_AUTH_TOPEER_FAILED;
817         return;
818     }
819
820     if (need_peer_eap && !ho->neg_eap) {
821         warn("peer doesn't want to authenticate us with eap");
822         lcp_close(unit, "couldn't negotiate eap");
823         status = EXIT_PEER_AUTH_FAILED;
824         return;
825     }
826 #endif
827
828     new_phase(PHASE_AUTHENTICATE);
829     auth = 0;
830     if (go->neg_eap) {
831         eap_authpeer(unit, our_name);
832         auth |= EAP_PEER;
833     } else if (go->neg_chap) {
834         chap_auth_peer(unit, our_name, CHAP_DIGEST(go->chap_mdtype));
835         auth |= CHAP_PEER;
836     } else if (go->neg_upap) {
837         upap_authpeer(unit);
838         auth |= PAP_PEER;
839     }
840     if (ho->neg_eap) {
841         eap_authwithpeer(unit, user);
842         auth |= EAP_WITHPEER;
843     } else if (ho->neg_chap) {
844         chap_auth_with_peer(unit, user, CHAP_DIGEST(ho->chap_mdtype));
845         auth |= CHAP_WITHPEER;
846     } else if (ho->neg_upap) {
847         /* If a blank password was explicitly given as an option, trust
848            the user and don't try to look up one. */
849         if (passwd[0] == 0 && !explicit_passwd) {
850             passwd_from_file = 1;
851             if (!get_pap_passwd(passwd))
852                 error("No secret found for PAP login");
853         }
854         upap_authwithpeer(unit, user, passwd);
855         auth |= PAP_WITHPEER;
856     }
857     auth_pending[unit] = auth;
858     auth_done[unit] = 0;
859
860     if (!auth)
861         network_phase(unit);
862 }
863
864 /*
865  * Proceed to the network phase.
866  */
867 static void
868 network_phase(int unit)
869 {
870     lcp_options *go = &lcp_gotoptions[unit];
871
872     /* Log calling number. */
873     if (*remote_number)
874         notice("peer from calling number %q authorized", remote_number);
875
876     /*
877      * If the peer had to authenticate, run the auth-up script now.
878      */
879     notify(auth_up_notifier, 0);
880     if (go->neg_chap || go->neg_upap || go->neg_eap) {
881         auth_state = s_up;
882         if (auth_script_state == s_down && auth_script_pid == 0) {
883             auth_script_state = s_up;
884             auth_script(_PATH_AUTHUP);
885         }
886     }
887
888 #ifdef CBCP_SUPPORT
889     /*
890      * If we negotiated callback, do it now.
891      */
892     if (go->neg_cbcp) {
893         new_phase(PHASE_CALLBACK);
894         (*cbcp_protent.open)(unit);
895         return;
896     }
897 #endif
898
899     /*
900      * Process extra options from the secrets file
901      */
902     if (extra_options) {
903         options_from_list(extra_options, 1);
904         free_wordlist(extra_options);
905         extra_options = 0;
906     }
907     start_networks(unit);
908 }
909
910 void
911 start_networks(int unit)
912 {
913     int i;
914     struct protent *protp;
915     int ecp_required, mppe_required;
916
917     new_phase(PHASE_NETWORK);
918
919 #ifdef HAVE_MULTILINK
920     if (multilink) {
921         if (mp_join_bundle()) {
922             if (multilink_join_hook)
923                 (*multilink_join_hook)();
924             if (updetach && !nodetach)
925                 detach();
926             return;
927         }
928     }
929 #endif /* HAVE_MULTILINK */
930
931 #ifdef PPP_FILTER
932     if (!demand)
933         set_filters(&pass_filter, &active_filter);
934 #endif
935     /* Start CCP and ECP */
936     for (i = 0; (protp = protocols[i]) != NULL; ++i)
937         if ((protp->protocol == PPP_ECP || protp->protocol == PPP_CCP)
938             && protp->enabled_flag && protp->open != NULL)
939             (*protp->open)(0);
940
941     /*
942      * Bring up other network protocols iff encryption is not required.
943      */
944     ecp_required = ecp_gotoptions[unit].required;
945     mppe_required = ccp_gotoptions[unit].mppe;
946     if (!ecp_required && !mppe_required)
947         continue_networks(unit);
948 }
949
950 void
951 continue_networks(int unit)
952 {
953     int i;
954     struct protent *protp;
955
956     /*
957      * Start the "real" network protocols.
958      */
959     for (i = 0; (protp = protocols[i]) != NULL; ++i)
960         if (protp->protocol < 0xC000
961             && protp->protocol != PPP_CCP && protp->protocol != PPP_ECP
962             && protp->enabled_flag && protp->open != NULL) {
963             (*protp->open)(0);
964             ++num_np_open;
965         }
966
967     if (num_np_open == 0)
968         /* nothing to do */
969         lcp_close(0, "No network protocols running");
970 }
971
972 /*
973  * The peer has failed to authenticate himself using `protocol'.
974  */
975 void
976 auth_peer_fail(int unit, int protocol)
977 {
978     /*
979      * Authentication failure: take the link down
980      */
981     status = EXIT_PEER_AUTH_FAILED;
982     lcp_close(unit, "Authentication failed");
983 }
984
985 /*
986  * The peer has been successfully authenticated using `protocol'.
987  */
988 void
989 auth_peer_success(int unit, int protocol, int prot_flavor,
990                   char *name, int namelen)
991 {
992     int bit;
993
994     switch (protocol) {
995     case PPP_CHAP:
996         bit = CHAP_PEER;
997         switch (prot_flavor) {
998         case CHAP_MD5:
999             bit |= CHAP_MD5_PEER;
1000             break;
1001 #ifdef CHAPMS
1002         case CHAP_MICROSOFT:
1003             bit |= CHAP_MS_PEER;
1004             break;
1005         case CHAP_MICROSOFT_V2:
1006             bit |= CHAP_MS2_PEER;
1007             break;
1008 #endif
1009         }
1010         break;
1011     case PPP_PAP:
1012         bit = PAP_PEER;
1013         break;
1014     case PPP_EAP:
1015         bit = EAP_PEER;
1016         break;
1017     default:
1018         warn("auth_peer_success: unknown protocol %x", protocol);
1019         return;
1020     }
1021
1022     /*
1023      * Save the authenticated name of the peer for later.
1024      */
1025     if (namelen > sizeof(peer_authname) - 1)
1026         namelen = sizeof(peer_authname) - 1;
1027     BCOPY(name, peer_authname, namelen);
1028     peer_authname[namelen] = 0;
1029     script_setenv("PEERNAME", peer_authname, 0);
1030
1031     /* Save the authentication method for later. */
1032     auth_done[unit] |= bit;
1033
1034     /*
1035      * If there is no more authentication still to be done,
1036      * proceed to the network (or callback) phase.
1037      */
1038     if ((auth_pending[unit] &= ~bit) == 0)
1039         network_phase(unit);
1040 }
1041
1042 /*
1043  * We have failed to authenticate ourselves to the peer using `protocol'.
1044  */
1045 void
1046 auth_withpeer_fail(int unit, int protocol)
1047 {
1048     if (passwd_from_file)
1049         BZERO(passwd, MAXSECRETLEN);
1050     /*
1051      * We've failed to authenticate ourselves to our peer.
1052      * Some servers keep sending CHAP challenges, but there
1053      * is no point in persisting without any way to get updated
1054      * authentication secrets.
1055      */
1056     status = EXIT_AUTH_TOPEER_FAILED;
1057     lcp_close(unit, "Failed to authenticate ourselves to peer");
1058 }
1059
1060 /*
1061  * We have successfully authenticated ourselves with the peer using `protocol'.
1062  */
1063 void
1064 auth_withpeer_success(int unit, int protocol, int prot_flavor)
1065 {
1066     int bit;
1067     const char *prot = "";
1068
1069     switch (protocol) {
1070     case PPP_CHAP:
1071         bit = CHAP_WITHPEER;
1072         prot = "CHAP";
1073         switch (prot_flavor) {
1074         case CHAP_MD5:
1075             bit |= CHAP_MD5_WITHPEER;
1076             break;
1077 #ifdef CHAPMS
1078         case CHAP_MICROSOFT:
1079             bit |= CHAP_MS_WITHPEER;
1080             break;
1081         case CHAP_MICROSOFT_V2:
1082             bit |= CHAP_MS2_WITHPEER;
1083             break;
1084 #endif
1085         }
1086         break;
1087     case PPP_PAP:
1088         if (passwd_from_file)
1089             BZERO(passwd, MAXSECRETLEN);
1090         bit = PAP_WITHPEER;
1091         prot = "PAP";
1092         break;
1093     case PPP_EAP:
1094         bit = EAP_WITHPEER;
1095         prot = "EAP";
1096         break;
1097     default:
1098         warn("auth_withpeer_success: unknown protocol %x", protocol);
1099         bit = 0;
1100     }
1101
1102     notice("%s authentication succeeded", prot);
1103
1104     /* Save the authentication method for later. */
1105     auth_done[unit] |= bit;
1106
1107     /*
1108      * If there is no more authentication still being done,
1109      * proceed to the network (or callback) phase.
1110      */
1111     if ((auth_pending[unit] &= ~bit) == 0)
1112         network_phase(unit);
1113 }
1114
1115
1116 /*
1117  * np_up - a network protocol has come up.
1118  */
1119 void
1120 np_up(int unit, int proto)
1121 {
1122     int tlim;
1123
1124     if (num_np_up == 0) {
1125         /*
1126          * At this point we consider that the link has come up successfully.
1127          */
1128         status = EXIT_OK;
1129         unsuccess = 0;
1130         new_phase(PHASE_RUNNING);
1131
1132         if (idle_time_hook != 0)
1133             tlim = (*idle_time_hook)(NULL);
1134         else
1135             tlim = idle_time_limit;
1136         if (tlim > 0)
1137             TIMEOUT(check_idle, NULL, tlim);
1138
1139         /*
1140          * Set a timeout to close the connection once the maximum
1141          * connect time has expired.
1142          */
1143         if (maxconnect > 0)
1144             TIMEOUT(connect_time_expired, 0, maxconnect);
1145
1146 #ifdef MAXOCTETS
1147         if (maxoctets > 0)
1148             TIMEOUT(check_maxoctets, NULL, maxoctets_timeout);
1149 #endif
1150
1151         /*
1152          * Detach now, if the updetach option was given.
1153          */
1154         if (updetach && !nodetach) {
1155             dbglog("updetach is set. Now detaching.");
1156             detach();
1157 #ifdef SYSTEMD
1158         } else if (nodetach && up_sdnotify) {
1159             dbglog("up_sdnotify is set. Now notifying systemd: READY=1");
1160             sd_notify(0, "READY=1");
1161 #endif
1162         }
1163     }
1164     ++num_np_up;
1165 }
1166
1167 /*
1168  * np_down - a network protocol has gone down.
1169  */
1170 void
1171 np_down(int unit, int proto)
1172 {
1173     if (--num_np_up == 0) {
1174         UNTIMEOUT(check_idle, NULL);
1175         UNTIMEOUT(connect_time_expired, NULL);
1176 #ifdef MAXOCTETS
1177         UNTIMEOUT(check_maxoctets, NULL);
1178 #endif  
1179         new_phase(PHASE_NETWORK);
1180     }
1181 }
1182
1183 /*
1184  * np_finished - a network protocol has finished using the link.
1185  */
1186 void
1187 np_finished(int unit, int proto)
1188 {
1189     if (--num_np_open <= 0) {
1190         /* no further use for the link: shut up shop. */
1191         lcp_close(0, "No network protocols running");
1192     }
1193 }
1194
1195 #ifdef MAXOCTETS
1196 static void
1197 check_maxoctets(void *arg)
1198 {
1199     unsigned int used;
1200
1201     update_link_stats(ifunit);
1202     link_stats_valid=0;
1203     
1204     switch(maxoctets_dir) {
1205         case PPP_OCTETS_DIRECTION_IN:
1206             used = link_stats.bytes_in;
1207             break;
1208         case PPP_OCTETS_DIRECTION_OUT:
1209             used = link_stats.bytes_out;
1210             break;
1211         case PPP_OCTETS_DIRECTION_MAXOVERAL:
1212         case PPP_OCTETS_DIRECTION_MAXSESSION:
1213             used = (link_stats.bytes_in > link_stats.bytes_out) ? link_stats.bytes_in : link_stats.bytes_out;
1214             break;
1215         default:
1216             used = link_stats.bytes_in+link_stats.bytes_out;
1217             break;
1218     }
1219     if (used > maxoctets) {
1220         notice("Traffic limit reached. Limit: %u Used: %u", maxoctets, used);
1221         status = EXIT_TRAFFIC_LIMIT;
1222         lcp_close(0, "Traffic limit");
1223         need_holdoff = 0;
1224     } else {
1225         TIMEOUT(check_maxoctets, NULL, maxoctets_timeout);
1226     }
1227 }
1228 #endif
1229
1230 /*
1231  * check_idle - check whether the link has been idle for long
1232  * enough that we can shut it down.
1233  */
1234 static void
1235 check_idle(void *arg)
1236 {
1237     struct ppp_idle idle;
1238     time_t itime;
1239     int tlim;
1240
1241     if (!get_idle_time(0, &idle))
1242         return;
1243     if (idle_time_hook != 0) {
1244         tlim = idle_time_hook(&idle);
1245     } else {
1246         itime = MIN(idle.xmit_idle, idle.recv_idle);
1247         tlim = idle_time_limit - itime;
1248     }
1249     if (tlim <= 0) {
1250         /* link is idle: shut it down. */
1251         notice("Terminating connection due to lack of activity.");
1252         status = EXIT_IDLE_TIMEOUT;
1253         lcp_close(0, "Link inactive");
1254         need_holdoff = 0;
1255     } else {
1256         TIMEOUT(check_idle, NULL, tlim);
1257     }
1258 }
1259
1260 /*
1261  * connect_time_expired - log a message and close the connection.
1262  */
1263 static void
1264 connect_time_expired(void *arg)
1265 {
1266     info("Connect time expired");
1267     status = EXIT_CONNECT_TIME;
1268     lcp_close(0, "Connect time expired");       /* Close connection */
1269 }
1270
1271 /*
1272  * auth_check_options - called to check authentication options.
1273  */
1274 void
1275 auth_check_options(void)
1276 {
1277     lcp_options *wo = &lcp_wantoptions[0];
1278     int can_auth;
1279     int lacks_ip;
1280
1281     /* Default our_name to hostname, and user to our_name */
1282     if (our_name[0] == 0 || usehostname)
1283         strlcpy(our_name, hostname, sizeof(our_name));
1284     /* If a blank username was explicitly given as an option, trust
1285        the user and don't use our_name */
1286     if (user[0] == 0 && !explicit_user)
1287         strlcpy(user, our_name, sizeof(user));
1288
1289     /*
1290      * If we have a default route, require the peer to authenticate
1291      * unless the noauth option was given or the real user is root.
1292      */
1293     if (!auth_required && !allow_any_ip && have_route_to(0) && !privileged) {
1294         auth_required = 1;
1295         default_auth = 1;
1296     }
1297
1298     /* If we selected any CHAP flavors, we should probably negotiate it. :-) */
1299     if (wo->chap_mdtype)
1300         wo->neg_chap = 1;
1301
1302     /* If authentication is required, ask peer for CHAP, PAP, or EAP. */
1303     if (auth_required) {
1304         allow_any_ip = 0;
1305         if (!wo->neg_chap && !wo->neg_upap && !wo->neg_eap) {
1306             wo->neg_chap = chap_mdtype_all != MDTYPE_NONE;
1307             wo->chap_mdtype = chap_mdtype_all;
1308             wo->neg_upap = 1;
1309             wo->neg_eap = 1;
1310         }
1311     } else {
1312         wo->neg_chap = 0;
1313         wo->chap_mdtype = MDTYPE_NONE;
1314         wo->neg_upap = 0;
1315         wo->neg_eap = 0;
1316     }
1317
1318     /*
1319      * Check whether we have appropriate secrets to use
1320      * to authenticate the peer.  Note that EAP can authenticate by way
1321      * of a CHAP-like exchanges as well as SRP.
1322      */
1323     lacks_ip = 0;
1324     can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip));
1325     if (!can_auth && (wo->neg_chap || wo->neg_eap)) {
1326         can_auth = have_chap_secret((explicit_remote? remote_name: NULL),
1327                                     our_name, 1, &lacks_ip);
1328     }
1329     if (!can_auth && wo->neg_eap) {
1330         can_auth = have_srp_secret((explicit_remote? remote_name: NULL),
1331                                     our_name, 1, &lacks_ip);
1332     }
1333
1334 #ifdef USE_EAPTLS
1335     if (!can_auth && wo->neg_eap) {
1336         can_auth =
1337             have_eaptls_secret_server((explicit_remote ? remote_name :
1338                                        NULL), our_name, 1, &lacks_ip);
1339
1340     }
1341 #endif
1342
1343     if (auth_required && !can_auth && noauth_addrs == NULL) {
1344         if (default_auth) {
1345             option_error(
1346 "By default the remote system is required to authenticate itself");
1347             option_error(
1348 "(because this system has a default route to the internet)");
1349         } else if (explicit_remote)
1350             option_error(
1351 "The remote system (%s) is required to authenticate itself",
1352                          remote_name);
1353         else
1354             option_error(
1355 "The remote system is required to authenticate itself");
1356         option_error(
1357 "but I couldn't find any suitable secret (password) for it to use to do so.");
1358         if (lacks_ip)
1359             option_error(
1360 "(None of the available passwords would let it use an IP address.)");
1361
1362         exit(1);
1363     }
1364
1365     /*
1366      * Early check for remote number authorization.
1367      */
1368     if (!auth_number()) {
1369         warn("calling number %q is not authorized", remote_number);
1370         exit(EXIT_CNID_AUTH_FAILED);
1371     }
1372 }
1373
1374 /*
1375  * auth_reset - called when LCP is starting negotiations to recheck
1376  * authentication options, i.e. whether we have appropriate secrets
1377  * to use for authenticating ourselves and/or the peer.
1378  */
1379 void
1380 auth_reset(int unit)
1381 {
1382     lcp_options *go = &lcp_gotoptions[unit];
1383     lcp_options *ao = &lcp_allowoptions[unit];
1384     int hadchap;
1385
1386     hadchap = -1;
1387     ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL));
1388     ao->neg_chap = (!refuse_chap || !refuse_mschap || !refuse_mschap_v2)
1389         && ((passwd[0] != 0 || explicit_passwd) ||
1390             (hadchap = have_chap_secret(user, (explicit_remote? remote_name:
1391                                                NULL), 0, NULL)));
1392     ao->neg_eap = !refuse_eap && (
1393         passwd[0] != 0 ||
1394         (hadchap == 1 || (hadchap == -1 && have_chap_secret(user,
1395             (explicit_remote? remote_name: NULL), 0, NULL))) ||
1396         have_srp_secret(user, (explicit_remote? remote_name: NULL), 0, NULL)
1397 #ifdef USE_EAPTLS
1398                 || have_eaptls_secret_client(user, (explicit_remote? remote_name: NULL))
1399 #endif
1400         );
1401
1402     hadchap = -1;
1403     if (go->neg_upap && !uselogin && !have_pap_secret(NULL))
1404         go->neg_upap = 0;
1405     if (go->neg_chap) {
1406         if (!(hadchap = have_chap_secret((explicit_remote? remote_name: NULL),
1407                               our_name, 1, NULL)))
1408             go->neg_chap = 0;
1409     }
1410     if (go->neg_eap &&
1411         (hadchap == 0 || (hadchap == -1 &&
1412             !have_chap_secret((explicit_remote? remote_name: NULL), our_name,
1413                 1, NULL))) &&
1414         !have_srp_secret((explicit_remote? remote_name: NULL), our_name, 1,
1415             NULL)
1416 #ifdef USE_EAPTLS
1417          && !have_eaptls_secret_server((explicit_remote? remote_name: NULL),
1418                                    our_name, 1, NULL)
1419 #endif
1420                 )
1421         go->neg_eap = 0;
1422 }
1423
1424
1425 /*
1426  * check_passwd - Check the user name and passwd against the PAP secrets
1427  * file.  If requested, also check against the system password database,
1428  * and login the user if OK.
1429  *
1430  * returns:
1431  *      UPAP_AUTHNAK: Authentication failed.
1432  *      UPAP_AUTHACK: Authentication succeeded.
1433  * In either case, msg points to an appropriate message.
1434  */
1435 int
1436 check_passwd(int unit,
1437              char *auser, int userlen,
1438              char *apasswd, int passwdlen, char **msg)
1439 {
1440     int ret;
1441     char *filename;
1442     FILE *f;
1443     struct wordlist *addrs = NULL, *opts = NULL;
1444     char passwd[256], user[256];
1445     char secret[MAXWORDLEN];
1446     static int attempts = 0;
1447
1448     /*
1449      * Make copies of apasswd and auser, then null-terminate them.
1450      * If there are unprintable characters in the password, make
1451      * them visible.
1452      */
1453     slprintf(passwd, sizeof(passwd), "%.*v", passwdlen, apasswd);
1454     slprintf(user, sizeof(user), "%.*v", userlen, auser);
1455     *msg = "";
1456
1457     /*
1458      * Check if a plugin wants to handle this.
1459      */
1460     if (pap_auth_hook) {
1461         ret = (*pap_auth_hook)(user, passwd, msg, &addrs, &opts);
1462         if (ret >= 0) {
1463             /* note: set_allowed_addrs() saves opts (but not addrs):
1464                don't free it! */
1465             if (ret)
1466                 set_allowed_addrs(unit, addrs, opts);
1467             else if (opts != 0)
1468                 free_wordlist(opts);
1469             if (addrs != 0)
1470                 free_wordlist(addrs);
1471             BZERO(passwd, sizeof(passwd));
1472             return ret? UPAP_AUTHACK: UPAP_AUTHNAK;
1473         }
1474     }
1475
1476     /*
1477      * Open the file of pap secrets and scan for a suitable secret
1478      * for authenticating this user.
1479      */
1480     filename = _PATH_UPAPFILE;
1481     addrs = opts = NULL;
1482     ret = UPAP_AUTHNAK;
1483     f = fopen(filename, "r");
1484     if (f == NULL) {
1485         error("Can't open PAP password file %s: %m", filename);
1486
1487     } else {
1488         check_access(f, filename);
1489         if (scan_authfile(f, user, our_name, secret, &addrs, &opts, filename, 0) < 0) {
1490             warn("no PAP secret found for %s", user);
1491         } else {
1492             /*
1493              * If the secret is "@login", it means to check
1494              * the password against the login database.
1495              */
1496             int login_secret = strcmp(secret, "@login") == 0;
1497             ret = UPAP_AUTHACK;
1498             if (uselogin || login_secret) {
1499                 /* login option or secret is @login */
1500                 if (session_full(user, passwd, devnam, msg) == 0) {
1501                     ret = UPAP_AUTHNAK;
1502                 }
1503             } else if (session_mgmt) {
1504                 if (session_check(user, NULL, devnam, NULL) == 0) {
1505                     warn("Peer %q failed PAP Session verification", user);
1506                     ret = UPAP_AUTHNAK;
1507                 }
1508             }
1509             if (secret[0] != 0 && !login_secret) {
1510                 /* password given in pap-secrets - must match */
1511                 if (cryptpap || strcmp(passwd, secret) != 0) {
1512                     char *cbuf = crypt(passwd, secret);
1513                     if (!cbuf || strcmp(cbuf, secret) != 0)
1514                         ret = UPAP_AUTHNAK;
1515                 }
1516             }
1517         }
1518         fclose(f);
1519     }
1520
1521     if (ret == UPAP_AUTHNAK) {
1522         if (**msg == 0)
1523             *msg = "Login incorrect";
1524         /*
1525          * XXX can we ever get here more than once??
1526          * Frustrate passwd stealer programs.
1527          * Allow 10 tries, but start backing off after 3 (stolen from login).
1528          * On 10'th, drop the connection.
1529          */
1530         if (attempts++ >= 10) {
1531             warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user);
1532             lcp_close(unit, "login failed");
1533         }
1534         if (attempts > 3)
1535             sleep((u_int) (attempts - 3) * 5);
1536         if (opts != NULL)
1537             free_wordlist(opts);
1538
1539     } else {
1540         attempts = 0;                   /* Reset count */
1541         if (**msg == 0)
1542             *msg = "Login ok";
1543         set_allowed_addrs(unit, addrs, opts);
1544     }
1545
1546     if (addrs != NULL)
1547         free_wordlist(addrs);
1548     BZERO(passwd, sizeof(passwd));
1549     BZERO(secret, sizeof(secret));
1550
1551     return ret;
1552 }
1553
1554 /*
1555  * null_login - Check if a username of "" and a password of "" are
1556  * acceptable, and iff so, set the list of acceptable IP addresses
1557  * and return 1.
1558  */
1559 static int
1560 null_login(int unit)
1561 {
1562     char *filename;
1563     FILE *f;
1564     int i, ret;
1565     struct wordlist *addrs, *opts;
1566     char secret[MAXWORDLEN];
1567
1568     /*
1569      * Check if a plugin wants to handle this.
1570      */
1571     ret = -1;
1572     if (null_auth_hook)
1573         ret = (*null_auth_hook)(&addrs, &opts);
1574
1575     /*
1576      * Open the file of pap secrets and scan for a suitable secret.
1577      */
1578     if (ret <= 0) {
1579         filename = _PATH_UPAPFILE;
1580         addrs = NULL;
1581         f = fopen(filename, "r");
1582         if (f == NULL)
1583             return 0;
1584         check_access(f, filename);
1585
1586         i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename, 0);
1587         ret = i >= 0 && secret[0] == 0;
1588         BZERO(secret, sizeof(secret));
1589         fclose(f);
1590     }
1591
1592     if (ret)
1593         set_allowed_addrs(unit, addrs, opts);
1594     else if (opts != 0)
1595         free_wordlist(opts);
1596     if (addrs != 0)
1597         free_wordlist(addrs);
1598
1599     return ret;
1600 }
1601
1602
1603 /*
1604  * get_pap_passwd - get a password for authenticating ourselves with
1605  * our peer using PAP.  Returns 1 on success, 0 if no suitable password
1606  * could be found.
1607  * Assumes passwd points to MAXSECRETLEN bytes of space (if non-null).
1608  */
1609 static int
1610 get_pap_passwd(char *passwd)
1611 {
1612     char *filename;
1613     FILE *f;
1614     int ret;
1615     char secret[MAXWORDLEN];
1616
1617     /*
1618      * Check whether a plugin wants to supply this.
1619      */
1620     if (pap_passwd_hook) {
1621         ret = (*pap_passwd_hook)(user, passwd);
1622         if (ret >= 0)
1623             return ret;
1624     }
1625
1626     filename = _PATH_UPAPFILE;
1627     f = fopen(filename, "r");
1628     if (f == NULL)
1629         return 0;
1630     check_access(f, filename);
1631     ret = scan_authfile(f, user,
1632                         (remote_name[0]? remote_name: NULL),
1633                         secret, NULL, NULL, filename, 0);
1634     fclose(f);
1635     if (ret < 0)
1636         return 0;
1637     if (passwd != NULL)
1638         strlcpy(passwd, secret, MAXSECRETLEN);
1639     BZERO(secret, sizeof(secret));
1640     return 1;
1641 }
1642
1643
1644 /*
1645  * have_pap_secret - check whether we have a PAP file with any
1646  * secrets that we could possibly use for authenticating the peer.
1647  */
1648 static int
1649 have_pap_secret(int *lacks_ipp)
1650 {
1651     FILE *f;
1652     int ret;
1653     char *filename;
1654     struct wordlist *addrs;
1655
1656     /* let the plugin decide, if there is one */
1657     if (pap_check_hook) {
1658         ret = (*pap_check_hook)();
1659         if (ret >= 0)
1660             return ret;
1661     }
1662
1663     filename = _PATH_UPAPFILE;
1664     f = fopen(filename, "r");
1665     if (f == NULL)
1666         return 0;
1667
1668     ret = scan_authfile(f, (explicit_remote? remote_name: NULL), our_name,
1669                         NULL, &addrs, NULL, filename, 0);
1670     fclose(f);
1671     if (ret >= 0 && !some_ip_ok(addrs)) {
1672         if (lacks_ipp != 0)
1673             *lacks_ipp = 1;
1674         ret = -1;
1675     }
1676     if (addrs != 0)
1677         free_wordlist(addrs);
1678
1679     return ret >= 0;
1680 }
1681
1682
1683 /*
1684  * have_chap_secret - check whether we have a CHAP file with a
1685  * secret that we could possibly use for authenticating `client'
1686  * on `server'.  Either can be the null string, meaning we don't
1687  * know the identity yet.
1688  */
1689 static int
1690 have_chap_secret(char *client, char *server,
1691                  int need_ip, int *lacks_ipp)
1692 {
1693     FILE *f;
1694     int ret;
1695     char *filename;
1696     struct wordlist *addrs;
1697
1698     if (chap_check_hook) {
1699         ret = (*chap_check_hook)();
1700         if (ret >= 0) {
1701             return ret;
1702         }
1703     }
1704
1705     filename = _PATH_CHAPFILE;
1706     f = fopen(filename, "r");
1707     if (f == NULL)
1708         return 0;
1709
1710     if (client != NULL && client[0] == 0)
1711         client = NULL;
1712     else if (server != NULL && server[0] == 0)
1713         server = NULL;
1714
1715     ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0);
1716     fclose(f);
1717     if (ret >= 0 && need_ip && !some_ip_ok(addrs)) {
1718         if (lacks_ipp != 0)
1719             *lacks_ipp = 1;
1720         ret = -1;
1721     }
1722     if (addrs != 0)
1723         free_wordlist(addrs);
1724
1725     return ret >= 0;
1726 }
1727
1728
1729 /*
1730  * have_srp_secret - check whether we have a SRP file with a
1731  * secret that we could possibly use for authenticating `client'
1732  * on `server'.  Either can be the null string, meaning we don't
1733  * know the identity yet.
1734  */
1735 static int
1736 have_srp_secret(char *client, char *server, int need_ip, int *lacks_ipp)
1737 {
1738     FILE *f;
1739     int ret;
1740     char *filename;
1741     struct wordlist *addrs;
1742
1743     filename = _PATH_SRPFILE;
1744     f = fopen(filename, "r");
1745     if (f == NULL)
1746         return 0;
1747
1748     if (client != NULL && client[0] == 0)
1749         client = NULL;
1750     else if (server != NULL && server[0] == 0)
1751         server = NULL;
1752
1753     ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0);
1754     fclose(f);
1755     if (ret >= 0 && need_ip && !some_ip_ok(addrs)) {
1756         if (lacks_ipp != 0)
1757             *lacks_ipp = 1;
1758         ret = -1;
1759     }
1760     if (addrs != 0)
1761         free_wordlist(addrs);
1762
1763     return ret >= 0;
1764 }
1765
1766
1767 /*
1768  * get_secret - open the CHAP secret file and return the secret
1769  * for authenticating the given client on the given server.
1770  * (We could be either client or server).
1771  */
1772 int
1773 get_secret(int unit, char *client, char *server,
1774            char *secret, int *secret_len, int am_server)
1775 {
1776     FILE *f;
1777     int ret, len;
1778     char *filename;
1779     struct wordlist *addrs, *opts;
1780     char secbuf[MAXWORDLEN];
1781
1782     if (!am_server && passwd[0] != 0) {
1783         strlcpy(secbuf, passwd, sizeof(secbuf));
1784     } else if (!am_server && chap_passwd_hook) {
1785         if ( (*chap_passwd_hook)(client, secbuf) < 0) {
1786             error("Unable to obtain CHAP password for %s on %s from plugin",
1787                   client, server);
1788             return 0;
1789         }
1790     } else {
1791         filename = _PATH_CHAPFILE;
1792         addrs = NULL;
1793         secbuf[0] = 0;
1794
1795         f = fopen(filename, "r");
1796         if (f == NULL) {
1797             error("Can't open chap secret file %s: %m", filename);
1798             return 0;
1799         }
1800         check_access(f, filename);
1801
1802         ret = scan_authfile(f, client, server, secbuf, &addrs, &opts, filename, 0);
1803         fclose(f);
1804         if (ret < 0)
1805             return 0;
1806
1807         if (am_server)
1808             set_allowed_addrs(unit, addrs, opts);
1809         else if (opts != 0)
1810             free_wordlist(opts);
1811         if (addrs != 0)
1812             free_wordlist(addrs);
1813     }
1814
1815     len = strlen(secbuf);
1816     if (len > MAXSECRETLEN) {
1817         error("Secret for %s on %s is too long", client, server);
1818         len = MAXSECRETLEN;
1819     }
1820     BCOPY(secbuf, secret, len);
1821     BZERO(secbuf, sizeof(secbuf));
1822     *secret_len = len;
1823
1824     return 1;
1825 }
1826
1827
1828 /*
1829  * get_srp_secret - open the SRP secret file and return the secret
1830  * for authenticating the given client on the given server.
1831  * (We could be either client or server).
1832  */
1833 int
1834 get_srp_secret(int unit, char *client, char *server,
1835                char *secret, int am_server)
1836 {
1837     FILE *fp;
1838     int ret;
1839     char *filename;
1840     struct wordlist *addrs, *opts;
1841
1842     if (!am_server && passwd[0] != '\0') {
1843         strlcpy(secret, passwd, MAXWORDLEN);
1844     } else {
1845         filename = _PATH_SRPFILE;
1846         addrs = NULL;
1847
1848         fp = fopen(filename, "r");
1849         if (fp == NULL) {
1850             error("Can't open srp secret file %s: %m", filename);
1851             return 0;
1852         }
1853         check_access(fp, filename);
1854
1855         secret[0] = '\0';
1856         ret = scan_authfile(fp, client, server, secret, &addrs, &opts,
1857             filename, am_server);
1858         fclose(fp);
1859         if (ret < 0)
1860             return 0;
1861
1862         if (am_server)
1863             set_allowed_addrs(unit, addrs, opts);
1864         else if (opts != NULL)
1865             free_wordlist(opts);
1866         if (addrs != NULL)
1867             free_wordlist(addrs);
1868     }
1869
1870     return 1;
1871 }
1872
1873 /*
1874  * set_allowed_addrs() - set the list of allowed addresses.
1875  * Also looks for `--' indicating options to apply for this peer
1876  * and leaves the following words in extra_options.
1877  */
1878 static void
1879 set_allowed_addrs(int unit, struct wordlist *addrs,
1880                   struct wordlist *opts)
1881 {
1882     int n;
1883     struct wordlist *ap, **plink;
1884     struct permitted_ip *ip;
1885     char *ptr_word, *ptr_mask;
1886     struct hostent *hp;
1887     struct netent *np;
1888     u_int32_t a, mask, ah, offset;
1889     struct ipcp_options *wo = &ipcp_wantoptions[unit];
1890     u_int32_t suggested_ip = 0;
1891
1892     if (addresses[unit] != NULL)
1893         free(addresses[unit]);
1894     addresses[unit] = NULL;
1895     if (extra_options != NULL)
1896         free_wordlist(extra_options);
1897     extra_options = opts;
1898
1899     /*
1900      * Count the number of IP addresses given.
1901      */
1902     n = wordlist_count(addrs) + wordlist_count(noauth_addrs);
1903     if (n == 0)
1904         return;
1905     ip = (struct permitted_ip *) malloc((n + 1) * sizeof(struct permitted_ip));
1906     if (ip == 0)
1907         return;
1908
1909     /* temporarily append the noauth_addrs list to addrs */
1910     for (plink = &addrs; *plink != NULL; plink = &(*plink)->next)
1911         ;
1912     *plink = noauth_addrs;
1913
1914     n = 0;
1915     for (ap = addrs; ap != NULL; ap = ap->next) {
1916         /* "-" means no addresses authorized, "*" means any address allowed */
1917         ptr_word = ap->word;
1918         if (strcmp(ptr_word, "-") == 0)
1919             break;
1920         if (strcmp(ptr_word, "*") == 0) {
1921             ip[n].permit = 1;
1922             ip[n].base = ip[n].mask = 0;
1923             ++n;
1924             break;
1925         }
1926
1927         ip[n].permit = 1;
1928         if (*ptr_word == '!') {
1929             ip[n].permit = 0;
1930             ++ptr_word;
1931         }
1932
1933         mask = ~ (u_int32_t) 0;
1934         offset = 0;
1935         ptr_mask = strchr (ptr_word, '/');
1936         if (ptr_mask != NULL) {
1937             int bit_count;
1938             char *endp;
1939
1940             bit_count = (int) strtol (ptr_mask+1, &endp, 10);
1941             if (bit_count <= 0 || bit_count > 32) {
1942                 warn("invalid address length %v in auth. address list",
1943                      ptr_mask+1);
1944                 continue;
1945             }
1946             bit_count = 32 - bit_count; /* # bits in host part */
1947             if (*endp == '+') {
1948                 offset = ifunit + 1;
1949                 ++endp;
1950             }
1951             if (*endp != 0) {
1952                 warn("invalid address length syntax: %v", ptr_mask+1);
1953                 continue;
1954             }
1955             *ptr_mask = '\0';
1956             mask <<= bit_count;
1957         }
1958
1959         hp = gethostbyname(ptr_word);
1960         if (hp != NULL && hp->h_addrtype == AF_INET) {
1961             a = *(u_int32_t *)hp->h_addr;
1962         } else {
1963             np = getnetbyname (ptr_word);
1964             if (np != NULL && np->n_addrtype == AF_INET) {
1965                 a = htonl ((u_int32_t)np->n_net);
1966                 if (ptr_mask == NULL) {
1967                     /* calculate appropriate mask for net */
1968                     ah = ntohl(a);
1969                     if (IN_CLASSA(ah))
1970                         mask = IN_CLASSA_NET;
1971                     else if (IN_CLASSB(ah))
1972                         mask = IN_CLASSB_NET;
1973                     else if (IN_CLASSC(ah))
1974                         mask = IN_CLASSC_NET;
1975                 }
1976             } else {
1977                 a = inet_addr (ptr_word);
1978             }
1979         }
1980
1981         if (ptr_mask != NULL)
1982             *ptr_mask = '/';
1983
1984         if (a == (u_int32_t)-1L) {
1985             warn("unknown host %s in auth. address list", ap->word);
1986             continue;
1987         }
1988         if (offset != 0) {
1989             if (offset >= ~mask) {
1990                 warn("interface unit %d too large for subnet %v",
1991                      ifunit, ptr_word);
1992                 continue;
1993             }
1994             a = htonl((ntohl(a) & mask) + offset);
1995             mask = ~(u_int32_t)0;
1996         }
1997         ip[n].mask = htonl(mask);
1998         ip[n].base = a & ip[n].mask;
1999         ++n;
2000         if (~mask == 0 && suggested_ip == 0)
2001             suggested_ip = a;
2002     }
2003     *plink = NULL;
2004
2005     ip[n].permit = 0;           /* make the last entry forbid all addresses */
2006     ip[n].base = 0;             /* to terminate the list */
2007     ip[n].mask = 0;
2008
2009     addresses[unit] = ip;
2010
2011     /*
2012      * If the address given for the peer isn't authorized, or if
2013      * the user hasn't given one, AND there is an authorized address
2014      * which is a single host, then use that if we find one.
2015      */
2016     if (suggested_ip != 0
2017         && (wo->hisaddr == 0 || !auth_ip_addr(unit, wo->hisaddr))) {
2018         wo->hisaddr = suggested_ip;
2019         /*
2020          * Do we insist on this address?  No, if there are other
2021          * addresses authorized than the suggested one.
2022          */
2023         if (n > 1)
2024             wo->accept_remote = 1;
2025     }
2026 }
2027
2028 /*
2029  * auth_ip_addr - check whether the peer is authorized to use
2030  * a given IP address.  Returns 1 if authorized, 0 otherwise.
2031  */
2032 int
2033 auth_ip_addr(int unit, u_int32_t addr)
2034 {
2035     int ok;
2036
2037     /* don't allow loopback or multicast address */
2038     if (bad_ip_adrs(addr))
2039         return 0;
2040
2041     if (allowed_address_hook) {
2042         ok = allowed_address_hook(addr);
2043         if (ok >= 0) return ok;
2044     }
2045
2046     if (addresses[unit] != NULL) {
2047         ok = ip_addr_check(addr, addresses[unit]);
2048         if (ok >= 0)
2049             return ok;
2050     }
2051
2052     if (auth_required)
2053         return 0;               /* no addresses authorized */
2054     return allow_any_ip || privileged || !have_route_to(addr);
2055 }
2056
2057 static int
2058 ip_addr_check(u_int32_t addr, struct permitted_ip *addrs)
2059 {
2060     for (; ; ++addrs)
2061         if ((addr & addrs->mask) == addrs->base)
2062             return addrs->permit;
2063 }
2064
2065 /*
2066  * bad_ip_adrs - return 1 if the IP address is one we don't want
2067  * to use, such as an address in the loopback net or a multicast address.
2068  * addr is in network byte order.
2069  */
2070 int
2071 bad_ip_adrs(u_int32_t addr)
2072 {
2073     addr = ntohl(addr);
2074     return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
2075         || IN_MULTICAST(addr) || IN_BADCLASS(addr);
2076 }
2077
2078 /*
2079  * some_ip_ok - check a wordlist to see if it authorizes any
2080  * IP address(es).
2081  */
2082 static int
2083 some_ip_ok(struct wordlist *addrs)
2084 {
2085     for (; addrs != 0; addrs = addrs->next) {
2086         if (addrs->word[0] == '-')
2087             break;
2088         if (addrs->word[0] != '!')
2089             return 1;           /* some IP address is allowed */
2090     }
2091     return 0;
2092 }
2093
2094 /*
2095  * auth_number - check whether the remote number is allowed to connect.
2096  * Returns 1 if authorized, 0 otherwise.
2097  */
2098 int
2099 auth_number(void)
2100 {
2101     struct wordlist *wp = permitted_numbers;
2102     int l;
2103
2104     /* Allow all if no authorization list. */
2105     if (!wp)
2106         return 1;
2107
2108     /* Allow if we have a match in the authorization list. */
2109     while (wp) {
2110         /* trailing '*' wildcard */
2111         l = strlen(wp->word);
2112         if ((wp->word)[l - 1] == '*')
2113             l--;
2114         if (!strncasecmp(wp->word, remote_number, l))
2115             return 1;
2116         wp = wp->next;
2117     }
2118
2119     return 0;
2120 }
2121
2122 /*
2123  * check_access - complain if a secret file has too-liberal permissions.
2124  */
2125 static void
2126 check_access(FILE *f, char *filename)
2127 {
2128     struct stat sbuf;
2129
2130     if (fstat(fileno(f), &sbuf) < 0) {
2131         warn("cannot stat secret file %s: %m", filename);
2132     } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) {
2133         warn("Warning - secret file %s has world and/or group access",
2134              filename);
2135     }
2136 }
2137
2138
2139 /*
2140  * scan_authfile - Scan an authorization file for a secret suitable
2141  * for authenticating `client' on `server'.  The return value is -1
2142  * if no secret is found, otherwise >= 0.  The return value has
2143  * NONWILD_CLIENT set if the secret didn't have "*" for the client, and
2144  * NONWILD_SERVER set if the secret didn't have "*" for the server.
2145  * Any following words on the line up to a "--" (i.e. address authorization
2146  * info) are placed in a wordlist and returned in *addrs.  Any
2147  * following words (extra options) are placed in a wordlist and
2148  * returned in *opts.
2149  * We assume secret is NULL or points to MAXWORDLEN bytes of space.
2150  * Flags are non-zero if we need two colons in the secret in order to
2151  * match.
2152  */
2153 static int
2154 scan_authfile(FILE *f, char *client, char *server,
2155               char *secret, struct wordlist **addrs,
2156               struct wordlist **opts, char *filename,
2157               int flags)
2158 {
2159     int newline, xxx;
2160     int got_flag, best_flag;
2161     FILE *sf;
2162     struct wordlist *ap, *addr_list, *alist, **app;
2163     char word[MAXWORDLEN];
2164     char atfile[MAXWORDLEN];
2165     char lsecret[MAXWORDLEN];
2166     char *cp;
2167
2168     if (addrs != NULL)
2169         *addrs = NULL;
2170     if (opts != NULL)
2171         *opts = NULL;
2172     addr_list = NULL;
2173     if (!getword(f, word, &newline, filename))
2174         return -1;              /* file is empty??? */
2175     newline = 1;
2176     best_flag = -1;
2177     for (;;) {
2178         /*
2179          * Skip until we find a word at the start of a line.
2180          */
2181         while (!newline && getword(f, word, &newline, filename))
2182             ;
2183         if (!newline)
2184             break;              /* got to end of file */
2185
2186         /*
2187          * Got a client - check if it's a match or a wildcard.
2188          */
2189         got_flag = 0;
2190         if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) {
2191             newline = 0;
2192             continue;
2193         }
2194         if (!ISWILD(word))
2195             got_flag = NONWILD_CLIENT;
2196
2197         /*
2198          * Now get a server and check if it matches.
2199          */
2200         if (!getword(f, word, &newline, filename))
2201             break;
2202         if (newline)
2203             continue;
2204         if (!ISWILD(word)) {
2205             if (server != NULL && strcmp(word, server) != 0)
2206                 continue;
2207             got_flag |= NONWILD_SERVER;
2208         }
2209
2210         /*
2211          * Got some sort of a match - see if it's better than what
2212          * we have already.
2213          */
2214         if (got_flag <= best_flag)
2215             continue;
2216
2217         /*
2218          * Get the secret.
2219          */
2220         if (!getword(f, word, &newline, filename))
2221             break;
2222         if (newline)
2223             continue;
2224
2225         /*
2226          * SRP-SHA1 authenticator should never be reading secrets from
2227          * a file.  (Authenticatee may, though.)
2228          */
2229         if (flags && ((cp = strchr(word, ':')) == NULL ||
2230             strchr(cp + 1, ':') == NULL))
2231             continue;
2232
2233         if (secret != NULL) {
2234             /*
2235              * Special syntax: @/pathname means read secret from file.
2236              */
2237             if (word[0] == '@' && word[1] == '/') {
2238                 strlcpy(atfile, word+1, sizeof(atfile));
2239                 if ((sf = fopen(atfile, "r")) == NULL) {
2240                     warn("can't open indirect secret file %s", atfile);
2241                     continue;
2242                 }
2243                 check_access(sf, atfile);
2244                 if (!getword(sf, word, &xxx, atfile)) {
2245                     warn("no secret in indirect secret file %s", atfile);
2246                     fclose(sf);
2247                     continue;
2248                 }
2249                 fclose(sf);
2250             }
2251             strlcpy(lsecret, word, sizeof(lsecret));
2252         }
2253
2254         /*
2255          * Now read address authorization info and make a wordlist.
2256          */
2257         app = &alist;
2258         for (;;) {
2259             if (!getword(f, word, &newline, filename) || newline)
2260                 break;
2261             ap = (struct wordlist *)
2262                     malloc(sizeof(struct wordlist) + strlen(word) + 1);
2263             if (ap == NULL)
2264                 novm("authorized addresses");
2265             ap->word = (char *) (ap + 1);
2266             strcpy(ap->word, word);
2267             *app = ap;
2268             app = &ap->next;
2269         }
2270         *app = NULL;
2271
2272         /*
2273          * This is the best so far; remember it.
2274          */
2275         best_flag = got_flag;
2276         if (addr_list)
2277             free_wordlist(addr_list);
2278         addr_list = alist;
2279         if (secret != NULL)
2280             strlcpy(secret, lsecret, MAXWORDLEN);
2281
2282         if (!newline)
2283             break;
2284     }
2285
2286     /* scan for a -- word indicating the start of options */
2287     for (app = &addr_list; (ap = *app) != NULL; app = &ap->next)
2288         if (strcmp(ap->word, "--") == 0)
2289             break;
2290     /* ap = start of options */
2291     if (ap != NULL) {
2292         ap = ap->next;          /* first option */
2293         free(*app);                     /* free the "--" word */
2294         *app = NULL;            /* terminate addr list */
2295     }
2296     if (opts != NULL)
2297         *opts = ap;
2298     else if (ap != NULL)
2299         free_wordlist(ap);
2300     if (addrs != NULL)
2301         *addrs = addr_list;
2302     else if (addr_list != NULL)
2303         free_wordlist(addr_list);
2304
2305     return best_flag;
2306 }
2307
2308 /*
2309  * wordlist_count - return the number of items in a wordlist
2310  */
2311 static int
2312 wordlist_count(struct wordlist *wp)
2313 {
2314     int n;
2315
2316     for (n = 0; wp != NULL; wp = wp->next)
2317         ++n;
2318     return n;
2319 }
2320
2321 /*
2322  * free_wordlist - release memory allocated for a wordlist.
2323  */
2324 static void
2325 free_wordlist(struct wordlist *wp)
2326 {
2327     struct wordlist *next;
2328
2329     while (wp != NULL) {
2330         next = wp->next;
2331         free(wp);
2332         wp = next;
2333     }
2334 }
2335
2336 /*
2337  * auth_script_done - called when the auth-up or auth-down script
2338  * has finished.
2339  */
2340 static void
2341 auth_script_done(void *arg)
2342 {
2343     auth_script_pid = 0;
2344     switch (auth_script_state) {
2345     case s_up:
2346         if (auth_state == s_down) {
2347             auth_script_state = s_down;
2348             auth_script(_PATH_AUTHDOWN);
2349         }
2350         break;
2351     case s_down:
2352         if (auth_state == s_up) {
2353             auth_script_state = s_up;
2354             auth_script(_PATH_AUTHUP);
2355         }
2356         break;
2357     }
2358 }
2359
2360 /*
2361  * auth_script - execute a script with arguments
2362  * interface-name peer-name real-user tty speed
2363  */
2364 static void
2365 auth_script(char *script)
2366 {
2367     char strspeed[32];
2368     struct passwd *pw;
2369     char struid[32];
2370     char *user_name;
2371     char *argv[8];
2372
2373     if ((pw = getpwuid(getuid())) != NULL && pw->pw_name != NULL)
2374         user_name = pw->pw_name;
2375     else {
2376         slprintf(struid, sizeof(struid), "%d", getuid());
2377         user_name = struid;
2378     }
2379     slprintf(strspeed, sizeof(strspeed), "%d", baud_rate);
2380
2381     argv[0] = script;
2382     argv[1] = ifname;
2383     argv[2] = peer_authname;
2384     argv[3] = user_name;
2385     argv[4] = devnam;
2386     argv[5] = strspeed;
2387     argv[6] = NULL;
2388
2389     auth_script_pid = run_program(script, argv, 0, auth_script_done, NULL, 0);
2390 }
2391
2392
2393 #ifdef USE_EAPTLS
2394 static int
2395 have_eaptls_secret_server(char *client, char *server,
2396                           int need_ip, int *lacks_ipp)
2397 {
2398     FILE *f;
2399     int ret;
2400     char *filename;
2401     struct wordlist *addrs;
2402     char servcertfile[MAXWORDLEN];
2403     char clicertfile[MAXWORDLEN];
2404     char cacertfile[MAXWORDLEN];
2405     char pkfile[MAXWORDLEN];
2406
2407     filename = _PATH_EAPTLSSERVFILE;
2408     f = fopen(filename, "r");
2409     if (f == NULL)
2410                 return 0;
2411
2412     if (client != NULL && client[0] == 0)
2413                 client = NULL;
2414     else if (server != NULL && server[0] == 0)
2415                 server = NULL;
2416
2417     ret =
2418         scan_authfile_eaptls(f, client, server, clicertfile, servcertfile,
2419                              cacertfile, pkfile, &addrs, NULL, filename,
2420                              0);
2421
2422     fclose(f);
2423
2424 /*
2425     if (ret >= 0 && !eaptls_init_ssl(1, cacertfile, servcertfile,
2426                                 clicertfile, pkfile))
2427                 ret = -1;
2428 */
2429
2430         if (ret >= 0 && need_ip && !some_ip_ok(addrs)) {
2431                 if (lacks_ipp != 0)
2432                         *lacks_ipp = 1;
2433                 ret = -1;
2434     }
2435     if (addrs != 0)
2436                 free_wordlist(addrs);
2437
2438     return ret >= 0;
2439 }
2440
2441
2442 static int
2443 have_eaptls_secret_client(char *client, char *server)
2444 {
2445     FILE *f;
2446     int ret;
2447     char *filename;
2448     struct wordlist *addrs = NULL;
2449     char servcertfile[MAXWORDLEN];
2450     char clicertfile[MAXWORDLEN];
2451     char cacertfile[MAXWORDLEN];
2452     char pkfile[MAXWORDLEN];
2453
2454     if (client != NULL && client[0] == 0)
2455                 client = NULL;
2456     else if (server != NULL && server[0] == 0)
2457                 server = NULL;
2458
2459         if ((cacert_file || ca_path) && cert_file && privkey_file)
2460                 return 1;
2461
2462     filename = _PATH_EAPTLSCLIFILE;
2463     f = fopen(filename, "r");
2464     if (f == NULL)
2465                 return 0;
2466
2467     ret =
2468         scan_authfile_eaptls(f, client, server, clicertfile, servcertfile,
2469                              cacertfile, pkfile, &addrs, NULL, filename,
2470                              0);
2471     fclose(f);
2472
2473 /*
2474     if (ret >= 0 && !eaptls_init_ssl(0, cacertfile, clicertfile,
2475                                 servcertfile, pkfile))
2476                 ret = -1;
2477 */
2478
2479     if (addrs != 0)
2480                 free_wordlist(addrs);
2481
2482     return ret >= 0;
2483 }
2484
2485
2486 static int
2487 scan_authfile_eaptls(FILE *f, char *client, char *server,
2488                      char *cli_cert, char *serv_cert, char *ca_cert,
2489                      char *pk, struct wordlist **addrs,
2490                      struct wordlist **opts,
2491                      char *filename, int flags)
2492 {
2493     int newline;
2494     int got_flag, best_flag;
2495     struct wordlist *ap, *addr_list, *alist, **app;
2496     char word[MAXWORDLEN];
2497
2498     if (addrs != NULL)
2499         *addrs = NULL;
2500     if (opts != NULL)
2501         *opts = NULL;
2502     addr_list = NULL;
2503     if (!getword(f, word, &newline, filename))
2504         return -1;              /* file is empty??? */
2505     newline = 1;
2506     best_flag = -1;
2507     for (;;) {
2508         /*
2509          * Skip until we find a word at the start of a line.
2510          */
2511         while (!newline && getword(f, word, &newline, filename));
2512         if (!newline)
2513             break;              /* got to end of file */
2514
2515         /*
2516          * Got a client - check if it's a match or a wildcard.
2517          */
2518         got_flag = 0;
2519         if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) {
2520             newline = 0;
2521             continue;
2522         }
2523         if (!ISWILD(word))
2524             got_flag = NONWILD_CLIENT;
2525
2526         /*
2527          * Now get a server and check if it matches.
2528          */
2529         if (!getword(f, word, &newline, filename))
2530             break;
2531         if (newline)
2532             continue;
2533         if (!ISWILD(word)) {
2534             if (server != NULL && strcmp(word, server) != 0)
2535                 continue;
2536             got_flag |= NONWILD_SERVER;
2537         }
2538
2539         /*
2540          * Got some sort of a match - see if it's better than what
2541          * we have already.
2542          */
2543         if (got_flag <= best_flag)
2544             continue;
2545
2546         /*
2547          * Get the cli_cert
2548          */
2549         if (!getword(f, word, &newline, filename))
2550             break;
2551         if (newline)
2552             continue;
2553         if (strcmp(word, "-") != 0) {
2554             strlcpy(cli_cert, word, MAXWORDLEN);
2555         } else
2556             cli_cert[0] = 0;
2557
2558         /*
2559          * Get serv_cert
2560          */
2561         if (!getword(f, word, &newline, filename))
2562             break;
2563         if (newline)
2564             continue;
2565         if (strcmp(word, "-") != 0) {
2566             strlcpy(serv_cert, word, MAXWORDLEN);
2567         } else
2568             serv_cert[0] = 0;
2569
2570         /*
2571          * Get ca_cert
2572          */
2573         if (!getword(f, word, &newline, filename))
2574             break;
2575         if (newline)
2576             continue;
2577         strlcpy(ca_cert, word, MAXWORDLEN);
2578
2579         /*
2580          * Get pk
2581          */
2582         if (!getword(f, word, &newline, filename))
2583             break;
2584         if (newline)
2585             continue;
2586         strlcpy(pk, word, MAXWORDLEN);
2587
2588
2589         /*
2590          * Now read address authorization info and make a wordlist.
2591          */
2592         app = &alist;
2593         for (;;) {
2594             if (!getword(f, word, &newline, filename) || newline)
2595                 break;
2596             ap = (struct wordlist *)
2597                 malloc(sizeof(struct wordlist) + strlen(word) + 1);
2598             if (ap == NULL)
2599                 novm("authorized addresses");
2600             ap->word = (char *) (ap + 1);
2601             strcpy(ap->word, word);
2602             *app = ap;
2603             app = &ap->next;
2604         }
2605         *app = NULL;
2606         /*
2607          * This is the best so far; remember it.
2608          */
2609         best_flag = got_flag;
2610         if (addr_list)
2611             free_wordlist(addr_list);
2612         addr_list = alist;
2613
2614         if (!newline)
2615             break;
2616     }
2617
2618     /* scan for a -- word indicating the start of options */
2619     for (app = &addr_list; (ap = *app) != NULL; app = &ap->next)
2620         if (strcmp(ap->word, "--") == 0)
2621             break;
2622     /* ap = start of options */
2623     if (ap != NULL) {
2624         ap = ap->next;          /* first option */
2625         free(*app);             /* free the "--" word */
2626         *app = NULL;            /* terminate addr list */
2627     }
2628     if (opts != NULL)
2629         *opts = ap;
2630     else if (ap != NULL)
2631         free_wordlist(ap);
2632     if (addrs != NULL)
2633         *addrs = addr_list;
2634     else if (addr_list != NULL)
2635         free_wordlist(addr_list);
2636
2637     return best_flag;
2638 }
2639
2640
2641 int
2642 get_eaptls_secret(int unit, char *client, char *server,
2643                   char *clicertfile, char *servcertfile, char *cacertfile,
2644                   char *capath, char *pkfile, int am_server)
2645 {
2646     FILE *fp;
2647     int ret;
2648     char *filename         = NULL;
2649     struct wordlist *addrs = NULL;
2650     struct wordlist *opts  = NULL;
2651
2652         /* maybe overkill, but it eases debugging */
2653         bzero(clicertfile, MAXWORDLEN);
2654         bzero(servcertfile, MAXWORDLEN);
2655         bzero(cacertfile, MAXWORDLEN);
2656         bzero(capath, MAXWORDLEN);
2657         bzero(pkfile, MAXWORDLEN);
2658
2659         /* the ca+cert+privkey can also be specified as options */
2660         if (!am_server && (cacert_file || ca_path) && cert_file && privkey_file )
2661         {
2662                 strlcpy( clicertfile, cert_file, MAXWORDLEN );
2663                 if (cacert_file)
2664                         strlcpy( cacertfile, cacert_file, MAXWORDLEN );
2665                 if (ca_path)
2666                         strlcpy( capath, ca_path, MAXWORDLEN );
2667                 strlcpy( pkfile, privkey_file, MAXWORDLEN );
2668         }
2669         else
2670         {
2671                 filename = (am_server ? _PATH_EAPTLSSERVFILE : _PATH_EAPTLSCLIFILE);
2672                 addrs = NULL;
2673
2674                 fp = fopen(filename, "r");
2675                 if (fp == NULL)
2676                 {
2677                         error("Can't open eap-tls secret file %s: %m", filename);
2678                         return 0;
2679                 }
2680
2681                 check_access(fp, filename);
2682
2683                 ret = scan_authfile_eaptls(fp, client, server, clicertfile, servcertfile,
2684                                 cacertfile, pkfile, &addrs, &opts, filename, 0);
2685
2686                 fclose(fp);
2687
2688                 if (ret < 0) return 0;
2689         }
2690
2691     if (eaptls_passwd_hook)
2692     {
2693                 dbglog( "Calling eaptls password hook" );
2694                 if ( (*eaptls_passwd_hook)(pkfile, passwd) < 0)
2695                 {
2696                          error("Unable to obtain EAP-TLS password for %s (%s) from plugin",
2697                                 client, pkfile);
2698                     return 0;
2699                 }
2700         }
2701     if (am_server)
2702                 set_allowed_addrs(unit, addrs, opts);
2703     else if (opts != NULL)
2704                 free_wordlist(opts);
2705     if (addrs != NULL)
2706                 free_wordlist(addrs);
2707
2708     return 1;
2709 }
2710 #endif