seccomp.c 24.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 * linux/kernel/seccomp.c
 *
 * Copyright 2004-2005  Andrea Arcangeli <andrea@cpushare.com>
 *
6 7 8 9 10 11 12 13
 * Copyright (C) 2012 Google, Inc.
 * Will Drewry <wad@chromium.org>
 *
 * This defines a simple but solid secure-computing facility.
 *
 * Mode 1 uses a fixed list of allowed system calls.
 * Mode 2 allows user-defined system call filters in the form
 *        of Berkeley Packet Filters/Linux Socket Filters.
Linus Torvalds's avatar
Linus Torvalds committed
14 15
 */

16
#include <linux/atomic.h>
17
#include <linux/audit.h>
18
#include <linux/compat.h>
19
#include <linux/coredump.h>
20
#include <linux/sched.h>
21
#include <linux/sched/task_stack.h>
22
#include <linux/seccomp.h>
23
#include <linux/slab.h>
Kees Cook's avatar
Kees Cook committed
24
#include <linux/syscalls.h>
Linus Torvalds's avatar
Linus Torvalds committed
25

26
#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER
27
#include <asm/syscall.h>
28
#endif
29 30 31

#ifdef CONFIG_SECCOMP_FILTER
#include <linux/filter.h>
32
#include <linux/pid.h>
33
#include <linux/ptrace.h>
34 35 36 37 38 39 40 41 42 43 44 45
#include <linux/security.h>
#include <linux/tracehook.h>
#include <linux/uaccess.h>

/**
 * struct seccomp_filter - container for seccomp BPF programs
 *
 * @usage: reference count to manage the object lifetime.
 *         get/put helpers should be used when accessing an instance
 *         outside of a lifetime-guarded section.  In general, this
 *         is only needed for handling filters shared across tasks.
 * @prev: points to a previously installed, or inherited, filter
46
 * @prog: the BPF program to evaluate
47 48 49 50 51 52 53 54 55 56 57 58 59 60
 *
 * seccomp_filter objects are organized in a tree linked via the @prev
 * pointer.  For any task, it appears to be a singly-linked list starting
 * with current->seccomp.filter, the most recently attached or inherited filter.
 * However, multiple filters may share a @prev node, by way of fork(), which
 * results in a unidirectional tree existing in memory.  This is similar to
 * how namespaces work.
 *
 * seccomp_filter objects should never be modified after being attached
 * to a task_struct (other than @usage).
 */
struct seccomp_filter {
	atomic_t usage;
	struct seccomp_filter *prev;
61
	struct bpf_prog *prog;
62 63 64 65 66
};

/* Limit any path through the tree to 256KB worth of instructions. */
#define MAX_INSNS_PER_PATH ((1 << 18) / sizeof(struct sock_filter))

67
/*
68 69 70
 * Endianness is explicitly ignored and left for BPF program authors to manage
 * as per the specific architecture.
 */
71
static void populate_seccomp_data(struct seccomp_data *sd)
72
{
73 74
	struct task_struct *task = current;
	struct pt_regs *regs = task_pt_regs(task);
75
	unsigned long args[6];
76

77
	sd->nr = syscall_get_nr(task, regs);
78
	sd->arch = syscall_get_arch();
79 80 81 82 83 84 85
	syscall_get_arguments(task, regs, 0, 6, args);
	sd->args[0] = args[0];
	sd->args[1] = args[1];
	sd->args[2] = args[2];
	sd->args[3] = args[3];
	sd->args[4] = args[4];
	sd->args[5] = args[5];
86
	sd->instruction_pointer = KSTK_EIP(task);
87 88 89 90 91 92 93
}

/**
 *	seccomp_check_filter - verify seccomp filter code
 *	@filter: filter to verify
 *	@flen: length of filter
 *
94
 * Takes a previously checked filter (by bpf_check_classic) and
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
 * redirects all filter code that loads struct sk_buff data
 * and related data through seccomp_bpf_load.  It also
 * enforces length and alignment checking of those loads.
 *
 * Returns 0 if the rule set is legal or -EINVAL if not.
 */
