extend syntax for allowable hosts in secrets files;
[ppp.git] / pppd / auth.c
index cdeb2b6b7874daa292c32b23082f89c4134eae93..1cbc14973acad1d0ef4a54ad7843f3275a78f924 100644 (file)
  */
 
 #ifndef lint
-static char rcsid[] = "$Id: auth.c,v 1.1 1993/11/11 03:54:25 paulus Exp $";
+static char rcsid[] = "$Id: auth.c,v 1.20 1995/12/18 03:43:04 paulus Exp $";
 #endif
 
 #include <stdio.h>
 #include <stddef.h>
+#include <stdlib.h>
 #include <syslog.h>
 #include <pwd.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/socket.h>
 
 #include <netdb.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 
-#include "ppp.h"
+#ifdef HAS_SHADOW
+#include <shadow.h>
+#include <shadow/pwauth.h>
+#ifndef PW_PPP
+#define PW_PPP PW_LOGIN
+#endif
+#endif
+
 #include "pppd.h"
 #include "fsm.h"
 #include "lcp.h"
 #include "upap.h"
-#include "chap.h"
-#include "ipcp.h"
 #include "pathnames.h"
 
-#ifdef sparc
+#if defined(sun) && defined(sparc)
 #include <alloca.h>
-#ifndef __GNUC__
-/* why alloca.h doesn't define what alloca() returns is a mystery */
-char *alloca __ARGS((int));
-#endif /*__GNUC__*/
 #endif /*sparc*/
 
 /* Used for storing a sequence of words.  Usually malloced. */
