Update copyright years
[ptyas/ptyas.git] / 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-2021  Simon Ruderich
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU Affero 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 Affero General Public License for more details.
16  *
17  * You should have received a copy of the GNU Affero General Public License
18  * along with this program.  If not, see <https://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     /*
86      * The user must be able to write to the new TTY. Normally grantpt() would
87      * do this for us, but we don't trust the user and thus don't want to pass
88      * the pty_master to a process running under that uid.
89      */
90     if (chown(slave_path, uid, (gid_t)-1) != 0) {
91         die("chown slave tty");
92     }
93 }
94
95 static void close_or_die(int fd) {
96     if (close(fd) != 0) {
97         die("close");
98     }
99 }
100 static void dup2_or_die(int oldfd, int newfd) {
101     if (dup2(oldfd, newfd) != newfd) {
102         die("dup2");
103     }
104 }
105 static int snprintf_or_assert(char *str, size_t size, const char *format, ...) {
106     int ret;
107     va_list ap;
108
109     va_start(ap, format);
110     ret = vsnprintf(str, size, format, ap);
111     assert(size <= (size_t)INT_MAX);
112     assert(ret < (int)size); /* assert output fit into buffer */
113     va_end(ap);
114
115     return ret;
116 }
117
118 static void drop_privileges_or_die(uid_t uid, gid_t gid) {
119     /* Drop all supplementary group IDs. */
120 #ifdef __FreeBSD__
121     {
122         /* FreeBSD uses the first gid to set the egid of the process. */
123         gid_t egid = gid;
124         if (setgroups(1, &egid) != 0) {
125             die("setgroups");
126         }
127         if (getgroups(1, &egid) != 1) {
128             die_fmt("failed to drop all supplementary groups\n");
129         }
130         if (egid != gid) {
131             die_fmt("failed to drop all supplementary groups (egid): %d %d\n",
132                     egid, gid);
133         }
134     }
135 #else
136     if (setgroups(0, NULL) != 0) {
137         die("setgroups");
138     }
139     if (getgroups(0, NULL) != 0) {
140         die_fmt("failed to drop all supplementary groups\n");
141     }
142 #endif
143
144     /* Dropping groups may require privileges, do that first. */
145     if (setresgid(gid, gid, gid) != 0) {
146         die("setresgid");
147     }
148     if (setresuid(uid, uid, uid) != 0) {
149         die("setresuid");
150     }
151
152     /* Ensure we dropped all privileges. */
153     {
154         uid_t ruid, euid, suid;
155         gid_t rgid, egid, sgid;
156
157         if (getresuid(&ruid, &euid, &suid) != 0) {
158             die("getresuid");
159         }
160         if (getresgid(&rgid, &egid, &sgid) != 0) {
161             die("getresgid");
162         }
163         if (       uid != ruid || uid != euid || uid != suid
164                 || gid != rgid || gid != egid || gid != sgid) {
165             die_fmt("failed to drop privileges\n");
166         }
167     }
168     /* Just to be safe. */
169     if (setuid(0) != -1) {
170         die_fmt("failed to drop privileges (setuid)\n");
171     }
172 }
173
174 static void quit_with_matching_code(int status) {
175     if (WIFEXITED(status)) {
176         exit(WEXITSTATUS(status));
177     } else if (WIFSIGNALED(status)) {
178         kill(getpid(), WTERMSIG(status));
179         /* Fall-through, should not happen. */
180     }
181     abort(); /* Should never happen, die painfully. */
182 }
183
184 static bool read_from_write_to(int from, int to) {
185     char buf[4096];
186
187     ssize_t r = read(from, buf, sizeof(buf));
188     if (r < 0) {
189         return false;
190     }
191
192     size_t left = (size_t)r;
193     char *data = buf;
194
195     while (left > 0) {
196         ssize_t w = write(to, data, left);
197         if (w < 0) {
198             if (errno == EINTR) {
199                 continue;
200             }
201             return false;
202         }
203         left -= (size_t)w;
204         data += (size_t)w;
205     }
206
207     return true;
208 }
209
210 static void proxy_input_between_ttys(int pty_master, int ctty, volatile pid_t *pid_to_wait_for) {
211     struct pollfd fds[] = {
212         { /* 0 */
213             .fd = pty_master,
214             .events = POLLIN,
215         },
216         { /* 1 */
217             .fd = ctty,
218             .events = POLLIN,
219         },
220     };
221
222     sigset_t sigset, sigset_old;
223     sigemptyset(&sigset);
224     sigaddset(&sigset, SIGCHLD);
225     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
226         die("sigprocmask block sigchld proxy");
227     }
228
229     /* Proxy data until our child has terminated. */
230     while (*pid_to_wait_for != 0) {
231         /*
232          * If a signal happens here _and_ the child hasn't closed pty_slave,
233          * we would hang in poll(); therefore ppoll() is necessary.
234          */
235         nfds_t nfds = sizeof(fds)/sizeof(*fds);
236         if (ppoll(fds, nfds, NULL /* no timeout */, &sigset_old) == -1) {
237             if (errno == EAGAIN || errno == EINTR) {
238                 continue;
239             }
240             perror("poll");
241             break;
242         }
243
244         /*
245          * Handle errors first. (Data available before the error occurred
246          * might be dropped, but shouldn't matter here.)
247          */
248         if (fds[0].revents & (POLLERR | POLLNVAL)) {
249             fprintf(stderr, "poll: error on master: %d\n", fds[0].revents);
250             break;
251         }
252         if (fds[1].revents & (POLLERR | POLLNVAL)) {
253             fprintf(stderr, "poll: error on ctty: %d\n", fds[1].revents);
254             break;
255         }
256
257         /* Read data if available. */
258         if (fds[0].revents & POLLIN) {
259             if (!read_from_write_to(pty_master, ctty)) {
260                 perror("read from master write to ctty");
261                 break;
262             }
263         }
264         if (fds[1].revents & POLLIN) {
265             if (!read_from_write_to(ctty, pty_master)) {
266                 perror("read from ctty write to master");
267                 break;
268             }
269         }
270
271         /* Finally we are done if either side of the pty has disconnected. */
272         if ((fds[0].revents & POLLHUP) || (fds[1].revents & POLLHUP)) {
273             break;
274         }
275     }
276
277     if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
278         die("sigprocmask setmask proxy");
279     }
280 }
281
282
283 /*
284  * Not sig_atomic_t (as required by POSIX) but I don't know how to do that any
285  * other way.
286  */
287 static volatile pid_t pid_to_wait_for;
288 static int pid_to_wait_for_status;
289
290 static void sigchld_handler(int signal) {
291     int status;
292     pid_t pid;
293
294     (void)signal;
295
296     while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
297         if (pid == pid_to_wait_for) {
298             /* Mark that our child has died and we should exit as well. */
299             pid_to_wait_for = 0;
300             /* We must exit like our child, save status. */
301             pid_to_wait_for_status = status;
302         }
303     }
304 }
305
306 /*
307  * SIGWINCH handler to handle resizes of the outer terminal.
308  *
309  * Errors are ignored without message because printing in signal handlers is
310  * problematic (no FILE * usable due to locks) and there's not much we can do
311  * at this point.
312  */
313 static int sigwinch_ctty = -1;
314 static int sigwinch_slave = -1;
315
316 static void sigwinch_handler(int signal) {
317     (void)signal;
318
319     struct winsize size;
320     if (ioctl(sigwinch_ctty, TIOCGWINSZ, &size) == -1) {
321         return;
322     }
323     if (ioctl(sigwinch_slave, TIOCSWINSZ, &size) == -1) {
324         return;
325     }
326 }
327
328
329 int main(int argc, char **argv) {
330     char *exec_argv_shell[] = { NULL, NULL }; /* filled below */
331     char **exec_argv = NULL;
332
333     if (argc == 2) {
334         /* exec_argv set below */
335     } else if (argc > 2) {
336         exec_argv = argv + 2;
337     } else {
338         die_fmt("%s <user> [<cmd>...]\n", argv[0]);
339     }
340
341     const char *user = argv[1];
342
343     struct passwd *passwd = getpwnam(user);
344     if (!passwd) {
345         die_fmt("unknown user name '%s'\n", user);
346     }
347
348     uid_t uid = passwd->pw_uid;
349     gid_t gid = passwd->pw_gid;
350
351     if (!exec_argv) {
352         assert(argc == 2);
353         exec_argv_shell[0] = passwd->pw_shell;
354         exec_argv = exec_argv_shell;
355     }
356
357     int pty_master, pty_slave;
358
359     open_pty_or_die(&pty_master, &pty_slave, uid);
360
361     int ctty = open("/dev/tty", O_RDWR | O_NOCTTY); /* controlling TTY */
362     if (ctty == -1) {
363         die("open /dev/tty");
364     }
365
366     sigset_t sigset, sigset_old;
367     sigemptyset(&sigset);
368     sigaddset(&sigset, SIGCHLD);
369     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
370         die("sigprocmask block sigchld");
371     }
372
373     pid_t pid = fork();
374     if (pid == -1) {
375         die("fork parent");
376     } else if (pid == 0) {
377         /* child, will become a session leader */
378
379         if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
380             die("sigprocmask setmask child");
381         }
382
383         struct winsize size;
384         if (ioctl(ctty, TIOCGWINSZ, &size) == -1) {
385             die("ioctl TIOCGWINSZ");
386         }
387
388         close_or_die(pty_master);
389         close_or_die(ctty);
390
391         /* Start a new session and attach controlling TTY. */
392         if (setsid() == -1) {
393             die("setsid");
394         }
395         if (ioctl(pty_slave, TIOCSCTTY, 0) == -1) {
396             die("ioctl TIOCSCTTY");
397         }
398
399         if (ioctl(pty_slave, TIOCSWINSZ, &size) == -1) {
400             die("ioctl TIOCSWINSZ");
401         }
402
403         pid_t pid = fork();
404         if (pid == -1) {
405             die("fork child");
406         } else if (pid == 0) {
407             /*
408              * Drop the privileges just now so that the other user doesn't get
409              * access to the master TTY or the session leader (which might
410              * have additional privileges).
411              */
412             drop_privileges_or_die(uid, gid);
413
414             dup2_or_die(pty_slave, STDIN_FILENO);
415             dup2_or_die(pty_slave, STDOUT_FILENO);
416             dup2_or_die(pty_slave, STDERR_FILENO);
417             close_or_die(pty_slave);
418
419             const char *term_orig = getenv("TERM");
420             const char *term = term_orig;
421             if (!term) {
422                 term = ""; /* for strlen() below */
423             }
424             const char *home = passwd->pw_dir;
425
426             /*
427              * Ignore errors here as we don't want to die on non-existent home
428              * directories to allow running as any user (think "/nonexistent"
429              * as home) and an error message will be annoying to ignore when
430              * running this command in scripts.
431              */
432             chdir(home);
433
434             char envp_user[strlen("USER=") + strlen(user) + 1];
435             char envp_home[strlen("HOME=") + strlen(home) + 1];
436             char envp_term[strlen("TERM=") + strlen(term) + 1];
437             snprintf_or_assert(envp_user, sizeof(envp_user), "USER=%s", user);
438             snprintf_or_assert(envp_home, sizeof(envp_home), "HOME=%s", home);
439             snprintf_or_assert(envp_term, sizeof(envp_term), "TERM=%s", term);
440
441             char *exec_envp[] = {
442                 "PATH=" PTYAS_DEFAULT_PATH,
443                 envp_user,
444                 envp_home,
445                 term_orig ? envp_term : NULL,
446                 NULL,
447             };
448
449             execve(exec_argv[0], exec_argv, exec_envp);
450             die("execve");
451         }
452         close_or_die(pty_slave);
453         close_or_die(STDIN_FILENO);
454         close_or_die(STDOUT_FILENO);
455         close_or_die(STDERR_FILENO);
456
457         /* TODO: EINTR? */
458         int status;
459         if (waitpid(pid, &status, 0) <= 0) {
460             die("waitpid child");
461         }
462         quit_with_matching_code(status);
463     }
464     /* Don't close pty_slave here as it's used in sigwinch_handler(). */
465
466     sigwinch_ctty = ctty;
467     sigwinch_slave = pty_slave;
468
469     struct sigaction action_sigwinch = {
470         .sa_handler = sigwinch_handler,
471     };
472     sigemptyset(&action_sigwinch.sa_mask);
473     if (sigaction(SIGWINCH, &action_sigwinch, NULL) != 0) {
474         die("sigaction SIGWINCH");
475     }
476
477     pid_to_wait_for = pid;
478     struct sigaction action_sigchld = {
479         .sa_handler = sigchld_handler,
480     };
481     sigemptyset(&action_sigchld.sa_mask);
482     if (sigaction(SIGCHLD, &action_sigchld, NULL) != 0) {
483         die("sigaction SIGCHLD");
484     }
485
486     if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
487         die("sigprocmask setmask parent");
488     }
489
490     struct termios old_term, term;
491
492     /* Change terminal to raw mode. */
493     if (tcgetattr(ctty, &old_term) != 0) {
494         die("tcgetattr");
495     }
496     term = old_term;
497     /* From man 3 cfmakeraw; cfmakeraw is non-standard so set it manually. */
498     term.c_iflag &= ~(tcflag_t)(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
499     term.c_oflag &= ~(tcflag_t)(OPOST);
500     term.c_lflag &= ~(tcflag_t)(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
501     term.c_cflag &= ~(tcflag_t)(CSIZE | PARENB);
502     term.c_cflag |= CS8;
503     if (tcsetattr(ctty, TCSADRAIN, &term) != 0) {
504         die("tcsetattr");
505     }
506
507     proxy_input_between_ttys(pty_master, ctty, &pid_to_wait_for);
508
509     /* Restore terminal mode. */
510     if (tcsetattr(ctty, TCSADRAIN, &old_term) != 0) {
511         die("tcsetattr restore");
512     }
513
514     /*
515      * Wait until we got the status code from our child. poll() might already
516      * exit after POLLHUP while we haven't collected the child yet.
517      */
518     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
519         die("sigprocmask block sigchld loop");
520     }
521     while (pid_to_wait_for != 0) {
522         sigsuspend(&sigset_old);
523         if (errno != EINTR) {
524             die("sigsuspend");
525         }
526     }
527     if (sigprocmask(SIG_SETMASK, &sigset, &sigset_old) != 0) {
528         die("sigprocmask setmask sigchld loop");
529     }
530
531     /* Try to exit the same way as the spawned process. */
532     if (pid_to_wait_for == 0) {
533         quit_with_matching_code(pid_to_wait_for_status);
534     }
535     return EXIT_FAILURE;
536 }