X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=pppd%2Fauth.c;h=778397d7b02df33237c7e159f68a7378ad33b9e6;hp=3b0e24341292050657c63d99d37d70aab0989c9b;hb=093489a1ce40a2075b1c5c9feb03c7ab1659d884;hpb=7a4dc0ff500aaa176a41965d8d4ad15a97a70904 diff --git a/pppd/auth.c b/pppd/auth.c index 3b0e243..778397d 100644 --- a/pppd/auth.c +++ b/pppd/auth.c @@ -33,7 +33,7 @@ */ #ifndef lint -static char rcsid[] = "$Id: auth.c,v 1.46 1999/03/16 03:15:12 paulus Exp $"; +static char rcsid[] = "$Id: auth.c,v 1.50 1999/04/01 07:08:47 paulus Exp $"; #endif #include @@ -90,9 +90,6 @@ struct wordlist { #define ISWILD(word) (word[0] == '*' && word[1] == 0) -#define FALSE 0 -#define TRUE 1 - /* The name by which the peer authenticated itself to us. */ char peer_authname[MAXNAMELEN]; @@ -102,12 +99,8 @@ static int auth_pending[NUM_PPP]; /* Set if we have successfully called plogin() */ static int logged_in; -/* Set if we have run the /etc/ppp/auth-up script. */ -static int did_authup; -static pid_t authup_pid; /* process ID of auth-up/down script */ - /* List of addresses which the peer may use. */ -static struct wordlist *addresses[NUM_PPP]; +static struct permitted_ip *addresses[NUM_PPP]; /* Number of network protocols which we have opened. */ static int num_np_open; @@ -118,6 +111,19 @@ static int num_np_up; /* Set if we got the contents of passwd[] from the pap-secrets file. */ static int passwd_from_file; +/* + * This is used to ensure that we don't start an auth-up/down + * script while one is already running. + */ +enum script_state { + s_down, + s_up +}; + +static enum script_state auth_state = s_down; +static enum script_state auth_script_state = s_down; +static pid_t auth_script_pid = 0; + /* * Option variables. */ @@ -128,6 +134,8 @@ bool refuse_chap = 0; /* Don't wanna auth. ourselves with CHAP */ bool usehostname = 0; /* Use hostname for our_name */ bool auth_required = 0; /* Always require authentication from peer */ bool allow_any_ip = 0; /* Allow peer to use any IP address */ +bool explicit_remote = 0; /* User specified explicit remote name */ +char remote_name[MAXNAMELEN]; /* Peer's name for authentication */ /* Bits in auth_pending[] */ #define PAP_WITHPEER 1 @@ -146,16 +154,19 @@ static int plogin __P((char *, char *, char **, int *)); static void plogout __P((void)); static int null_login __P((int)); static int get_pap_passwd __P((char *)); -static int have_pap_secret __P((void)); -static int have_chap_secret __P((char *, char *, u_int32_t)); -static int ip_addr_check __P((u_int32_t, struct wordlist *)); -static int scan_authfile __P((FILE *, char *, char *, u_int32_t, char *, +static int have_pap_secret __P((int *)); +static int have_chap_secret __P((char *, char *, int, int *)); +static int ip_addr_check __P((u_int32_t, struct permitted_ip *)); +static int scan_authfile __P((FILE *, char *, char *, char *, struct wordlist **, char *)); static void free_wordlist __P((struct wordlist *)); static void auth_script __P((char *)); +static void auth_script_done __P((void *)); static void set_allowed_addrs __P((int, struct wordlist *)); +static int some_ip_ok __P((struct wordlist *)); static int setupapfile __P((char **)); static int privgroup __P((char **)); +static void check_access __P((FILE *, char *)); /* * Authentication-related options. @@ -185,7 +196,8 @@ option_t auth_options[] = { { "usehostname", o_bool, &usehostname, "Must use hostname for authentication", 1 }, { "remotename", o_string, remote_name, - "Set remote name for authentication", OPT_STATIC, NULL, MAXNAMELEN }, + "Set remote name for authentication", OPT_STATIC, + &explicit_remote, MAXNAMELEN }, { "auth", o_bool, &auth_required, "Require authentication from peer", 1 }, { "noauth", o_bool, &auth_required, @@ -221,12 +233,6 @@ setupapfile(argv) option_error("unable to open user login data file %s", *argv); return 0; } -#if 0 /* check done by setting effective UID above */ - if (!readable(fileno(ufile))) { - option_error("%s: access denied", *argv); - return 0; - } -#endif check_access(ufile, *argv); /* get username */ @@ -310,9 +316,10 @@ link_down(unit) int i; struct protent *protp; - if (did_authup) { + auth_state = s_down; + if (auth_script_state == s_up && auth_script_pid == 0) { + auth_script_state = s_down; auth_script(_PATH_AUTHDOWN); - did_authup = 0; } for (i = 0; (protp = protocols[i]) != NULL; ++i) { if (!protp->enabled_flag) @@ -405,9 +412,12 @@ network_phase(unit) /* * If the peer had to authenticate, run the auth-up script now. */ - if ((go->neg_chap || go->neg_upap) && !did_authup) { - auth_script(_PATH_AUTHUP); - did_authup = 1; + if (go->neg_chap || go->neg_upap) { + auth_state = s_up; + if (auth_script_state == s_down && auth_script_pid == 0) { + auth_script_state = s_up; + auth_script(_PATH_AUTHUP); + } } #ifdef CBCP_SUPPORT @@ -613,7 +623,7 @@ check_idle(arg) itime = MIN(idle.xmit_idle, idle.recv_idle); if (itime >= idle_time_limit) { /* link is idle: shut it down. */ - info("Terminating connection due to lack of activity."); + notice("Terminating connection due to lack of activity."); lcp_close(0, "Link inactive"); } else { TIMEOUT(check_idle, NULL, idle_time_limit - itime); @@ -639,14 +649,20 @@ auth_check_options() { lcp_options *wo = &lcp_wantoptions[0]; int can_auth; - ipcp_options *ipwo = &ipcp_wantoptions[0]; - u_int32_t remote; + int lacks_ip; /* Default our_name to hostname, and user to our_name */ if (our_name[0] == 0 || usehostname) - strlcpy(our_name, sizeof(our_name), hostname); + strlcpy(our_name, hostname, sizeof(our_name)); if (user[0] == 0) - strlcpy(user, sizeof(user), our_name); + strlcpy(user, our_name, sizeof(user)); + + /* + * If we have a default route, require the peer to authenticate + * unless the noauth option was given. + */ + if (!auth_required && !allow_any_ip && have_route_to(0)) + auth_required = 1; /* If authentication is required, ask peer for CHAP or PAP. */ if (auth_required) { @@ -659,30 +675,33 @@ auth_check_options() wo->neg_upap = 0; } - /* - * If we have a default route, require the peer to authenticate - * unless the noauth option was given. - */ - if (!auth_required && !allow_any_ip && have_route_to(0)) - auth_required = 1; - /* * Check whether we have appropriate secrets to use * to authenticate the peer. */ - can_auth = wo->neg_upap && (uselogin || have_pap_secret()); + lacks_ip = 0; + can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip)); if (!can_auth && wo->neg_chap) { - remote = ipwo->accept_remote? 0: ipwo->hisaddr; - can_auth = have_chap_secret(remote_name, our_name, remote); + can_auth = have_chap_secret((explicit_remote? remote_name: NULL), + our_name, 1, &lacks_ip); } if (auth_required && !can_auth) { - option_error("peer authentication required but no suitable secret(s) found\n"); - if (remote_name[0] == 0) - option_error("for authenticating any peer to us (%s)\n", our_name); + if (explicit_remote) + option_error( +"The remote system (%s) is required to authenticate itself but I", + remote_name); else - option_error("for authenticating peer %s to us (%s)\n", - remote_name, our_name); + option_error( +"The remote system is required to authenticate itself but I"); + + if (!lacks_ip) + option_error( +"couldn't find any suitable secret (password) for it to use to do so."); + else + option_error( +"couldn't find any secret (password) which would let it use an IP address."); + exit(1); } } @@ -698,18 +717,17 @@ auth_reset(unit) { lcp_options *go = &lcp_gotoptions[unit]; lcp_options *ao = &lcp_allowoptions[0]; - ipcp_options *ipwo = &ipcp_wantoptions[0]; - u_int32_t remote; ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL)); ao->neg_chap = !refuse_chap - && have_chap_secret(user, remote_name, (u_int32_t)0); + && have_chap_secret(user, (explicit_remote? remote_name: NULL), + 0, NULL); - if (go->neg_upap && !uselogin && !have_pap_secret()) + if (go->neg_upap && !uselogin && !have_pap_secret(NULL)) go->neg_upap = 0; if (go->neg_chap) { - remote = ipwo->accept_remote? 0: ipwo->hisaddr; - if (!have_chap_secret(remote_name, our_name, remote)) + if (!have_chap_secret((explicit_remote? remote_name: NULL), + our_name, 1, NULL)) go->neg_chap = 0; } } @@ -739,8 +757,6 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) char *filename; FILE *f; struct wordlist *addrs; - u_int32_t remote; - ipcp_options *ipwo = &ipcp_wantoptions[unit]; char passwd[256], user[256]; char secret[MAXWORDLEN]; static int attempts = 0; @@ -768,9 +784,7 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) } else { check_access(f, filename); - remote = ipwo->accept_remote? 0: ipwo->hisaddr; - if (scan_authfile(f, user, our_name, remote, - secret, &addrs, filename) < 0 + if (scan_authfile(f, user, our_name, secret, &addrs, filename) < 0 || (secret[0] != 0 && (cryptpap || strcmp(passwd, secret) != 0) && strcmp(crypt(passwd, secret), secret) != 0)) { warn("PAP authentication failure for %s", user); @@ -791,13 +805,14 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) *msg = "Login incorrect"; *msglen = strlen(*msg); /* + * XXX can we ever get here more than once?? * Frustrate passwd stealer programs. * Allow 10 tries, but start backing off after 3 (stolen from login). * On 10'th, drop the connection. */ if (attempts++ >= 10) { warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user); - quit(); + lcp_close(unit, "login failed"); } if (attempts > 3) sleep((u_int) (attempts - 3) * 5); @@ -823,63 +838,65 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) */ #ifdef USE_PAM -static char *PAM_username = ""; -static char *PAM_password = ""; - -#ifdef PAM_ESTABLISH_CRED /* new PAM defines :(^ */ -#define MY_PAM_STRERROR(err_code) (char *) pam_strerror(pamh,err_code) -#else -#define MY_PAM_STRERROR(err_code) (char *) pam_strerror(err_code) -#endif +/* Static variables used to communicate between the conversation function + * and the server_login function + */ +static char *PAM_username; +static char *PAM_password; +static int PAM_error = 0; +static pam_handle_t *pamh = NULL; + +/* PAM conversation function + * Here we assume (for now, at least) that echo on means login name, and + * echo off means password. + */ -static int pam_conv (int num_msg, - const struct pam_message **msg, - struct pam_response **resp, - void *appdata_ptr) +static int PAM_conv (int num_msg, const struct pam_message **msg, + struct pam_response **resp, void *appdata_ptr) { - int count = 0, replies = 0; + int replies = 0; struct pam_response *reply = NULL; - int size = 0; - - for (count = 0; count < num_msg; count++) - { - size += sizeof (struct pam_response); - reply = realloc (reply, size); /* ANSI: is malloc() if reply==NULL */ - if (!reply) - return PAM_CONV_ERR; - - switch (msg[count]->msg_style) - { - case PAM_PROMPT_ECHO_ON: - reply[replies].resp_retcode = PAM_SUCCESS; - reply[replies++].resp = strdup(PAM_username); /* never NULL */ - break; - - case PAM_PROMPT_ECHO_OFF: - reply[replies].resp_retcode = PAM_SUCCESS; - reply[replies++].resp = strdup(PAM_password); /* never NULL */ - break; - - case PAM_TEXT_INFO: - reply[replies].resp_retcode = PAM_SUCCESS; - reply[replies++].resp = NULL; - break; - - case PAM_ERROR_MSG: - default: - free (reply); - return PAM_CONV_ERR; - } - } - - if (resp) - *resp = reply; - else - free (reply); +#define COPY_STRING(s) (s) ? strdup(s) : NULL + + reply = malloc(sizeof(struct pam_response) * num_msg); + if (!reply) return PAM_CONV_ERR; + + for (replies = 0; replies < num_msg; replies++) { + switch (msg[replies]->msg_style) { + case PAM_PROMPT_ECHO_ON: + reply[replies].resp_retcode = PAM_SUCCESS; + reply[replies].resp = COPY_STRING(PAM_username); + /* PAM frees resp */ + break; + case PAM_PROMPT_ECHO_OFF: + reply[replies].resp_retcode = PAM_SUCCESS; + reply[replies].resp = COPY_STRING(PAM_password); + /* PAM frees resp */ + break; + case PAM_TEXT_INFO: + /* fall through */ + case PAM_ERROR_MSG: + /* ignore it, but pam still wants a NULL response... */ + reply[replies].resp_retcode = PAM_SUCCESS; + reply[replies].resp = NULL; + break; + default: + /* Must be an error of some sort... */ + free (reply); + PAM_error = 1; + return PAM_CONV_ERR; + } + } + *resp = reply; return PAM_SUCCESS; } -#endif + +static struct pam_conv PAM_conversation = { + &PAM_conv, + NULL +}; +#endif /* USE_PAM */ /* * plogin - Check the user name and password against the system @@ -898,71 +915,61 @@ plogin(user, passwd, msg, msglen) char **msg; int *msglen; { + char *tty; #ifdef USE_PAM - - struct pam_conv pam_conversation; - pam_handle_t *pamh; int pam_error; -/* - * Fill the pam_conversion structure - */ - memset (&pam_conversation, '\0', sizeof (struct pam_conv)); - pam_conversation.conv = &pam_conv; - - pam_error = pam_start ("ppp", user, &pam_conversation, &pamh); + pam_error = pam_start ("ppp", user, &PAM_conversation, &pamh); if (pam_error != PAM_SUCCESS) { - *msg = MY_PAM_STRERROR (pam_error); + *msg = (char *) pam_strerror (pamh, pam_error); + reopen_log(); return UPAP_AUTHNAK; } -/* - * Define the fields for the credintial validation - */ - (void) pam_set_item (pamh, PAM_TTY, devnam); + /* + * Define the fields for the credential validation + */ + PAM_username = user; PAM_password = passwd; -/* - * Validate the user - */ + PAM_error = 0; + pam_set_item (pamh, PAM_TTY, devnam); /* this might be useful to some modules */ + + /* + * Validate the user + */ pam_error = pam_authenticate (pamh, PAM_SILENT); - if (pam_error == PAM_SUCCESS) { + if (pam_error == PAM_SUCCESS && !PAM_error) { pam_error = pam_acct_mgmt (pamh, PAM_SILENT); - - /* start a session for this user. Session closed when link ends. */ - if (pam_error == PAM_SUCCESS) - (void) pam_open_session (pamh, PAM_SILENT); + if (pam_error == PAM_SUCCESS) + pam_open_session (pamh, PAM_SILENT); } - *msg = MY_PAM_STRERROR (pam_error); - - PAM_username = - PAM_password = ""; -/* - * Clean up the mess - */ - (void) pam_end (pamh, pam_error); + *msg = (char *) pam_strerror (pamh, pam_error); + /* + * Clean up the mess + */ + reopen_log(); /* apparently the PAM stuff does closelog() */ + PAM_username = NULL; + PAM_password = NULL; if (pam_error != PAM_SUCCESS) return UPAP_AUTHNAK; +#else /* #ifdef USE_PAM */ + /* * Use the non-PAM methods directly */ -#else /* #ifdef USE_PAM */ - - struct passwd *pw; - char *tty; #ifdef HAS_SHADOW struct spwd *spwd; struct spwd *getspnam(); #endif + struct passwd *pw = getpwnam(user); - pw = getpwnam(user); endpwent(); - if (pw == NULL) { + if (pw == NULL) return (UPAP_AUTHNAK); - } #ifdef HAS_SHADOW spwd = getspnam(user); @@ -985,15 +992,11 @@ plogin(user, passwd, msg, msglen) /* * If no passwd, don't let them login. */ - if (pw->pw_passwd == NULL || *pw->pw_passwd == '\0' + if (pw->pw_passwd == NULL || strlen(pw->pw_passwd) < 2 || strcmp(crypt(passwd, pw->pw_passwd), pw->pw_passwd) != 0) return (UPAP_AUTHNAK); - /* These functions are not enabled for PAM. The reason for this is that */ - /* there is not necessarily a "passwd" entry for this user. That is */ - /* real purpose of 'PAM' -- to virtualize the account data from the */ - /* application. If you want to do the same thing, write the entry in */ - /* the 'session' hook. */ +#endif /* #ifdef USE_PAM */ /* * Write a wtmp entry for this user. @@ -1004,8 +1007,8 @@ plogin(user, passwd, msg, msglen) tty += 5; logwtmp(tty, user, remote_name); /* Add wtmp login entry */ -#if defined(_PATH_LASTLOG) - { +#if defined(_PATH_LASTLOG) && !defined(USE_PAM) + if (pw != (struct passwd *)NULL) { struct lastlog ll; int fd; @@ -1013,17 +1016,15 @@ plogin(user, passwd, msg, msglen) (void)lseek(fd, (off_t)(pw->pw_uid * sizeof(ll)), SEEK_SET); memset((void *)&ll, 0, sizeof(ll)); (void)time(&ll.ll_time); - (void)strlcpy(ll.ll_line, sizeof(ll.ll_line), tty); + (void)strlcpy(ll.ll_line, tty, sizeof(ll.ll_line)); (void)write(fd, (char *)&ll, sizeof(ll)); (void)close(fd); } } -#endif - -#endif /* #ifdef USE_PAM */ +#endif /* _PATH_LASTLOG and not USE_PAM */ info("user %s logged in", user); - logged_in = TRUE; + logged_in = 1; return (UPAP_AUTHACK); } @@ -1035,34 +1036,24 @@ static void plogout() { #ifdef USE_PAM - struct pam_conv pam_conversation; - pam_handle_t *pamh; int pam_error; -/* - * Fill the pam_conversion structure. The PAM specification states that the - * session must be able to be closed by a totally different handle from which - * it was created. Hold the PAM group to their own specification! - */ - memset (&pam_conversation, '\0', sizeof (struct pam_conv)); - pam_conversation.conv = &pam_conv; - - pam_error = pam_start ("ppp", user, &pam_conversation, &pamh); - if (pam_error == PAM_SUCCESS) { - (void) pam_set_item (pamh, PAM_TTY, devnam); - (void) pam_close_session (pamh, PAM_SILENT); - (void) pam_end (pamh, PAM_SUCCESS); - } -#else + if (pamh != NULL) { + pam_error = pam_close_session (pamh, PAM_SILENT); + pam_end (pamh, pam_error); + pamh = NULL; + } + /* Apparently the pam stuff does closelog(). */ + reopen_log(); +#else /* ! USE_PAM */ char *tty; tty = devnam; if (strncmp(tty, "/dev/", 5) == 0) tty += 5; logwtmp(tty, "", ""); /* Wipe out utmp logout entry */ -#endif - - logged_in = FALSE; +#endif /* ! USE_PAM */ + logged_in = 0; } @@ -1092,7 +1083,7 @@ null_login(unit) return 0; check_access(f, filename); - i = scan_authfile(f, "", our_name, (u_int32_t)0, secret, &addrs, filename); + i = scan_authfile(f, "", our_name, secret, &addrs, filename); ret = i >= 0 && (i & NONWILD_CLIENT) != 0 && secret[0] == 0; BZERO(secret, sizeof(secret)); @@ -1129,13 +1120,13 @@ get_pap_passwd(passwd) return 0; check_access(f, filename); ret = scan_authfile(f, user, - remote_name[0]? remote_name: NULL, - (u_int32_t)0, secret, NULL, filename); + (remote_name[0]? remote_name: NULL), + secret, NULL, filename); fclose(f); if (ret < 0) return 0; if (passwd != NULL) - strlcpy(passwd, MAXSECRETLEN, secret); + strlcpy(passwd, secret, MAXSECRETLEN); BZERO(secret, sizeof(secret)); return 1; } @@ -1146,26 +1137,31 @@ get_pap_passwd(passwd) * secrets that we could possibly use for authenticating the peer. */ static int -have_pap_secret() +have_pap_secret(lacks_ipp) + int *lacks_ipp; { FILE *f; int ret; char *filename; - ipcp_options *ipwo = &ipcp_wantoptions[0]; - u_int32_t remote; + struct wordlist *addrs; filename = _PATH_UPAPFILE; f = fopen(filename, "r"); if (f == NULL) return 0; - remote = ipwo->accept_remote? 0: ipwo->hisaddr; - ret = scan_authfile(f, NULL, our_name, remote, NULL, NULL, filename); + ret = scan_authfile(f, (explicit_remote? remote_name: NULL), our_name, + NULL, &addrs, filename); fclose(f); - if (ret < 0) - return 0; + if (ret >= 0 && !some_ip_ok(addrs)) { + if (lacks_ipp != 0) + *lacks_ipp = 1; + ret = -1; + } + if (addrs != 0) + free_wordlist(addrs); - return 1; + return ret >= 0; } @@ -1176,31 +1172,38 @@ have_pap_secret() * know the identity yet. */ static int -have_chap_secret(client, server, remote) +have_chap_secret(client, server, need_ip, lacks_ipp) char *client; char *server; - u_int32_t remote; + int need_ip; + int *lacks_ipp; { FILE *f; int ret; char *filename; + struct wordlist *addrs; filename = _PATH_CHAPFILE; f = fopen(filename, "r"); if (f == NULL) return 0; - if (client[0] == 0) + if (client != NULL && client[0] == 0) client = NULL; - else if (server[0] == 0) + else if (server != NULL && server[0] == 0) server = NULL; - ret = scan_authfile(f, client, server, remote, NULL, NULL, filename); + ret = scan_authfile(f, client, server, NULL, &addrs, filename); fclose(f); - if (ret < 0) - return 0; + if (ret >= 0 && need_ip && !some_ip_ok(addrs)) { + if (lacks_ipp != 0) + *lacks_ipp = 1; + ret = -1; + } + if (addrs != 0) + free_wordlist(addrs); - return 1; + return ret >= 0; } @@ -1235,8 +1238,7 @@ get_secret(unit, client, server, secret, secret_len, save_addrs) } check_access(f, filename); - ret = scan_authfile(f, client, server, (u_int32_t)0, - secbuf, &addrs, filename); + ret = scan_authfile(f, client, server, secbuf, &addrs, filename); fclose(f); if (ret < 0) return 0; @@ -1264,79 +1266,44 @@ set_allowed_addrs(unit, addrs) int unit; struct wordlist *addrs; { - if (addresses[unit] != NULL) - free_wordlist(addresses[unit]); - addresses[unit] = addrs; - - /* - * If there's only one authorized address we might as well - * ask our peer for that one right away - */ - if (addrs != NULL && addrs->next == NULL) { - char *p = addrs->word; - struct ipcp_options *wo = &ipcp_wantoptions[unit]; - u_int32_t a; - struct hostent *hp; - - if (*p != '!' && *p != '-' && *p != '*' && strchr(p, '/') == NULL) { - hp = gethostbyname(p); - if (hp != NULL && hp->h_addrtype == AF_INET) - a = *(u_int32_t *)hp->h_addr; - else - a = inet_addr(p); - if (a != (u_int32_t) -1) - wo->hisaddr = a; - } - } -} - -/* - * auth_ip_addr - check whether the peer is authorized to use - * a given IP address. Returns 1 if authorized, 0 otherwise. - */ -int -auth_ip_addr(unit, addr) - int unit; - u_int32_t addr; -{ - - if (addresses[unit] == NULL) { - if (auth_required) - return 0; /* no addresses authorized */ - return allow_any_ip || !have_route_to(addr); - } - return ip_addr_check(addr, addresses[unit]); -} - -static int -ip_addr_check(addr, addrs) - u_int32_t addr; - struct wordlist *addrs; -{ - u_int32_t a, mask, ah; - int accept; + int n = 0; + struct wordlist *ap; + struct permitted_ip *ip; char *ptr_word, *ptr_mask; struct hostent *hp; struct netent *np; + u_int32_t a, mask, ah; + struct ipcp_options *wo = &ipcp_wantoptions[unit]; + u_int32_t suggested_ip = 0; - /* don't allow loopback or multicast address */ - if (bad_ip_adrs(addr)) - return 0; + if (addresses[unit] != NULL) + free(addresses[unit]); + addresses[unit] = NULL; - if (addrs == NULL) - return 0; /* no addresses authorized */ + for (ap = addrs; ap != NULL; ap = ap->next) + ++n; + if (n == 0) + return; + ip = (struct permitted_ip *) malloc((n + 1) * sizeof(struct permitted_ip)); + if (ip == 0) + return; - for (; addrs != NULL; addrs = addrs->next) { + n = 0; + for (ap = addrs; ap != NULL; ap = ap->next) { /* "-" means no addresses authorized, "*" means any address allowed */ - ptr_word = addrs->word; + ptr_word = ap->word; if (strcmp(ptr_word, "-") == 0) break; - if (strcmp(ptr_word, "*") == 0) - return 1; + if (strcmp(ptr_word, "*") == 0) { + ip[n].permit = 1; + ip[n].base = ip[n].mask = 0; + ++n; + break; + } - accept = 1; + ip[n].permit = 1; if (*ptr_word == '!') { - accept = 0; + ip[n].permit = 0; ++ptr_word; } @@ -1381,14 +1348,61 @@ ip_addr_check(addr, addrs) *ptr_mask = '/'; if (a == (u_int32_t)-1L) - warn("unknown host %s in auth. address list", addrs->word); - else - /* Here a and addr are in network byte order, - and mask is in host order. */ - if (((addr ^ a) & htonl(mask)) == 0) - return accept; + warn("unknown host %s in auth. address list", ap->word); + else { + ip[n].mask = htonl(mask); + ip[n].base = a & ip[n].mask; + ++n; + if (~mask == 0 && suggested_ip == 0) + suggested_ip = a; + } + } + + ip[n].permit = 0; /* make the last entry forbid all addresses */ + ip[n].base = 0; /* to terminate the list */ + ip[n].mask = 0; + + addresses[unit] = ip; + + /* + * If the address given for the peer isn't authorized, or if + * the user hasn't given one, AND there is an authorized address + * which is a single host, then use that if we find one. + */ + if (suggested_ip != 0 + && (wo->hisaddr == 0 || !auth_ip_addr(unit, wo->hisaddr))) + wo->hisaddr = suggested_ip; +} + +/* + * auth_ip_addr - check whether the peer is authorized to use + * a given IP address. Returns 1 if authorized, 0 otherwise. + */ +int +auth_ip_addr(unit, addr) + int unit; + u_int32_t addr; +{ + if (addresses[unit] == NULL) { + if (auth_required) + return 0; /* no addresses authorized */ + return allow_any_ip || !have_route_to(addr); } - return 0; /* not in list => can't have it */ + return ip_addr_check(addr, addresses[unit]); +} + +static int +ip_addr_check(addr, addrs) + u_int32_t addr; + struct permitted_ip *addrs; +{ + /* don't allow loopback or multicast address */ + if (bad_ip_adrs(addr)) + return 0; + + for (; ; ++addrs) + if ((addr & addrs->mask) == addrs->base) + return addrs->permit; } /* @@ -1405,10 +1419,27 @@ bad_ip_adrs(addr) || IN_MULTICAST(addr) || IN_BADCLASS(addr); } +/* + * some_ip_ok - check a wordlist to see if it authorizes any + * IP address(es). + */ +static int +some_ip_ok(addrs) + struct wordlist *addrs; +{ + for (; addrs != 0; addrs = addrs->next) { + if (strcmp(addrs->word, "-") == 0) + break; + if (addrs->word[0] != '!') + return 1; /* some IP address is allowed */ + } + return 0; +} + /* * check_access - complain if a secret file has too-liberal permissions. */ -void +static void check_access(f, filename) FILE *f; char *filename; @@ -1435,11 +1466,10 @@ check_access(f, filename) * We assume secret is NULL or points to MAXWORDLEN bytes of space. */ static int -scan_authfile(f, client, server, ipaddr, secret, addrs, filename) +scan_authfile(f, client, server, secret, addrs, filename) FILE *f; char *client; char *server; - u_int32_t ipaddr; char *secret; struct wordlist **addrs; char *filename; @@ -1486,10 +1516,11 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) break; if (newline) continue; - if (server != NULL && strcmp(word, server) != 0 && !ISWILD(word)) - continue; - if (!ISWILD(word)) + if (!ISWILD(word)) { + if (server != NULL && strcmp(word, server) != 0) + continue; got_flag |= NONWILD_SERVER; + } /* * Got some sort of a match - see if it's better than what @@ -1510,7 +1541,7 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) * Special syntax: @filename means read secret from file. */ if (word[0] == '@') { - strlcpy(atfile, sizeof(atfile), word+1); + strlcpy(atfile, word+1, sizeof(atfile)); if ((sf = fopen(atfile, "r")) == NULL) { warn("can't open indirect secret file %s", atfile); continue; @@ -1524,7 +1555,7 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) fclose(sf); } if (secret != NULL) - strlcpy(lsecret, sizeof(lsecret), word); + strlcpy(lsecret, word, sizeof(lsecret)); /* * Now read address authorization info and make a wordlist. @@ -1547,16 +1578,6 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) alast = ap; } - /* - * Check if the given IP address is allowed by the wordlist. - * XXX accepts this entry even if it has no allowed IP addresses - * if they didn't specify a remote IP address. XXX - */ - if (ipaddr != 0 && !ip_addr_check(ipaddr, alist)) { - free_wordlist(alist); - continue; - } - /* * This is the best so far; remember it. */ @@ -1565,7 +1586,7 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) free_wordlist(addr_list); addr_list = alist; if (secret != NULL) - strlcpy(secret, MAXWORDLEN, lsecret); + strlcpy(secret, lsecret, MAXWORDLEN); if (!newline) break; @@ -1595,6 +1616,31 @@ free_wordlist(wp) } } +/* + * auth_script_done - called when the auth-up or auth-down script + * has finished. + */ +static void +auth_script_done(arg) + void *arg; +{ + auth_script_pid = 0; + switch (auth_script_state) { + case s_up: + if (auth_state == s_down) { + auth_script_state = s_down; + auth_script(_PATH_AUTHDOWN); + } + break; + case s_down: + if (auth_state == s_up) { + auth_script_state = s_up; + auth_script(_PATH_AUTHUP); + } + break; + } +} + /* * auth_script - execute a script with arguments * interface-name peer-name real-user tty speed @@ -1625,5 +1671,5 @@ auth_script(script) argv[5] = strspeed; argv[6] = NULL; - authup_pid = run_program(script, argv, 0, NULL, NULL); + auth_script_pid = run_program(script, argv, 0, auth_script_done, NULL); }