@@ -80,20 +83,10 @@ struct wordlist {
 #define FALSE  0
 #define TRUE   1
 
-extern char user[];
-extern char passwd[];
-extern char devname[];
-extern char our_name[];
-extern char remote_name[];
-extern char hostname[];
-extern int uselogin;
-extern int usehostname;
-extern int auth_required;
-
 /* Records which authentication operations haven't completed yet. */
-static int auth_pending[NPPP];
+static int auth_pending[NUM_PPP];
 static int logged_in;
-static struct wordlist *addresses[NPPP];
+static struct wordlist *addresses[NUM_PPP];
 
 /* Bits in auth_pending[] */
 #define UPAP_WITHPEER  1
@@ -101,19 +94,20 @@ static struct wordlist *addresses[NPPP];
 #define CHAP_WITHPEER  4
 #define CHAP_PEER      8
 
-/* Prototypes */
-void check_access __ARGS((FILE *, char *));
+/* Prototypes for procedures local to this file. */
 
-static int  login __ARGS((char *, char *, char **, int *));
-static void logout __ARGS((void));
-static int  get_upap_passwd __ARGS((void));
-static int  have_upap_secret __ARGS((void));
-static int  have_chap_secret __ARGS((char *, char *));
-static int  scan_authfile __ARGS((FILE *, char *, char *, char *,
+static void network_phase __P((int));
+static int  login __P((char *, char *, char **, int *));
+static void logout __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 *));
+static int  scan_authfile __P((FILE *, char *, char *, char *,
                                  struct wordlist **, char *));
-static void free_wordlist __ARGS((struct wordlist *));
+static void free_wordlist __P((struct wordlist *));
 
-extern char *crypt __ARGS((char *, char *));
+extern char *crypt __P((char *, char *));
 
 /*
  * An Open on LCP has requested a change from Dead to Establish phase.
@@ -133,13 +127,31 @@ void
 link_terminated(unit)
     int unit;
 {
+    if (phase == PHASE_DEAD)
+       return;
     if (logged_in)
        logout();
-    if (lcp_wantoptions[unit].restart) {
-       lcp_lowerdown(unit);
-       lcp_lowerup(unit);
-    } else
-       EXIT(unit);
+    phase = PHASE_DEAD;
+    syslog(LOG_NOTICE, "Connection terminated.");
+}
+
+/*
+ * LCP has gone down; it will either die or try to re-establish.
+ */
+void
+link_down(unit)
+    int unit;
+{
+    int i;
+    struct protent *protp;
+
+    for (i = 0; (protp = protocols[i]) != NULL; ++i) {
+        if (protp->protocol != PPP_LCP && protp->lowerdown != NULL)
+           (*protp->lowerdown)(unit);
+        if (protp->protocol < 0xC000 && protp->close != NULL)
+           (*protp->close)(unit);
+    }
+    phase = PHASE_TERMINATE;
 }
 
 /*
@@ -154,17 +166,31 @@ link_established(unit)
     lcp_options *wo = &lcp_wantoptions[unit];
     lcp_options *go = &lcp_gotoptions[unit];
     lcp_options *ho = &lcp_hisoptions[unit];
+    int i;
+    struct protent *protp;
+
+    /*
+     * Tell higher-level protocols that LCP is up.
+     */
+    for (i = 0; (protp = protocols[i]) != NULL; ++i)
+        if (protp->protocol != PPP_LCP && protp->lowerup != NULL)
+           (*protp->lowerup)(unit);
 
     if (auth_required && !(go->neg_chap || go->neg_upap)) {
        /*
-        * We wanted the peer to authenticate himself, and he refused:
-        * tell him to go away.
+        * We wanted the peer to authenticate itself, and it refused:
+        * treat it as though it authenticated with PAP using a username
+        * of "" and a password of "".  If that's not OK, boot it out.
         */
-       syslog(LOG_WARNING, "peer refused to authenticate");
-       lcp_close(unit);
-       return;
+       if (!wo->neg_upap || !null_login(unit)) {
+           syslog(LOG_WARNING, "peer refused to authenticate");
+           lcp_close(unit, "peer refused to authenticate");
+           phase = PHASE_TERMINATE;
+           return;
+       }
     }
 
+    phase = PHASE_AUTHENTICATE;
     auth = 0;
     if (go->neg_chap) {
        ChapAuthPeer(unit, our_name, go->chap_mdtype);
@@ -183,7 +209,23 @@ link_established(unit)
     auth_pending[unit] = auth;
 
     if (!auth)
-       ipcp_open(unit);
+       network_phase(unit);
+}
+
+/*
+ * Proceed to the network phase.
+ */
+static void
+network_phase(unit)
+    int unit;
+{
+    int i;
+    struct protent *protp;
+
+    phase = PHASE_NETWORK;
+    for (i = 0; (protp = protocols[i]) != NULL; ++i)
+        if (protp->protocol < 0xC000 && protp->open != NULL)
+           (*protp->open)(unit);
 }
 
 /*
@@ -196,7 +238,8 @@ auth_peer_fail(unit, protocol)
     /*
      * Authentication failure: take the link down
      */
-    lcp_close(unit);
+    lcp_close(unit, "Authentication failed");
+    phase = PHASE_TERMINATE;
 }
 
 /*
@@ -209,10 +252,10 @@ auth_peer_success(unit, protocol)
     int bit;
 
     switch (protocol) {
-    case CHAP:
+    case PPP_CHAP:
        bit = CHAP_PEER;
        break;
-    case UPAP:
+    case PPP_PAP:
        bit = UPAP_PEER;
        break;
     default:
@@ -226,7 +269,7 @@ auth_peer_success(unit, protocol)
      * proceed to the network phase.
      */
     if ((auth_pending[unit] &= ~bit) == 0)
-       ipcp_open(unit);
+        network_phase(unit);
 }
 
 /*
@@ -253,15 +296,16 @@ auth_withpeer_success(unit, protocol)
     int bit;
 
     switch (protocol) {
-    case CHAP:
+    case PPP_CHAP:
        bit = CHAP_WITHPEER;
        break;
-    case UPAP:
+    case PPP_PAP:
        bit = UPAP_WITHPEER;
        break;
     default:
        syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x",
               protocol);
+       bit = 0;
     }
 
     /*
@@ -269,7 +313,7 @@ auth_withpeer_success(unit, protocol)
      * proceed to the network phase.
      */
     if ((auth_pending[unit] &= ~bit) == 0)
-       ipcp_open(unit);
+       network_phase(unit);
 }
 
 