static int seccomp_check_filter(struct sock_filter *filter, unsigned int flen)
{
	int pc;
	for (pc = 0; pc < flen; pc++) {
		struct sock_filter *ftest = &filter[pc];
		u16 code = ftest->code;
		u32 k = ftest->k;

		switch (code) {
110
		case BPF_LD | BPF_W | BPF_ABS:
111
			ftest->code = BPF_LDX | BPF_W | BPF_ABS;
112 113 114 115
			/* 32-bit aligned and not out of bounds. */
			if (k >= sizeof(struct seccomp_data) || k & 3)
				return -EINVAL;
			continue;
116
		case BPF_LD | BPF_W | BPF_LEN:
117
			ftest->code = BPF_LD | BPF_IMM;
118 119
			ftest->k = sizeof(struct seccomp_data);
			continue;
120
		case BPF_LDX | BPF_W | BPF_LEN:
121
			ftest->code = BPF_LDX | BPF_IMM;
122 123 124
			ftest->k = sizeof(struct seccomp_data);
			continue;
		/* Explicitly include allowed calls. */
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
		case BPF_RET | BPF_K:
		case BPF_RET | BPF_A:
		case BPF_ALU | BPF_ADD | BPF_K:
		case BPF_ALU | BPF_ADD | BPF_X:
		case BPF_ALU | BPF_SUB | BPF_K:
		case BPF_ALU | BPF_SUB | BPF_X:
		case BPF_ALU | BPF_MUL | BPF_K:
		case BPF_ALU | BPF_MUL | BPF_X:
		case BPF_ALU | BPF_DIV | BPF_K:
		case BPF_ALU | BPF_DIV | BPF_X:
		case BPF_ALU | BPF_AND | BPF_K:
		case BPF_ALU | BPF_AND | BPF_X:
		case BPF_ALU | BPF_OR | BPF_K:
		case BPF_ALU | BPF_OR | BPF_X:
		case BPF_ALU | BPF_XOR | BPF_K:
		case BPF_ALU | BPF_XOR | BPF_X:
		case BPF_ALU | BPF_LSH | BPF_K:
		case BPF_ALU | BPF_LSH | BPF_X:
		case BPF_ALU | BPF_RSH | BPF_K:
		case BPF_ALU | BPF_RSH | BPF_X:
		case BPF_ALU | BPF_NEG:
		case BPF_LD | BPF_IMM:
		case BPF_LDX | BPF_IMM:
		case BPF_MISC | BPF_TAX:
		case BPF_MISC | BPF_TXA:
		case BPF_LD | BPF_MEM:
		case BPF_LDX | BPF_MEM:
		case BPF_ST:
		case BPF_STX:
		case BPF_JMP | BPF_JA:
		case BPF_JMP | BPF_JEQ | BPF_K:
		case BPF_JMP | BPF_JEQ | BPF_X:
		case BPF_JMP | BPF_JGE | BPF_K:
		case BPF_JMP | BPF_JGE | BPF_X:
		case BPF_JMP | BPF_JGT | BPF_K:
		case BPF_JMP | BPF_JGT | BPF_X:
		case BPF_JMP | BPF_JSET | BPF_K:
		case BPF_JMP | BPF_JSET | BPF_X:
163 164 165 166 167 168 169 170 171
			continue;
		default:
			return -EINVAL;
		}
	}
	return 0;
}

/**
172 173
 * seccomp_run_filters - evaluates all seccomp filters against @sd
 * @sd: optional seccomp data to be passed to filters
174 175 176
 *
 * Returns valid seccomp BPF response codes.
 */
Kees Cook's avatar
Kees Cook committed
177
static u32 seccomp_run_filters(const struct seccomp_data *sd)
178
{
179
	struct seccomp_data sd_local;
Will Drewry's avatar
Will Drewry committed
180
	u32 ret = SECCOMP_RET_ALLOW;
181 182 183
	/* Make sure cross-thread synced filter points somewhere sane. */
	struct seccomp_filter *f =
			lockless_dereference(current->seccomp.filter);
Will Drewry's avatar
Will Drewry committed
184 185

	/* Ensure unexpected behavior doesn't result in failing open. */
186
	if (unlikely(WARN_ON(f == NULL)))
Will Drewry's avatar
Will Drewry committed
187 188
		return SECCOMP_RET_KILL;

189 190 191 192
	if (!sd) {
		populate_seccomp_data(&sd_local);
		sd = &sd_local;
	}
193

194 195
	/*
	 * All filters in the list are evaluated and the lowest BPF return
Will Drewry's avatar
Will Drewry committed
196
	 * value always takes priority (ignoring the DATA).
197
	 */
198
	for (; f; f = f->prev) {
199
		u32 cur_ret = BPF_PROG_RUN(f->prog, sd);
200

Will Drewry's avatar
Will Drewry committed
201 202
		if ((cur_ret & SECCOMP_RET_ACTION) < (ret & SECCOMP_RET_ACTION))
			ret = cur_ret;
203 204 205
	}
	return ret;
}
206
#endif /* CONFIG_SECCOMP_FILTER */
207

