X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=pppd%2Fauth.c;h=778397d7b02df33237c7e159f68a7378ad33b9e6;hp=0f07195047d83afadcd8088d043a2bdfb493ce23;hb=1f32921b4018b34f7b05b2302f5946f58f48df61;hpb=9caa78784f2aa4cb5356adac623e0949b6a5c465 diff --git a/pppd/auth.c b/pppd/auth.c index 0f07195..778397d 100644 --- a/pppd/auth.c +++ b/pppd/auth.c @@ -33,40 +33,35 @@ */ #ifndef lint -static char rcsid[] = "$Id: auth.c,v 1.24 1996/06/26 00:56:11 paulus Exp $"; +static char rcsid[] = "$Id: auth.c,v 1.50 1999/04/01 07:08:47 paulus Exp $"; #endif #include #include #include #include -#include #include +#include #include #include #include #include +#include +#include +#if defined(_PATH_LASTLOG) && defined(_linux_) +#include +#endif #include #include #include -#ifdef SVR4 -#include -#else -#ifdef SUNOS4 -extern char *crypt(); -#endif -#endif - #ifdef USE_PAM #include -#include #endif #ifdef HAS_SHADOW #include -#include #ifndef PW_PPP #define PW_PPP PW_LOGIN #endif @@ -78,16 +73,15 @@ extern char *crypt(); #include "ipcp.h" #include "upap.h" #include "chap.h" +#ifdef CBCP_SUPPORT +#include "cbcp.h" +#endif #include "pathnames.h" -#if defined(sun) && defined(sparc) -#include -#endif /*sparc*/ - /* Used for storing a sequence of words. Usually malloced. */ struct wordlist { struct wordlist *next; - char word[1]; + char *word; }; /* Bits in scan_authfile return value */ @@ -96,23 +90,17 @@ 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]; /* Records which authentication operations haven't completed yet. */ static int auth_pending[NUM_PPP]; -/* Set if we have successfully called login() */ +/* 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; - /* 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; @@ -120,27 +108,177 @@ static int num_np_open; /* Number of network protocols which have come up. */ 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. + */ +bool uselogin = 0; /* Use /etc/passwd for checking PAP */ +bool cryptpap = 0; /* Passwords in pap-secrets are encrypted */ +bool refuse_pap = 0; /* Don't wanna auth. ourselves with PAP */ +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 UPAP_WITHPEER 1 -#define UPAP_PEER 2 +#define PAP_WITHPEER 1 +#define PAP_PEER 2 #define CHAP_WITHPEER 4 #define CHAP_PEER 8 +extern char *crypt __P((const char *, const char *)); + /* Prototypes for procedures local to this file. */ static void network_phase __P((int)); -static void check_idle __P((caddr_t)); -static int login __P((char *, char *, char **, int *)); -static void logout __P((void)); +static void check_idle __P((void *)); +static void connect_time_expired __P((void *)); +static int plogin __P((char *, char *, char **, int *)); +static void plogout __P((void)); static int null_login __P((int)); -static int get_upap_passwd __P((void)); -static int have_upap_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 get_pap_passwd __P((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. + */ +option_t auth_options[] = { + { "require-pap", o_bool, &lcp_wantoptions[0].neg_upap, + "Require PAP authentication from peer", 1, &auth_required }, + { "+pap", o_bool, &lcp_wantoptions[0].neg_upap, + "Require PAP authentication from peer", 1, &auth_required }, + { "refuse-pap", o_bool, &refuse_pap, + "Don't agree to auth to peer with PAP", 1 }, + { "-pap", o_bool, &refuse_pap, + "Don't allow PAP authentication with peer", 1 }, + { "require-chap", o_bool, &lcp_wantoptions[0].neg_chap, + "Require CHAP authentication from peer", 1, &auth_required }, + { "+chap", o_bool, &lcp_wantoptions[0].neg_chap, + "Require CHAP authentication from peer", 1, &auth_required }, + { "refuse-chap", o_bool, &refuse_chap, + "Don't agree to auth to peer with CHAP", 1 }, + { "-chap", o_bool, &refuse_chap, + "Don't allow CHAP authentication with peer", 1 }, + { "name", o_string, our_name, + "Set local name for authentication", + OPT_PRIV|OPT_STATIC, NULL, MAXNAMELEN }, + { "user", o_string, user, + "Set name for auth with peer", OPT_STATIC, NULL, MAXNAMELEN }, + { "usehostname", o_bool, &usehostname, + "Must use hostname for authentication", 1 }, + { "remotename", o_string, remote_name, + "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, + "Don't require peer to authenticate", OPT_PRIV, &allow_any_ip }, + { "login", o_bool, &uselogin, + "Use system password database for PAP", 1 }, + { "papcrypt", o_bool, &cryptpap, + "PAP passwords are encrypted", 1 }, + { "+ua", o_special, setupapfile, + "Get PAP user and password from file" }, + { "privgroup", o_special, privgroup, + "Allow group members to use privileged options", OPT_PRIV }, + { NULL } +}; + +/* + * setupapfile - specifies UPAP info for authenticating with peer. + */ +static int +setupapfile(argv) + char **argv; +{ + FILE * ufile; + int l; + + lcp_allowoptions[0].neg_upap = 1; + + /* open user info file */ + seteuid(getuid()); + ufile = fopen(*argv, "r"); + seteuid(0); + if (ufile == NULL) { + option_error("unable to open user login data file %s", *argv); + return 0; + } + check_access(ufile, *argv); + + /* get username */ + if (fgets(user, MAXNAMELEN - 1, ufile) == NULL + || fgets(passwd, MAXSECRETLEN - 1, ufile) == NULL){ + option_error("unable to read user login data file %s", *argv); + return 0; + } + fclose(ufile); + + /* get rid of newlines */ + l = strlen(user); + if (l > 0 && user[l-1] == '\n') + user[l-1] = 0; + l = strlen(passwd); + if (l > 0 && passwd[l-1] == '\n') + passwd[l-1] = 0; + + return (1); +} + + +/* + * privgroup - allow members of the group to have privileged access. + */ +static int +privgroup(argv) + char **argv; +{ + struct group *g; + int i; + + g = getgrnam(*argv); + if (g == 0) { + option_error("group %s is unknown", *argv); + return 0; + } + for (i = 0; i < ngroups; ++i) { + if (groups[i] == g->gr_gid) { + privileged = 1; + break; + } + } + return 1; +} + /* * An Open on LCP has requested a change from Dead to Establish phase. @@ -163,9 +301,9 @@ link_terminated(unit) if (phase == PHASE_DEAD) return; if (logged_in) - logout(); + plogout(); phase = PHASE_DEAD; - syslog(LOG_NOTICE, "Connection terminated."); + notice("Connection terminated."); } /* @@ -178,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) @@ -192,7 +331,8 @@ link_down(unit) } num_np_open = 0; num_np_up = 0; - phase = PHASE_TERMINATE; + if (phase != PHASE_DEAD) + phase = PHASE_TERMINATE; } /* @@ -225,9 +365,8 @@ link_established(unit) * of "" and a password of "". If that's not OK, boot it out. */ if (!wo->neg_upap || !null_login(unit)) { - syslog(LOG_WARNING, "peer refused to authenticate"); + warn("peer refused to authenticate: terminating link"); lcp_close(unit, "peer refused to authenticate"); - phase = PHASE_TERMINATE; return; } } @@ -239,14 +378,19 @@ link_established(unit) auth |= CHAP_PEER; } else if (go->neg_upap) { upap_authpeer(unit); - auth |= UPAP_PEER; + auth |= PAP_PEER; } if (ho->neg_chap) { - ChapAuthWithPeer(unit, our_name, ho->chap_mdtype); + ChapAuthWithPeer(unit, user, ho->chap_mdtype); auth |= CHAP_WITHPEER; } else if (ho->neg_upap) { + if (passwd[0] == 0) { + passwd_from_file = 1; + if (!get_pap_passwd(passwd)) + error("No secret found for PAP login"); + } upap_authwithpeer(unit, user, passwd); - auth |= UPAP_WITHPEER; + auth |= PAP_WITHPEER; } auth_pending[unit] = auth; @@ -268,10 +412,24 @@ 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 + /* + * If we negotiated callback, do it now. + */ + if (go->neg_cbcp) { + phase = PHASE_CALLBACK; + (*cbcp_protent.open)(unit); + return; } +#endif phase = PHASE_NETWORK; #if 0 @@ -285,6 +443,10 @@ network_phase(unit) if (protp->protocol != PPP_CCP) ++num_np_open; } + + if (num_np_open == 0) + /* nothing to do */ + lcp_close(0, "No network protocols running"); } /* @@ -298,7 +460,6 @@ auth_peer_fail(unit, protocol) * Authentication failure: take the link down */ lcp_close(unit, "Authentication failed"); - phase = PHASE_TERMINATE; } /* @@ -317,11 +478,10 @@ auth_peer_success(unit, protocol, name, namelen) bit = CHAP_PEER; break; case PPP_PAP: - bit = UPAP_PEER; + bit = PAP_PEER; break; default: - syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x", - protocol); + warn("auth_peer_success: unknown protocol %x", protocol); return; } @@ -332,10 +492,11 @@ auth_peer_success(unit, protocol, name, namelen) namelen = sizeof(peer_authname) - 1; BCOPY(name, peer_authname, namelen); peer_authname[namelen] = 0; + script_setenv("PEERNAME", peer_authname); /* * If there is no more authentication still to be done, - * proceed to the network phase. + * proceed to the network (or callback) phase. */ if ((auth_pending[unit] &= ~bit) == 0) network_phase(unit); @@ -348,6 +509,8 @@ void auth_withpeer_fail(unit, protocol) int unit, protocol; { + if (passwd_from_file) + BZERO(passwd, MAXSECRETLEN); /* * We've failed to authenticate ourselves to our peer. * He'll probably take the link down, and there's not much @@ -369,17 +532,18 @@ auth_withpeer_success(unit, protocol) bit = CHAP_WITHPEER; break; case PPP_PAP: - bit = UPAP_WITHPEER; + if (passwd_from_file) + BZERO(passwd, MAXSECRETLEN); + bit = PAP_WITHPEER; break; default: - syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x", - protocol); + warn("auth_withpeer_success: unknown protocol %x", protocol); bit = 0; } /* * If there is no more authentication still being done, - * proceed to the network phase. + * proceed to the network (or callback) phase. */ if ((auth_pending[unit] &= ~bit) == 0) network_phase(unit); @@ -393,8 +557,27 @@ void np_up(unit, proto) int unit, proto; { - if (num_np_up == 0 && idle_time_limit > 0) { - TIMEOUT(check_idle, NULL, idle_time_limit); + if (num_np_up == 0) { + /* + * At this point we consider that the link has come up successfully. + */ + need_holdoff = 0; + + if (idle_time_limit > 0) + TIMEOUT(check_idle, NULL, idle_time_limit); + + /* + * Set a timeout to close the connection once the maximum + * connect time has expired. + */ + if (maxconnect > 0) + TIMEOUT(connect_time_expired, 0, maxconnect); + + /* + * Detach now, if the updetach option was given. + */ + if (updetach && !nodetach) + detach(); } ++num_np_up; } @@ -430,7 +613,7 @@ np_finished(unit, proto) */ static void check_idle(arg) - caddr_t arg; + void *arg; { struct ppp_idle idle; time_t itime; @@ -440,13 +623,24 @@ check_idle(arg) itime = MIN(idle.xmit_idle, idle.recv_idle); if (itime >= idle_time_limit) { /* link is idle: shut it down. */ - syslog(LOG_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); } } +/* + * connect_time_expired - log a message and close the connection. + */ +static void +connect_time_expired(arg) + void *arg; +{ + info("Connect time expired"); + lcp_close(0, "Connect time expired"); /* Close connection */ +} + /* * auth_check_options - called to check authentication options. */ @@ -454,44 +648,88 @@ void auth_check_options() { lcp_options *wo = &lcp_wantoptions[0]; - lcp_options *ao = &lcp_allowoptions[0]; - ipcp_options *ipwo = &ipcp_wantoptions[0]; - u_int32_t remote; + int can_auth; + int lacks_ip; /* Default our_name to hostname, and user to our_name */ if (our_name[0] == 0 || usehostname) - strcpy(our_name, hostname); + strlcpy(our_name, hostname, sizeof(our_name)); if (user[0] == 0) - strcpy(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 && !wo->neg_chap && !wo->neg_upap) { - wo->neg_chap = 1; - wo->neg_upap = 1; + if (auth_required) { + if (!wo->neg_chap && !wo->neg_upap) { + wo->neg_chap = 1; + wo->neg_upap = 1; + } + } else { + wo->neg_chap = 0; + wo->neg_upap = 0; } /* * Check whether we have appropriate secrets to use - * to authenticate ourselves and/or the peer. + * to authenticate the peer. */ - if (ao->neg_upap && passwd[0] == 0 && !get_upap_passwd()) - ao->neg_upap = 0; - if (wo->neg_upap && !uselogin && !have_upap_secret()) - wo->neg_upap = 0; - if (ao->neg_chap && !have_chap_secret(our_name, remote_name, (u_int32_t)0)) - ao->neg_chap = 0; - if (wo->neg_chap) { - remote = ipwo->accept_remote? 0: ipwo->hisaddr; - if (!have_chap_secret(remote_name, our_name, remote)) - wo->neg_chap = 0; + lacks_ip = 0; + can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip)); + if (!can_auth && wo->neg_chap) { + can_auth = have_chap_secret((explicit_remote? remote_name: NULL), + our_name, 1, &lacks_ip); } - if (auth_required && !wo->neg_chap && !wo->neg_upap) { - fprintf(stderr, "\ -pppd: peer authentication required but no suitable secret(s) found\n"); + if (auth_required && !can_auth) { + if (explicit_remote) + option_error( +"The remote system (%s) is required to authenticate itself but I", + remote_name); + else + 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); } +} +/* + * auth_reset - called when LCP is starting negotiations to recheck + * authentication options, i.e. whether we have appropriate secrets + * to use for authenticating ourselves and/or the peer. + */ +void +auth_reset(unit) + int unit; +{ + lcp_options *go = &lcp_gotoptions[unit]; + lcp_options *ao = &lcp_allowoptions[0]; + + ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL)); + ao->neg_chap = !refuse_chap + && have_chap_secret(user, (explicit_remote? remote_name: NULL), + 0, NULL); + + if (go->neg_upap && !uselogin && !have_pap_secret(NULL)) + go->neg_upap = 0; + if (go->neg_chap) { + if (!have_chap_secret((explicit_remote? remote_name: NULL), + our_name, 1, NULL)) + go->neg_chap = 0; + } } @@ -519,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; @@ -535,7 +771,7 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) *msg = (char *) 0; /* - * Open the file of upap secrets and scan for a suitable secret + * Open the file of pap secrets and scan for a suitable secret * for authenticating this user. */ filename = _PATH_UPAPFILE; @@ -543,28 +779,24 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) ret = UPAP_AUTHACK; f = fopen(filename, "r"); if (f == NULL) { - if (!uselogin) { - syslog(LOG_ERR, "Can't open PAP password file %s: %m", filename); - ret = UPAP_AUTHNAK; - } + error("Can't open PAP password file %s: %m", filename); + ret = UPAP_AUTHNAK; } 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)) { - syslog(LOG_WARNING, "PAP authentication failure for %s", user); + warn("PAP authentication failure for %s", user); ret = UPAP_AUTHNAK; } fclose(f); } if (uselogin && ret == UPAP_AUTHACK) { - ret = login(user, passwd, msg, msglen); + ret = plogin(user, passwd, msg, msglen); if (ret == UPAP_AUTHNAK) { - syslog(LOG_WARNING, "PAP login failure for %s", user); + warn("PAP login failure for %s", user); } } @@ -573,14 +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) { - syslog(LOG_WARNING, "%d LOGIN FAILURES ON %s, %s", - attempts, devnam, user); - quit(); + warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user); + lcp_close(unit, "login failed"); } if (attempts > 3) sleep((u_int) (attempts - 3) * 5); @@ -592,91 +824,82 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) if (*msg == (char *) 0) *msg = "Login ok"; *msglen = strlen(*msg); - if (addresses[unit] != NULL) - free_wordlist(addresses[unit]); - addresses[unit] = addrs; + set_allowed_addrs(unit, addrs); } + BZERO(passwd, sizeof(passwd)); + BZERO(secret, sizeof(secret)); + return ret; } -#ifdef HAS_SHADOW -/************** - * This function was lifted from the shadow-3.3.2 version by John Haugh II. - * It is included because the function was not in the standard libshadow - * library. If it is included in the library then I can remove it from here. - */ - -#define DAY (24L*3600L) /* - * isexpired - determine if account is expired yet - * - * isexpired calculates the expiration date based on the - * password expiration criteria. + * This function is needed for PAM. */ -/*ARGSUSED*/ -int -isexpired (pw, sp) -struct passwd *pw; -struct spwd *sp; -{ - long clock; - - clock = time ((time_t *) 0) / DAY; - - /* - * Quick and easy - there is an expired account field - * along with an inactive account field. Do the expired - * one first since it is worse. - */ - - if (sp->sp_expire > 0 && sp->sp_expire < clock) - return 3; - - if (sp->sp_inact > 0 && sp->sp_lstchg > 0 && sp->sp_max > 0 && - sp->sp_inact + sp->sp_lstchg + sp->sp_max < clock) - return 2; - - /* - * The last and max fields must be present for an account - * to have an expired password. A maximum of >10000 days - * is considered to be infinite. - */ - - if (sp->sp_lstchg == -1 || - sp->sp_max == -1 || sp->sp_max >= 10000L) - return 0; - - /* - * Calculate today's day and the day on which the password - * is going to expire. If that date has already passed, - * the password has expired. - */ - - if (sp->sp_lstchg + sp->sp_max < clock) - return 1; - - return 0; -} -#endif - - -/* - * This function is needed for PAM. However, it should not be called. - * If it is, return the error code. +#ifdef USE_PAM +/* 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. */ -#ifdef USE_PAM -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) { - return PAM_CONV_ERR; + int replies = 0; + struct pam_response *reply = NULL; + +#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 */ /* - * login - Check the user name and password against the system + * plogin - Check the user name and password against the system * password database, and login the user if OK. * * returns: @@ -686,7 +909,7 @@ static int pam_conv(int num_msg, const struct pam_message **msg, */ static int -login(user, passwd, msg, msglen) +plogin(user, passwd, msg, msglen) char *user; char *passwd; char **msg; @@ -695,126 +918,142 @@ login(user, passwd, msg, msglen) char *tty; #ifdef USE_PAM - struct pam_conv pam_conversation; - pam_handle_t *pamh; int pam_error; - char *pass; - char *dev; -/* - * 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 = (char *) 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_AUTHTOK, passwd); - (void) pam_set_item (pamh, PAM_TTY, devnam); -/* - * Validate the user - */ + /* + * Define the fields for the credential validation + */ + + PAM_username = user; + PAM_password = passwd; + 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); + if (pam_error == PAM_SUCCESS) + pam_open_session (pamh, PAM_SILENT); + } - *msg = (char *) pam_strerror (pam_error); -/* - * 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 *epasswd; #ifdef HAS_SHADOW struct spwd *spwd; struct spwd *getspnam(); #endif + struct passwd *pw = getpwnam(user); - if ((pw = getpwnam(user)) == NULL) { + endpwent(); + if (pw == NULL) return (UPAP_AUTHNAK); - } #ifdef HAS_SHADOW - if ((spwd = getspnam(user)) == NULL) { - pw->pw_passwd = ""; - } else { + spwd = getspnam(user); + endspent(); + if (spwd) { + /* check the age of the password entry */ + long now = time(NULL) / 86400L; + + if ((spwd->sp_expire > 0 && now >= spwd->sp_expire) + || ((spwd->sp_max >= 0 && spwd->sp_max < 10000) + && spwd->sp_lstchg >= 0 + && now >= spwd->sp_lstchg + spwd->sp_max)) { + warn("Password for %s has expired", user); + return (UPAP_AUTHNAK); + } pw->pw_passwd = spwd->sp_pwdp; } #endif /* - * XXX If no passwd, let them login without one. + * If no passwd, don't let them login. */ - if (pw->pw_passwd == '\0') { - return (UPAP_AUTHACK); - } - -#ifdef HAS_SHADOW - if (pw->pw_passwd) { - if (pw->pw_passwd[0] == '@') { - if (pw_auth (pw->pw_passwd+1, pw->pw_name, PW_PPP, NULL)) { - return (UPAP_AUTHNAK); - } - } else { - epasswd = pw_encrypt(passwd, pw->pw_passwd); - if (strcmp(epasswd, pw->pw_passwd)) { - return (UPAP_AUTHNAK); - } - } - /* check the age of the password entry */ - if (spwd && (isexpired (pw, spwd) != 0)) { - return (UPAP_AUTHNAK); - } - } -#else - epasswd = crypt(passwd, pw->pw_passwd); - if (strcmp(epasswd, pw->pw_passwd)) { + if (pw->pw_passwd == NULL || strlen(pw->pw_passwd) < 2 + || strcmp(crypt(passwd, pw->pw_passwd), pw->pw_passwd) != 0) return (UPAP_AUTHNAK); - } -#endif -#endif /* #ifdef USE_PAM */ - syslog(LOG_INFO, "user %s logged in", user); +#endif /* #ifdef USE_PAM */ /* * Write a wtmp entry for this user. */ + tty = devnam; if (strncmp(tty, "/dev/", 5) == 0) tty += 5; logwtmp(tty, user, remote_name); /* Add wtmp login entry */ - logged_in = TRUE; + +#if defined(_PATH_LASTLOG) && !defined(USE_PAM) + if (pw != (struct passwd *)NULL) { + struct lastlog ll; + int fd; + + if ((fd = open(_PATH_LASTLOG, O_RDWR, 0)) >= 0) { + (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, tty, sizeof(ll.ll_line)); + (void)write(fd, (char *)&ll, sizeof(ll)); + (void)close(fd); + } + } +#endif /* _PATH_LASTLOG and not USE_PAM */ + + info("user %s logged in", user); + logged_in = 1; return (UPAP_AUTHACK); } /* - * logout - Logout the user. + * plogout - Logout the user. */ static void -logout() +plogout() { +#ifdef USE_PAM + int pam_error; + + 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 wtmp logout entry */ - logged_in = FALSE; + logwtmp(tty, "", ""); /* Wipe out utmp logout entry */ +#endif /* ! USE_PAM */ + logged_in = 0; } @@ -834,7 +1073,7 @@ null_login(unit) char secret[MAXWORDLEN]; /* - * Open the file of upap secrets and scan for a suitable secret. + * Open the file of pap secrets and scan for a suitable secret. * We don't accept a wildcard client. */ filename = _PATH_UPAPFILE; @@ -844,14 +1083,14 @@ 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)); - if (ret) { - if (addresses[unit] != NULL) - free_wordlist(addresses[unit]); - addresses[unit] = addrs; - } + if (ret) + set_allowed_addrs(unit, addrs); + else + free_wordlist(addrs); fclose(f); return ret; @@ -859,15 +1098,18 @@ null_login(unit) /* - * get_upap_passwd - get a password for authenticating ourselves with + * get_pap_passwd - get a password for authenticating ourselves with * our peer using PAP. Returns 1 on success, 0 if no suitable password * could be found. + * Assumes passwd points to MAXSECRETLEN bytes of space (if non-null). */ static int -get_upap_passwd() +get_pap_passwd(passwd) + char *passwd; { char *filename; FILE *f; + int ret; struct wordlist *addrs; char secret[MAXWORDLEN]; @@ -877,40 +1119,49 @@ get_upap_passwd() if (f == NULL) return 0; check_access(f, filename); - if (scan_authfile(f, user, remote_name, (u_int32_t)0, - secret, NULL, filename) < 0) + ret = scan_authfile(f, user, + (remote_name[0]? remote_name: NULL), + secret, NULL, filename); + fclose(f); + if (ret < 0) return 0; - strncpy(passwd, secret, MAXSECRETLEN); - passwd[MAXSECRETLEN-1] = 0; + if (passwd != NULL) + strlcpy(passwd, secret, MAXSECRETLEN); + BZERO(secret, sizeof(secret)); return 1; } /* - * have_upap_secret - check whether we have a PAP file with any + * have_pap_secret - check whether we have a PAP file with any * secrets that we could possibly use for authenticating the peer. */ static int -have_upap_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; } @@ -921,31 +1172,38 @@ have_upap_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; } @@ -975,73 +1233,77 @@ get_secret(unit, client, server, secret, secret_len, save_addrs) f = fopen(filename, "r"); if (f == NULL) { - syslog(LOG_ERR, "Can't open chap secret file %s: %m", filename); + error("Can't open chap secret file %s: %m", filename); return 0; } 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; - if (save_addrs) { - if (addresses[unit] != NULL) - free_wordlist(addresses[unit]); - addresses[unit] = addrs; - } + if (save_addrs) + set_allowed_addrs(unit, addrs); len = strlen(secbuf); if (len > MAXSECRETLEN) { - syslog(LOG_ERR, "Secret for %s on %s is too long", client, server); + error("Secret for %s on %s is too long", client, server); len = MAXSECRETLEN; } BCOPY(secbuf, secret, len); + BZERO(secbuf, sizeof(secbuf)); *secret_len = len; return 1; } /* - * auth_ip_addr - check whether the peer is authorized to use - * a given IP address. Returns 1 if authorized, 0 otherwise. + * set_allowed_addrs() - set the list of allowed addresses. */ -int -auth_ip_addr(unit, addr) +static void +set_allowed_addrs(unit, addrs) int unit; - u_int32_t 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 1; /* no restriction */ + 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) { - /* "-" means no addresses authorized */ - ptr_word = addrs->word; + n = 0; + for (ap = addrs; ap != NULL; ap = ap->next) { + /* "-" means no addresses authorized, "*" means any address allowed */ + ptr_word = ap->word; if (strcmp(ptr_word, "-") == 0) break; + 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; } @@ -1052,9 +1314,8 @@ ip_addr_check(addr, addrs) bit_count = (int) strtol (ptr_mask+1, (char **) 0, 10); if (bit_count <= 0 || bit_count > 32) { - syslog (LOG_WARNING, - "invalid address length %s in auth. address list", - ptr_mask); + warn("invalid address length %v in auth. address list", + ptr_mask); continue; } *ptr_mask = '\0'; @@ -1063,38 +1324,85 @@ ip_addr_check(addr, addrs) hp = gethostbyname(ptr_word); if (hp != NULL && hp->h_addrtype == AF_INET) { - a = *(u_int32_t *)hp->h_addr; - mask = ~ (u_int32_t) 0; /* are we sure we want this? */ + a = *(u_int32_t *)hp->h_addr; } else { np = getnetbyname (ptr_word); - if (np != NULL && np->n_addrtype == AF_INET) + if (np != NULL && np->n_addrtype == AF_INET) { a = htonl (*(u_int32_t *)np->n_net); - else + if (ptr_mask == NULL) { + /* calculate appropriate mask for net */ + ah = ntohl(a); + if (IN_CLASSA(ah)) + mask = IN_CLASSA_NET; + else if (IN_CLASSB(ah)) + mask = IN_CLASSB_NET; + else if (IN_CLASSC(ah)) + mask = IN_CLASSC_NET; + } + } else { a = inet_addr (ptr_word); - if (ptr_mask == NULL) { - /* calculate appropriate mask for net */ - ah = ntohl(a); - if (IN_CLASSA(ah)) - mask = IN_CLASSA_NET; - else if (IN_CLASSB(ah)) - mask = IN_CLASSB_NET; - else if (IN_CLASSC(ah)) - mask = IN_CLASSC_NET; } } if (ptr_mask != NULL) *ptr_mask = '/'; - if (a == -1L) - syslog (LOG_WARNING, - "unknown host %s in auth. address list", - addrs->word); - else - if (((addr ^ a) & htonl(mask)) == 0) - return accept; + if (a == (u_int32_t)-1L) + 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; } /* @@ -1111,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; @@ -1122,9 +1447,10 @@ check_access(f, filename) struct stat sbuf; if (fstat(fileno(f), &sbuf) < 0) { - syslog(LOG_WARNING, "cannot stat secret file %s: %m", filename); + warn("cannot stat secret file %s: %m", filename); } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) { - syslog(LOG_WARNING, "Warning - secret file %s has world and/or group access", filename); + warn("Warning - secret file %s has world and/or group access", + filename); } } @@ -1136,14 +1462,14 @@ check_access(f, filename) * NONWILD_CLIENT set if the secret didn't have "*" for the client, and * NONWILD_SERVER set if the secret didn't have "*" for the server. * Any following words on the line (i.e. address authorization - * info) are placed in a wordlist and returned in *addrs. + * info) are placed in a wordlist and returned in *addrs. + * 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; @@ -1190,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 @@ -1214,23 +1541,21 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) * Special syntax: @filename means read secret from file. */ if (word[0] == '@') { - strcpy(atfile, word+1); + strlcpy(atfile, word+1, sizeof(atfile)); if ((sf = fopen(atfile, "r")) == NULL) { - syslog(LOG_WARNING, "can't open indirect secret file %s", - atfile); + warn("can't open indirect secret file %s", atfile); continue; } check_access(sf, atfile); if (!getword(sf, word, &xxx, atfile)) { - syslog(LOG_WARNING, "no secret in indirect secret file %s", - atfile); + warn("no secret in indirect secret file %s", atfile); fclose(sf); continue; } fclose(sf); } if (secret != NULL) - strcpy(lsecret, word); + strlcpy(lsecret, word, sizeof(lsecret)); /* * Now read address authorization info and make a wordlist. @@ -1239,12 +1564,13 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) for (;;) { if (!getword(f, word, &newline, filename) || newline) break; - ap = (struct wordlist *) malloc(sizeof(struct wordlist) - + strlen(word)); + ap = (struct wordlist *) malloc(sizeof(struct wordlist)); if (ap == NULL) novm("authorized addresses"); ap->next = NULL; - strcpy(ap->word, word); + ap->word = strdup(word); + if (ap->word == NULL) + novm("authorized address"); if (alist == NULL) alist = ap; else @@ -1252,14 +1578,6 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) alast = ap; } - /* - * Check if the given IP address is allowed by the wordlist. - */ - if (ipaddr != 0 && !ip_addr_check(ipaddr, alist)) { - free_wordlist(alist); - continue; - } - /* * This is the best so far; remember it. */ @@ -1268,7 +1586,7 @@ scan_authfile(f, client, server, ipaddr, secret, addrs, filename) free_wordlist(addr_list); addr_list = alist; if (secret != NULL) - strcpy(secret, lsecret); + strlcpy(secret, lsecret, MAXWORDLEN); if (!newline) break; @@ -1298,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 @@ -1315,10 +1658,10 @@ auth_script(script) if ((pw = getpwuid(getuid())) != NULL && pw->pw_name != NULL) user_name = pw->pw_name; else { - sprintf(struid, "%d", getuid()); + slprintf(struid, sizeof(struid), "%d", getuid()); user_name = struid; } - sprintf(strspeed, "%d", baud_rate); + slprintf(strspeed, sizeof(strspeed), "%d", baud_rate); argv[0] = script; argv[1] = ifname; @@ -1328,5 +1671,5 @@ auth_script(script) argv[5] = strspeed; argv[6] = NULL; - run_program(script, argv, 0); + auth_script_pid = run_program(script, argv, 0, auth_script_done, NULL); }