@@ -362,16 +406,16 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen)
     f = fopen(filename, "r");
     if (f == NULL) {
        if (!uselogin) {
-           syslog(LOG_ERR, "Can't open upap password file %s: %m", filename);
+           syslog(LOG_ERR, "Can't open PAP password file %s: %m", filename);
            ret = UPAP_AUTHNAK;
        }
 
     } else {
        check_access(f, filename);
        if (scan_authfile(f, user, our_name, secret, &addrs, filename) < 0
-           || (secret[0] != 0 && strcmp(passwd, secret) != 0
+           || (secret[0] != 0 && (cryptpap || strcmp(passwd, secret) != 0)
                && strcmp(crypt(passwd, secret), secret) != 0)) {
-           syslog(LOG_WARNING, "upap authentication failure for %s", user);
+           syslog(LOG_WARNING, "PAP authentication failure for %s", user);
            ret = UPAP_AUTHNAK;
        }
        fclose(f);
@@ -380,7 +424,7 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen)
     if (uselogin && ret == UPAP_AUTHACK) {
        ret = login(user, passwd, msg, msglen);
        if (ret == UPAP_AUTHNAK) {
-           syslog(LOG_WARNING, "upap login failure for %s", user);
+           syslog(LOG_WARNING, "PAP login failure for %s", user);
        }
     }
 
@@ -394,7 +438,7 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen)
         */
        if (attempts++ >= 10) {
            syslog(LOG_WARNING, "%d LOGIN FAILURES ON %s, %s",
-                  attempts, devname, user);
+                  attempts, devnam, user);
            quit();
        }
        if (attempts > 3)
@@ -435,10 +479,23 @@ login(user, passwd, msg, msglen)
     char *epasswd;
     char *tty;
 
+#ifdef HAS_SHADOW
+    struct spwd *spwd;
+    struct spwd *getspnam();
+#endif
+
     if ((pw = getpwnam(user)) == NULL) {
        return (UPAP_AUTHNAK);
     }
 
+#ifdef HAS_SHADOW
+    if ((spwd = getspnam(user)) == NULL) {
+        pw->pw_passwd = "";
+    } else {
+       pw->pw_passwd = spwd->sp_pwdp;
+    }
+#endif
+
     /*
      * XXX If no passwd, let them login without one.
      */
@@ -446,21 +503,27 @@ login(user, passwd, msg, msglen)
        return (UPAP_AUTHACK);
     }
 
+#ifdef HAS_SHADOW
+    if ((pw->pw_passwd && pw->pw_passwd[0] == '@'
+        && pw_auth (pw->pw_passwd+1, pw->pw_name, PW_PPP, NULL))
+       || !valid (passwd, pw)) {
+       return (UPAP_AUTHNAK);
+    }
+#else
     epasswd = crypt(passwd, pw->pw_passwd);
     if (strcmp(epasswd, pw->pw_passwd)) {
        return (UPAP_AUTHNAK);
     }
+#endif
 
     syslog(LOG_INFO, "user %s logged in", user);
 
     /*
      * Write a wtmp entry for this user.
      */
-    tty = strrchr(devname, '/');
-    if (tty == NULL)
-       tty = devname;
-    else
-       tty++;
+    tty = devnam;
+    if (strncmp(tty, "/dev/", 5) == 0)
+       tty += 5;
     logwtmp(tty, user, "");            /* Add wtmp login entry */
     logged_in = TRUE;
 
@@ -475,16 +538,54 @@ logout()
 {
     char *tty;
 
-    tty = strrchr(devname, '/');
-    if (tty == NULL)
-       tty = devname;
-    else
-       tty++;
+    tty = devnam;
+    if (strncmp(tty, "/dev/", 5) == 0)
+       tty += 5;
     logwtmp(tty, "", "");              /* Wipe out wtmp logout entry */
     logged_in = FALSE;
 }
 
 