208 209
static inline bool seccomp_may_assign_mode(unsigned long seccomp_mode)
{
210
	assert_spin_locked(&current->sighand->siglock);
211

212 213 214 215 216 217
	if (current->seccomp.mode && current->seccomp.mode != seccomp_mode)
		return false;

	return true;
}

218 219
static inline void seccomp_assign_mode(struct task_struct *task,
				       unsigned long seccomp_mode)
220
{
221
	assert_spin_locked(&task->sighand->siglock);
222

223 224 225 226 227 228 229
	task->seccomp.mode = seccomp_mode;
	/*
	 * Make sure TIF_SECCOMP cannot be set before the mode (and
	 * filter) is set.
	 */
	smp_mb__before_atomic();
	set_tsk_thread_flag(task, TIF_SECCOMP);
230 231 232
}

#ifdef CONFIG_SECCOMP_FILTER
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
/* Returns 1 if the parent is an ancestor of the child. */
static int is_ancestor(struct seccomp_filter *parent,
		       struct seccomp_filter *child)
{
	/* NULL is the root ancestor. */
	if (parent == NULL)
		return 1;
	for (; child; child = child->prev)
		if (child == parent)
			return 1;
	return 0;
}

/**
 * seccomp_can_sync_threads: checks if all threads can be synchronized
 *
 * Expects sighand and cred_guard_mutex locks to be held.
 *
 * Returns 0 on success, -ve on error, or the pid of a thread which was
 * either not in the correct seccomp mode or it did not have an ancestral
 * seccomp filter.
 */
static inline pid_t seccomp_can_sync_threads(void)
{
	struct task_struct *thread, *caller;

	BUG_ON(!mutex_is_locked(&current->signal->cred_guard_mutex));
260
	assert_spin_locked(&current->sighand->siglock);
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300

	/* Validate all threads being eligible for synchronization. */
	caller = current;
	for_each_thread(caller, thread) {
		pid_t failed;

		/* Skip current, since it is initiating the sync. */
		if (thread == caller)
			continue;

		if (thread->seccomp.mode == SECCOMP_MODE_DISABLED ||
		    (thread->seccomp.mode == SECCOMP_MODE_FILTER &&
		     is_ancestor(thread->seccomp.filter,
				 caller->seccomp.filter)))
			continue;

		/* Return the first thread that cannot be synchronized. */
		failed = task_pid_vnr(thread);
		/* If the pid cannot be resolved, then return -ESRCH */
		if (unlikely(WARN_ON(failed == 0)))
			failed = -ESRCH;
		return failed;
	}

	return 0;
}

/**
 * seccomp_sync_threads: sets all threads to use current's filter
 *
 * Expects sighand and cred_guard_mutex locks to be held, and for
 * seccomp_can_sync_threads() to have returned success already
 * without dropping the locks.
 *
 */
static inline void seccomp_sync_threads(void)
{
	struct task_struct *thread, *caller;

	BUG_ON(!mutex_is_locked(&current->signal->cred_guard_mutex));
301
	assert_spin_locked(&current->sighand->siglock);
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319

	/* Synchronize all threads. */
	caller = current;
	for_each_thread(caller, thread) {
		/* Skip current, since it needs no changes. */
		if (thread == caller)
			continue;

		/* Get a task reference for the new leaf node. */
		get_seccomp_filter(caller);
		/*
		 * Drop the task reference to the shared ancestor since
		 * current's path will hold a reference.  (This also
		 * allows a put before the assignment.)
		 */
		put_seccomp_filter(thread);
		smp_store_release(&thread->seccomp.filter,
				  caller->seccomp.filter);
320 321 322 323 324 325 326 327 328 329

		/*
		 * Don't let an unprivileged task work around
		 * the no_new_privs restriction by creating
		 * a thread that sets it up, enters seccomp,
		 * then dies.
		 */
		if (task_no_new_privs(caller))
			task_set_no_new_privs(thread);

330 331 332 333 334 335
		/*
		 * Opt the other thread into seccomp if needed.
		 * As threads are considered to be trust-realm
		 * equivalent (see ptrace_may_access), it is safe to
		 * allow one thread to transition the other.
		 */
336
		if (thread->seccomp.mode == SECCOMP_MODE_DISABLED)
337 338 339 340
			seccomp_assign_mode(thread, SECCOMP_MODE_FILTER);
	}
}

