1 /*
2 * AppArmor security module
3 *
4 * This file contains AppArmor policy definitions.
5 *
6 * Copyright (C) 1998-2008 Novell/SUSE
7 * Copyright 2009-2010 Canonical Ltd.
8 *
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
12 * License.
13 */
14
15 #ifndef __AA_POLICY_H
16 #define __AA_POLICY_H
17
18 #include <linux/capability.h>
19 #include <linux/cred.h>
20 #include <linux/kref.h>
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 #include <linux/socket.h>
24
25 #include "apparmor.h"
26 #include "audit.h"
27 #include "capability.h"
28 #include "domain.h"
29 #include "file.h"
30 #include "resource.h"
31
32 extern const char *const profile_mode_names[];
33 #define APPARMOR_NAMES_MAX_INDEX 3
34
35 #define COMPLAIN_MODE(_profile) \
36 ((aa_g_profile_mode == APPARMOR_COMPLAIN) || \
37 ((_profile)->mode == APPARMOR_COMPLAIN))
38
39 #define KILL_MODE(_profile) \
40 ((aa_g_profile_mode == APPARMOR_KILL) || \
41 ((_profile)->mode == APPARMOR_KILL))
42
43 #define PROFILE_IS_HAT(_profile) ((_profile)->flags & PFLAG_HAT)
44
45 /*
46 * FIXME: currently need a clean way to replace and remove profiles as a
47 * set. It should be done at the namespace level.
48 * Either, with a set of profiles loaded at the namespace level or via
49 * a mark and remove marked interface.
50 */
51 enum profile_mode {
52 APPARMOR_ENFORCE, /* enforce access rules */
53 APPARMOR_COMPLAIN, /* allow and log access violations */
54 APPARMOR_KILL, /* kill task on access violation */
55 };
56
57 enum profile_flags {
58 PFLAG_HAT = 1, /* profile is a hat */
59 PFLAG_UNCONFINED = 2, /* profile is an unconfined profile */
60 PFLAG_NULL = 4, /* profile is null learning profile */
61 PFLAG_IX_ON_NAME_ERROR = 8, /* fallback to ix on name lookup fail */
62 PFLAG_IMMUTABLE = 0x10, /* don't allow changes/replacement */
63 PFLAG_USER_DEFINED = 0x20, /* user based profile - lower privs */
64 PFLAG_NO_LIST_REF = 0x40, /* list doesn't keep profile ref */
65 PFLAG_OLD_NULL_TRANS = 0x100, /* use // as the null transition */
66
67 /* These flags must correspond with PATH_flags */
68 PFLAG_MEDIATE_DELETED = 0x10000, /* mediate instead delegate deleted */
69 };
70
71 struct aa_profile;
72
73 /* struct aa_policy - common part of both namespaces and profiles
74 * @name: name of the object
75 * @hname - The hierarchical name
76 * @count: reference count of the obj
77 * @list: list policy object is on
78 * @profiles: head of the profiles list contained in the object
79 */
80 struct aa_policy {
81 char *name;
82 char *hname;
83 struct kref count;
84 struct list_head list;
85 struct list_head profiles;
86 };
87
88 /* struct aa_ns_acct - accounting of profiles in namespace
89 * @max_size: maximum space allowed for all profiles in namespace
90 * @max_count: maximum number of profiles that can be in this namespace
91 * @size: current size of profiles
92 * @count: current count of profiles (includes null profiles)
93 */
94 struct aa_ns_acct {
95 int max_size;
96 int max_count;
97 int size;
98 int count;
99 };
100
101 /* struct aa_namespace - namespace for a set of profiles
102 * @base: common policy
103 * @parent: parent of namespace
104 * @lock: lock for modifying the object
105 * @acct: accounting for the namespace
106 * @unconfined: special unconfined profile for the namespace
107 * @sub_ns: list of namespaces under the current namespace.
108 *
109 * An aa_namespace defines the set profiles that are searched to determine
110 * which profile to attach to a task. Profiles can not be shared between
111 * aa_namespaces and profile names within a namespace are guaranteed to be
112 * unique. When profiles in separate namespaces have the same name they
113 * are NOT considered to be equivalent.
114 *
115 * Namespaces are hierarchical and only namespaces and profiles below the
116 * current namespace are visible.
117 *
118 * Namespace names must be unique and can not contain the characters :/\0
119 *
120 * FIXME TODO: add vserver support of namespaces (can it all be done in
121 * userspace?)
122 */
123 struct aa_namespace {
124 struct aa_policy base;
125 struct aa_namespace *parent;
126 rwlock_t lock;
127 struct aa_ns_acct acct;
128 struct aa_profile *unconfined;
129 struct list_head sub_ns;
130 };
131
132 /* struct aa_policydb - match engine for a policy
133 * dfa: dfa pattern match
134 * start: set of start states for the different classes of data
135 */
136 struct aa_policydb {
137 /* Generic policy DFA specific rule types will be subsections of it */
138 struct aa_dfa *dfa;
139 unsigned int start[AA_CLASS_LAST + 1];
140
141 };
142
143 /* struct aa_profile - basic confinement data
144 * @base - base components of the profile (name, refcount, lists, lock ...)
145 * @parent: parent of profile
146 * @ns: namespace the profile is in
147 * @replacedby: is set to the profile that replaced this profile
148 * @rename: optional profile name that this profile renamed
149 * @xmatch: optional extended matching for unconfined executables names
150 * @xmatch_len: xmatch prefix len, used to determine xmatch priority
151 * @sid: the unique security id number of this profile
152 * @audit: the auditing mode of the profile
153 * @mode: the enforcement mode of the profile
154 * @flags: flags controlling profile behavior
155 * @path_flags: flags controlling path generation behavior
156 * @size: the memory consumed by this profiles rules
157 * @policy: general match rules governing policy
158 * @file: The set of rules governing basic file access and domain transitions
159 * @caps: capabilities for the profile
160 * @rlimits: rlimits for the profile
161 *
162 * The AppArmor profile contains the basic confinement data. Each profile
163 * has a name, and exists in a namespace. The @name and @exec_match are
164 * used to determine profile attachment against unconfined tasks. All other
165 * attachments are determined by profile X transition rules.
166 *
167 * The @replacedby field is write protected by the profile lock. Reads
168 * are assumed to be atomic, and are done without locking.
169 *
170 * Profiles have a hierarchy where hats and children profiles keep
171 * a reference to their parent.
172 *
173 * Profile names can not begin with a : and can not contain the \0
174 * character. If a profile name begins with / it will be considered when
175 * determining profile attachment on "unconfined" tasks.
176 */
177 struct aa_profile {
178 struct aa_policy base;
179 struct aa_profile *parent;
180
181 struct aa_namespace *ns;
182 struct aa_profile *replacedby;
183 const char *rename;
184
185 struct aa_dfa *xmatch;
186 int xmatch_len;
187 u32 sid;
188 enum audit_mode audit;
189 enum profile_mode mode;
190 u32 flags;
191 u32 path_flags;
192 int size;
193
194 struct aa_policydb policy;
195 struct aa_file_rules file;
196 struct aa_caps caps;
197 struct aa_rlimit rlimits;
198 };
199
200 extern struct aa_namespace *root_ns;
201 extern enum profile_mode aa_g_profile_mode;
202
203 void aa_add_profile(struct aa_policy *common, struct aa_profile *profile);
204
205 bool aa_ns_visible(struct aa_namespace *curr, struct aa_namespace *view);
206 const char *aa_ns_name(struct aa_namespace *parent, struct aa_namespace *child);
207 int aa_alloc_root_ns(void);
208 void aa_free_root_ns(void);
209 void aa_free_namespace_kref(struct kref *kref);
210
211 struct aa_namespace *aa_find_namespace(struct aa_namespace *root,
212 const char *name);
213
aa_get_common(struct aa_policy * c)214 static inline struct aa_policy *aa_get_common(struct aa_policy *c)
215 {
216 if (c)
217 kref_get(&c->count);
218
219 return c;
220 }
221
222 /**
223 * aa_get_namespace - increment references count on @ns
224 * @ns: namespace to increment reference count of (MAYBE NULL)
225 *
226 * Returns: pointer to @ns, if @ns is NULL returns NULL
227 * Requires: @ns must be held with valid refcount when called
228 */
aa_get_namespace(struct aa_namespace * ns)229 static inline struct aa_namespace *aa_get_namespace(struct aa_namespace *ns)
230 {
231 if (ns)
232 kref_get(&(ns->base.count));
233
234 return ns;
235 }
236
237 /**
238 * aa_put_namespace - decrement refcount on @ns
239 * @ns: namespace to put reference of
240 *
241 * Decrement reference count of @ns and if no longer in use free it
242 */
aa_put_namespace(struct aa_namespace * ns)243 static inline void aa_put_namespace(struct aa_namespace *ns)
244 {
245 if (ns)
246 kref_put(&ns->base.count, aa_free_namespace_kref);
247 }
248
249 struct aa_profile *aa_alloc_profile(const char *name);
250 struct aa_profile *aa_new_null_profile(struct aa_profile *parent, int hat);
251 void aa_free_profile_kref(struct kref *kref);
252 struct aa_profile *aa_find_child(struct aa_profile *parent, const char *name);
253 struct aa_profile *aa_lookup_profile(struct aa_namespace *ns, const char *name);
254 struct aa_profile *aa_match_profile(struct aa_namespace *ns, const char *name);
255
256 ssize_t aa_replace_profiles(void *udata, size_t size, bool noreplace);
257 ssize_t aa_remove_profiles(char *name, size_t size);
258
259 #define PROF_ADD 1
260 #define PROF_REPLACE 0
261
262 #define unconfined(X) ((X)->flags & PFLAG_UNCONFINED)
263
264 /**
265 * aa_newest_version - find the newest version of @profile
266 * @profile: the profile to check for newer versions of (NOT NULL)
267 *
268 * Returns: newest version of @profile, if @profile is the newest version
269 * return @profile.
270 *
271 * NOTE: the profile returned is not refcounted, The refcount on @profile
272 * must be held until the caller decides what to do with the returned newest
273 * version.
274 */
aa_newest_version(struct aa_profile * profile)275 static inline struct aa_profile *aa_newest_version(struct aa_profile *profile)
276 {
277 while (profile->replacedby)
278 profile = profile->replacedby;
279
280 return profile;
281 }
282
283 /**
284 * aa_get_profile - increment refcount on profile @p
285 * @p: profile (MAYBE NULL)
286 *
287 * Returns: pointer to @p if @p is NULL will return NULL
288 * Requires: @p must be held with valid refcount when called
289 */
aa_get_profile(struct aa_profile * p)290 static inline struct aa_profile *aa_get_profile(struct aa_profile *p)
291 {
292 if (p)
293 kref_get(&(p->base.count));
294
295 return p;
296 }
297
298 /**
299 * aa_put_profile - decrement refcount on profile @p
300 * @p: profile (MAYBE NULL)
301 */
aa_put_profile(struct aa_profile * p)302 static inline void aa_put_profile(struct aa_profile *p)
303 {
304 if (p)
305 kref_put(&p->base.count, aa_free_profile_kref);
306 }
307
AUDIT_MODE(struct aa_profile * profile)308 static inline int AUDIT_MODE(struct aa_profile *profile)
309 {
310 if (aa_g_audit != AUDIT_NORMAL)
311 return aa_g_audit;
312
313 return profile->audit;
314 }
315
316 bool aa_may_manage_policy(int op);
317
318 #endif /* __AA_POLICY_H */
319