Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * AppArmor security module
4 : : *
5 : : * This file contains AppArmor LSM hooks.
6 : : *
7 : : * Copyright (C) 1998-2008 Novell/SUSE
8 : : * Copyright 2009-2010 Canonical Ltd.
9 : : */
10 : :
11 : : #include <linux/lsm_hooks.h>
12 : : #include <linux/moduleparam.h>
13 : : #include <linux/mm.h>
14 : : #include <linux/mman.h>
15 : : #include <linux/mount.h>
16 : : #include <linux/namei.h>
17 : : #include <linux/ptrace.h>
18 : : #include <linux/ctype.h>
19 : : #include <linux/sysctl.h>
20 : : #include <linux/audit.h>
21 : : #include <linux/user_namespace.h>
22 : : #include <linux/netfilter_ipv4.h>
23 : : #include <linux/netfilter_ipv6.h>
24 : : #include <net/sock.h>
25 : : #include <uapi/linux/mount.h>
26 : :
27 : : #include "include/apparmor.h"
28 : : #include "include/apparmorfs.h"
29 : : #include "include/audit.h"
30 : : #include "include/capability.h"
31 : : #include "include/cred.h"
32 : : #include "include/file.h"
33 : : #include "include/ipc.h"
34 : : #include "include/net.h"
35 : : #include "include/path.h"
36 : : #include "include/label.h"
37 : : #include "include/policy.h"
38 : : #include "include/policy_ns.h"
39 : : #include "include/procattr.h"
40 : : #include "include/mount.h"
41 : : #include "include/secid.h"
42 : :
43 : : /* Flag indicating whether initialization completed */
44 : : int apparmor_initialized;
45 : :
46 : : DEFINE_PER_CPU(struct aa_buffers, aa_buffers);
47 : :
48 : :
49 : : /*
50 : : * LSM hook functions
51 : : */
52 : :
53 : : /*
54 : : * put the associated labels
55 : : */
56 : 0 : static void apparmor_cred_free(struct cred *cred)
57 : : {
58 : : aa_put_label(cred_label(cred));
59 : : set_cred_label(cred, NULL);
60 : 0 : }
61 : :
62 : : /*
63 : : * allocate the apparmor part of blank credentials
64 : : */
65 : 0 : static int apparmor_cred_alloc_blank(struct cred *cred, gfp_t gfp)
66 : : {
67 : : set_cred_label(cred, NULL);
68 : 0 : return 0;
69 : : }
70 : :
71 : : /*
72 : : * prepare new cred label for modification by prepare_cred block
73 : : */
74 : 0 : static int apparmor_cred_prepare(struct cred *new, const struct cred *old,
75 : : gfp_t gfp)
76 : : {
77 : 0 : set_cred_label(new, aa_get_newest_label(cred_label(old)));
78 : 0 : return 0;
79 : : }
80 : :
81 : : /*
82 : : * transfer the apparmor data to a blank set of creds
83 : : */
84 : 0 : static void apparmor_cred_transfer(struct cred *new, const struct cred *old)
85 : : {
86 : 0 : set_cred_label(new, aa_get_newest_label(cred_label(old)));
87 : 0 : }
88 : :
89 : 0 : static void apparmor_task_free(struct task_struct *task)
90 : : {
91 : :
92 : 0 : aa_free_task_ctx(task_ctx(task));
93 : 0 : }
94 : :
95 : 0 : static int apparmor_task_alloc(struct task_struct *task,
96 : : unsigned long clone_flags)
97 : : {
98 : : struct aa_task_ctx *new = task_ctx(task);
99 : :
100 : 0 : aa_dup_task_ctx(new, task_ctx(current));
101 : :
102 : 0 : return 0;
103 : : }
104 : :
105 : 0 : static int apparmor_ptrace_access_check(struct task_struct *child,
106 : : unsigned int mode)
107 : : {
108 : : struct aa_label *tracer, *tracee;
109 : : int error;
110 : :
111 : 0 : tracer = __begin_current_label_crit_section();
112 : 0 : tracee = aa_get_task_label(child);
113 [ # # ]: 0 : error = aa_may_ptrace(tracer, tracee,
114 : 0 : (mode & PTRACE_MODE_READ) ? AA_PTRACE_READ
115 : : : AA_PTRACE_TRACE);
116 : : aa_put_label(tracee);
117 : 0 : __end_current_label_crit_section(tracer);
118 : :
119 : 0 : return error;
120 : : }
121 : :
122 : 0 : static int apparmor_ptrace_traceme(struct task_struct *parent)
123 : : {
124 : : struct aa_label *tracer, *tracee;
125 : : int error;
126 : :
127 : 0 : tracee = __begin_current_label_crit_section();
128 : 0 : tracer = aa_get_task_label(parent);
129 : 0 : error = aa_may_ptrace(tracer, tracee, AA_PTRACE_TRACE);
130 : : aa_put_label(tracer);
131 : 0 : __end_current_label_crit_section(tracee);
132 : :
133 : 0 : return error;
134 : : }
135 : :
136 : : /* Derived from security/commoncap.c:cap_capget */
137 : 0 : static int apparmor_capget(struct task_struct *target, kernel_cap_t *effective,
138 : : kernel_cap_t *inheritable, kernel_cap_t *permitted)
139 : : {
140 : : struct aa_label *label;
141 : : const struct cred *cred;
142 : :
143 : : rcu_read_lock();
144 : 0 : cred = __task_cred(target);
145 : : label = aa_get_newest_cred_label(cred);
146 : :
147 : : /*
148 : : * cap_capget is stacked ahead of this and will
149 : : * initialize effective and permitted.
150 : : */
151 [ # # ]: 0 : if (!unconfined(label)) {
152 : : struct aa_profile *profile;
153 : : struct label_it i;
154 : :
155 [ # # ]: 0 : label_for_each_confined(i, label, profile) {
156 [ # # # # ]: 0 : if (COMPLAIN_MODE(profile))
157 : 0 : continue;
158 : 0 : *effective = cap_intersect(*effective,
159 : : profile->caps.allow);
160 : 0 : *permitted = cap_intersect(*permitted,
161 : : profile->caps.allow);
162 : : }
163 : : }
164 : : rcu_read_unlock();
165 : : aa_put_label(label);
166 : :
167 : 0 : return 0;
168 : : }
169 : :
170 : 0 : static int apparmor_capable(const struct cred *cred, struct user_namespace *ns,
171 : : int cap, unsigned int opts)
172 : : {
173 : : struct aa_label *label;
174 : : int error = 0;
175 : :
176 : : label = aa_get_newest_cred_label(cred);
177 [ # # ]: 0 : if (!unconfined(label))
178 : 0 : error = aa_capable(label, cap, opts);
179 : : aa_put_label(label);
180 : :
181 : 0 : return error;
182 : : }
183 : :
184 : : /**
185 : : * common_perm - basic common permission check wrapper fn for paths
186 : : * @op: operation being checked
187 : : * @path: path to check permission of (NOT NULL)
188 : : * @mask: requested permissions mask
189 : : * @cond: conditional info for the permission request (NOT NULL)
190 : : *
191 : : * Returns: %0 else error code if error or permission denied
192 : : */
193 : 0 : static int common_perm(const char *op, const struct path *path, u32 mask,
194 : : struct path_cond *cond)
195 : : {
196 : : struct aa_label *label;
197 : : int error = 0;
198 : :
199 : 0 : label = __begin_current_label_crit_section();
200 [ # # ]: 0 : if (!unconfined(label))
201 : 0 : error = aa_path_perm(op, label, path, 0, mask, cond);
202 : 0 : __end_current_label_crit_section(label);
203 : :
204 : 0 : return error;
205 : : }
206 : :
207 : : /**
208 : : * common_perm_cond - common permission wrapper around inode cond
209 : : * @op: operation being checked
210 : : * @path: location to check (NOT NULL)
211 : : * @mask: requested permissions mask
212 : : *
213 : : * Returns: %0 else error code if error or permission denied
214 : : */
215 : 0 : static int common_perm_cond(const char *op, const struct path *path, u32 mask)
216 : : {
217 : 0 : struct path_cond cond = { d_backing_inode(path->dentry)->i_uid,
218 : 0 : d_backing_inode(path->dentry)->i_mode
219 : : };
220 : :
221 [ # # ]: 0 : if (!path_mediated_fs(path->dentry))
222 : : return 0;
223 : :
224 : 0 : return common_perm(op, path, mask, &cond);
225 : : }
226 : :
227 : : /**
228 : : * common_perm_dir_dentry - common permission wrapper when path is dir, dentry
229 : : * @op: operation being checked
230 : : * @dir: directory of the dentry (NOT NULL)
231 : : * @dentry: dentry to check (NOT NULL)
232 : : * @mask: requested permissions mask
233 : : * @cond: conditional info for the permission request (NOT NULL)
234 : : *
235 : : * Returns: %0 else error code if error or permission denied
236 : : */
237 : : static int common_perm_dir_dentry(const char *op, const struct path *dir,
238 : : struct dentry *dentry, u32 mask,
239 : : struct path_cond *cond)
240 : : {
241 : 0 : struct path path = { .mnt = dir->mnt, .dentry = dentry };
242 : :
243 : 0 : return common_perm(op, &path, mask, cond);
244 : : }
245 : :
246 : : /**
247 : : * common_perm_rm - common permission wrapper for operations doing rm
248 : : * @op: operation being checked
249 : : * @dir: directory that the dentry is in (NOT NULL)
250 : : * @dentry: dentry being rm'd (NOT NULL)
251 : : * @mask: requested permission mask
252 : : *
253 : : * Returns: %0 else error code if error or permission denied
254 : : */
255 : 0 : static int common_perm_rm(const char *op, const struct path *dir,
256 : : struct dentry *dentry, u32 mask)
257 : : {
258 : : struct inode *inode = d_backing_inode(dentry);
259 : 0 : struct path_cond cond = { };
260 : :
261 [ # # # # ]: 0 : if (!inode || !path_mediated_fs(dentry))
262 : : return 0;
263 : :
264 : 0 : cond.uid = inode->i_uid;
265 : 0 : cond.mode = inode->i_mode;
266 : :
267 : 0 : return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
268 : : }
269 : :
270 : : /**
271 : : * common_perm_create - common permission wrapper for operations doing create
272 : : * @op: operation being checked
273 : : * @dir: directory that dentry will be created in (NOT NULL)
274 : : * @dentry: dentry to create (NOT NULL)
275 : : * @mask: request permission mask
276 : : * @mode: created file mode
277 : : *
278 : : * Returns: %0 else error code if error or permission denied
279 : : */
280 : 0 : static int common_perm_create(const char *op, const struct path *dir,
281 : : struct dentry *dentry, u32 mask, umode_t mode)
282 : : {
283 : 0 : struct path_cond cond = { current_fsuid(), mode };
284 : :
285 [ # # ]: 0 : if (!path_mediated_fs(dir->dentry))
286 : : return 0;
287 : :
288 : 0 : return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
289 : : }
290 : :
291 : 0 : static int apparmor_path_unlink(const struct path *dir, struct dentry *dentry)
292 : : {
293 : 0 : return common_perm_rm(OP_UNLINK, dir, dentry, AA_MAY_DELETE);
294 : : }
295 : :
296 : 0 : static int apparmor_path_mkdir(const struct path *dir, struct dentry *dentry,
297 : : umode_t mode)
298 : : {
299 : 0 : return common_perm_create(OP_MKDIR, dir, dentry, AA_MAY_CREATE,
300 : : S_IFDIR);
301 : : }
302 : :
303 : 0 : static int apparmor_path_rmdir(const struct path *dir, struct dentry *dentry)
304 : : {
305 : 0 : return common_perm_rm(OP_RMDIR, dir, dentry, AA_MAY_DELETE);
306 : : }
307 : :
308 : 0 : static int apparmor_path_mknod(const struct path *dir, struct dentry *dentry,
309 : : umode_t mode, unsigned int dev)
310 : : {
311 : 0 : return common_perm_create(OP_MKNOD, dir, dentry, AA_MAY_CREATE, mode);
312 : : }
313 : :
314 : 0 : static int apparmor_path_truncate(const struct path *path)
315 : : {
316 : 0 : return common_perm_cond(OP_TRUNC, path, MAY_WRITE | AA_MAY_SETATTR);
317 : : }
318 : :
319 : 0 : static int apparmor_path_symlink(const struct path *dir, struct dentry *dentry,
320 : : const char *old_name)
321 : : {
322 : 0 : return common_perm_create(OP_SYMLINK, dir, dentry, AA_MAY_CREATE,
323 : : S_IFLNK);
324 : : }
325 : :
326 : 0 : static int apparmor_path_link(struct dentry *old_dentry, const struct path *new_dir,
327 : : struct dentry *new_dentry)
328 : : {
329 : : struct aa_label *label;
330 : : int error = 0;
331 : :
332 [ # # ]: 0 : if (!path_mediated_fs(old_dentry))
333 : : return 0;
334 : :
335 : 0 : label = begin_current_label_crit_section();
336 [ # # ]: 0 : if (!unconfined(label))
337 : 0 : error = aa_path_link(label, old_dentry, new_dir, new_dentry);
338 : 0 : end_current_label_crit_section(label);
339 : :
340 : 0 : return error;
341 : : }
342 : :
343 : 0 : static int apparmor_path_rename(const struct path *old_dir, struct dentry *old_dentry,
344 : : const struct path *new_dir, struct dentry *new_dentry)
345 : : {
346 : : struct aa_label *label;
347 : : int error = 0;
348 : :
349 [ # # ]: 0 : if (!path_mediated_fs(old_dentry))
350 : : return 0;
351 : :
352 : 0 : label = begin_current_label_crit_section();
353 [ # # ]: 0 : if (!unconfined(label)) {
354 : 0 : struct path old_path = { .mnt = old_dir->mnt,
355 : : .dentry = old_dentry };
356 : 0 : struct path new_path = { .mnt = new_dir->mnt,
357 : : .dentry = new_dentry };
358 : 0 : struct path_cond cond = { d_backing_inode(old_dentry)->i_uid,
359 : 0 : d_backing_inode(old_dentry)->i_mode
360 : : };
361 : :
362 : 0 : error = aa_path_perm(OP_RENAME_SRC, label, &old_path, 0,
363 : : MAY_READ | AA_MAY_GETATTR | MAY_WRITE |
364 : : AA_MAY_SETATTR | AA_MAY_DELETE,
365 : : &cond);
366 [ # # ]: 0 : if (!error)
367 : 0 : error = aa_path_perm(OP_RENAME_DEST, label, &new_path,
368 : : 0, MAY_WRITE | AA_MAY_SETATTR |
369 : : AA_MAY_CREATE, &cond);
370 : :
371 : : }
372 : 0 : end_current_label_crit_section(label);
373 : :
374 : 0 : return error;
375 : : }
376 : :
377 : 0 : static int apparmor_path_chmod(const struct path *path, umode_t mode)
378 : : {
379 : 0 : return common_perm_cond(OP_CHMOD, path, AA_MAY_CHMOD);
380 : : }
381 : :
382 : 0 : static int apparmor_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
383 : : {
384 : 0 : return common_perm_cond(OP_CHOWN, path, AA_MAY_CHOWN);
385 : : }
386 : :
387 : 0 : static int apparmor_inode_getattr(const struct path *path)
388 : : {
389 : 0 : return common_perm_cond(OP_GETATTR, path, AA_MAY_GETATTR);
390 : : }
391 : :
392 : 0 : static int apparmor_file_open(struct file *file)
393 : : {
394 : : struct aa_file_ctx *fctx = file_ctx(file);
395 : : struct aa_label *label;
396 : : int error = 0;
397 : :
398 [ # # ]: 0 : if (!path_mediated_fs(file->f_path.dentry))
399 : : return 0;
400 : :
401 : : /* If in exec, permission is handled by bprm hooks.
402 : : * Cache permissions granted by the previous exec check, with
403 : : * implicit read and executable mmap which are required to
404 : : * actually execute the image.
405 : : */
406 [ # # ]: 0 : if (current->in_execve) {
407 : 0 : fctx->allow = MAY_EXEC | MAY_READ | AA_EXEC_MMAP;
408 : 0 : return 0;
409 : : }
410 : :
411 : 0 : label = aa_get_newest_cred_label(file->f_cred);
412 [ # # ]: 0 : if (!unconfined(label)) {
413 : : struct inode *inode = file_inode(file);
414 : 0 : struct path_cond cond = { inode->i_uid, inode->i_mode };
415 : :
416 : 0 : error = aa_path_perm(OP_OPEN, label, &file->f_path, 0,
417 : : aa_map_file_to_perms(file), &cond);
418 : : /* todo cache full allowed permissions set and state */
419 : 0 : fctx->allow = aa_map_file_to_perms(file);
420 : : }
421 : : aa_put_label(label);
422 : :
423 : 0 : return error;
424 : : }
425 : :
426 : 0 : static int apparmor_file_alloc_security(struct file *file)
427 : : {
428 : : struct aa_file_ctx *ctx = file_ctx(file);
429 : 0 : struct aa_label *label = begin_current_label_crit_section();
430 : :
431 : 0 : spin_lock_init(&ctx->lock);
432 : 0 : rcu_assign_pointer(ctx->label, aa_get_label(label));
433 : 0 : end_current_label_crit_section(label);
434 : 0 : return 0;
435 : : }
436 : :
437 : 0 : static void apparmor_file_free_security(struct file *file)
438 : : {
439 : : struct aa_file_ctx *ctx = file_ctx(file);
440 : :
441 [ # # ]: 0 : if (ctx)
442 : 0 : aa_put_label(rcu_access_pointer(ctx->label));
443 : 0 : }
444 : :
445 : 0 : static int common_file_perm(const char *op, struct file *file, u32 mask)
446 : : {
447 : : struct aa_label *label;
448 : : int error = 0;
449 : :
450 : : /* don't reaudit files closed during inheritance */
451 [ # # ]: 0 : if (file->f_path.dentry == aa_null.dentry)
452 : : return -EACCES;
453 : :
454 : 0 : label = __begin_current_label_crit_section();
455 : 0 : error = aa_file_perm(op, label, file, mask);
456 : 0 : __end_current_label_crit_section(label);
457 : :
458 : 0 : return error;
459 : : }
460 : :
461 : 0 : static int apparmor_file_receive(struct file *file)
462 : : {
463 : 0 : return common_file_perm(OP_FRECEIVE, file, aa_map_file_to_perms(file));
464 : : }
465 : :
466 : 0 : static int apparmor_file_permission(struct file *file, int mask)
467 : : {
468 : 0 : return common_file_perm(OP_FPERM, file, mask);
469 : : }
470 : :
471 : 0 : static int apparmor_file_lock(struct file *file, unsigned int cmd)
472 : : {
473 : : u32 mask = AA_MAY_LOCK;
474 : :
475 [ # # ]: 0 : if (cmd == F_WRLCK)
476 : : mask |= MAY_WRITE;
477 : :
478 : 0 : return common_file_perm(OP_FLOCK, file, mask);
479 : : }
480 : :
481 : 0 : static int common_mmap(const char *op, struct file *file, unsigned long prot,
482 : : unsigned long flags)
483 : : {
484 : : int mask = 0;
485 : :
486 [ # # # # ]: 0 : if (!file || !file_ctx(file))
487 : : return 0;
488 : :
489 [ # # ]: 0 : if (prot & PROT_READ)
490 : : mask |= MAY_READ;
491 : : /*
492 : : * Private mappings don't require write perms since they don't
493 : : * write back to the files
494 : : */
495 [ # # # # ]: 0 : if ((prot & PROT_WRITE) && !(flags & MAP_PRIVATE))
496 : 0 : mask |= MAY_WRITE;
497 [ # # ]: 0 : if (prot & PROT_EXEC)
498 : 0 : mask |= AA_EXEC_MMAP;
499 : :
500 : 0 : return common_file_perm(op, file, mask);
501 : : }
502 : :
503 : 0 : static int apparmor_mmap_file(struct file *file, unsigned long reqprot,
504 : : unsigned long prot, unsigned long flags)
505 : : {
506 : 0 : return common_mmap(OP_FMMAP, file, prot, flags);
507 : : }
508 : :
509 : 0 : static int apparmor_file_mprotect(struct vm_area_struct *vma,
510 : : unsigned long reqprot, unsigned long prot)
511 : : {
512 [ # # ]: 0 : return common_mmap(OP_FMPROT, vma->vm_file, prot,
513 : 0 : !(vma->vm_flags & VM_SHARED) ? MAP_PRIVATE : 0);
514 : : }
515 : :
516 : 0 : static int apparmor_sb_mount(const char *dev_name, const struct path *path,
517 : : const char *type, unsigned long flags, void *data)
518 : : {
519 : : struct aa_label *label;
520 : : int error = 0;
521 : :
522 : : /* Discard magic */
523 [ # # ]: 0 : if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
524 : 0 : flags &= ~MS_MGC_MSK;
525 : :
526 : 0 : flags &= ~AA_MS_IGNORE_MASK;
527 : :
528 : 0 : label = __begin_current_label_crit_section();
529 [ # # ]: 0 : if (!unconfined(label)) {
530 [ # # ]: 0 : if (flags & MS_REMOUNT)
531 : 0 : error = aa_remount(label, path, flags, data);
532 [ # # ]: 0 : else if (flags & MS_BIND)
533 : 0 : error = aa_bind_mount(label, path, dev_name, flags);
534 [ # # ]: 0 : else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE |
535 : : MS_UNBINDABLE))
536 : 0 : error = aa_mount_change_type(label, path, flags);
537 [ # # ]: 0 : else if (flags & MS_MOVE)
538 : 0 : error = aa_move_mount(label, path, dev_name);
539 : : else
540 : 0 : error = aa_new_mount(label, dev_name, path, type,
541 : : flags, data);
542 : : }
543 : 0 : __end_current_label_crit_section(label);
544 : :
545 : 0 : return error;
546 : : }
547 : :
548 : 0 : static int apparmor_sb_umount(struct vfsmount *mnt, int flags)
549 : : {
550 : : struct aa_label *label;
551 : : int error = 0;
552 : :
553 : 0 : label = __begin_current_label_crit_section();
554 [ # # ]: 0 : if (!unconfined(label))
555 : 0 : error = aa_umount(label, mnt, flags);
556 : 0 : __end_current_label_crit_section(label);
557 : :
558 : 0 : return error;
559 : : }
560 : :
561 : 0 : static int apparmor_sb_pivotroot(const struct path *old_path,
562 : : const struct path *new_path)
563 : : {
564 : : struct aa_label *label;
565 : : int error = 0;
566 : :
567 : 0 : label = aa_get_current_label();
568 [ # # ]: 0 : if (!unconfined(label))
569 : 0 : error = aa_pivotroot(label, old_path, new_path);
570 : : aa_put_label(label);
571 : :
572 : 0 : return error;
573 : : }
574 : :
575 : 0 : static int apparmor_getprocattr(struct task_struct *task, char *name,
576 : : char **value)
577 : : {
578 : : int error = -ENOENT;
579 : : /* released below */
580 : 0 : const struct cred *cred = get_task_cred(task);
581 : 0 : struct aa_task_ctx *ctx = task_ctx(current);
582 : : struct aa_label *label = NULL;
583 : :
584 [ # # ]: 0 : if (strcmp(name, "current") == 0)
585 : 0 : label = aa_get_newest_label(cred_label(cred));
586 [ # # # # ]: 0 : else if (strcmp(name, "prev") == 0 && ctx->previous)
587 : 0 : label = aa_get_newest_label(ctx->previous);
588 [ # # # # ]: 0 : else if (strcmp(name, "exec") == 0 && ctx->onexec)
589 : 0 : label = aa_get_newest_label(ctx->onexec);
590 : : else
591 : : error = -EINVAL;
592 : :
593 [ # # ]: 0 : if (label)
594 : 0 : error = aa_getprocattr(label, value);
595 : :
596 : : aa_put_label(label);
597 : 0 : put_cred(cred);
598 : :
599 : 0 : return error;
600 : : }
601 : :
602 : 0 : static int apparmor_setprocattr(const char *name, void *value,
603 : : size_t size)
604 : : {
605 : 0 : char *command, *largs = NULL, *args = value;
606 : : size_t arg_size;
607 : : int error;
608 : 0 : DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_NONE, OP_SETPROCATTR);
609 : :
610 [ # # ]: 0 : if (size == 0)
611 : : return -EINVAL;
612 : :
613 : : /* AppArmor requires that the buffer must be null terminated atm */
614 [ # # ]: 0 : if (args[size - 1] != '\0') {
615 : : /* null terminate */
616 : 0 : largs = args = kmalloc(size + 1, GFP_KERNEL);
617 [ # # ]: 0 : if (!args)
618 : : return -ENOMEM;
619 : 0 : memcpy(args, value, size);
620 : 0 : args[size] = '\0';
621 : : }
622 : :
623 : : error = -EINVAL;
624 : 0 : args = strim(args);
625 : 0 : command = strsep(&args, " ");
626 [ # # ]: 0 : if (!args)
627 : : goto out;
628 : 0 : args = skip_spaces(args);
629 [ # # ]: 0 : if (!*args)
630 : : goto out;
631 : :
632 [ # # ]: 0 : arg_size = size - (args - (largs ? largs : (char *) value));
633 [ # # ]: 0 : if (strcmp(name, "current") == 0) {
634 [ # # ]: 0 : if (strcmp(command, "changehat") == 0) {
635 : 0 : error = aa_setprocattr_changehat(args, arg_size,
636 : : AA_CHANGE_NOFLAGS);
637 [ # # ]: 0 : } else if (strcmp(command, "permhat") == 0) {
638 : 0 : error = aa_setprocattr_changehat(args, arg_size,
639 : : AA_CHANGE_TEST);
640 [ # # ]: 0 : } else if (strcmp(command, "changeprofile") == 0) {
641 : 0 : error = aa_change_profile(args, AA_CHANGE_NOFLAGS);
642 [ # # ]: 0 : } else if (strcmp(command, "permprofile") == 0) {
643 : 0 : error = aa_change_profile(args, AA_CHANGE_TEST);
644 [ # # ]: 0 : } else if (strcmp(command, "stack") == 0) {
645 : 0 : error = aa_change_profile(args, AA_CHANGE_STACK);
646 : : } else
647 : : goto fail;
648 [ # # ]: 0 : } else if (strcmp(name, "exec") == 0) {
649 [ # # ]: 0 : if (strcmp(command, "exec") == 0)
650 : 0 : error = aa_change_profile(args, AA_CHANGE_ONEXEC);
651 [ # # ]: 0 : else if (strcmp(command, "stack") == 0)
652 : 0 : error = aa_change_profile(args, (AA_CHANGE_ONEXEC |
653 : : AA_CHANGE_STACK));
654 : : else
655 : : goto fail;
656 : : } else
657 : : /* only support the "current" and "exec" process attributes */
658 : : goto fail;
659 : :
660 [ # # ]: 0 : if (!error)
661 : 0 : error = size;
662 : : out:
663 : 0 : kfree(largs);
664 : 0 : return error;
665 : :
666 : : fail:
667 : 0 : aad(&sa)->label = begin_current_label_crit_section();
668 : 0 : aad(&sa)->info = name;
669 : 0 : aad(&sa)->error = error = -EINVAL;
670 : 0 : aa_audit_msg(AUDIT_APPARMOR_DENIED, &sa, NULL);
671 : 0 : end_current_label_crit_section(aad(&sa)->label);
672 : 0 : goto out;
673 : : }
674 : :
675 : : /**
676 : : * apparmor_bprm_committing_creds - do task cleanup on committing new creds
677 : : * @bprm: binprm for the exec (NOT NULL)
678 : : */
679 : 0 : static void apparmor_bprm_committing_creds(struct linux_binprm *bprm)
680 : : {
681 : : struct aa_label *label = aa_current_raw_label();
682 : 0 : struct aa_label *new_label = cred_label(bprm->cred);
683 : :
684 : : /* bail out if unconfined or not changing profile */
685 [ # # # # ]: 0 : if ((new_label->proxy == label->proxy) ||
686 : 0 : (unconfined(new_label)))
687 : 0 : return;
688 : :
689 : 0 : aa_inherit_files(bprm->cred, current->files);
690 : :
691 : 0 : current->pdeath_signal = 0;
692 : :
693 : : /* reset soft limits and set hard limits for the new label */
694 : 0 : __aa_transition_rlimits(label, new_label);
695 : : }
696 : :
697 : : /**
698 : : * apparmor_bprm_committed_cred - do cleanup after new creds committed
699 : : * @bprm: binprm for the exec (NOT NULL)
700 : : */
701 : 0 : static void apparmor_bprm_committed_creds(struct linux_binprm *bprm)
702 : : {
703 : : /* clear out temporary/transitional state from the context */
704 : 0 : aa_clear_task_ctx_trans(task_ctx(current));
705 : :
706 : 0 : return;
707 : : }
708 : :
709 : 0 : static void apparmor_task_getsecid(struct task_struct *p, u32 *secid)
710 : : {
711 : 0 : struct aa_label *label = aa_get_task_label(p);
712 : 0 : *secid = label->secid;
713 : : aa_put_label(label);
714 : 0 : }
715 : :
716 : 0 : static int apparmor_task_setrlimit(struct task_struct *task,
717 : : unsigned int resource, struct rlimit *new_rlim)
718 : : {
719 : 0 : struct aa_label *label = __begin_current_label_crit_section();
720 : : int error = 0;
721 : :
722 [ # # ]: 0 : if (!unconfined(label))
723 : 0 : error = aa_task_setrlimit(label, task, resource, new_rlim);
724 : 0 : __end_current_label_crit_section(label);
725 : :
726 : 0 : return error;
727 : : }
728 : :
729 : 0 : static int apparmor_task_kill(struct task_struct *target, struct kernel_siginfo *info,
730 : : int sig, const struct cred *cred)
731 : : {
732 : : struct aa_label *cl, *tl;
733 : : int error;
734 : :
735 [ # # ]: 0 : if (cred) {
736 : : /*
737 : : * Dealing with USB IO specific behavior
738 : : */
739 : : cl = aa_get_newest_cred_label(cred);
740 : 0 : tl = aa_get_task_label(target);
741 : 0 : error = aa_may_signal(cl, tl, sig);
742 : : aa_put_label(cl);
743 : : aa_put_label(tl);
744 : 0 : return error;
745 : : }
746 : :
747 : 0 : cl = __begin_current_label_crit_section();
748 : 0 : tl = aa_get_task_label(target);
749 : 0 : error = aa_may_signal(cl, tl, sig);
750 : : aa_put_label(tl);
751 : 0 : __end_current_label_crit_section(cl);
752 : :
753 : 0 : return error;
754 : : }
755 : :
756 : : /**
757 : : * apparmor_sk_alloc_security - allocate and attach the sk_security field
758 : : */
759 : 0 : static int apparmor_sk_alloc_security(struct sock *sk, int family, gfp_t flags)
760 : : {
761 : : struct aa_sk_ctx *ctx;
762 : :
763 : 0 : ctx = kzalloc(sizeof(*ctx), flags);
764 [ # # ]: 0 : if (!ctx)
765 : : return -ENOMEM;
766 : :
767 : 0 : SK_CTX(sk) = ctx;
768 : :
769 : 0 : return 0;
770 : : }
771 : :
772 : : /**
773 : : * apparmor_sk_free_security - free the sk_security field
774 : : */
775 : 0 : static void apparmor_sk_free_security(struct sock *sk)
776 : : {
777 : 0 : struct aa_sk_ctx *ctx = SK_CTX(sk);
778 : :
779 : 0 : SK_CTX(sk) = NULL;
780 : 0 : aa_put_label(ctx->label);
781 : 0 : aa_put_label(ctx->peer);
782 : 0 : kfree(ctx);
783 : 0 : }
784 : :
785 : : /**
786 : : * apparmor_clone_security - clone the sk_security field
787 : : */
788 : 0 : static void apparmor_sk_clone_security(const struct sock *sk,
789 : : struct sock *newsk)
790 : : {
791 : 0 : struct aa_sk_ctx *ctx = SK_CTX(sk);
792 : 0 : struct aa_sk_ctx *new = SK_CTX(newsk);
793 : :
794 [ # # ]: 0 : if (new->label)
795 : : aa_put_label(new->label);
796 : 0 : new->label = aa_get_label(ctx->label);
797 : :
798 [ # # ]: 0 : if (new->peer)
799 : : aa_put_label(new->peer);
800 : 0 : new->peer = aa_get_label(ctx->peer);
801 : 0 : }
802 : :
803 : : /**
804 : : * apparmor_socket_create - check perms before creating a new socket
805 : : */
806 : 0 : static int apparmor_socket_create(int family, int type, int protocol, int kern)
807 : : {
808 : : struct aa_label *label;
809 : : int error = 0;
810 : :
811 : : AA_BUG(in_interrupt());
812 : :
813 : 0 : label = begin_current_label_crit_section();
814 [ # # # # ]: 0 : if (!(kern || unconfined(label)))
815 : 0 : error = af_select(family,
816 : : create_perm(label, family, type, protocol),
817 : : aa_af_perm(label, OP_CREATE, AA_MAY_CREATE,
818 : : family, type, protocol));
819 : 0 : end_current_label_crit_section(label);
820 : :
821 : 0 : return error;
822 : : }
823 : :
824 : : /**
825 : : * apparmor_socket_post_create - setup the per-socket security struct
826 : : *
827 : : * Note:
828 : : * - kernel sockets currently labeled unconfined but we may want to
829 : : * move to a special kernel label
830 : : * - socket may not have sk here if created with sock_create_lite or
831 : : * sock_alloc. These should be accept cases which will be handled in
832 : : * sock_graft.
833 : : */
834 : 0 : static int apparmor_socket_post_create(struct socket *sock, int family,
835 : : int type, int protocol, int kern)
836 : : {
837 : : struct aa_label *label;
838 : :
839 [ # # ]: 0 : if (kern) {
840 : 0 : struct aa_ns *ns = aa_get_current_ns();
841 : :
842 : 0 : label = aa_get_label(ns_unconfined(ns));
843 : 0 : aa_put_ns(ns);
844 : : } else
845 : 0 : label = aa_get_current_label();
846 : :
847 [ # # ]: 0 : if (sock->sk) {
848 : 0 : struct aa_sk_ctx *ctx = SK_CTX(sock->sk);
849 : :
850 : 0 : aa_put_label(ctx->label);
851 : 0 : ctx->label = aa_get_label(label);
852 : : }
853 : : aa_put_label(label);
854 : :
855 : 0 : return 0;
856 : : }
857 : :
858 : : /**
859 : : * apparmor_socket_bind - check perms before bind addr to socket
860 : : */
861 : 0 : static int apparmor_socket_bind(struct socket *sock,
862 : : struct sockaddr *address, int addrlen)
863 : : {
864 : : AA_BUG(!sock);
865 : : AA_BUG(!sock->sk);
866 : : AA_BUG(!address);
867 : : AA_BUG(in_interrupt());
868 : :
869 : 0 : return af_select(sock->sk->sk_family,
870 : : bind_perm(sock, address, addrlen),
871 : : aa_sk_perm(OP_BIND, AA_MAY_BIND, sock->sk));
872 : : }
873 : :
874 : : /**
875 : : * apparmor_socket_connect - check perms before connecting @sock to @address
876 : : */
877 : 0 : static int apparmor_socket_connect(struct socket *sock,
878 : : struct sockaddr *address, int addrlen)
879 : : {
880 : : AA_BUG(!sock);
881 : : AA_BUG(!sock->sk);
882 : : AA_BUG(!address);
883 : : AA_BUG(in_interrupt());
884 : :
885 : 0 : return af_select(sock->sk->sk_family,
886 : : connect_perm(sock, address, addrlen),
887 : : aa_sk_perm(OP_CONNECT, AA_MAY_CONNECT, sock->sk));
888 : : }
889 : :
890 : : /**
891 : : * apparmor_socket_list - check perms before allowing listen
892 : : */
893 : 0 : static int apparmor_socket_listen(struct socket *sock, int backlog)
894 : : {
895 : : AA_BUG(!sock);
896 : : AA_BUG(!sock->sk);
897 : : AA_BUG(in_interrupt());
898 : :
899 : 0 : return af_select(sock->sk->sk_family,
900 : : listen_perm(sock, backlog),
901 : : aa_sk_perm(OP_LISTEN, AA_MAY_LISTEN, sock->sk));
902 : : }
903 : :
904 : : /**
905 : : * apparmor_socket_accept - check perms before accepting a new connection.
906 : : *
907 : : * Note: while @newsock is created and has some information, the accept
908 : : * has not been done.
909 : : */
910 : 0 : static int apparmor_socket_accept(struct socket *sock, struct socket *newsock)
911 : : {
912 : : AA_BUG(!sock);
913 : : AA_BUG(!sock->sk);
914 : : AA_BUG(!newsock);
915 : : AA_BUG(in_interrupt());
916 : :
917 : 0 : return af_select(sock->sk->sk_family,
918 : : accept_perm(sock, newsock),
919 : : aa_sk_perm(OP_ACCEPT, AA_MAY_ACCEPT, sock->sk));
920 : : }
921 : :
922 : : static int aa_sock_msg_perm(const char *op, u32 request, struct socket *sock,
923 : : struct msghdr *msg, int size)
924 : : {
925 : : AA_BUG(!sock);
926 : : AA_BUG(!sock->sk);
927 : : AA_BUG(!msg);
928 : : AA_BUG(in_interrupt());
929 : :
930 : 0 : return af_select(sock->sk->sk_family,
931 : : msg_perm(op, request, sock, msg, size),
932 : : aa_sk_perm(op, request, sock->sk));
933 : : }
934 : :
935 : : /**
936 : : * apparmor_socket_sendmsg - check perms before sending msg to another socket
937 : : */
938 : 0 : static int apparmor_socket_sendmsg(struct socket *sock,
939 : : struct msghdr *msg, int size)
940 : : {
941 : 0 : return aa_sock_msg_perm(OP_SENDMSG, AA_MAY_SEND, sock, msg, size);
942 : : }
943 : :
944 : : /**
945 : : * apparmor_socket_recvmsg - check perms before receiving a message
946 : : */
947 : 0 : static int apparmor_socket_recvmsg(struct socket *sock,
948 : : struct msghdr *msg, int size, int flags)
949 : : {
950 : 0 : return aa_sock_msg_perm(OP_RECVMSG, AA_MAY_RECEIVE, sock, msg, size);
951 : : }
952 : :
953 : : /* revaliation, get/set attr, shutdown */
954 : : static int aa_sock_perm(const char *op, u32 request, struct socket *sock)
955 : : {
956 : : AA_BUG(!sock);
957 : : AA_BUG(!sock->sk);
958 : : AA_BUG(in_interrupt());
959 : :
960 : 0 : return af_select(sock->sk->sk_family,
961 : : sock_perm(op, request, sock),
962 : : aa_sk_perm(op, request, sock->sk));
963 : : }
964 : :
965 : : /**
966 : : * apparmor_socket_getsockname - check perms before getting the local address
967 : : */
968 : 0 : static int apparmor_socket_getsockname(struct socket *sock)
969 : : {
970 : 0 : return aa_sock_perm(OP_GETSOCKNAME, AA_MAY_GETATTR, sock);
971 : : }
972 : :
973 : : /**
974 : : * apparmor_socket_getpeername - check perms before getting remote address
975 : : */
976 : 0 : static int apparmor_socket_getpeername(struct socket *sock)
977 : : {
978 : 0 : return aa_sock_perm(OP_GETPEERNAME, AA_MAY_GETATTR, sock);
979 : : }
980 : :
981 : : /* revaliation, get/set attr, opt */
982 : : static int aa_sock_opt_perm(const char *op, u32 request, struct socket *sock,
983 : : int level, int optname)
984 : : {
985 : : AA_BUG(!sock);
986 : : AA_BUG(!sock->sk);
987 : : AA_BUG(in_interrupt());
988 : :
989 : 0 : return af_select(sock->sk->sk_family,
990 : : opt_perm(op, request, sock, level, optname),
991 : : aa_sk_perm(op, request, sock->sk));
992 : : }
993 : :
994 : : /**
995 : : * apparmor_getsockopt - check perms before getting socket options
996 : : */
997 : 0 : static int apparmor_socket_getsockopt(struct socket *sock, int level,
998 : : int optname)
999 : : {
1000 : 0 : return aa_sock_opt_perm(OP_GETSOCKOPT, AA_MAY_GETOPT, sock,
1001 : : level, optname);
1002 : : }
1003 : :
1004 : : /**
1005 : : * apparmor_setsockopt - check perms before setting socket options
1006 : : */
1007 : 0 : static int apparmor_socket_setsockopt(struct socket *sock, int level,
1008 : : int optname)
1009 : : {
1010 : 0 : return aa_sock_opt_perm(OP_SETSOCKOPT, AA_MAY_SETOPT, sock,
1011 : : level, optname);
1012 : : }
1013 : :
1014 : : /**
1015 : : * apparmor_socket_shutdown - check perms before shutting down @sock conn
1016 : : */
1017 : 0 : static int apparmor_socket_shutdown(struct socket *sock, int how)
1018 : : {
1019 : 0 : return aa_sock_perm(OP_SHUTDOWN, AA_MAY_SHUTDOWN, sock);
1020 : : }
1021 : :
1022 : : #ifdef CONFIG_NETWORK_SECMARK
1023 : : /**
1024 : : * apparmor_socket_sock_recv_skb - check perms before associating skb to sk
1025 : : *
1026 : : * Note: can not sleep may be called with locks held
1027 : : *
1028 : : * dont want protocol specific in __skb_recv_datagram()
1029 : : * to deny an incoming connection socket_sock_rcv_skb()
1030 : : */
1031 : : static int apparmor_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
1032 : : {
1033 : : struct aa_sk_ctx *ctx = SK_CTX(sk);
1034 : :
1035 : : if (!skb->secmark)
1036 : : return 0;
1037 : :
1038 : : return apparmor_secmark_check(ctx->label, OP_RECVMSG, AA_MAY_RECEIVE,
1039 : : skb->secmark, sk);
1040 : : }
1041 : : #endif
1042 : :
1043 : :
1044 : : static struct aa_label *sk_peer_label(struct sock *sk)
1045 : : {
1046 : 0 : struct aa_sk_ctx *ctx = SK_CTX(sk);
1047 : :
1048 [ # # ]: 0 : if (ctx->peer)
1049 : : return ctx->peer;
1050 : :
1051 : : return ERR_PTR(-ENOPROTOOPT);
1052 : : }
1053 : :
1054 : : /**
1055 : : * apparmor_socket_getpeersec_stream - get security context of peer
1056 : : *
1057 : : * Note: for tcp only valid if using ipsec or cipso on lan
1058 : : */
1059 : 0 : static int apparmor_socket_getpeersec_stream(struct socket *sock,
1060 : : char __user *optval,
1061 : : int __user *optlen,
1062 : : unsigned int len)
1063 : : {
1064 : : char *name;
1065 : : int slen, error = 0;
1066 : : struct aa_label *label;
1067 : : struct aa_label *peer;
1068 : :
1069 : 0 : label = begin_current_label_crit_section();
1070 : 0 : peer = sk_peer_label(sock->sk);
1071 [ # # ]: 0 : if (IS_ERR(peer)) {
1072 : : error = PTR_ERR(peer);
1073 : 0 : goto done;
1074 : : }
1075 : 0 : slen = aa_label_asxprint(&name, labels_ns(label), peer,
1076 : : FLAG_SHOW_MODE | FLAG_VIEW_SUBNS |
1077 : : FLAG_HIDDEN_UNCONFINED, GFP_KERNEL);
1078 : : /* don't include terminating \0 in slen, it breaks some apps */
1079 [ # # ]: 0 : if (slen < 0) {
1080 : : error = -ENOMEM;
1081 : : } else {
1082 [ # # ]: 0 : if (slen > len) {
1083 : : error = -ERANGE;
1084 [ # # ]: 0 : } else if (copy_to_user(optval, name, slen)) {
1085 : : error = -EFAULT;
1086 : : goto out;
1087 : : }
1088 [ # # ]: 0 : if (put_user(slen, optlen))
1089 : : error = -EFAULT;
1090 : : out:
1091 : 0 : kfree(name);
1092 : :
1093 : : }
1094 : :
1095 : : done:
1096 : 0 : end_current_label_crit_section(label);
1097 : :
1098 : 0 : return error;
1099 : : }
1100 : :
1101 : : /**
1102 : : * apparmor_socket_getpeersec_dgram - get security label of packet
1103 : : * @sock: the peer socket
1104 : : * @skb: packet data
1105 : : * @secid: pointer to where to put the secid of the packet
1106 : : *
1107 : : * Sets the netlabel socket state on sk from parent
1108 : : */
1109 : 0 : static int apparmor_socket_getpeersec_dgram(struct socket *sock,
1110 : : struct sk_buff *skb, u32 *secid)
1111 : :
1112 : : {
1113 : : /* TODO: requires secid support */
1114 : 0 : return -ENOPROTOOPT;
1115 : : }
1116 : :
1117 : : /**
1118 : : * apparmor_sock_graft - Initialize newly created socket
1119 : : * @sk: child sock
1120 : : * @parent: parent socket
1121 : : *
1122 : : * Note: could set off of SOCK_CTX(parent) but need to track inode and we can
1123 : : * just set sk security information off of current creating process label
1124 : : * Labeling of sk for accept case - probably should be sock based
1125 : : * instead of task, because of the case where an implicitly labeled
1126 : : * socket is shared by different tasks.
1127 : : */
1128 : 0 : static void apparmor_sock_graft(struct sock *sk, struct socket *parent)
1129 : : {
1130 : 0 : struct aa_sk_ctx *ctx = SK_CTX(sk);
1131 : :
1132 [ # # ]: 0 : if (!ctx->label)
1133 : 0 : ctx->label = aa_get_current_label();
1134 : 0 : }
1135 : :
1136 : : #ifdef CONFIG_NETWORK_SECMARK
1137 : : static int apparmor_inet_conn_request(struct sock *sk, struct sk_buff *skb,
1138 : : struct request_sock *req)
1139 : : {
1140 : : struct aa_sk_ctx *ctx = SK_CTX(sk);
1141 : :
1142 : : if (!skb->secmark)
1143 : : return 0;
1144 : :
1145 : : return apparmor_secmark_check(ctx->label, OP_CONNECT, AA_MAY_CONNECT,
1146 : : skb->secmark, sk);
1147 : : }
1148 : : #endif
1149 : :
1150 : : /*
1151 : : * The cred blob is a pointer to, not an instance of, an aa_task_ctx.
1152 : : */
1153 : : struct lsm_blob_sizes apparmor_blob_sizes __lsm_ro_after_init = {
1154 : : .lbs_cred = sizeof(struct aa_task_ctx *),
1155 : : .lbs_file = sizeof(struct aa_file_ctx),
1156 : : .lbs_task = sizeof(struct aa_task_ctx),
1157 : : };
1158 : :
1159 : : static struct security_hook_list apparmor_hooks[] __lsm_ro_after_init = {
1160 : : LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),
1161 : : LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),
1162 : : LSM_HOOK_INIT(capget, apparmor_capget),
1163 : : LSM_HOOK_INIT(capable, apparmor_capable),
1164 : :
1165 : : LSM_HOOK_INIT(sb_mount, apparmor_sb_mount),
1166 : : LSM_HOOK_INIT(sb_umount, apparmor_sb_umount),
1167 : : LSM_HOOK_INIT(sb_pivotroot, apparmor_sb_pivotroot),
1168 : :
1169 : : LSM_HOOK_INIT(path_link, apparmor_path_link),
1170 : : LSM_HOOK_INIT(path_unlink, apparmor_path_unlink),
1171 : : LSM_HOOK_INIT(path_symlink, apparmor_path_symlink),
1172 : : LSM_HOOK_INIT(path_mkdir, apparmor_path_mkdir),
1173 : : LSM_HOOK_INIT(path_rmdir, apparmor_path_rmdir),
1174 : : LSM_HOOK_INIT(path_mknod, apparmor_path_mknod),
1175 : : LSM_HOOK_INIT(path_rename, apparmor_path_rename),
1176 : : LSM_HOOK_INIT(path_chmod, apparmor_path_chmod),
1177 : : LSM_HOOK_INIT(path_chown, apparmor_path_chown),
1178 : : LSM_HOOK_INIT(path_truncate, apparmor_path_truncate),
1179 : : LSM_HOOK_INIT(inode_getattr, apparmor_inode_getattr),
1180 : :
1181 : : LSM_HOOK_INIT(file_open, apparmor_file_open),
1182 : : LSM_HOOK_INIT(file_receive, apparmor_file_receive),
1183 : : LSM_HOOK_INIT(file_permission, apparmor_file_permission),
1184 : : LSM_HOOK_INIT(file_alloc_security, apparmor_file_alloc_security),
1185 : : LSM_HOOK_INIT(file_free_security, apparmor_file_free_security),
1186 : : LSM_HOOK_INIT(mmap_file, apparmor_mmap_file),
1187 : : LSM_HOOK_INIT(file_mprotect, apparmor_file_mprotect),
1188 : : LSM_HOOK_INIT(file_lock, apparmor_file_lock),
1189 : :
1190 : : LSM_HOOK_INIT(getprocattr, apparmor_getprocattr),
1191 : : LSM_HOOK_INIT(setprocattr, apparmor_setprocattr),
1192 : :
1193 : : LSM_HOOK_INIT(sk_alloc_security, apparmor_sk_alloc_security),
1194 : : LSM_HOOK_INIT(sk_free_security, apparmor_sk_free_security),
1195 : : LSM_HOOK_INIT(sk_clone_security, apparmor_sk_clone_security),
1196 : :
1197 : : LSM_HOOK_INIT(socket_create, apparmor_socket_create),
1198 : : LSM_HOOK_INIT(socket_post_create, apparmor_socket_post_create),
1199 : : LSM_HOOK_INIT(socket_bind, apparmor_socket_bind),
1200 : : LSM_HOOK_INIT(socket_connect, apparmor_socket_connect),
1201 : : LSM_HOOK_INIT(socket_listen, apparmor_socket_listen),
1202 : : LSM_HOOK_INIT(socket_accept, apparmor_socket_accept),
1203 : : LSM_HOOK_INIT(socket_sendmsg, apparmor_socket_sendmsg),
1204 : : LSM_HOOK_INIT(socket_recvmsg, apparmor_socket_recvmsg),
1205 : : LSM_HOOK_INIT(socket_getsockname, apparmor_socket_getsockname),
1206 : : LSM_HOOK_INIT(socket_getpeername, apparmor_socket_getpeername),
1207 : : LSM_HOOK_INIT(socket_getsockopt, apparmor_socket_getsockopt),
1208 : : LSM_HOOK_INIT(socket_setsockopt, apparmor_socket_setsockopt),
1209 : : LSM_HOOK_INIT(socket_shutdown, apparmor_socket_shutdown),
1210 : : #ifdef CONFIG_NETWORK_SECMARK
1211 : : LSM_HOOK_INIT(socket_sock_rcv_skb, apparmor_socket_sock_rcv_skb),
1212 : : #endif
1213 : : LSM_HOOK_INIT(socket_getpeersec_stream,
1214 : : apparmor_socket_getpeersec_stream),
1215 : : LSM_HOOK_INIT(socket_getpeersec_dgram,
1216 : : apparmor_socket_getpeersec_dgram),
1217 : : LSM_HOOK_INIT(sock_graft, apparmor_sock_graft),
1218 : : #ifdef CONFIG_NETWORK_SECMARK
1219 : : LSM_HOOK_INIT(inet_conn_request, apparmor_inet_conn_request),
1220 : : #endif
1221 : :
1222 : : LSM_HOOK_INIT(cred_alloc_blank, apparmor_cred_alloc_blank),
1223 : : LSM_HOOK_INIT(cred_free, apparmor_cred_free),
1224 : : LSM_HOOK_INIT(cred_prepare, apparmor_cred_prepare),
1225 : : LSM_HOOK_INIT(cred_transfer, apparmor_cred_transfer),
1226 : :
1227 : : LSM_HOOK_INIT(bprm_set_creds, apparmor_bprm_set_creds),
1228 : : LSM_HOOK_INIT(bprm_committing_creds, apparmor_bprm_committing_creds),
1229 : : LSM_HOOK_INIT(bprm_committed_creds, apparmor_bprm_committed_creds),
1230 : :
1231 : : LSM_HOOK_INIT(task_free, apparmor_task_free),
1232 : : LSM_HOOK_INIT(task_alloc, apparmor_task_alloc),
1233 : : LSM_HOOK_INIT(task_getsecid, apparmor_task_getsecid),
1234 : : LSM_HOOK_INIT(task_setrlimit, apparmor_task_setrlimit),
1235 : : LSM_HOOK_INIT(task_kill, apparmor_task_kill),
1236 : :
1237 : : #ifdef CONFIG_AUDIT
1238 : : LSM_HOOK_INIT(audit_rule_init, aa_audit_rule_init),
1239 : : LSM_HOOK_INIT(audit_rule_known, aa_audit_rule_known),
1240 : : LSM_HOOK_INIT(audit_rule_match, aa_audit_rule_match),
1241 : : LSM_HOOK_INIT(audit_rule_free, aa_audit_rule_free),
1242 : : #endif
1243 : :
1244 : : LSM_HOOK_INIT(secid_to_secctx, apparmor_secid_to_secctx),
1245 : : LSM_HOOK_INIT(secctx_to_secid, apparmor_secctx_to_secid),
1246 : : LSM_HOOK_INIT(release_secctx, apparmor_release_secctx),
1247 : : };
1248 : :
1249 : : /*
1250 : : * AppArmor sysfs module parameters
1251 : : */
1252 : :
1253 : : static int param_set_aabool(const char *val, const struct kernel_param *kp);
1254 : : static int param_get_aabool(char *buffer, const struct kernel_param *kp);
1255 : : #define param_check_aabool param_check_bool
1256 : : static const struct kernel_param_ops param_ops_aabool = {
1257 : : .flags = KERNEL_PARAM_OPS_FL_NOARG,
1258 : : .set = param_set_aabool,
1259 : : .get = param_get_aabool
1260 : : };
1261 : :
1262 : : static int param_set_aauint(const char *val, const struct kernel_param *kp);
1263 : : static int param_get_aauint(char *buffer, const struct kernel_param *kp);
1264 : : #define param_check_aauint param_check_uint
1265 : : static const struct kernel_param_ops param_ops_aauint = {
1266 : : .set = param_set_aauint,
1267 : : .get = param_get_aauint
1268 : : };
1269 : :
1270 : : static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp);
1271 : : static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp);
1272 : : #define param_check_aalockpolicy param_check_bool
1273 : : static const struct kernel_param_ops param_ops_aalockpolicy = {
1274 : : .flags = KERNEL_PARAM_OPS_FL_NOARG,
1275 : : .set = param_set_aalockpolicy,
1276 : : .get = param_get_aalockpolicy
1277 : : };
1278 : :
1279 : : static int param_set_audit(const char *val, const struct kernel_param *kp);
1280 : : static int param_get_audit(char *buffer, const struct kernel_param *kp);
1281 : :
1282 : : static int param_set_mode(const char *val, const struct kernel_param *kp);
1283 : : static int param_get_mode(char *buffer, const struct kernel_param *kp);
1284 : :
1285 : : /* Flag values, also controllable via /sys/module/apparmor/parameters
1286 : : * We define special types as we want to do additional mediation.
1287 : : */
1288 : :
1289 : : /* AppArmor global enforcement switch - complain, enforce, kill */
1290 : : enum profile_mode aa_g_profile_mode = APPARMOR_ENFORCE;
1291 : : module_param_call(mode, param_set_mode, param_get_mode,
1292 : : &aa_g_profile_mode, S_IRUSR | S_IWUSR);
1293 : :
1294 : : /* whether policy verification hashing is enabled */
1295 : : bool aa_g_hash_policy = IS_ENABLED(CONFIG_SECURITY_APPARMOR_HASH_DEFAULT);
1296 : : #ifdef CONFIG_SECURITY_APPARMOR_HASH
1297 : : module_param_named(hash_policy, aa_g_hash_policy, aabool, S_IRUSR | S_IWUSR);
1298 : : #endif
1299 : :
1300 : : /* Debug mode */
1301 : : bool aa_g_debug = IS_ENABLED(CONFIG_SECURITY_APPARMOR_DEBUG_MESSAGES);
1302 : : module_param_named(debug, aa_g_debug, aabool, S_IRUSR | S_IWUSR);
1303 : :
1304 : : /* Audit mode */
1305 : : enum audit_mode aa_g_audit;
1306 : : module_param_call(audit, param_set_audit, param_get_audit,
1307 : : &aa_g_audit, S_IRUSR | S_IWUSR);
1308 : :
1309 : : /* Determines if audit header is included in audited messages. This
1310 : : * provides more context if the audit daemon is not running
1311 : : */
1312 : : bool aa_g_audit_header = true;
1313 : : module_param_named(audit_header, aa_g_audit_header, aabool,
1314 : : S_IRUSR | S_IWUSR);
1315 : :
1316 : : /* lock out loading/removal of policy
1317 : : * TODO: add in at boot loading of policy, which is the only way to
1318 : : * load policy, if lock_policy is set
1319 : : */
1320 : : bool aa_g_lock_policy;
1321 : : module_param_named(lock_policy, aa_g_lock_policy, aalockpolicy,
1322 : : S_IRUSR | S_IWUSR);
1323 : :
1324 : : /* Syscall logging mode */
1325 : : bool aa_g_logsyscall;
1326 : : module_param_named(logsyscall, aa_g_logsyscall, aabool, S_IRUSR | S_IWUSR);
1327 : :
1328 : : /* Maximum pathname length before accesses will start getting rejected */
1329 : : unsigned int aa_g_path_max = 2 * PATH_MAX;
1330 : : module_param_named(path_max, aa_g_path_max, aauint, S_IRUSR);
1331 : :
1332 : : /* Determines how paranoid loading of policy is and how much verification
1333 : : * on the loaded policy is done.
1334 : : * DEPRECATED: read only as strict checking of load is always done now
1335 : : * that none root users (user namespaces) can load policy.
1336 : : */
1337 : : bool aa_g_paranoid_load = true;
1338 : : module_param_named(paranoid_load, aa_g_paranoid_load, aabool, S_IRUGO);
1339 : :
1340 : : static int param_get_aaintbool(char *buffer, const struct kernel_param *kp);
1341 : : static int param_set_aaintbool(const char *val, const struct kernel_param *kp);
1342 : : #define param_check_aaintbool param_check_int
1343 : : static const struct kernel_param_ops param_ops_aaintbool = {
1344 : : .set = param_set_aaintbool,
1345 : : .get = param_get_aaintbool
1346 : : };
1347 : : /* Boot time disable flag */
1348 : : static int apparmor_enabled __lsm_ro_after_init = 1;
1349 : : module_param_named(enabled, apparmor_enabled, aaintbool, 0444);
1350 : :
1351 : 0 : static int __init apparmor_enabled_setup(char *str)
1352 : : {
1353 : : unsigned long enabled;
1354 : : int error = kstrtoul(str, 0, &enabled);
1355 [ # # ]: 0 : if (!error)
1356 : 0 : apparmor_enabled = enabled ? 1 : 0;
1357 : 0 : return 1;
1358 : : }
1359 : :
1360 : : __setup("apparmor=", apparmor_enabled_setup);
1361 : :
1362 : : /* set global flag turning off the ability to load policy */
1363 : 0 : static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp)
1364 : : {
1365 [ # # ]: 0 : if (!apparmor_enabled)
1366 : : return -EINVAL;
1367 [ # # # # ]: 0 : if (apparmor_initialized && !policy_admin_capable(NULL))
1368 : : return -EPERM;
1369 : 0 : return param_set_bool(val, kp);
1370 : : }
1371 : :
1372 : 0 : static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp)
1373 : : {
1374 [ # # ]: 0 : if (!apparmor_enabled)
1375 : : return -EINVAL;
1376 [ # # # # ]: 0 : if (apparmor_initialized && !policy_view_capable(NULL))
1377 : : return -EPERM;
1378 : 0 : return param_get_bool(buffer, kp);
1379 : : }
1380 : :
1381 : 0 : static int param_set_aabool(const char *val, const struct kernel_param *kp)
1382 : : {
1383 [ # # ]: 0 : if (!apparmor_enabled)
1384 : : return -EINVAL;
1385 [ # # # # ]: 0 : if (apparmor_initialized && !policy_admin_capable(NULL))
1386 : : return -EPERM;
1387 : 0 : return param_set_bool(val, kp);
1388 : : }
1389 : :
1390 : 0 : static int param_get_aabool(char *buffer, const struct kernel_param *kp)
1391 : : {
1392 [ # # ]: 0 : if (!apparmor_enabled)
1393 : : return -EINVAL;
1394 [ # # # # ]: 0 : if (apparmor_initialized && !policy_view_capable(NULL))
1395 : : return -EPERM;
1396 : 0 : return param_get_bool(buffer, kp);
1397 : : }
1398 : :
1399 : 0 : static int param_set_aauint(const char *val, const struct kernel_param *kp)
1400 : : {
1401 : : int error;
1402 : :
1403 [ # # ]: 0 : if (!apparmor_enabled)
1404 : : return -EINVAL;
1405 : : /* file is ro but enforce 2nd line check */
1406 [ # # ]: 0 : if (apparmor_initialized)
1407 : : return -EPERM;
1408 : :
1409 : 0 : error = param_set_uint(val, kp);
1410 : 0 : pr_info("AppArmor: buffer size set to %d bytes\n", aa_g_path_max);
1411 : :
1412 : 0 : return error;
1413 : : }
1414 : :
1415 : 0 : static int param_get_aauint(char *buffer, const struct kernel_param *kp)
1416 : : {
1417 [ # # ]: 0 : if (!apparmor_enabled)
1418 : : return -EINVAL;
1419 [ # # # # ]: 0 : if (apparmor_initialized && !policy_view_capable(NULL))
1420 : : return -EPERM;
1421 : 0 : return param_get_uint(buffer, kp);
1422 : : }
1423 : :
1424 : : /* Can only be set before AppArmor is initialized (i.e. on boot cmdline). */
1425 : 0 : static int param_set_aaintbool(const char *val, const struct kernel_param *kp)
1426 : : {
1427 : : struct kernel_param kp_local;
1428 : : bool value;
1429 : : int error;
1430 : :
1431 [ # # ]: 0 : if (apparmor_initialized)
1432 : : return -EPERM;
1433 : :
1434 : : /* Create local copy, with arg pointing to bool type. */
1435 : 0 : value = !!*((int *)kp->arg);
1436 : 0 : memcpy(&kp_local, kp, sizeof(kp_local));
1437 : 0 : kp_local.arg = &value;
1438 : :
1439 : 0 : error = param_set_bool(val, &kp_local);
1440 [ # # ]: 0 : if (!error)
1441 : 0 : *((int *)kp->arg) = *((bool *)kp_local.arg);
1442 : 0 : return error;
1443 : : }
1444 : :
1445 : : /*
1446 : : * To avoid changing /sys/module/apparmor/parameters/enabled from Y/N to
1447 : : * 1/0, this converts the "int that is actually bool" back to bool for
1448 : : * display in the /sys filesystem, while keeping it "int" for the LSM
1449 : : * infrastructure.
1450 : : */
1451 : 7846 : static int param_get_aaintbool(char *buffer, const struct kernel_param *kp)
1452 : : {
1453 : : struct kernel_param kp_local;
1454 : : bool value;
1455 : :
1456 : : /* Create local copy, with arg pointing to bool type. */
1457 : 7846 : value = !!*((int *)kp->arg);
1458 : 7846 : memcpy(&kp_local, kp, sizeof(kp_local));
1459 : 7846 : kp_local.arg = &value;
1460 : :
1461 : 7846 : return param_get_bool(buffer, &kp_local);
1462 : : }
1463 : :
1464 : 0 : static int param_get_audit(char *buffer, const struct kernel_param *kp)
1465 : : {
1466 [ # # ]: 0 : if (!apparmor_enabled)
1467 : : return -EINVAL;
1468 [ # # # # ]: 0 : if (apparmor_initialized && !policy_view_capable(NULL))
1469 : : return -EPERM;
1470 : 0 : return sprintf(buffer, "%s", audit_mode_names[aa_g_audit]);
1471 : : }
1472 : :
1473 : 0 : static int param_set_audit(const char *val, const struct kernel_param *kp)
1474 : : {
1475 : : int i;
1476 : :
1477 [ # # ]: 0 : if (!apparmor_enabled)
1478 : : return -EINVAL;
1479 [ # # ]: 0 : if (!val)
1480 : : return -EINVAL;
1481 [ # # # # ]: 0 : if (apparmor_initialized && !policy_admin_capable(NULL))
1482 : : return -EPERM;
1483 : :
1484 : 0 : i = match_string(audit_mode_names, AUDIT_MAX_INDEX, val);
1485 [ # # ]: 0 : if (i < 0)
1486 : : return -EINVAL;
1487 : :
1488 : 0 : aa_g_audit = i;
1489 : 0 : return 0;
1490 : : }
1491 : :
1492 : 0 : static int param_get_mode(char *buffer, const struct kernel_param *kp)
1493 : : {
1494 [ # # ]: 0 : if (!apparmor_enabled)
1495 : : return -EINVAL;
1496 [ # # # # ]: 0 : if (apparmor_initialized && !policy_view_capable(NULL))
1497 : : return -EPERM;
1498 : :
1499 : 0 : return sprintf(buffer, "%s", aa_profile_mode_names[aa_g_profile_mode]);
1500 : : }
1501 : :
1502 : 0 : static int param_set_mode(const char *val, const struct kernel_param *kp)
1503 : : {
1504 : : int i;
1505 : :
1506 [ # # ]: 0 : if (!apparmor_enabled)
1507 : : return -EINVAL;
1508 [ # # ]: 0 : if (!val)
1509 : : return -EINVAL;
1510 [ # # # # ]: 0 : if (apparmor_initialized && !policy_admin_capable(NULL))
1511 : : return -EPERM;
1512 : :
1513 : 0 : i = match_string(aa_profile_mode_names, APPARMOR_MODE_NAMES_MAX_INDEX,
1514 : : val);
1515 [ # # ]: 0 : if (i < 0)
1516 : : return -EINVAL;
1517 : :
1518 : 0 : aa_g_profile_mode = i;
1519 : 0 : return 0;
1520 : : }
1521 : :
1522 : : /*
1523 : : * AppArmor init functions
1524 : : */
1525 : :
1526 : : /**
1527 : : * set_init_ctx - set a task context and profile on the first task.
1528 : : *
1529 : : * TODO: allow setting an alternate profile than unconfined
1530 : : */
1531 : 0 : static int __init set_init_ctx(void)
1532 : : {
1533 : 0 : struct cred *cred = (struct cred *)current->real_cred;
1534 : :
1535 : 0 : set_cred_label(cred, aa_get_label(ns_unconfined(root_ns)));
1536 : :
1537 : 0 : return 0;
1538 : : }
1539 : :
1540 : 0 : static void destroy_buffers(void)
1541 : : {
1542 : : u32 i, j;
1543 : :
1544 [ # # ]: 0 : for_each_possible_cpu(i) {
1545 [ # # ]: 0 : for_each_cpu_buffer(j) {
1546 : 0 : kfree(per_cpu(aa_buffers, i).buf[j]);
1547 : 0 : per_cpu(aa_buffers, i).buf[j] = NULL;
1548 : : }
1549 : : }
1550 : 0 : }
1551 : :
1552 : 0 : static int __init alloc_buffers(void)
1553 : : {
1554 : : u32 i, j;
1555 : :
1556 [ # # ]: 0 : for_each_possible_cpu(i) {
1557 [ # # ]: 0 : for_each_cpu_buffer(j) {
1558 : : char *buffer;
1559 : :
1560 : : if (cpu_to_node(i) > num_online_nodes())
1561 : : /* fallback to kmalloc for offline nodes */
1562 : : buffer = kmalloc(aa_g_path_max, GFP_KERNEL);
1563 : : else
1564 : 0 : buffer = kmalloc_node(aa_g_path_max, GFP_KERNEL,
1565 : : cpu_to_node(i));
1566 [ # # ]: 0 : if (!buffer) {
1567 : 0 : destroy_buffers();
1568 : 0 : return -ENOMEM;
1569 : : }
1570 : 0 : per_cpu(aa_buffers, i).buf[j] = buffer;
1571 : : }
1572 : : }
1573 : :
1574 : : return 0;
1575 : : }
1576 : :
1577 : : #ifdef CONFIG_SYSCTL
1578 : 0 : static int apparmor_dointvec(struct ctl_table *table, int write,
1579 : : void __user *buffer, size_t *lenp, loff_t *ppos)
1580 : : {
1581 [ # # ]: 0 : if (!policy_admin_capable(NULL))
1582 : : return -EPERM;
1583 [ # # ]: 0 : if (!apparmor_enabled)
1584 : : return -EINVAL;
1585 : :
1586 : 0 : return proc_dointvec(table, write, buffer, lenp, ppos);
1587 : : }
1588 : :
1589 : : static struct ctl_path apparmor_sysctl_path[] = {
1590 : : { .procname = "kernel", },
1591 : : { }
1592 : : };
1593 : :
1594 : : static struct ctl_table apparmor_sysctl_table[] = {
1595 : : {
1596 : : .procname = "unprivileged_userns_apparmor_policy",
1597 : : .data = &unprivileged_userns_apparmor_policy,
1598 : : .maxlen = sizeof(int),
1599 : : .mode = 0600,
1600 : : .proc_handler = apparmor_dointvec,
1601 : : },
1602 : : { }
1603 : : };
1604 : :
1605 : 0 : static int __init apparmor_init_sysctl(void)
1606 : : {
1607 : 0 : return register_sysctl_paths(apparmor_sysctl_path,
1608 [ # # ]: 0 : apparmor_sysctl_table) ? 0 : -ENOMEM;
1609 : : }
1610 : : #else
1611 : : static inline int apparmor_init_sysctl(void)
1612 : : {
1613 : : return 0;
1614 : : }
1615 : : #endif /* CONFIG_SYSCTL */
1616 : :
1617 : : #if defined(CONFIG_NETFILTER) && defined(CONFIG_NETWORK_SECMARK)
1618 : : static unsigned int apparmor_ip_postroute(void *priv,
1619 : : struct sk_buff *skb,
1620 : : const struct nf_hook_state *state)
1621 : : {
1622 : : struct aa_sk_ctx *ctx;
1623 : : struct sock *sk;
1624 : :
1625 : : if (!skb->secmark)
1626 : : return NF_ACCEPT;
1627 : :
1628 : : sk = skb_to_full_sk(skb);
1629 : : if (sk == NULL)
1630 : : return NF_ACCEPT;
1631 : :
1632 : : ctx = SK_CTX(sk);
1633 : : if (!apparmor_secmark_check(ctx->label, OP_SENDMSG, AA_MAY_SEND,
1634 : : skb->secmark, sk))
1635 : : return NF_ACCEPT;
1636 : :
1637 : : return NF_DROP_ERR(-ECONNREFUSED);
1638 : :
1639 : : }
1640 : :
1641 : : static unsigned int apparmor_ipv4_postroute(void *priv,
1642 : : struct sk_buff *skb,
1643 : : const struct nf_hook_state *state)
1644 : : {
1645 : : return apparmor_ip_postroute(priv, skb, state);
1646 : : }
1647 : :
1648 : : #if IS_ENABLED(CONFIG_IPV6)
1649 : : static unsigned int apparmor_ipv6_postroute(void *priv,
1650 : : struct sk_buff *skb,
1651 : : const struct nf_hook_state *state)
1652 : : {
1653 : : return apparmor_ip_postroute(priv, skb, state);
1654 : : }
1655 : : #endif
1656 : :
1657 : : static const struct nf_hook_ops apparmor_nf_ops[] = {
1658 : : {
1659 : : .hook = apparmor_ipv4_postroute,
1660 : : .pf = NFPROTO_IPV4,
1661 : : .hooknum = NF_INET_POST_ROUTING,
1662 : : .priority = NF_IP_PRI_SELINUX_FIRST,
1663 : : },
1664 : : #if IS_ENABLED(CONFIG_IPV6)
1665 : : {
1666 : : .hook = apparmor_ipv6_postroute,
1667 : : .pf = NFPROTO_IPV6,
1668 : : .hooknum = NF_INET_POST_ROUTING,
1669 : : .priority = NF_IP6_PRI_SELINUX_FIRST,
1670 : : },
1671 : : #endif
1672 : : };
1673 : :
1674 : : static int __net_init apparmor_nf_register(struct net *net)
1675 : : {
1676 : : int ret;
1677 : :
1678 : : ret = nf_register_net_hooks(net, apparmor_nf_ops,
1679 : : ARRAY_SIZE(apparmor_nf_ops));
1680 : : return ret;
1681 : : }
1682 : :
1683 : : static void __net_exit apparmor_nf_unregister(struct net *net)
1684 : : {
1685 : : nf_unregister_net_hooks(net, apparmor_nf_ops,
1686 : : ARRAY_SIZE(apparmor_nf_ops));
1687 : : }
1688 : :
1689 : : static struct pernet_operations apparmor_net_ops = {
1690 : : .init = apparmor_nf_register,
1691 : : .exit = apparmor_nf_unregister,
1692 : : };
1693 : :
1694 : : static int __init apparmor_nf_ip_init(void)
1695 : : {
1696 : : int err;
1697 : :
1698 : : if (!apparmor_enabled)
1699 : : return 0;
1700 : :
1701 : : err = register_pernet_subsys(&apparmor_net_ops);
1702 : : if (err)
1703 : : panic("Apparmor: register_pernet_subsys: error %d\n", err);
1704 : :
1705 : : return 0;
1706 : : }
1707 : : __initcall(apparmor_nf_ip_init);
1708 : : #endif
1709 : :
1710 : 0 : static int __init apparmor_init(void)
1711 : : {
1712 : : int error;
1713 : :
1714 : 0 : aa_secids_init();
1715 : :
1716 : 0 : error = aa_setup_dfa_engine();
1717 [ # # ]: 0 : if (error) {
1718 [ # # ]: 0 : AA_ERROR("Unable to setup dfa engine\n");
1719 : : goto alloc_out;
1720 : : }
1721 : :
1722 : 0 : error = aa_alloc_root_ns();
1723 [ # # ]: 0 : if (error) {
1724 [ # # ]: 0 : AA_ERROR("Unable to allocate default profile namespace\n");
1725 : : goto alloc_out;
1726 : : }
1727 : :
1728 : 0 : error = apparmor_init_sysctl();
1729 [ # # ]: 0 : if (error) {
1730 [ # # ]: 0 : AA_ERROR("Unable to register sysctls\n");
1731 : : goto alloc_out;
1732 : :
1733 : : }
1734 : :
1735 : 0 : error = alloc_buffers();
1736 [ # # ]: 0 : if (error) {
1737 [ # # ]: 0 : AA_ERROR("Unable to allocate work buffers\n");
1738 : : goto buffers_out;
1739 : : }
1740 : :
1741 : 0 : error = set_init_ctx();
1742 [ # # ]: 0 : if (error) {
1743 [ # # ]: 0 : AA_ERROR("Failed to set context on init task\n");
1744 : 0 : aa_free_root_ns();
1745 : 0 : goto buffers_out;
1746 : : }
1747 : 0 : security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks),
1748 : : "apparmor");
1749 : :
1750 : : /* Report that AppArmor successfully initialized */
1751 : 0 : apparmor_initialized = 1;
1752 [ # # ]: 0 : if (aa_g_profile_mode == APPARMOR_COMPLAIN)
1753 : 0 : aa_info_message("AppArmor initialized: complain mode enabled");
1754 [ # # ]: 0 : else if (aa_g_profile_mode == APPARMOR_KILL)
1755 : 0 : aa_info_message("AppArmor initialized: kill mode enabled");
1756 : : else
1757 : 0 : aa_info_message("AppArmor initialized");
1758 : :
1759 : 0 : return error;
1760 : :
1761 : : buffers_out:
1762 : 0 : destroy_buffers();
1763 : :
1764 : : alloc_out:
1765 : 0 : aa_destroy_aafs();
1766 : 0 : aa_teardown_dfa_engine();
1767 : :
1768 : 0 : apparmor_enabled = false;
1769 : 0 : return error;
1770 : : }
1771 : :
1772 : : DEFINE_LSM(apparmor) = {
1773 : : .name = "apparmor",
1774 : : .flags = LSM_FLAG_LEGACY_MAJOR | LSM_FLAG_EXCLUSIVE,
1775 : : .enabled = &apparmor_enabled,
1776 : : .blobs = &apparmor_blob_sizes,
1777 : : .init = apparmor_init,
1778 : : };
|