341
/**
342
 * seccomp_prepare_filter: Prepares a seccomp filter for use.
343 344
 * @fprog: BPF program to install
 *
345
 * Returns filter on success or an ERR_PTR on failure.
346
 */
347
static struct seccomp_filter *seccomp_prepare_filter(struct sock_fprog *fprog)
348
{
349 350
	struct seccomp_filter *sfilter;
	int ret;
351
	const bool save_orig = IS_ENABLED(CONFIG_CHECKPOINT_RESTORE);
352 353

	if (fprog->len == 0 || fprog->len > BPF_MAXINSNS)
354
		return ERR_PTR(-EINVAL);
355

356
	BUG_ON(INT_MAX / fprog->len < sizeof(struct sock_filter));
357 358

	/*
359
	 * Installing a seccomp filter requires that the task has
360 361 362 363
	 * CAP_SYS_ADMIN in its namespace or be running with no_new_privs.
	 * This avoids scenarios where unprivileged tasks can affect the
	 * behavior of privileged children.
	 */
364
	if (!task_no_new_privs(current) &&
365 366
	    security_capable_noaudit(current_cred(), current_user_ns(),
				     CAP_SYS_ADMIN) != 0)
367
		return ERR_PTR(-EACCES);
368

369
	/* Allocate a new seccomp_filter */
370 371
	sfilter = kzalloc(sizeof(*sfilter), GFP_KERNEL | __GFP_NOWARN);
	if (!sfilter)
372
		return ERR_PTR(-ENOMEM);
373 374

	ret = bpf_prog_create_from_user(&sfilter->prog, fprog,
375
					seccomp_check_filter, save_orig);
376 377 378
	if (ret < 0) {
		kfree(sfilter);
		return ERR_PTR(ret);
379
	}
380

381
	atomic_set(&sfilter->usage, 1);
382

383
	return sfilter;
384 385 386
}

/**
387
 * seccomp_prepare_user_filter - prepares a user-supplied sock_fprog
388 389 390 391
 * @user_filter: pointer to the user data containing a sock_fprog.
 *
 * Returns 0 on success and non-zero otherwise.
 */
392 393
static struct seccomp_filter *
seccomp_prepare_user_filter(const char __user *user_filter)
394 395
{
	struct sock_fprog fprog;
396
	struct seccomp_filter *filter = ERR_PTR(-EFAULT);
397 398

#ifdef CONFIG_COMPAT
399
	if (in_compat_syscall()) {
400 401 402 403 404 405 406 407 408
		struct compat_sock_fprog fprog32;
		if (copy_from_user(&fprog32, user_filter, sizeof(fprog32)))
			goto out;
		fprog.len = fprog32.len;
		fprog.filter = compat_ptr(fprog32.filter);
	} else /* falls through to the if below. */
#endif
	if (copy_from_user(&fprog, user_filter, sizeof(fprog)))
		goto out;
409
	filter = seccomp_prepare_filter(&fprog);
410
out:
411 412 413 414 415 416 417 418
	return filter;
}

/**
 * seccomp_attach_filter: validate and attach filter
 * @flags:  flags to change filter behavior
 * @filter: seccomp filter to add to the current process
 *
419 420
 * Caller must be holding current->sighand->siglock lock.
 *
421 422 423 424 425 426 427 428
 * Returns 0 on success, -ve on error.
 */
static long seccomp_attach_filter(unsigned int flags,
				  struct seccomp_filter *filter)
{
	unsigned long total_insns;
	struct seccomp_filter *walker;

429
	assert_spin_locked(&current->sighand->siglock);
430

431 432 433 434 435 436 437
	/* Validate resulting filter length. */
	total_insns = filter->prog->len;
	for (walker = current->seccomp.filter; walker; walker = walker->prev)
		total_insns += walker->prog->len + 4;  /* 4 instr penalty */
	if (total_insns > MAX_INSNS_PER_PATH)
		return -ENOMEM;

438 439 440 441 442 443 444 445 446
	/* If thread sync has been requested, check that it is possible. */
	if (flags & SECCOMP_FILTER_FLAG_TSYNC) {
		int ret;

		ret = seccomp_can_sync_threads();
		if (ret)
			return ret;
	}

447 448 449 450 451 452 453
	/*
	 * If there is an existing filter, make it the prev and don't drop its
	 * task reference.
	 */
	filter->prev = current->seccomp.filter;
	current->seccomp.filter = filter;

454 455 456 457
	/* Now that the new filter is in place, synchronize to all threads. */
	if (flags & SECCOMP_FILTER_FLAG_TSYNC)
		seccomp_sync_threads();

458
	return 0;
459 460 461 462 463 464 465 466 467 468 469 470
}

