1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "compat.h"
18 
19 #include "fs.h"
20 #include "telescope.h"
21 
22 #ifdef __OpenBSD__
23 
24 # include <errno.h>
25 # include <limits.h>
26 # include <stdlib.h>
27 # include <string.h>
28 # include <unistd.h>
29 
30 void
31 sandbox_net_process(void)
32 {
33 	if (pledge("stdio inet dns", NULL) == -1)
34 		err(1, "pledge");
35 }
36 
37 void
38 sandbox_ui_process(void)
39 {
40 	if (pledge("stdio tty unix recvfd", NULL) == -1)
41 		err(1, "pledge");
42 }
43 
44 void
45 sandbox_fs_process(void)
46 {
47 	char path[PATH_MAX];
48 
49 	if (unveil("/tmp", "rwc") == -1)
50 		err(1, "unveil(/tmp)");
51 
52 	strlcpy(path, getenv("HOME"), sizeof(path));
53 	strlcat(path, "/Downloads", sizeof(path));
54 	if (unveil(path, "rwc") == -1 && errno != ENOENT)
55 		err(1, "unveil(%s)", path);
56 
57 	if (unveil(config_path_base, "rwc") == -1)
58 		err(1, "unveil(%s)", config_path_base);
59 
60 	if (unveil(data_path_base, "rwc") == -1)
61 		err(1, "unveil(%s)", data_path_base);
62 
63 	if (unveil(cache_path_base, "rwc") == -1)
64 		err(1, "unveil(%s)", cache_path_base);
65 
66 	if (pledge("stdio rpath wpath cpath sendfd", NULL) == -1)
67 		err(1, "pledge");
68 }
69 
70 #elif HAVE_LINUX_LANDLOCK_H
71 
72 #include <linux/landlock.h>
73 #include <linux/prctl.h>
74 
75 #include <sys/prctl.h>
76 #include <sys/stat.h>
77 #include <sys/syscall.h>
78 
79 #include <errno.h>
80 #include <fcntl.h>
81 #include <stdlib.h>
82 #include <string.h>
83 #include <unistd.h>
84 
85 /*
86  * What's the deal with landlock?  While distro with linux >= 5.13
87  * have the struct declarations, libc wrappers are missing.  The
88  * sample landlock code provided by the authors includes these "shims"
89  * in their example for the landlock API until libc provides them.
90  *
91  * Linux is such a mess sometimes.  /rant
92  */
93 
94 #ifndef landlock_create_ruleset
95 static inline int
96 landlock_create_ruleset(const struct landlock_ruleset_attr *attr, size_t size,
97     __u32 flags)
98 {
99 	return syscall(__NR_landlock_create_ruleset, attr, size, flags);
100 }
101 #endif
102 
103 #ifndef landlock_add_rule
104 static inline int
105 landlock_add_rule(int ruleset_fd, enum landlock_rule_type type,
106     const void *attr, __u32 flags)
107 {
108 	return syscall(__NR_landlock_add_rule, ruleset_fd, type, attr, flags);
109 }
110 #endif
111 
112 #ifndef landlock_restrict_self
113 static inline int
114 landlock_restrict_self(int ruleset_fd, __u32 flags)
115 {
116 	return syscall(__NR_landlock_restrict_self, ruleset_fd, flags);
117 }
118 #endif
119 
120 static int
121 open_landlock(void)
122 {
123 	int fd;
124 	struct landlock_ruleset_attr attr = {
125 		.handled_access_fs =	LANDLOCK_ACCESS_FS_EXECUTE |
126 					LANDLOCK_ACCESS_FS_READ_FILE |
127 					LANDLOCK_ACCESS_FS_READ_DIR |
128 					LANDLOCK_ACCESS_FS_WRITE_FILE |
129 					LANDLOCK_ACCESS_FS_REMOVE_DIR |
130 					LANDLOCK_ACCESS_FS_REMOVE_FILE |
131 					LANDLOCK_ACCESS_FS_MAKE_CHAR |
132 					LANDLOCK_ACCESS_FS_MAKE_DIR |
133 					LANDLOCK_ACCESS_FS_MAKE_REG |
134 					LANDLOCK_ACCESS_FS_MAKE_SOCK |
135 					LANDLOCK_ACCESS_FS_MAKE_FIFO |
136 					LANDLOCK_ACCESS_FS_MAKE_BLOCK |
137 					LANDLOCK_ACCESS_FS_MAKE_SYM,
138 	};
139 
140 	fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
141 	if (fd == -1) {
142 		switch (errno) {
143 		case ENOSYS:
144 		case EOPNOTSUPP:
145 			return -1;
146 		default:
147 			err(1, "can't create landlock ruleset");
148 		}
149 	}
150 	return fd;
151 }
152 
153 static int
154 landlock_unveil(int landlock_fd, const char *path, int perms)
155 {
156 	struct landlock_path_beneath_attr pb;
157 	int err, saved_errno;
158 
159 	pb.allowed_access = perms;
160 
161 	if ((pb.parent_fd = open(path, O_PATH)) == -1)
162 		return -1;
163 
164 	err = landlock_add_rule(landlock_fd, LANDLOCK_RULE_PATH_BENEATH,
165 	    &pb, 0);
166 	saved_errno = errno;
167 	close(pb.parent_fd);
168 	errno = saved_errno;
169 	return err ? -1 : 0;
170 }
171 
172 static int
173 landlock_apply(int fd)
174 {
175 	int r, saved_errno;
176 
177 	if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) == -1)
178 		err(1, "%s: prctl(PR_SET_NO_NEW_PRIVS)", __func__);
179 
180 	r = landlock_restrict_self(fd, 0);
181 	saved_errno = errno;
182 	close(fd);
183 	errno = saved_errno;
184 	return r ? -1 : 0;
185 }
186 
187 static int
188 landlock_no_fs(void)
189 {
190 	int fd;
191 
192 	/*
193 	 * XXX: landlock disabled at runtime, pretend everything's
194 	 * good.
195 	 */
196 	if ((fd = open_landlock()) == -1)
197 		return 0;
198 
199 	return landlock_apply(fd);
200 }
201 
202 void
203 sandbox_net_process(void)
204 {
205 	/*
206 	 * We don't know what paths are required for the TLS stack.
207 	 * Yes, it sucks.
208 	 */
209 	return;
210 }
211 
212 void
213 sandbox_ui_process(void)
214 {
215 	if (landlock_no_fs() == -1)
216 		err(1, "landlock");
217 }
218 
219 void
220 sandbox_fs_process(void)
221 {
222 	int fd, rwc;
223 	char path[PATH_MAX];
224 
225 	/*
226 	 * XXX: at build-time we found landlock.h but we've just
227 	 * realized it's not available on this kernel, so do nothing.
228 	 */
229 	if ((fd = open_landlock()) == -1)
230 		return;
231 
232 	rwc =	LANDLOCK_ACCESS_FS_READ_FILE	|
233 		LANDLOCK_ACCESS_FS_READ_DIR	|
234 		LANDLOCK_ACCESS_FS_WRITE_FILE	|
235 		LANDLOCK_ACCESS_FS_MAKE_DIR	|
236 		LANDLOCK_ACCESS_FS_MAKE_REG;
237 
238 	if (landlock_unveil(fd, "/tmp", rwc) == -1)
239 		err(1, "landlock_unveil(/tmp)");
240 
241 	strlcpy(path, getenv("HOME"), sizeof(path));
242 	strlcat(path, "/Downloads", sizeof(path));
243 	if (landlock_unveil(fd, path, rwc) == -1 && errno != ENOENT)
244 		err(1, "landlock_unveil(%s)", path);
245 
246 	if (landlock_unveil(fd, config_path_base, rwc) == -1)
247 		err(1, "landlock_unveil(%s)", config_path_base);
248 
249 	if (landlock_unveil(fd, data_path_base, rwc) == -1)
250 		err(1, "landlock_unveil(%s)", data_path_base);
251 
252 	if (landlock_unveil(fd, cache_path_base, rwc) == -1)
253 		err(1, "landlock_unveil(%s)", cache_path_base);
254 }
255 
256 #else
257 
258 #warning "No sandbox for this OS"
259 
260 void
261 sandbox_net_process(void)
262 {
263 	return;
264 }
265 
266 void
267 sandbox_ui_process(void)
268 {
269 	return;
270 }
271 
272 void
273 sandbox_fs_process(void)
274 {
275 	return;
276 }
277 
278 #endif