innd/inndstart.c

   1 /*  $Id: inndstart.c 7749 2008-04-06 14:15:04Z iulius $
   2 **
   3 **  Open the privileged port, then exec innd.
   4 **
   5 **  inndstart, in a normal INN installation, is installed setuid root and
   6 **  executable only by users in the news group.  Because it is setuid root,
   7 **  it's very important to ensure that it be as simple and secure as
   8 **  possible so that news access can't be leveraged into root access.
   9 **
  10 **  Fighting against this desire, as much of INN's operation as possible
  11 **  should be configurable at run-time using inn.conf, and the news system
  12 **  should be able to an alternate inn.conf by setting INNCONF to the path
  13 **  to that file before starting any programs.  The configuration data
  14 **  therefore can't be trusted.
  15 **
  16 **  Our security model is therefore:
  17 **
  18 **   - The only three operations performed while privileged are determining
  19 **     the UID and GID of NEWSUSER and NEWSGRP, setting system limits, and
  20 **     opening the privileged port we're binding to.
  21 **
  22 **   - We can only be executed by the NEWSUSER and NEWSGRP, both compile-
  23 **     time constants; otherwise, we exit.  Similarly, we will only setuid()
  24 **     to the NEWSUSER.  This is to prevent someone other than the NEWSUSER
  25 **     but still able to execute inndstart for whatever reason from using it
  26 **     to run innd as the news user with bogus configuration information,
  27 **     thereby possibly compromising the news account.
  28 **
  29 **   - The only ports < 1024 that we'll bind to are 119 and 433, or a port
  30 **     given at configure time with --with-innd-port.  This is to prevent
  31 **     the news user from taking over a service such as telnet or POP and
  32 **     potentially gaining access to user passwords.
  33 **
  34 **  This program therefore gives the news user the ability to revoke system
  35 **  file descriptor limits and bind to the news port, and nothing else.
  36 **
  37 **  Note that we do use getpwnam() to determine the UID of NEWSUSER, which
  38 **  potentially opens an exploitable hole on those systems that don't
  39 **  correctly prevent a user running a setuid program from interfering with
  40 **  the running process (replacing system calls, for example, or using
  41 **  things like LD_PRELOAD).
  42 */
  43
  44 #include "config.h"
  45 #include "clibrary.h"
  46 #include "portable/socket.h"
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #include <grp.h>
  50 #include <pwd.h>
  51 #include <syslog.h>
  52
  53 #ifdef HAVE_INET6
  54 # include <netdb.h>
  55 #endif
  56
  57 #include "inn/innconf.h"
  58 #include "inn/messages.h"
  59 #include "libinn.h"
  60 #include "paths.h"
  61
  62 /* Fake up a do-nothing setgroups for Cygwin. */
  63 #if !HAVE_SETGROUPS
  64 # define setgroups(n, list)     0
  65 #endif
  66
  67 /* To run innd under the debugger, uncomment this and fix the path. */
  68 /* #define DEBUGGER "/usr/ucb/dbx" */
  69
  70
  71 int
  72 main(int argc, char *argv[])
  73 {
  74     struct passwd *pwd;
  75     struct group *grp;
  76     uid_t news_uid, real_uid;
  77     gid_t news_gid;
  78     int snum = 0;
  79     int port, s[MAX_SOCKETS + 1], i, j;
  80 #ifdef HAVE_INET6
  81     struct in6_addr address6;
  82     bool addr6_specified = false;
  83 #endif
  84     struct in_addr address;
  85     bool addr_specified = false;
  86     char *p;
  87     char **innd_argv;
  88     char pflag[SMBUF];
  89 #ifdef PURIFY
  90     char *innd_env[11];
  91 #else
  92     char *innd_env[9];
  93 #endif
  94
  95     /* Set up the error handlers.  Always print to stderr, and for warnings
  96        also syslog with a priority of LOG_ERR.  For fatal errors, also
  97        syslog with a priority of LOG_CRIT.  These priority levels are a
  98        little high, but they're chosen to match innd. */
  99     openlog("inndstart", LOG_CONS, LOG_INN_PROG);
 100     message_handlers_warn(2, message_log_stderr, message_log_syslog_err);
 101     message_handlers_die(2, message_log_stderr, message_log_syslog_crit);
 102     message_program_name = "inndstart";
 103
 104     /* Convert NEWSUSER and NEWSGRP to a UID and GID.  getpwnam() and
 105        getgrnam() don't set errno normally, so don't print strerror() on
 106        failure; it probably contains garbage.*/
 107     pwd = getpwnam(NEWSUSER);
 108     if (!pwd)
 109         die("can't getpwnam(%s)", NEWSUSER);
 110     news_uid = pwd->pw_uid;
 111     grp = getgrnam(NEWSGRP);
 112     if (!grp)
 113         die("can't getgrnam(%s)", NEWSGRP);
 114     news_gid = grp->gr_gid;
 115
 116     /* Exit if run by any other user or group. */
 117     real_uid = getuid();
 118     if (real_uid != news_uid)
 119         die("must be run by user %s (%lu), not %lu", NEWSUSER,
 120                 (unsigned long)news_uid, (unsigned long)real_uid);
 121
 122     /* Drop all supplemental groups and drop privileges to read inn.conf.
 123        setgroups() can only be invoked by root, so if inndstart isn't setuid
 124        root this is where we fail. */
 125     if (setgroups(1, &news_gid) < 0)
 126         syswarn("can't setgroups (is inndstart setuid root?)");
 127     if (seteuid(news_uid) < 0)
 128         sysdie("can't seteuid to %lu", (unsigned long)news_uid);
 129     if (!innconf_read(NULL))
 130         exit(1);
 131
 132     /* Check for a bind address specified in inn.conf.  "any" or "all" will
 133        cause inndstart to bind to INADDR_ANY. */
 134     address.s_addr = htonl(INADDR_ANY);
 135     p = innconf->bindaddress;
 136     if (p && strcmp(p, "all") != 0 && strcmp(p, "any") != 0) {
 137         if (!inet_aton(p, &address))
 138             die("invalid bindaddress in inn.conf (%s)", p);
 139         addr_specified = true;
 140     }
 141 #ifdef HAVE_INET6
 142     address6 = in6addr_any;
 143     p = innconf->bindaddress6;
 144     if (p && strcmp(p, "all") != 0 && strcmp(p, "any") != 0) {
 145         if (inet_pton(AF_INET6, p, &address6) < 1)
 146             die("invalid bindaddress6 in inn.conf (%s)", p);
 147         addr6_specified = true;
 148     }
 149 #endif
 150
 151     /* Parse our command-line options.  The only options we take are -P,
 152        which specifies what port number to bind to, and -I, which specifies
 153        what IP address to bind to.  Both override inn.conf.  Support both
 154        "-P <port>" and "-P<port>".  All other options are passed through to
 155        innd. */
 156     port = innconf->port;
 157     for (i = 1; i < argc; i++) {
 158         if (strncmp("-P", argv[i], 2) == 0) {
 159             if (strlen(argv[i]) > 2) {
 160                 port = atoi(&argv[i][2]);
 161             } else {
 162                 i++;
 163                 if (argv[i] == NULL)
 164                     die("missing port after -P");
 165                 port = atoi(argv[i]);
 166             }
 167             if (port == 0)
 168                 die("invalid port %s (must be a number)", argv[i]);
 169 #ifdef HAVE_INET6
 170         } else if (strncmp("-6", argv[i], 2) == 0) {
 171             if (strlen(argv[i]) > 2) {
 172                 p = &argv[i][2];
 173             } else {
 174                 i++;
 175                 if (argv[i] == NULL)
 176                     die("missing address after -6");
 177                 p = argv[i];
 178             }
 179             if (inet_pton(AF_INET6, p, &address6) < 1)
 180                 die("invalid address %s", p);
 181             addr6_specified = true;
 182 #endif
 183         } else if (strncmp("-I", argv[i], 2) == 0) {
 184             if (strlen(argv[i]) > 2) {
 185                 p = &argv[i][2];
 186             } else {
 187                 i++;
 188                 if (argv[i] == NULL)
 189                     die("missing address after -I");
 190                 p = argv[i];
 191             }
 192             if (!inet_aton(p, &address))
 193                 die("invalid address %s", p);
 194             addr_specified = true;
 195         }
 196     }
 197
 198     /* Make sure that the requested port is legitimate. */
 199     if (port < 1024 && port != 119
 200 #ifdef INND_PORT
 201         && port != INND_PORT
 202 #endif
 203         && port != 433)
 204         die("can't bind to restricted port %d", port);
 205
 206     /* Now, regain privileges so that we can change system limits and bind
 207        to our desired port. */
 208     if (seteuid(0) < 0)
 209         sysdie("can't seteuid to 0");
 210
 211     /* innconf->rlimitnofile <= 0 says to leave it alone. */
 212     if (innconf->rlimitnofile > 0 && setfdlimit(innconf->rlimitnofile) < 0)
 213         syswarn("can't set file descriptor limit to %ld",
 214                 innconf->rlimitnofile);
 215
 216 #if defined(HAVE_INET6) && defined(IPV6_V6ONLY)
 217     /* If we have the IPV6_V6ONLY socket option, and it works,
 218        always open separate IPv4 and IPv6 sockets. */
 219     if (addr_specified == 0 && addr6_specified == 0) {
 220         j = socket(PF_INET6, SOCK_STREAM, 0);
 221         if (j >= 0) {
 222             i = 1;
 223             if (setsockopt (j, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&i,
 224                              sizeof i) == 0) {
 225                 addr_specified = 1;
 226                 addr6_specified = 1;
 227             }
 228             close (j);
 229         }
 230     }
 231 #endif
 232
 233     /* Create a socket and name it. */
 234 #ifdef HAVE_INET6
 235     if( ! (addr_specified || addr6_specified) ) {
 236         struct addrinfo hints, *addr, *ressave;
 237         char service[16];
 238         int error;
 239
 240         memset(&hints, 0, sizeof hints);
 241         hints.ai_family = PF_UNSPEC;
 242         hints.ai_flags = AI_PASSIVE;
 243         hints.ai_socktype = SOCK_STREAM;
 244         snprintf(service, sizeof(service), "%d", port);
 245         error = getaddrinfo(NULL, service, &hints, &addr);
 246         if (error < 0)
 247             die("getaddrinfo: %s", gai_strerror(error));
 248
 249         for (ressave = addr; addr; addr = addr->ai_next) {
 250             if ((i = socket(addr->ai_family, addr->ai_socktype,
 251                             addr->ai_protocol)) < 0)
 252                 continue; /* ignore */
 253 #ifdef SO_REUSEADDR
 254             j = 1;
 255             if (setsockopt(i, SOL_SOCKET, SO_REUSEADDR, (char *)&j,
 256                         sizeof j) < 0)
 257                 syswarn("can't set SO_REUSEADDR");
 258 #endif
 259             if (bind(i, addr->ai_addr, addr->ai_addrlen) < 0) {
 260                 j = errno;
 261                 close(i);
 262                 errno = j;
 263                 continue; /* ignore */
 264             }
 265             s[snum++] = i;
 266             if (snum == MAX_SOCKETS)
 267                 break;
 268         }
 269         freeaddrinfo(ressave);
 270
 271         if (snum == 0)
 272             sysdie("can't bind socket");
 273     } else {
 274         if ( addr6_specified ) {
 275             struct sockaddr_in6 server6;
 276
 277             s[snum] = socket(PF_INET6, SOCK_STREAM, 0);
 278             if (s[snum] < 0)
 279                 sysdie("can't open inet6 socket");
 280 #ifdef SO_REUSEADDR
 281             i = 1;
 282             if (setsockopt(s[snum], SOL_SOCKET, SO_REUSEADDR, (char *)&i,
 283                         sizeof i) < 0)
 284                 syswarn("can't set SO_REUSEADDR");
 285 #endif
 286 #ifdef IPV6_V6ONLY
 287             i = 1;
 288             if (setsockopt(s[snum], IPPROTO_IPV6, IPV6_V6ONLY, (char *)&i,
 289                         sizeof i) < 0)
 290                 syswarn("can't set IPV6_V6ONLY");
 291 #endif
 292             memset(&server6, 0, sizeof server6);
 293             server6.sin6_port = htons(port);
 294             server6.sin6_family = AF_INET6;
 295             server6.sin6_addr = address6;
 296 #ifdef HAVE_SOCKADDR_LEN
 297             server6.sin6_len = sizeof server6;
 298 #endif
 299             if (bind(s[snum], (struct sockaddr *)&server6, sizeof server6) < 0)
 300                 sysdie("can't bind inet6 socket");
 301             snum++;
 302         }
 303         if ( addr_specified )
 304 #endif /* HAVE_INET6 */
 305         {
 306             struct sockaddr_in server;
 307
 308             s[snum] = socket(PF_INET, SOCK_STREAM, 0);
 309             if (s[snum] < 0)
 310                 sysdie("can't open inet socket");
 311 #ifdef SO_REUSEADDR
 312             i = 1;
 313             if (setsockopt(s[snum], SOL_SOCKET, SO_REUSEADDR, (char *) &i,
 314                         sizeof i) < 0)
 315                 syswarn("can't set SO_REUSEADDR");
 316 #endif
 317             memset(&server, 0, sizeof server);
 318             server.sin_port = htons(port);
 319             server.sin_family = AF_INET;
 320 #ifdef HAVE_SOCKADDR_LEN
 321             server.sin_len = sizeof server;
 322 #endif
 323             server.sin_addr = address;
 324             if (bind(s[snum], (struct sockaddr *)&server, sizeof server) < 0)
 325                 sysdie("can't bind inet socket");
 326             snum++;
 327         }
 328 #ifdef HAVE_INET6
 329     }
 330 #endif
 331     s[snum] = -1;
 332
 333     /* Now, permanently drop privileges. */
 334     if (setgid(news_gid) < 0 || getgid() != news_gid)
 335         sysdie("can't setgid to %lu", (unsigned long)news_gid);
 336     if (setuid(news_uid) < 0 || getuid() != news_uid)
 337         sysdie("can't setuid to %lu", (unsigned long)news_uid);
 338
 339     /* Build the argument vector for innd.  Pass -p<port> to innd to tell it
 340        what port we just created and bound to for it. */
 341     innd_argv = xmalloc((1 + argc + 1) * sizeof(char *));
 342     i = 0;
 343     strlcpy(pflag, "-p ", sizeof(pflag));
 344     for (j = 0; s[j] > 0; j++) {
 345         char temp[16];
 346
 347         snprintf(temp, sizeof(temp), "%d,", s[j]);
 348         strlcat(pflag, temp, sizeof(pflag));
 349     }
 350     /* chop off the trailing , */
 351     j = strlen(pflag) - 1;
 352     pflag[j] = '\0';
 353 #ifdef DEBUGGER
 354     innd_argv[i++] = DEBUGGER;
 355     innd_argv[i++] = concatpath(innconf->pathbin, "innd");
 356     innd_argv[i] = 0;
 357     printf("When starting innd, use -d %s\n", s, pflag);
 358 #else /* DEBUGGER */
 359     innd_argv[i++] = concatpath(innconf->pathbin, "innd");
 360     innd_argv[i++] = pflag;
 361
 362     /* Don't pass along -p, -P, or -I.  Check the length of the argument
 363        string, and if it == 2 (meaning there's nothing after the -p or -P or
 364        -I), skip the next argument too, to support leaving a space between
 365        the argument and the value. */
 366     for (j = 1; j < argc; j++) {
 367         if (argv[j][0] == '-' && strchr("pP6I", argv[j][1])) {
 368             if (strlen(argv[j]) == 2)
 369                 j++;
 370             continue;
 371         } else {
 372             innd_argv[i++] = argv[j];
 373         }
 374     }
 375     innd_argv[i] = 0;
 376 #endif /* !DEBUGGER */
 377
 378     /* Set up the environment.  Note that we're trusting BIND_INADDR and TZ;
 379        everything else is either from inn.conf or from configure.  These
 380        should be sanity-checked before being propagated, but that requires
 381        knowledge of the range of possible values.  Just limiting their
 382        length doesn't necessarily do anything to prevent exploits and may
 383        stop things from working that should.  We have to pass BIND_INADDR so
 384        that it's set for programs, such as innfeed, that innd may spawn. */
 385     innd_env[0] = concat("PATH=", innconf->pathbin, ":", innconf->pathetc,
 386                          ":/bin:/usr/bin:/usr/ucb", (char *) 0);
 387     innd_env[1] = concat( "TMPDIR=", innconf->pathtmp,  (char *) 0);
 388     innd_env[2] = concat(  "SHELL=", _PATH_SH,          (char *) 0);
 389     innd_env[3] = concat("LOGNAME=", NEWSMASTER,        (char *) 0);
 390     innd_env[4] = concat(   "USER=", NEWSMASTER,        (char *) 0);
 391     innd_env[5] = concat(   "HOME=", innconf->pathnews, (char *) 0);
 392     i = 6;
 393     p = getenv("BIND_INADDR");
 394     if (p != NULL)
 395         innd_env[i++] = concat("BIND_INADDR=", p, (char *) 0);
 396     p = getenv("TZ");
 397     if (p != NULL)
 398         innd_env[i++] = concat("TZ=", p, (char *) 0);
 399 #ifdef PURIFY
 400     /* you have to compile with `purify cc -DPURIFY' to get this */
 401     p = getenv("DISPLAY");
 402     if (p != NULL)
 403         innd_env[i++] = concat("DISPLAY=", p, (char *) 0);
 404     p = getenv("PURIFYOPTIONS");
 405     if (p != NULL)
 406         innd_env[i++] = concat("PURIFYOPTIONS=", p, (char *) 0);
 407 #endif
 408     innd_env[i] = 0;
 409
 410     /* Go exec innd. */
 411     execve(innd_argv[0], innd_argv, innd_env);
 412     sysdie("can't exec %s", innd_argv[0]);
 413
 414     /* Not reached. */
 415     return 1;
 416 }