/* get_seccomp_filter - increments the reference count of the filter on @tsk */
void get_seccomp_filter(struct task_struct *tsk)
{
	struct seccomp_filter *orig = tsk->seccomp.filter;
	if (!orig)
		return;
	/* Reference count is bounded by the number of total processes. */
	atomic_inc(&orig->usage);
}

471 472 473
static inline void seccomp_filter_free(struct seccomp_filter *filter)
{
	if (filter) {
474
		bpf_prog_destroy(filter->prog);
475 476 477 478
		kfree(filter);
	}
}

479 480 481 482 483 484 485 486
/* put_seccomp_filter - decrements the ref count of tsk->seccomp.filter */
void put_seccomp_filter(struct task_struct *tsk)
{
	struct seccomp_filter *orig = tsk->seccomp.filter;
	/* Clean up single-reference branches iteratively. */
	while (orig && atomic_dec_and_test(&orig->usage)) {
		struct seccomp_filter *freeme = orig;
		orig = orig->prev;
487
		seccomp_filter_free(freeme);
488 489
	}
}
Will Drewry's avatar
Will Drewry committed
490

491 492 493 494 495 496 497 498 499 500 501
static void seccomp_init_siginfo(siginfo_t *info, int syscall, int reason)
{
	memset(info, 0, sizeof(*info));
	info->si_signo = SIGSYS;
	info->si_code = SYS_SECCOMP;
	info->si_call_addr = (void __user *)KSTK_EIP(current);
	info->si_errno = reason;
	info->si_arch = syscall_get_arch();
	info->si_syscall = syscall;
}

Will Drewry's avatar
Will Drewry committed
502 503 504 505 506 507 508 509 510 511
/**
 * seccomp_send_sigsys - signals the task to allow in-process syscall emulation
 * @syscall: syscall number to send to userland
 * @reason: filter-supplied reason code to send to userland (via si_errno)
 *
 * Forces a SIGSYS with a code of SYS_SECCOMP and related sigsys info.
 */
static void seccomp_send_sigsys(int syscall, int reason)
{
	struct siginfo info;
512
	seccomp_init_siginfo(&info, syscall, reason);
Will Drewry's avatar
Will Drewry committed
513 514
	force_sig_info(SIGSYS, &info, current);
}
515
#endif	/* CONFIG_SECCOMP_FILTER */
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518 519 520 521

/*
 * Secure computing mode 1 allows only read/write/exit/sigreturn.
 * To be fully secure this must be combined with rlimit
 * to limit the stack allocations too.
 */
522
static const int mode1_syscalls[] = {
Linus Torvalds's avatar
Linus Torvalds committed
523 524 525 526
	__NR_seccomp_read, __NR_seccomp_write, __NR_seccomp_exit, __NR_seccomp_sigreturn,
	0, /* null terminated */
};

527
static void __secure_computing_strict(int this_syscall)
Linus Torvalds's avatar
Linus Torvalds committed
528
{
529
	const int *syscall_whitelist = mode1_syscalls;
530
#ifdef CONFIG_COMPAT
531
	if (in_compat_syscall())
532
		syscall_whitelist = get_compat_mode1_syscalls();
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
#endif
	do {
		if (*syscall_whitelist == this_syscall)
			return;
	} while (*++syscall_whitelist);

#ifdef SECCOMP_DEBUG
	dump_stack();
#endif
	audit_seccomp(this_syscall, SIGKILL, SECCOMP_RET_KILL);
	do_exit(SIGKILL);
}

#ifndef CONFIG_HAVE_ARCH_SECCOMP_FILTER
void secure_computing_strict(int this_syscall)
{
	int mode = current->seccomp.mode;

551
	if (IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) &&
552 553 554
	    unlikely(current->ptrace & PT_SUSPEND_SECCOMP))
		return;

555
	if (mode == SECCOMP_MODE_DISABLED)
556 557 558 559 560 561 562
		return;
	else if (mode == SECCOMP_MODE_STRICT)
		__secure_computing_strict(this_syscall);
	else
		BUG();
}
#else
563 564

