2 * AppArmor security module
4 * This file contains AppArmor /sys/kernel/security/apparmor interface functions
6 * Copyright (C) 1998-2008 Novell/SUSE
7 * Copyright 2009-2010 Canonical Ltd.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation, version 2 of the
15 #include <linux/ctype.h>
16 #include <linux/security.h>
17 #include <linux/vmalloc.h>
18 #include <linux/module.h>
19 #include <linux/seq_file.h>
20 #include <linux/uaccess.h>
21 #include <linux/namei.h>
22 #include <linux/capability.h>
23 #include <linux/rcupdate.h>
25 #include "include/apparmor.h"
26 #include "include/apparmorfs.h"
27 #include "include/audit.h"
28 #include "include/context.h"
29 #include "include/crypto.h"
30 #include "include/policy.h"
31 #include "include/policy_ns.h"
32 #include "include/resource.h"
35 * aa_mangle_name - mangle a profile name to std profile layout form
36 * @name: profile name to mangle (NOT NULL)
37 * @target: buffer to store mangled name, same length as @name (MAYBE NULL)
39 * Returns: length of mangled name
41 static int mangle_name(char *name, char *target)
45 while (*name == '/' || *name == '.')
49 for (; *name; name++) {
52 else if (isspace(*name))
54 else if (isalnum(*name) || strchr("._-", *name))
61 for (; *name; name++) {
62 if (isalnum(*name) || isspace(*name) ||
63 strchr("/._-", *name))
74 * aa_simple_write_to_buffer - common routine for getting policy from user
75 * @op: operation doing the user buffer copy
76 * @userbuf: user buffer to copy data from (NOT NULL)
77 * @alloc_size: size of user buffer (REQUIRES: @alloc_size >= @copy_size)
78 * @copy_size: size of data to copy from user buffer
79 * @pos: position write is at in the file (NOT NULL)
81 * Returns: kernel buffer containing copy of user buffer data or an
84 static char *aa_simple_write_to_buffer(int op, const char __user *userbuf,
85 size_t alloc_size, size_t copy_size,
90 BUG_ON(copy_size > alloc_size);
93 /* only writes from pos 0, that is complete writes */
94 return ERR_PTR(-ESPIPE);
97 * Don't allow profile load/replace/remove from profiles that don't
100 if (!aa_may_manage_policy(op))
101 return ERR_PTR(-EACCES);
103 /* freed by caller to simple_write_to_buffer */
104 data = kvmalloc(alloc_size);
106 return ERR_PTR(-ENOMEM);
108 if (copy_from_user(data, userbuf, copy_size)) {
110 return ERR_PTR(-EFAULT);
117 /* .load file hook fn to load policy */
118 static ssize_t profile_load(struct file *f, const char __user *buf, size_t size,
124 data = aa_simple_write_to_buffer(OP_PROF_LOAD, buf, size, size, pos);
126 error = PTR_ERR(data);
128 error = aa_replace_profiles(data, size, PROF_ADD);
135 static const struct file_operations aa_fs_profile_load = {
136 .write = profile_load,
137 .llseek = default_llseek,
140 /* .replace file hook fn to load and/or replace policy */
141 static ssize_t profile_replace(struct file *f, const char __user *buf,
142 size_t size, loff_t *pos)
147 data = aa_simple_write_to_buffer(OP_PROF_REPL, buf, size, size, pos);
148 error = PTR_ERR(data);
150 error = aa_replace_profiles(data, size, PROF_REPLACE);
157 static const struct file_operations aa_fs_profile_replace = {
158 .write = profile_replace,
159 .llseek = default_llseek,
162 /* .remove file hook fn to remove loaded policy */
163 static ssize_t profile_remove(struct file *f, const char __user *buf,
164 size_t size, loff_t *pos)
170 * aa_remove_profile needs a null terminated string so 1 extra
171 * byte is allocated and the copied data is null terminated.
173 data = aa_simple_write_to_buffer(OP_PROF_RM, buf, size + 1, size, pos);
175 error = PTR_ERR(data);
178 error = aa_remove_profiles(data, size);
185 static const struct file_operations aa_fs_profile_remove = {
186 .write = profile_remove,
187 .llseek = default_llseek,
190 static int aa_fs_seq_show(struct seq_file *seq, void *v)
192 struct aa_fs_entry *fs_file = seq->private;
197 switch (fs_file->v_type) {
198 case AA_FS_TYPE_BOOLEAN:
199 seq_printf(seq, "%s\n", fs_file->v.boolean ? "yes" : "no");
201 case AA_FS_TYPE_STRING:
202 seq_printf(seq, "%s\n", fs_file->v.string);
205 seq_printf(seq, "%#08lx\n", fs_file->v.u64);
208 /* Ignore unpritable entry types. */
215 static int aa_fs_seq_open(struct inode *inode, struct file *file)
217 return single_open(file, aa_fs_seq_show, inode->i_private);
220 const struct file_operations aa_fs_seq_file_ops = {
221 .owner = THIS_MODULE,
222 .open = aa_fs_seq_open,
225 .release = single_release,
228 static int aa_fs_seq_profile_open(struct inode *inode, struct file *file,
229 int (*show)(struct seq_file *, void *))
231 struct aa_proxy *proxy = aa_get_proxy(inode->i_private);
232 int error = single_open(file, show, proxy);
235 file->private_data = NULL;
242 static int aa_fs_seq_profile_release(struct inode *inode, struct file *file)
244 struct seq_file *seq = (struct seq_file *) file->private_data;
246 aa_put_proxy(seq->private);
247 return single_release(inode, file);
250 static int aa_fs_seq_profname_show(struct seq_file *seq, void *v)
252 struct aa_proxy *proxy = seq->private;
253 struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
254 seq_printf(seq, "%s\n", profile->base.name);
255 aa_put_profile(profile);
260 static int aa_fs_seq_profname_open(struct inode *inode, struct file *file)
262 return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profname_show);
265 static const struct file_operations aa_fs_profname_fops = {
266 .owner = THIS_MODULE,
267 .open = aa_fs_seq_profname_open,
270 .release = aa_fs_seq_profile_release,
273 static int aa_fs_seq_profmode_show(struct seq_file *seq, void *v)
275 struct aa_proxy *proxy = seq->private;
276 struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
277 seq_printf(seq, "%s\n", aa_profile_mode_names[profile->mode]);
278 aa_put_profile(profile);
283 static int aa_fs_seq_profmode_open(struct inode *inode, struct file *file)
285 return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profmode_show);
288 static const struct file_operations aa_fs_profmode_fops = {
289 .owner = THIS_MODULE,
290 .open = aa_fs_seq_profmode_open,
293 .release = aa_fs_seq_profile_release,
296 static int aa_fs_seq_profattach_show(struct seq_file *seq, void *v)
298 struct aa_proxy *proxy = seq->private;
299 struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
301 seq_printf(seq, "%s\n", profile->attach);
302 else if (profile->xmatch)
303 seq_puts(seq, "<unknown>\n");
305 seq_printf(seq, "%s\n", profile->base.name);
306 aa_put_profile(profile);
311 static int aa_fs_seq_profattach_open(struct inode *inode, struct file *file)
313 return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profattach_show);
316 static const struct file_operations aa_fs_profattach_fops = {
317 .owner = THIS_MODULE,
318 .open = aa_fs_seq_profattach_open,
321 .release = aa_fs_seq_profile_release,
324 static int aa_fs_seq_hash_show(struct seq_file *seq, void *v)
326 struct aa_proxy *proxy = seq->private;
327 struct aa_profile *profile = aa_get_profile_rcu(&proxy->profile);
328 unsigned int i, size = aa_hash_size();
331 for (i = 0; i < size; i++)
332 seq_printf(seq, "%.2x", profile->hash[i]);
335 aa_put_profile(profile);
340 static int aa_fs_seq_hash_open(struct inode *inode, struct file *file)
342 return single_open(file, aa_fs_seq_hash_show, inode->i_private);
345 static const struct file_operations aa_fs_seq_hash_fops = {
346 .owner = THIS_MODULE,
347 .open = aa_fs_seq_hash_open,
350 .release = single_release,
353 /** fns to setup dynamic per profile/namespace files **/
354 void __aa_fs_profile_rmdir(struct aa_profile *profile)
356 struct aa_profile *child;
362 list_for_each_entry(child, &profile->base.profiles, base.list)
363 __aa_fs_profile_rmdir(child);
365 for (i = AAFS_PROF_SIZEOF - 1; i >= 0; --i) {
366 struct aa_proxy *proxy;
367 if (!profile->dents[i])
370 proxy = d_inode(profile->dents[i])->i_private;
371 securityfs_remove(profile->dents[i]);
373 profile->dents[i] = NULL;
377 void __aa_fs_profile_migrate_dents(struct aa_profile *old,
378 struct aa_profile *new)
382 for (i = 0; i < AAFS_PROF_SIZEOF; i++) {
383 new->dents[i] = old->dents[i];
385 new->dents[i]->d_inode->i_mtime = current_time(new->dents[i]->d_inode);
386 old->dents[i] = NULL;
390 static struct dentry *create_profile_file(struct dentry *dir, const char *name,
391 struct aa_profile *profile,
392 const struct file_operations *fops)
394 struct aa_proxy *proxy = aa_get_proxy(profile->proxy);
397 dent = securityfs_create_file(name, S_IFREG | 0444, dir, proxy, fops);
404 /* requires lock be held */
405 int __aa_fs_profile_mkdir(struct aa_profile *profile, struct dentry *parent)
407 struct aa_profile *child;
408 struct dentry *dent = NULL, *dir;
412 struct aa_profile *p;
413 p = aa_deref_parent(profile);
415 /* adding to parent that previously didn't have children */
416 dent = securityfs_create_dir("profiles", dent);
419 prof_child_dir(p) = parent = dent;
422 if (!profile->dirname) {
424 len = mangle_name(profile->base.name, NULL);
425 id_len = snprintf(NULL, 0, ".%ld", profile->ns->uniq_id);
427 profile->dirname = kmalloc(len + id_len + 1, GFP_KERNEL);
428 if (!profile->dirname)
431 mangle_name(profile->base.name, profile->dirname);
432 sprintf(profile->dirname + len, ".%ld", profile->ns->uniq_id++);
435 dent = securityfs_create_dir(profile->dirname, parent);
438 prof_dir(profile) = dir = dent;
440 dent = create_profile_file(dir, "name", profile, &aa_fs_profname_fops);
443 profile->dents[AAFS_PROF_NAME] = dent;
445 dent = create_profile_file(dir, "mode", profile, &aa_fs_profmode_fops);
448 profile->dents[AAFS_PROF_MODE] = dent;
450 dent = create_profile_file(dir, "attach", profile,
451 &aa_fs_profattach_fops);
454 profile->dents[AAFS_PROF_ATTACH] = dent;
457 dent = create_profile_file(dir, "sha1", profile,
458 &aa_fs_seq_hash_fops);
461 profile->dents[AAFS_PROF_HASH] = dent;
464 list_for_each_entry(child, &profile->base.profiles, base.list) {
465 error = __aa_fs_profile_mkdir(child, prof_child_dir(profile));
473 error = PTR_ERR(dent);
476 __aa_fs_profile_rmdir(profile);
481 void __aa_fs_ns_rmdir(struct aa_ns *ns)
484 struct aa_profile *child;
490 list_for_each_entry(child, &ns->base.profiles, base.list)
491 __aa_fs_profile_rmdir(child);
493 list_for_each_entry(sub, &ns->sub_ns, base.list) {
494 mutex_lock(&sub->lock);
495 __aa_fs_ns_rmdir(sub);
496 mutex_unlock(&sub->lock);
499 for (i = AAFS_NS_SIZEOF - 1; i >= 0; --i) {
500 securityfs_remove(ns->dents[i]);
505 int __aa_fs_ns_mkdir(struct aa_ns *ns, struct dentry *parent, const char *name)
508 struct aa_profile *child;
509 struct dentry *dent, *dir;
513 name = ns->base.name;
515 dent = securityfs_create_dir(name, parent);
518 ns_dir(ns) = dir = dent;
520 dent = securityfs_create_dir("profiles", dir);
523 ns_subprofs_dir(ns) = dent;
525 dent = securityfs_create_dir("namespaces", dir);
528 ns_subns_dir(ns) = dent;
530 list_for_each_entry(child, &ns->base.profiles, base.list) {
531 error = __aa_fs_profile_mkdir(child, ns_subprofs_dir(ns));
536 list_for_each_entry(sub, &ns->sub_ns, base.list) {
537 mutex_lock(&sub->lock);
538 error = __aa_fs_ns_mkdir(sub, ns_subns_dir(ns), NULL);
539 mutex_unlock(&sub->lock);
547 error = PTR_ERR(dent);
550 __aa_fs_ns_rmdir(ns);
556 #define list_entry_is_head(pos, head, member) (&pos->member == (head))
559 * __next_ns - find the next namespace to list
560 * @root: root namespace to stop search at (NOT NULL)
561 * @ns: current ns position (NOT NULL)
563 * Find the next namespace from @ns under @root and handle all locking needed
564 * while switching current namespace.
566 * Returns: next namespace or NULL if at last namespace under @root
567 * Requires: ns->parent->lock to be held
568 * NOTE: will not unlock root->lock
570 static struct aa_ns *__next_ns(struct aa_ns *root, struct aa_ns *ns)
572 struct aa_ns *parent, *next;
574 /* is next namespace a child */
575 if (!list_empty(&ns->sub_ns)) {
576 next = list_first_entry(&ns->sub_ns, typeof(*ns), base.list);
577 mutex_lock(&next->lock);
581 /* check if the next ns is a sibling, parent, gp, .. */
584 mutex_unlock(&ns->lock);
585 next = list_next_entry(ns, base.list);
586 if (!list_entry_is_head(next, &parent->sub_ns, base.list)) {
587 mutex_lock(&next->lock);
591 parent = parent->parent;
598 * __first_profile - find the first profile in a namespace
599 * @root: namespace that is root of profiles being displayed (NOT NULL)
600 * @ns: namespace to start in (NOT NULL)
602 * Returns: unrefcounted profile or NULL if no profile
603 * Requires: profile->ns.lock to be held
605 static struct aa_profile *__first_profile(struct aa_ns *root,
608 for (; ns; ns = __next_ns(root, ns)) {
609 if (!list_empty(&ns->base.profiles))
610 return list_first_entry(&ns->base.profiles,
611 struct aa_profile, base.list);
617 * __next_profile - step to the next profile in a profile tree
618 * @profile: current profile in tree (NOT NULL)
620 * Perform a depth first traversal on the profile tree in a namespace
622 * Returns: next profile or NULL if done
623 * Requires: profile->ns.lock to be held
625 static struct aa_profile *__next_profile(struct aa_profile *p)
627 struct aa_profile *parent;
628 struct aa_ns *ns = p->ns;
630 /* is next profile a child */
631 if (!list_empty(&p->base.profiles))
632 return list_first_entry(&p->base.profiles, typeof(*p),
635 /* is next profile a sibling, parent sibling, gp, sibling, .. */
636 parent = rcu_dereference_protected(p->parent,
637 mutex_is_locked(&p->ns->lock));
639 p = list_next_entry(p, base.list);
640 if (!list_entry_is_head(p, &parent->base.profiles, base.list))
643 parent = rcu_dereference_protected(parent->parent,
644 mutex_is_locked(&parent->ns->lock));
647 /* is next another profile in the namespace */
648 p = list_next_entry(p, base.list);
649 if (!list_entry_is_head(p, &ns->base.profiles, base.list))
656 * next_profile - step to the next profile in where ever it may be
657 * @root: root namespace (NOT NULL)
658 * @profile: current profile (NOT NULL)
660 * Returns: next profile or NULL if there isn't one
662 static struct aa_profile *next_profile(struct aa_ns *root,
663 struct aa_profile *profile)
665 struct aa_profile *next = __next_profile(profile);
669 /* finished all profiles in namespace move to next namespace */
670 return __first_profile(root, __next_ns(root, profile->ns));
674 * p_start - start a depth first traversal of profile tree
675 * @f: seq_file to fill
676 * @pos: current position
678 * Returns: first profile under current namespace or NULL if none found
680 * acquires first ns->lock
682 static void *p_start(struct seq_file *f, loff_t *pos)
684 struct aa_profile *profile = NULL;
685 struct aa_ns *root = aa_current_profile()->ns;
687 f->private = aa_get_ns(root);
690 /* find the first profile */
691 mutex_lock(&root->lock);
692 profile = __first_profile(root, root);
694 /* skip to position */
695 for (; profile && l > 0; l--)
696 profile = next_profile(root, profile);
702 * p_next - read the next profile entry
703 * @f: seq_file to fill
704 * @p: profile previously returned
705 * @pos: current position
707 * Returns: next profile after @p or NULL if none
709 * may acquire/release locks in namespace tree as necessary
711 static void *p_next(struct seq_file *f, void *p, loff_t *pos)
713 struct aa_profile *profile = p;
714 struct aa_ns *ns = f->private;
717 return next_profile(ns, profile);
721 * p_stop - stop depth first traversal
722 * @f: seq_file we are filling
723 * @p: the last profile writen
725 * Release all locking done by p_start/p_next on namespace tree
727 static void p_stop(struct seq_file *f, void *p)
729 struct aa_profile *profile = p;
730 struct aa_ns *root = f->private, *ns;
733 for (ns = profile->ns; ns && ns != root; ns = ns->parent)
734 mutex_unlock(&ns->lock);
736 mutex_unlock(&root->lock);
741 * seq_show_profile - show a profile entry
742 * @f: seq_file to file
743 * @p: current position (profile) (NOT NULL)
745 * Returns: error on failure
747 static int seq_show_profile(struct seq_file *f, void *p)
749 struct aa_profile *profile = (struct aa_profile *)p;
750 struct aa_ns *root = f->private;
752 if (profile->ns != root)
753 seq_printf(f, ":%s://", aa_ns_name(root, profile->ns));
754 seq_printf(f, "%s (%s)\n", profile->base.hname,
755 aa_profile_mode_names[profile->mode]);
760 static const struct seq_operations aa_fs_profiles_op = {
764 .show = seq_show_profile,
767 static int profiles_open(struct inode *inode, struct file *file)
769 return seq_open(file, &aa_fs_profiles_op);
772 static int profiles_release(struct inode *inode, struct file *file)
774 return seq_release(inode, file);
777 static const struct file_operations aa_fs_profiles_fops = {
778 .open = profiles_open,
781 .release = profiles_release,
785 /** Base file system setup **/
786 static struct aa_fs_entry aa_fs_entry_file[] = {
787 AA_FS_FILE_STRING("mask", "create read write exec append mmap_exec " \
792 static struct aa_fs_entry aa_fs_entry_domain[] = {
793 AA_FS_FILE_BOOLEAN("change_hat", 1),
794 AA_FS_FILE_BOOLEAN("change_hatv", 1),
795 AA_FS_FILE_BOOLEAN("change_onexec", 1),
796 AA_FS_FILE_BOOLEAN("change_profile", 1),
800 static struct aa_fs_entry aa_fs_entry_policy[] = {
801 AA_FS_FILE_BOOLEAN("set_load", 1),
805 static struct aa_fs_entry aa_fs_entry_features[] = {
806 AA_FS_DIR("policy", aa_fs_entry_policy),
807 AA_FS_DIR("domain", aa_fs_entry_domain),
808 AA_FS_DIR("file", aa_fs_entry_file),
809 AA_FS_FILE_U64("capability", VFS_CAP_FLAGS_MASK),
810 AA_FS_DIR("rlimit", aa_fs_entry_rlimit),
811 AA_FS_DIR("caps", aa_fs_entry_caps),
815 static struct aa_fs_entry aa_fs_entry_apparmor[] = {
816 AA_FS_FILE_FOPS(".load", 0640, &aa_fs_profile_load),
817 AA_FS_FILE_FOPS(".replace", 0640, &aa_fs_profile_replace),
818 AA_FS_FILE_FOPS(".remove", 0640, &aa_fs_profile_remove),
819 AA_FS_FILE_FOPS("profiles", 0640, &aa_fs_profiles_fops),
820 AA_FS_DIR("features", aa_fs_entry_features),
824 static struct aa_fs_entry aa_fs_entry =
825 AA_FS_DIR("apparmor", aa_fs_entry_apparmor);
828 * aafs_create_file - create a file entry in the apparmor securityfs
829 * @fs_file: aa_fs_entry to build an entry for (NOT NULL)
830 * @parent: the parent dentry in the securityfs
832 * Use aafs_remove_file to remove entries created with this fn.
834 static int __init aafs_create_file(struct aa_fs_entry *fs_file,
835 struct dentry *parent)
839 fs_file->dentry = securityfs_create_file(fs_file->name,
840 S_IFREG | fs_file->mode,
843 if (IS_ERR(fs_file->dentry)) {
844 error = PTR_ERR(fs_file->dentry);
845 fs_file->dentry = NULL;
850 static void __init aafs_remove_dir(struct aa_fs_entry *fs_dir);
852 * aafs_create_dir - recursively create a directory entry in the securityfs
853 * @fs_dir: aa_fs_entry (and all child entries) to build (NOT NULL)
854 * @parent: the parent dentry in the securityfs
856 * Use aafs_remove_dir to remove entries created with this fn.
858 static int __init aafs_create_dir(struct aa_fs_entry *fs_dir,
859 struct dentry *parent)
861 struct aa_fs_entry *fs_file;
865 dir = securityfs_create_dir(fs_dir->name, parent);
868 fs_dir->dentry = dir;
870 for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) {
871 if (fs_file->v_type == AA_FS_TYPE_DIR)
872 error = aafs_create_dir(fs_file, fs_dir->dentry);
874 error = aafs_create_file(fs_file, fs_dir->dentry);
882 aafs_remove_dir(fs_dir);
888 * aafs_remove_file - drop a single file entry in the apparmor securityfs
889 * @fs_file: aa_fs_entry to detach from the securityfs (NOT NULL)
891 static void __init aafs_remove_file(struct aa_fs_entry *fs_file)
893 if (!fs_file->dentry)
896 securityfs_remove(fs_file->dentry);
897 fs_file->dentry = NULL;
901 * aafs_remove_dir - recursively drop a directory entry from the securityfs
902 * @fs_dir: aa_fs_entry (and all child entries) to detach (NOT NULL)
904 static void __init aafs_remove_dir(struct aa_fs_entry *fs_dir)
906 struct aa_fs_entry *fs_file;
908 for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) {
909 if (fs_file->v_type == AA_FS_TYPE_DIR)
910 aafs_remove_dir(fs_file);
912 aafs_remove_file(fs_file);
915 aafs_remove_file(fs_dir);
919 * aa_destroy_aafs - cleanup and free aafs
921 * releases dentries allocated by aa_create_aafs
923 void __init aa_destroy_aafs(void)
925 aafs_remove_dir(&aa_fs_entry);
929 * aa_create_aafs - create the apparmor security filesystem
931 * dentries created here are released by aa_destroy_aafs
933 * Returns: error on failure
935 static int __init aa_create_aafs(void)
939 if (!apparmor_initialized)
942 if (aa_fs_entry.dentry) {
943 AA_ERROR("%s: AppArmor securityfs already exists\n", __func__);
947 /* Populate fs tree. */
948 error = aafs_create_dir(&aa_fs_entry, NULL);
952 error = __aa_fs_ns_mkdir(root_ns, aa_fs_entry.dentry, "policy");
956 /* TODO: add support for apparmorfs_null and apparmorfs_mnt */
958 /* Report that AppArmor fs is enabled */
959 aa_info_message("AppArmor Filesystem Enabled");
964 AA_ERROR("Error creating AppArmor securityfs\n");
968 fs_initcall(aa_create_aafs);