Make multi-line comments consistent
[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-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         /*
226          * Handle errors first. (Data available before the error occurred
227          * might be dropped, but shouldn't matter here.)
228          */
229         if (fds[0].revents & (POLLERR | POLLNVAL)) {
230             fprintf(stderr, "poll: error on master: %d\n", fds[0].revents);
231             break;
232         }
233         if (fds[1].revents & (POLLERR | POLLNVAL)) {
234             fprintf(stderr, "poll: error on ctty: %d\n", fds[1].revents);
235             break;
236         }
237
238         /* Read data if available. */
239         if (fds[0].revents & POLLIN) {
240             if (!read_from_write_to(pty_master, ctty)) {
241                 perror("read from master write to ctty");
242                 break;
243             }
244         }
245         if (fds[1].revents & POLLIN) {
246             if (!read_from_write_to(ctty, pty_master)) {
247                 perror("read from ctty write to master");
248                 break;
249             }
250         }
251
252         /* Finally we are done if either side of the pty has disconnected. */
253         if ((fds[0].revents & POLLHUP) || (fds[1].revents & POLLHUP)) {
254             break;
255         }
256     }
257
258     if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
259         die("sigprocmask setmask proxy");
260     }
261 }
262
263
264 /*
265  * Not sig_atomic_t (as required by POSIX) but I don't know how to do that any
266  * other way.
267  */
268 static volatile pid_t pid_to_wait_for;
269 static int pid_to_wait_for_status;
270
271 static void sigchld_handler() {
272     int status;
273     pid_t pid;
274
275     while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
276         if (pid == pid_to_wait_for) {
277             /* Mark that our child has died and we should exit as well. */
278             pid_to_wait_for = 0;
279             /* We must exit like our child, save status. */
280             pid_to_wait_for_status = status;
281         }
282     }
283 }
284
285
286 int main(int argc, char **argv) {
287     char *exec_argv_shell[] = { NULL, NULL }; /* filled below */
288     char **exec_argv = NULL;
289
290     if (argc == 2) {
291         /* exec_argv set below */
292     } else if (argc > 2) {
293         exec_argv = argv + 2;
294     } else {
295         die_fmt("%s <user> [<cmd>...]\n", argv[0]);
296     }
297
298     const char *user = argv[1];
299
300     struct passwd *passwd = getpwnam(user);
301     if (!passwd) {
302         die_fmt("unknown user name '%s'\n", user);
303     }
304
305     uid_t uid = passwd->pw_uid;
306     gid_t gid = passwd->pw_gid;
307
308     if (!exec_argv) {
309         assert(argc == 2);
310         exec_argv_shell[0] = passwd->pw_shell;
311         exec_argv = exec_argv_shell;
312     }
313
314     int pty_master, pty_slave;
315
316     open_pty_or_die(&pty_master, &pty_slave, uid);
317
318     int ctty = open("/dev/tty", O_RDWR | O_NOCTTY); /* controlling TTY */
319     if (ctty == -1) {
320         die("open /dev/tty");
321     }
322
323     sigset_t sigset, sigset_old;
324     sigemptyset(&sigset);
325     sigaddset(&sigset, SIGCHLD);
326     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
327         die("sigprocmask block sigchld");
328     }
329
330     pid_t pid = fork();
331     if (pid == -1) {
332         die("fork parent");
333     } else if (pid == 0) {
334         /* child, will become a session leader */
335
336         if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
337             die("sigprocmask setmask child");
338         }
339
340         struct winsize size;
341         if (ioctl(ctty, TIOCGWINSZ, &size) == -1) {
342             die("ioctl TIOCGWINSZ");
343         }
344
345         close_or_die(pty_master);
346         close_or_die(ctty);
347
348         /* Start a new session and attach controlling TTY. */
349         if (setsid() == -1) {
350             die("setsid");
351         }
352         if (ioctl(pty_slave, TIOCSCTTY, 0) == -1) {
353             die("ioctl TIOCSCTTY");
354         }
355
356         if (ioctl(pty_slave, TIOCSWINSZ, &size) == -1) {
357             die("ioctl TIOCSWINSZ");
358         }
359
360         pid_t pid = fork();
361         if (pid == -1) {
362             die("fork child");
363         } else if (pid == 0) {
364             /*
365              * Drop the privileges just now so that the other user doesn't get
366              * access to the master TTY or the session leader (which might
367              * have additional privileges).
368              */
369             drop_privileges_or_die(uid, gid);
370
371             dup2_or_die(pty_slave, STDIN_FILENO);
372             dup2_or_die(pty_slave, STDOUT_FILENO);
373             dup2_or_die(pty_slave, STDERR_FILENO);
374             close_or_die(pty_slave);
375
376             const char *term_orig = getenv("TERM");
377             const char *term = term_orig;
378             if (!term) {
379                 term = ""; /* for strlen() below */
380             }
381             const char *home = passwd->pw_dir;
382
383             /*
384              * Ignore errors here as we don't want to die on non-existent home
385              * directories to allow running as any user (think "/nonexistent"
386              * as home) and an error message will be annoying to ignore when
387              * running this command in scripts.
388              */
389             chdir(home);
390
391             char envp_user[strlen("USER=") + strlen(user) + 1];
392             char envp_home[strlen("HOME=") + strlen(home) + 1];
393             char envp_term[strlen("TERM=") + strlen(term) + 1];
394             snprintf_or_assert(envp_user, sizeof(envp_user), "USER=%s", user);
395             snprintf_or_assert(envp_home, sizeof(envp_home), "HOME=%s", home);
396             snprintf_or_assert(envp_term, sizeof(envp_term), "TERM=%s", term);
397
398             char *exec_envp[] = {
399                 "PATH=" PTYAS_DEFAULT_PATH,
400                 envp_user,
401                 envp_home,
402                 term_orig ? envp_term : NULL,
403                 NULL,
404             };
405
406             execve(exec_argv[0], exec_argv, exec_envp);
407             die("execve");
408         }
409         close_or_die(pty_slave);
410         close_or_die(STDIN_FILENO);
411         close_or_die(STDOUT_FILENO);
412         close_or_die(STDERR_FILENO);
413
414         /* TODO: EINTR? */
415         int status;
416         if (waitpid(pid, &status, 0) <= 0) {
417             die("waitpid child");
418         }
419         quit_with_matching_code(status);
420     }
421     close_or_die(pty_slave);
422
423     pid_to_wait_for = pid;
424     struct sigaction action = {
425         .sa_handler = sigchld_handler,
426     };
427     if (sigaction(SIGCHLD, &action, NULL) != 0) {
428         die("sigaction");
429     }
430
431     if (sigprocmask(SIG_SETMASK, &sigset_old, NULL) != 0) {
432         die("sigprocmask setmask parent");
433     }
434
435     struct termios old_term, term;
436
437     /* Change terminal to raw mode. */
438     if (tcgetattr(ctty, &old_term) != 0) {
439         die("tcgetattr");
440     }
441     term = old_term;
442     /* From man 3 cfmakeraw; cfmakeraw is non-standard so set it manually. */
443     term.c_iflag &= ~(tcflag_t)(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
444     term.c_oflag &= ~(tcflag_t)(OPOST);
445     term.c_lflag &= ~(tcflag_t)(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
446     term.c_cflag &= ~(tcflag_t)(CSIZE | PARENB);
447     term.c_cflag |= CS8;
448     if (tcsetattr(ctty, TCSADRAIN, &term) != 0) {
449         die("tcsetattr");
450     }
451
452     proxy_input_between_ttys(pty_master, ctty, &pid_to_wait_for);
453
454     /* Restore terminal mode. */
455     if (tcsetattr(ctty, TCSADRAIN, &old_term) != 0) {
456         die("tcsetattr restore");
457     }
458
459     /*
460      * Wait until we got the status code from our child. poll() might already
461      * exit after POLLHUP while we haven't collected the child yet.
462      */
463     if (sigprocmask(SIG_BLOCK, &sigset, &sigset_old) != 0) {
464         die("sigprocmask block sigchld loop");
465     }
466     while (pid_to_wait_for != 0) {
467         sigsuspend(&sigset_old);
468         if (errno != EINTR) {
469             die("sigsuspend");
470         }
471     }
472     if (sigprocmask(SIG_SETMASK, &sigset, &sigset_old) != 0) {
473         die("sigprocmask setmask sigchld loop");
474     }
475
476     /* Try to exit the same way as the spawned process. */
477     if (pid_to_wait_for == 0) {
478         quit_with_matching_code(pid_to_wait_for_status);
479     }
480     return EXIT_FAILURE;
481 }