#ifdef CONFIG_SECCOMP_FILTER
565 566
static int __seccomp_filter(int this_syscall, const struct seccomp_data *sd,
			    const bool recheck_after_trace)
567 568 569
{
	u32 filter_ret, action;
	int data;
Linus Torvalds's avatar
Linus Torvalds committed
570

571 572 573 574 575 576
	/*
	 * Make sure that any changes to mode from another thread have
	 * been seen after TIF_SECCOMP was seen.
	 */
	rmb();

577
	filter_ret = seccomp_run_filters(sd);
578 579 580 581 582
	data = filter_ret & SECCOMP_RET_DATA;
	action = filter_ret & SECCOMP_RET_ACTION;

	switch (action) {
	case SECCOMP_RET_ERRNO:
583 584 585
		/* Set low-order bits as an errno, capped at MAX_ERRNO. */
		if (data > MAX_ERRNO)
			data = MAX_ERRNO;
586
		syscall_set_return_value(current, task_pt_regs(current),
587 588 589 590 591
					 -data, 0);
		goto skip;

	case SECCOMP_RET_TRAP:
		/* Show the handler the original registers. */
592
		syscall_rollback(current, task_pt_regs(current));
593 594 595 596 597
		/* Let the filter pass back 16 bits of data. */
		seccomp_send_sigsys(this_syscall, data);
		goto skip;

	case SECCOMP_RET_TRACE:
598 599 600 601
		/* We've been put in this state by the ptracer already. */
		if (recheck_after_trace)
			return 0;

Kees Cook's avatar
Kees Cook committed
602 603 604 605 606 607 608 609 610 611 612 613
		/* ENOSYS these calls if there is no tracer attached. */
		if (!ptrace_event_enabled(current, PTRACE_EVENT_SECCOMP)) {
			syscall_set_return_value(current,
						 task_pt_regs(current),
						 -ENOSYS, 0);
			goto skip;
		}

		/* Allow the BPF to provide the event message */
		ptrace_event(PTRACE_EVENT_SECCOMP, data);
		/*
		 * The delivery of a fatal signal during event
614 615 616 617 618 619 620
		 * notification may silently skip tracer notification,
		 * which could leave us with a potentially unmodified
		 * syscall that the tracer would have liked to have
		 * changed. Since the process is about to die, we just
		 * force the syscall to be skipped and let the signal
		 * kill the process and correctly handle any tracer exit
		 * notifications.
Kees Cook's avatar
Kees Cook committed
621 622
		 */
		if (fatal_signal_pending(current))
623
			goto skip;
Kees Cook's avatar
Kees Cook committed
624 625 626 627 628
		/* Check if the tracer forced the syscall to be skipped. */
		this_syscall = syscall_get_nr(current, task_pt_regs(current));
		if (this_syscall < 0)
			goto skip;

629 630 631 632 633 634 635 636 637
		/*
		 * Recheck the syscall, since it may have changed. This
		 * intentionally uses a NULL struct seccomp_data to force
		 * a reload of all registers. This does not goto skip since
		 * a skip would have already been reported.
		 */
		if (__seccomp_filter(this_syscall, NULL, true))
			return -1;

Kees Cook's avatar
Kees Cook committed
638
		return 0;
639 640

	case SECCOMP_RET_ALLOW:
Kees Cook's avatar
Kees Cook committed
641
		return 0;
642 643

	case SECCOMP_RET_KILL:
644 645
	default: {
		siginfo_t info;
646
		audit_seccomp(this_syscall, SIGSYS, action);
647 648 649 650 651 652 653 654
		/* Dump core only if this is the last remaining thread. */
		if (get_nr_threads(current) == 1) {
			/* Show the original registers in the dump. */
			syscall_rollback(current, task_pt_regs(current));
			/* Trigger a manual coredump since do_exit skips it. */
			seccomp_init_siginfo(&info, this_syscall, data);
			do_coredump(&info);
		}
655 656
		do_exit(SIGSYS);
	}
657
	}
658 659 660 661 662

	unreachable();

skip:
	audit_seccomp(this_syscall, 0, action);
Kees Cook's avatar
Kees Cook committed
663 664 665
	return -1;
}
#else
666 667
static int __seccomp_filter(int this_syscall, const struct seccomp_data *sd,
			    const bool recheck_after_trace)
Kees Cook's avatar
Kees Cook committed
668 669
{
	BUG();
670
}
Linus Torvalds's avatar
Linus Torvalds committed
671
#endif
672

