ptyas.c

   1 /*
   2  * Run the login shell or command as the given user in a new pty to prevent
   3  * terminal injection attacks.
   4  *
   5  * Copyright (C) 2016-2017  Simon Ruderich
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #define _GNU_SOURCE
  22
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <grp.h>
  27 #include <limits.h>
  28 #include <poll.h>
  29 #include <pwd.h>
  30 #include <signal.h>
  31 #include <stdarg.h>
  32 #include <stdbool.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/types.h>
  38 #include <sys/wait.h>
  39 #include <termios.h>
  40 #include <unistd.h>
  41
  42 /* Default PATH for new process.*/
  43 #ifndef PTYAS_DEFAULT_PATH
  44 /* Default user PATH from Debian's /etc/profile, change as needed. */
  45 # define PTYAS_DEFAULT_PATH "/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
  46 #endif
  47
  48
  49 static void die(const char *s) {
  50     perror(s);
  51     exit(EXIT_FAILURE);
  52 }
  53 static void die_fmt(const char *fmt, ...) {
  54     va_list ap;
  55
  56     va_start(ap, fmt);
  57     vfprintf(stderr, fmt, ap);
  58     va_end(ap);
  59
  60     exit(EXIT_FAILURE);
  61 }
  62
  63 static void open_pty_or_die(int *pty_master, int *pty_slave, uid_t uid) {
  64     char *slave_path;
  65
  66     *pty_master = posix_openpt(O_RDWR | O_NOCTTY);
  67     if (*pty_master == -1) {
  68         die("posix_openpt");
  69     }
  70     slave_path = ptsname(*pty_master);
  71     if (!slave_path) {
  72         die("ptsname");
  73     }
  74     if (grantpt(*pty_master) != 0) {
  75         die("grantpt");
  76     }
  77     if (unlockpt(*pty_master) != 0) {
  78         die("unlockpt");
  79     }
  80
  81     *pty_slave = open(slave_path, O_RDWR | O_NOCTTY);
  82     if (*pty_slave == -1) {
  83         die("open slave tty");
  84     }
  85     /* The user must be able to write to the new TTY. Normally grantpt() would
  86      * do this for us, but we don't trust the user and thus don't want to pass
  87      * the pty_master to a process running under that uid. */
  88     if (chown(slave_path, uid, (gid_t)-1) != 0) {
  89         die("chown slave tty");
  90     }
  91 }
  92
  93 static void close_or_die(int fd) {
  94     if (close(fd) != 0) {
  95         die("close");
  96     }
  97 }
  98 static void dup2_or_die(int oldfd, int newfd) {
  99     if (dup2(oldfd, newfd) != newfd) {
 100         die("dup2");
 101     }
 102 }
 103 static int snprintf_or_assert(char *str, size_t size, const char *format, ...) {
 104     int ret;
 105     va_list ap;
 106
 107     va_start(ap, format);
 108     ret = vsnprintf(str, size, format, ap);
 109     assert(size <= (size_t)INT_MAX);
 110     assert(ret < (int)size); /* assert output fit into buffer */
 111     va_end(ap);
 112
 113     return ret;
 114 }
 115
 116 static void drop_privileges_or_die(uid_t uid, gid_t gid) {
 117     /* Drop all supplementary group IDs. */
 118     if (setgroups(0, NULL) != 0) {
 119         die("setgroups");
 120     }
 121     if (getgroups(0, NULL) != 0) {
 122         die_fmt("failed to drop all supplementary groups");
 123     }
 124
 125     /* Dropping groups may require privileges, do that first. */
 126     if (setresgid(gid, gid, gid) != 0) {
 127         die("setresgid");
 128     }
 129     if (setresuid(uid, uid, uid) != 0) {
 130         die("setresuid");
 131     }
 132
 133     /* Ensure we dropped all privileges. */
 134     {
 135         uid_t ruid, euid, suid;
 136         gid_t rgid, egid, sgid;
 137
 138         if (getresuid(&ruid, &euid, &suid) != 0) {
 139             die("getresuid");
 140         }
 141         if (getresgid(&rgid, &egid, &sgid) != 0) {
 142             die("getresgid");
 143         }
 144         if (       uid != ruid || uid != euid || uid != suid
 145                 || gid != rgid || gid != egid || gid != sgid) {
 146             die_fmt("failed to drop privileges");
 147         }
 148     }
 149     /* Just to be safe. */
 150     if (setuid(0) != -1) {
 151         die_fmt("failed to drop privileges (setuid)");
 152     }
 153 }
 154
 155 static void quit_with_matching_code(int status) {
 156     if (WIFEXITED(status)) {
 157         exit(WEXITSTATUS(status));
 158     } else if (WIFSIGNALED(status)) {
 159         kill(getpid(), WTERMSIG(status));
 160         /* Fall-through, should not happen. */
 161     }
 162     abort(); /* Should never happen, die painfully. */
 163 }
 164
 165 static bool read_from_write_to(int from, int to) {
 166     char buf[4096];
 167
 168     ssize_t r = read(from, buf, sizeof(buf));
 169     if (r < 0) {
 170         return false;
 171     }
 172
 173     size_t left = (size_t)r;
 174     char *data = buf;
 175
 176     while (left > 0) {
 177         ssize_t w = write(to, data, left);
 178         if (w < 0) {
 179             if (errno == EINTR) {
 180                 continue;
 181             }
 182             return false;
 183         }
 184         left -= (size_t)w;
 185         data += (size_t)w;
 186     }
 187
 188     return true;
 189 }
 190
 191 static void proxy_input_between_ttys(int pty_master, int ctty, volatile pid_t *pid_to_wait_for) {
 192     struct pollfd fds[] = {
 193         { /* 0 */
 194             .fd = pty_master,
 195             .events = POLLIN,
 196         },
 197         { /* 1 */
 198             .fd = ctty,
 199             .events = POLLIN,
 200         },
 201     };
 202
 203     sigset_t sigset, sigset_old;
 204     sigemptyset(&sigset);
 205     sigaddset(&sigset, SIGCHLD);
 206     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
 207         die("sigprocmask block sigchld proxy");
 208     }
 209
 210     /* Proxy data until our child has terminated. */
 211     while (*pid_to_wait_for != 0) {
 212         /*
 213          * If a signal happens here _and_ the child hasn't closed pty_slave,
 214          * we would hang in poll(); therefore ppoll() is necessary.
 215          */
 216         nfds_t nfds = sizeof(fds)/sizeof(*fds);
 217         if (ppoll(fds, nfds, NULL /* no timeout */, &sigset_old) == -1) {
 218             if (errno == EAGAIN || errno == EINTR) {
 219                 continue;
 220             }
 221             perror("poll");
 222             break;
 223         }
 224
 225         /* Handle errors first. (Data available before the error occurred
 226          * might be dropped, but shouldn't matter here.) */
 227         if (fds[0].revents & (POLLERR | POLLNVAL)) {
 228             fprintf(stderr, "poll: error on master: %d\n", fds[0].revents);
 229             break;
 230         }
 231         if (fds[1].revents & (POLLERR | POLLNVAL)) {
 232             fprintf(stderr, "poll: error on ctty: %d\n", fds[1].revents);
 233             break;
 234         }
 235
 236         /* Read data if available. */
 237         if (fds[0].revents & POLLIN) {
 238             if (!read_from_write_to(pty_master, ctty)) {
 239                 perror("read from master write to ctty");
 240                 break;
 241             }
 242         }
 243         if (fds[1].revents & POLLIN) {
 244             if (!read_from_write_to(ctty, pty_master)) {
 245                 perror("read from ctty write to master");
 246                 break;
 247             }
 248         }
 249
 250         /* Finally we are done if either side of the pty has disconnected. */
 251         if ((fds[0].revents & POLLHUP) || (fds[1].revents & POLLHUP)) {
 252             break;
 253         }
 254     }
 255
 256     if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
 257         die("sigprocmask setmask proxy");
 258     }
 259 }
 260
 261
 262 /*
 263  * Not sig_atomic_t (as required by POSIX) but I don't know how to do that any
 264  * other way.
 265  */
 266 static volatile pid_t pid_to_wait_for;
 267 static int pid_to_wait_for_status;
 268
 269 static void sigchld_handler() {
 270     int status;
 271     pid_t pid;
 272
 273     while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
 274         if (pid == pid_to_wait_for) {
 275             /* Mark that our child has died and we should exit as well. */
 276             pid_to_wait_for = 0;
 277             /* We must exit like our child, save status. */
 278             pid_to_wait_for_status = status;
 279         }
 280     }
 281 }
 282
 283
 284 int main(int argc, char **argv) {
 285     char *exec_argv_shell[] = { NULL, NULL }; /* filled below */
 286     char **exec_argv = NULL;
 287
 288     if (argc == 2) {
 289         /* exec_argv set below */
 290     } else if (argc > 2) {
 291         exec_argv = argv + 2;
 292     } else {
 293         die_fmt("%s <user> [<cmd>...]\n", argv[0]);
 294     }
 295
 296     const char *user = argv[1];
 297
 298     struct passwd *passwd = getpwnam(user);
 299     if (!passwd) {
 300         die_fmt("unknown user name '%s'\n", user);
 301     }
 302
 303     uid_t uid = passwd->pw_uid;
 304     gid_t gid = passwd->pw_gid;
 305
 306     if (!exec_argv) {
 307         assert(argc == 2);
 308         exec_argv_shell[0] = passwd->pw_shell;
 309         exec_argv = exec_argv_shell;
 310     }
 311
 312     int pty_master, pty_slave;
 313
 314     open_pty_or_die(&pty_master, &pty_slave, uid);
 315
 316     int ctty = open("/dev/tty", O_RDWR | O_NOCTTY); /* controlling TTY */
 317     if (ctty == -1) {
 318         die("open /dev/tty");
 319     }
 320
 321     sigset_t sigset, sigset_old;
 322     sigemptyset(&sigset);
 323     sigaddset(&sigset, SIGCHLD);
 324     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
 325         die("sigprocmask block sigchld");
 326     }
 327
 328     pid_t pid = fork();
 329     if (pid == -1) {
 330         die("fork parent");
 331     } else if (pid == 0) {
 332         /* child, will become a session leader */
 333
 334         if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
 335             die("sigprocmask setmask child");
 336         }
 337
 338         struct winsize size;
 339         if (ioctl(ctty, TIOCGWINSZ, &size) == -1) {
 340             die("ioctl TIOCGWINSZ");
 341         }
 342
 343         close_or_die(pty_master);
 344         close_or_die(ctty);
 345
 346         /* Start a new session and attach controlling TTY. */
 347         if (setsid() == -1) {
 348             die("setsid");
 349         }
 350         if (ioctl(pty_slave, TIOCSCTTY, 0) == -1) {
 351             die("ioctl TIOCSCTTY");
 352         }
 353
 354         if (ioctl(pty_slave, TIOCSWINSZ, &size) == -1) {
 355             die("ioctl TIOCSWINSZ");
 356         }
 357
 358         pid_t pid = fork();
 359         if (pid == -1) {
 360             die("fork child");
 361         } else if (pid == 0) {
 362             /* Drop the privileges just now so that the other user doesn't get
 363              * access to the master TTY or the session leader (which might
 364              * have additional privileges). */
 365             drop_privileges_or_die(uid, gid);
 366
 367             dup2_or_die(pty_slave, STDIN_FILENO);
 368             dup2_or_die(pty_slave, STDOUT_FILENO);
 369             dup2_or_die(pty_slave, STDERR_FILENO);
 370             close_or_die(pty_slave);
 371
 372             const char *term_orig = getenv("TERM");
 373             const char *term = term_orig;
 374             if (!term) {
 375                 term = ""; /* for strlen() below */
 376             }
 377             const char *home = passwd->pw_dir;
 378
 379             // Ignore errors here as we don't want to die on non-existent home
 380             // directories to allow running as any user (think "/nonexistent"
 381             // as home) and an error message will be annoying to ignore when
 382             // running this command in scripts.
 383             chdir(home);
 384
 385             char envp_user[strlen("USER=") + strlen(user) + 1];
 386             char envp_home[strlen("HOME=") + strlen(home) + 1];
 387             char envp_term[strlen("TERM=") + strlen(term) + 1];
 388             snprintf_or_assert(envp_user, sizeof(envp_user), "USER=%s", user);
 389             snprintf_or_assert(envp_home, sizeof(envp_home), "HOME=%s", home);
 390             snprintf_or_assert(envp_term, sizeof(envp_term), "TERM=%s", term);
 391
 392             char *exec_envp[] = {
 393                 "PATH=" PTYAS_DEFAULT_PATH,
 394                 envp_user,
 395                 envp_home,
 396                 term_orig ? envp_term : NULL,
 397                 NULL,
 398             };
 399
 400             execve(exec_argv[0], exec_argv, exec_envp);
 401             die("execve");
 402         }
 403         close_or_die(pty_slave);
 404         close_or_die(STDIN_FILENO);
 405         close_or_die(STDOUT_FILENO);
 406         close_or_die(STDERR_FILENO);
 407
 408         /* TODO: EINTR? */
 409         int status;
 410         if (waitpid(pid, &status, 0) <= 0) {
 411             die("waitpid child");
 412         }
 413         quit_with_matching_code(status);
 414     }
 415     close_or_die(pty_slave);
 416
 417     pid_to_wait_for = pid;
 418     struct sigaction action = {
 419         .sa_handler = sigchld_handler,
 420     };
 421     if (sigaction(SIGCHLD, &action, NULL) != 0) {
 422         die("sigaction");
 423     }
 424
 425     if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
 426         die("sigprocmask setmask parent");
 427     }
 428
 429     struct termios old_term, term;
 430
 431     /* Change terminal to raw mode. */
 432     if (tcgetattr(ctty, &old_term) != 0) {
 433         die("tcgetattr");
 434     }
 435     term = old_term;
 436     /* From man 3 cfmakeraw; cfmakeraw is non-standard so set it manually. */
 437     term.c_iflag &= ~(tcflag_t)(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
 438     term.c_oflag &= ~(tcflag_t)(OPOST);
 439     term.c_lflag &= ~(tcflag_t)(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
 440     term.c_cflag &= ~(tcflag_t)(CSIZE | PARENB);
 441     term.c_cflag |= CS8;
 442     if (tcsetattr(ctty, TCSADRAIN, &term) != 0) {
 443         die("tcsetattr");
 444     }
 445
 446     proxy_input_between_ttys(pty_master, ctty, &pid_to_wait_for);
 447
 448     /* Restore terminal mode. */
 449     if (tcsetattr(ctty, TCSADRAIN, &old_term) != 0) {
 450         die("tcsetattr restore");
 451     }
 452
 453     /* Wait until we got the status code from our child. poll() might already
 454      * exit after POLLHUP while we haven't collected the child yet. */
 455     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
 456         die("sigprocmask block sigchld loop");
 457     }
 458     while (pid_to_wait_for != 0) {
 459         sigsuspend(&sigset_old);
 460         if (errno != EINTR) {
 461             die("sigsuspend");
 462         }
 463     }
 464     if (sigprocmask(SIG_SETMASK, &sigset, &sigset_old) != 0) {
 465         die("sigprocmask setmask sigchld loop");
 466     }
 467
 468     /* Try to exit the same way as the spawned process. */
 469     if (pid_to_wait_for == 0) {
 470         quit_with_matching_code(pid_to_wait_for_status);
 471     }
 472     return EXIT_FAILURE;
 473 }