+/*
+ * null_login - Check if a username of "" and a password of "" are
+ * acceptable, and iff so, set the list of acceptable IP addresses
+ * and return 1.
+ */
+static int
+null_login(unit)
+    int unit;
+{
+    char *filename;
+    FILE *f;
+    int i, ret;
+    struct wordlist *addrs;
+    char secret[MAXWORDLEN];
+
+    /*
+     * Open the file of upap secrets and scan for a suitable secret.
+     * We don't accept a wildcard client.
+     */
+    filename = _PATH_UPAPFILE;
+    addrs = NULL;
+    f = fopen(filename, "r");
+    if (f == NULL)
+       return 0;
+    check_access(f, filename);
+
+    i = scan_authfile(f, "", our_name, secret, &addrs, filename);
+    ret = i >= 0 && (i & NONWILD_CLIENT) != 0 && secret[0] == 0;
+
+    if (ret) {
+       if (addresses[unit] != NULL)
+           free_wordlist(addresses[unit]);
+       addresses[unit] = addrs;
+    }
+
+    fclose(f);
+    return ret;
+}
+
+
 /*
  * get_upap_passwd - get a password for authenticating ourselves with
  * our peer using PAP.  Returns 1 on success, 0 if no suitable password
@@ -543,7 +644,7 @@ have_upap_secret()
  * on `server'.  Either can be the null string, meaning we don't
  * know the identity yet.
  */
-int
+static int
 have_chap_secret(client, server)
     char *client;
     char *server;
@@ -583,6 +684,7 @@ get_secret(unit, client, server, secret, secret_len, save_addrs)
     char *server;
     char *secret;
     int *secret_len;
+    int save_addrs;
 {
     FILE *f;
     int ret, len;
@@ -630,33 +732,90 @@ get_secret(unit, client, server, secret, secret_len, save_addrs)
 int
 auth_ip_addr(unit, addr)
     int unit;
-    u_long addr;
+    u_int32_t addr;
 {
-    u_long a;
+    u_int32_t a, mask;
+    int accept;
+    char *ptr_word, *ptr_mask;
     struct hostent *hp;
+    struct netent *np;
     struct wordlist *addrs;
 
+    /* don't allow loopback or multicast address */
+    if (bad_ip_adrs(addr))
+       return 0;
+
     if ((addrs = addresses[unit]) == NULL)
        return 1;               /* no restriction */
 
     for (; addrs != NULL; addrs = addrs->next) {
        /* "-" means no addresses authorized */
-       if (strcmp(addrs->word, "-") == 0)
+       ptr_word = addrs->word;
+       if (strcmp(ptr_word, "-") == 0)
            break;
-       if ((a = inet_addr(addrs->word)) == -1) {
-           if ((hp = gethostbyname(addrs->word)) == NULL) {
-               syslog(LOG_WARNING, "unknown host %s in auth. address list",
-                      addrs->word);
+
+       accept = 1;
+       if (*ptr_word == '!') {
+           accept = 0;
+           ++ptr_word;
+       }
+
+       mask = ~ (u_int32_t) 0;
+       ptr_mask = strchr (ptr_word, '/');
+       if (ptr_mask != NULL) {
+           int bit_count;
+
+           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);
                continue;
-           } else
-               a = *(u_long *)hp->h_addr;
+           }
+           *ptr_mask = '\0';
+           mask <<= 32 - bit_count;
        }
-       if (addr == a)
-           return 1;
+
+       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? */
+       } else {
+           np = getnetbyname (ptr_word);
+           if (np != NULL && np->n_addrtype == AF_INET)
+               a = htonl (*(u_int32_t *)np->n_net);
+           else
+               a = inet_addr (ptr_word);
+       }
+
+       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) & mask) == 0)
+               return accept;
     }
     return 0;                  /* not in list => can't have it */
 }
 
+/*
+ * bad_ip_adrs - return 1 if the IP address is one we don't want
+ * to use, such as an address in the loopback net or a multicast address.
+ * addr is in network byte order.
+ */
+int
+bad_ip_adrs(addr)
+    u_int32_t addr;
+{
+    addr = ntohl(addr);
+    return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
+       || IN_MULTICAST(addr) || IN_BADCLASS(addr);
+}
+
 /*
  * check_access - complain if a secret file has too-liberal permissions.
  */
@@ -783,7 +942,7 @@ scan_authfile(f, client, server, secret, addrs, filename)
         */
        if (addr_list)
            free_wordlist(addr_list);
-       addr_list = NULL;
+       addr_list = addr_last = NULL;
        for (;;) {
            if (!getword(f, word, &newline, filename) || newline)
                break;