Kees Cook's avatar
Kees Cook committed
673
int __secure_computing(const struct seccomp_data *sd)
674 675
{
	int mode = current->seccomp.mode;
Kees Cook's avatar
Kees Cook committed
676
	int this_syscall;
677

678
	if (IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) &&
679
	    unlikely(current->ptrace & PT_SUSPEND_SECCOMP))
Kees Cook's avatar
Kees Cook committed
680 681 682 683
		return 0;

	this_syscall = sd ? sd->nr :
		syscall_get_nr(current, task_pt_regs(current));
684

685
	switch (mode) {
686
	case SECCOMP_MODE_STRICT:
687
		__secure_computing_strict(this_syscall);  /* may call do_exit */
Kees Cook's avatar
Kees Cook committed
688
		return 0;
689
	case SECCOMP_MODE_FILTER:
690
		return __seccomp_filter(this_syscall, sd, false);
Linus Torvalds's avatar
Linus Torvalds committed
691 692 693
	default:
		BUG();
	}
694
}
695
#endif /* CONFIG_HAVE_ARCH_SECCOMP_FILTER */
696 697 698 699 700 701

long prctl_get_seccomp(void)
{
	return current->seccomp.mode;
}

702
/**
703
 * seccomp_set_mode_strict: internal function for setting strict seccomp
704 705 706 707 708
 *
 * Once current->seccomp.mode is non-zero, it may not be changed.
 *
 * Returns 0 on success or -EINVAL on failure.
 */
709
static long seccomp_set_mode_strict(void)
710
{
711
	const unsigned long seccomp_mode = SECCOMP_MODE_STRICT;
712
	long ret = -EINVAL;
713

714 715
	spin_lock_irq(&current->sighand->siglock);

716
	if (!seccomp_may_assign_mode(seccomp_mode))
717 718
		goto out;

719
#ifdef TIF_NOTSC
720
	disable_TSC();
721
#endif
722
	seccomp_assign_mode(current, seccomp_mode);
723 724 725
	ret = 0;

out:
726
	spin_unlock_irq(&current->sighand->siglock);
727 728 729 730

	return ret;
}

731
#ifdef CONFIG_SECCOMP_FILTER
732 733
/**
 * seccomp_set_mode_filter: internal function for setting seccomp filter
Kees Cook's avatar
Kees Cook committed
734
 * @flags:  flags to change filter behavior
735 736 737 738 739 740 741 742 743 744
 * @filter: struct sock_fprog containing filter
 *
 * This function may be called repeatedly to install additional filters.
 * Every filter successfully installed will be evaluated (in reverse order)
 * for each system call the task makes.
 *
 * Once current->seccomp.mode is non-zero, it may not be changed.
 *
 * Returns 0 on success or -EINVAL on failure.
 */
Kees Cook's avatar
Kees Cook committed
745 746
static long seccomp_set_mode_filter(unsigned int flags,
				    const char __user *filter)
747 748
{
	const unsigned long seccomp_mode = SECCOMP_MODE_FILTER;
749
	struct seccomp_filter *prepared = NULL;
750 751
	long ret = -EINVAL;

Kees Cook's avatar
Kees Cook committed
752
	/* Validate flags. */
753
	if (flags & ~SECCOMP_FILTER_FLAG_MASK)
754
		return -EINVAL;
Kees Cook's avatar
Kees Cook committed
755

756 757 758 759 760
	/* Prepare the new filter before holding any locks. */
	prepared = seccomp_prepare_user_filter(filter);
	if (IS_ERR(prepared))
		return PTR_ERR(prepared);

761 762 763 764 765 766 767 768
	/*
	 * Make sure we cannot change seccomp or nnp state via TSYNC
	 * while another thread is in the middle of calling exec.
	 */
	if (flags & SECCOMP_FILTER_FLAG_TSYNC &&
	    mutex_lock_killable(&current->signal->cred_guard_mutex))
		goto out_free;

769 770
	spin_lock_irq(&current->sighand->siglock);

771 772 773
	if (!seccomp_may_assign_mode(seccomp_mode))
		goto out;

774
	ret = seccomp_attach_filter(flags, prepared);
775
	if (ret)
776
		goto out;
777 778
	/* Do not free the successfully attached filter. */
	prepared = NULL;
779

780
	seccomp_assign_mode(current, seccomp_mode);
781
out:
782
	spin_unlock_irq(&current->sighand->siglock);
783 784 785
	if (flags & SECCOMP_FILTER_FLAG_TSYNC)
		mutex_unlock(&current->signal->cred_guard_mutex);
out_free:
786
	seccomp_filter_free(prepared);
787 788
	return ret;
}
789
#else
Kees Cook's avatar
Kees Cook committed
790 791
static inline long seccomp_set_mode_filter(unsigned int flags,
					   const char __user *filter)
792 793 794 795
{
	return -EINVAL;
}
#endif
796

Kees Cook's avatar
Kees Cook committed
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818
/* Common entry point for both prctl and syscall. */
static long do_seccomp(unsigned int op, unsigned int flags,
		       const char __user *uargs)
{
	switch (op) {
	case SECCOMP_SET_MODE_STRICT:
		if (flags != 0 || uargs != NULL)
			return -EINVAL;
		return seccomp_set_mode_strict();
	case SECCOMP_SET_MODE_FILTER:
		return seccomp_set_mode_filter(flags, uargs);
	default:
		return -EINVAL;
	}
}

SYSCALL_DEFINE3(seccomp, unsigned int, op, unsigned int, flags,
			 const char __user *, uargs)
{
	return do_seccomp(op, flags, uargs);
}

819 820 821 822 823 824 825 826 827
/**
 * prctl_set_seccomp: configures current->seccomp.mode
 * @seccomp_mode: requested mode to use
 * @filter: optional struct sock_fprog for use with SECCOMP_MODE_FILTER
 *
 * Returns 0 on success or -EINVAL on failure.
 */
long prctl_set_seccomp(unsigned long seccomp_mode, char __user *filter)
{
Kees Cook's avatar
Kees Cook committed
828 829 830
	unsigned int op;
	char __user *uargs;

831 832
	switch (seccomp_mode) {
	case SECCOMP_MODE_STRICT:
Kees Cook's avatar
Kees Cook committed
833 834 835 836 837 838 839 840
		op = SECCOMP_SET_MODE_STRICT;
		/*
		 * Setting strict mode through prctl always ignored filter,
		 * so make sure it is always NULL here to pass the internal
		 * check in do_seccomp().
		 */
		uargs = NULL;
		break;
841
	case SECCOMP_MODE_FILTER:
Kees Cook's avatar
Kees Cook committed
842 843 844
		op = SECCOMP_SET_MODE_FILTER;
		uargs = filter;
		break;
845 846 847
	default:
		return -EINVAL;
	}
Kees Cook's avatar
Kees Cook committed
848 849 850

	/* prctl interface doesn't have flags, so they are always zero. */
	return do_seccomp(op, 0, uargs);
851
}
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898

#if defined(CONFIG_SECCOMP_FILTER) && defined(CONFIG_CHECKPOINT_RESTORE)
long seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
			void __user *data)
{
	struct seccomp_filter *filter;
	struct sock_fprog_kern *fprog;
	long ret;
	unsigned long count = 0;

	if (!capable(CAP_SYS_ADMIN) ||
	    current->seccomp.mode != SECCOMP_MODE_DISABLED) {
		return -EACCES;
	}

	spin_lock_irq(&task->sighand->siglock);
	if (task->seccomp.mode != SECCOMP_MODE_FILTER) {
		ret = -EINVAL;
		goto out;
	}

	filter = task->seccomp.filter;
	while (filter) {
		filter = filter->prev;
		count++;
	}

	if (filter_off >= count) {
		ret = -ENOENT;
		goto out;
	}
	count -= filter_off;

	filter = task->seccomp.filter;
	while (filter && count > 1) {
		filter = filter->prev;
		count--;
	}

	if (WARN_ON(count != 1 || !filter)) {
		/* The filter tree shouldn't shrink while we're using it. */
		ret = -ENOENT;
		goto out;
	}

	fprog = filter->prog->orig_prog;
	if (!fprog) {
Mickaël Salaün's avatar
Mickaël Salaün committed
899
		/* This must be a new non-cBPF filter, since we save
900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
		 * every cBPF filter's orig_prog above when
		 * CONFIG_CHECKPOINT_RESTORE is enabled.
		 */
		ret = -EMEDIUMTYPE;
		goto out;
	}

	ret = fprog->len;
	if (!data)
		goto out;

	get_seccomp_filter(task);
	spin_unlock_irq(&task->sighand->siglock);

	if (copy_to_user(data, fprog->filter, bpf_classic_proglen(fprog)))
		ret = -EFAULT;

	put_seccomp_filter(task);
	return ret;

out:
	spin_unlock_irq(&task->sighand->siglock);
	return ret;
}
#endif