smack: limit privilege by label
[linux-2.6.git] / security / smack / smack_access.c
1 /*
2  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
3  *
4  *      This program is free software; you can redistribute it and/or modify
5  *      it under the terms of the GNU General Public License as published by
6  *      the Free Software Foundation, version 2.
7  *
8  * Author:
9  *      Casey Schaufler <casey@schaufler-ca.com>
10  *
11  */
12
13 #include <linux/types.h>
14 #include <linux/fs.h>
15 #include <linux/sched.h>
16 #include "smack.h"
17
18 struct smack_known smack_known_unset = {
19         .smk_next       = NULL,
20         .smk_known      = "UNSET",
21         .smk_secid      = 1,
22         .smk_cipso      = NULL,
23 };
24
25 struct smack_known smack_known_huh = {
26         .smk_next       = &smack_known_unset,
27         .smk_known      = "?",
28         .smk_secid      = 2,
29         .smk_cipso      = NULL,
30 };
31
32 struct smack_known smack_known_hat = {
33         .smk_next       = &smack_known_huh,
34         .smk_known      = "^",
35         .smk_secid      = 3,
36         .smk_cipso      = NULL,
37 };
38
39 struct smack_known smack_known_star = {
40         .smk_next       = &smack_known_hat,
41         .smk_known      = "*",
42         .smk_secid      = 4,
43         .smk_cipso      = NULL,
44 };
45
46 struct smack_known smack_known_floor = {
47         .smk_next       = &smack_known_star,
48         .smk_known      = "_",
49         .smk_secid      = 5,
50         .smk_cipso      = NULL,
51 };
52
53 struct smack_known smack_known_invalid = {
54         .smk_next       = &smack_known_floor,
55         .smk_known      = "",
56         .smk_secid      = 6,
57         .smk_cipso      = NULL,
58 };
59
60 struct smack_known *smack_known = &smack_known_invalid;
61
62 /*
63  * The initial value needs to be bigger than any of the
64  * known values above.
65  */
66 static u32 smack_next_secid = 10;
67
68 /**
69  * smk_access - determine if a subject has a specific access to an object
70  * @subject_label: a pointer to the subject's Smack label
71  * @object_label: a pointer to the object's Smack label
72  * @request: the access requested, in "MAY" format
73  *
74  * This function looks up the subject/object pair in the
75  * access rule list and returns 0 if the access is permitted,
76  * non zero otherwise.
77  *
78  * Even though Smack labels are usually shared on smack_list
79  * labels that come in off the network can't be imported
80  * and added to the list for locking reasons.
81  *
82  * Therefore, it is necessary to check the contents of the labels,
83  * not just the pointer values. Of course, in most cases the labels
84  * will be on the list, so checking the pointers may be a worthwhile
85  * optimization.
86  */
87 int smk_access(char *subject_label, char *object_label, int request)
88 {
89         u32 may = MAY_NOT;
90         struct smk_list_entry *sp;
91         struct smack_rule *srp;
92
93         /*
94          * Hardcoded comparisons.
95          *
96          * A star subject can't access any object.
97          */
98         if (subject_label == smack_known_star.smk_known ||
99             strcmp(subject_label, smack_known_star.smk_known) == 0)
100                 return -EACCES;
101         /*
102          * A star object can be accessed by any subject.
103          */
104         if (object_label == smack_known_star.smk_known ||
105             strcmp(object_label, smack_known_star.smk_known) == 0)
106                 return 0;
107         /*
108          * An object can be accessed in any way by a subject
109          * with the same label.
110          */
111         if (subject_label == object_label ||
112             strcmp(subject_label, object_label) == 0)
113                 return 0;
114         /*
115          * A hat subject can read any object.
116          * A floor object can be read by any subject.
117          */
118         if ((request & MAY_ANYREAD) == request) {
119                 if (object_label == smack_known_floor.smk_known ||
120                     strcmp(object_label, smack_known_floor.smk_known) == 0)
121                         return 0;
122                 if (subject_label == smack_known_hat.smk_known ||
123                     strcmp(subject_label, smack_known_hat.smk_known) == 0)
124                         return 0;
125         }
126         /*
127          * Beyond here an explicit relationship is required.
128          * If the requested access is contained in the available
129          * access (e.g. read is included in readwrite) it's
130          * good.
131          */
132         for (sp = smack_list; sp != NULL; sp = sp->smk_next) {
133                 srp = &sp->smk_rule;
134
135                 if (srp->smk_subject == subject_label ||
136                     strcmp(srp->smk_subject, subject_label) == 0) {
137                         if (srp->smk_object == object_label ||
138                             strcmp(srp->smk_object, object_label) == 0) {
139                                 may = srp->smk_access;
140                                 break;
141                         }
142                 }
143         }
144         /*
145          * This is a bit map operation.
146          */
147         if ((request & may) == request)
148                 return 0;
149
150         return -EACCES;
151 }
152
153 /**
154  * smk_curacc - determine if current has a specific access to an object
155  * @object_label: a pointer to the object's Smack label
156  * @request: the access requested, in "MAY" format
157  *
158  * This function checks the current subject label/object label pair
159  * in the access rule list and returns 0 if the access is permitted,
160  * non zero otherwise. It allows that current may have the capability
161  * to override the rules.
162  */
163 int smk_curacc(char *obj_label, u32 mode)
164 {
165         int rc;
166
167         rc = smk_access(current->security, obj_label, mode);
168         if (rc == 0)
169                 return 0;
170
171         /*
172          * Return if a specific label has been designated as the
173          * only one that gets privilege and current does not
174          * have that label.
175          */
176         if (smack_onlycap != NULL && smack_onlycap != current->security)
177                 return rc;
178
179         if (capable(CAP_MAC_OVERRIDE))
180                 return 0;
181
182         return rc;
183 }
184
185 static DEFINE_MUTEX(smack_known_lock);
186
187 /**
188  * smk_import_entry - import a label, return the list entry
189  * @string: a text string that might be a Smack label
190  * @len: the maximum size, or zero if it is NULL terminated.
191  *
192  * Returns a pointer to the entry in the label list that
193  * matches the passed string, adding it if necessary.
194  */
195 struct smack_known *smk_import_entry(const char *string, int len)
196 {
197         struct smack_known *skp;
198         char smack[SMK_LABELLEN];
199         int found;
200         int i;
201
202         if (len <= 0 || len > SMK_MAXLEN)
203                 len = SMK_MAXLEN;
204
205         for (i = 0, found = 0; i < SMK_LABELLEN; i++) {
206                 if (found)
207                         smack[i] = '\0';
208                 else if (i >= len || string[i] > '~' || string[i] <= ' ' ||
209                          string[i] == '/') {
210                         smack[i] = '\0';
211                         found = 1;
212                 } else
213                         smack[i] = string[i];
214         }
215
216         if (smack[0] == '\0')
217                 return NULL;
218
219         mutex_lock(&smack_known_lock);
220
221         for (skp = smack_known; skp != NULL; skp = skp->smk_next)
222                 if (strncmp(skp->smk_known, smack, SMK_MAXLEN) == 0)
223                         break;
224
225         if (skp == NULL) {
226                 skp = kzalloc(sizeof(struct smack_known), GFP_KERNEL);
227                 if (skp != NULL) {
228                         skp->smk_next = smack_known;
229                         strncpy(skp->smk_known, smack, SMK_MAXLEN);
230                         skp->smk_secid = smack_next_secid++;
231                         skp->smk_cipso = NULL;
232                         spin_lock_init(&skp->smk_cipsolock);
233                         /*
234                          * Make sure that the entry is actually
235                          * filled before putting it on the list.
236                          */
237                         smp_mb();
238                         smack_known = skp;
239                 }
240         }
241
242         mutex_unlock(&smack_known_lock);
243
244         return skp;
245 }
246
247 /**
248  * smk_import - import a smack label
249  * @string: a text string that might be a Smack label
250  * @len: the maximum size, or zero if it is NULL terminated.
251  *
252  * Returns a pointer to the label in the label list that
253  * matches the passed string, adding it if necessary.
254  */
255 char *smk_import(const char *string, int len)
256 {
257         struct smack_known *skp;
258
259         skp = smk_import_entry(string, len);
260         if (skp == NULL)
261                 return NULL;
262         return skp->smk_known;
263 }
264
265 /**
266  * smack_from_secid - find the Smack label associated with a secid
267  * @secid: an integer that might be associated with a Smack label
268  *
269  * Returns a pointer to the appropraite Smack label if there is one,
270  * otherwise a pointer to the invalid Smack label.
271  */
272 char *smack_from_secid(const u32 secid)
273 {
274         struct smack_known *skp;
275
276         for (skp = smack_known; skp != NULL; skp = skp->smk_next)
277                 if (skp->smk_secid == secid)
278                         return skp->smk_known;
279
280         /*
281          * If we got this far someone asked for the translation
282          * of a secid that is not on the list.
283          */
284         return smack_known_invalid.smk_known;
285 }
286
287 /**
288  * smack_to_secid - find the secid associated with a Smack label
289  * @smack: the Smack label
290  *
291  * Returns the appropriate secid if there is one,
292  * otherwise 0
293  */
294 u32 smack_to_secid(const char *smack)
295 {
296         struct smack_known *skp;
297
298         for (skp = smack_known; skp != NULL; skp = skp->smk_next)
299                 if (strncmp(skp->smk_known, smack, SMK_MAXLEN) == 0)
300                         return skp->smk_secid;
301         return 0;
302 }
303
304 /**
305  * smack_from_cipso - find the Smack label associated with a CIPSO option
306  * @level: Bell & LaPadula level from the network
307  * @cp: Bell & LaPadula categories from the network
308  * @result: where to put the Smack value
309  *
310  * This is a simple lookup in the label table.
311  *
312  * This is an odd duck as far as smack handling goes in that
313  * it sends back a copy of the smack label rather than a pointer
314  * to the master list. This is done because it is possible for
315  * a foreign host to send a smack label that is new to this
316  * machine and hence not on the list. That would not be an
317  * issue except that adding an entry to the master list can't
318  * be done at that point.
319  */
320 void smack_from_cipso(u32 level, char *cp, char *result)
321 {
322         struct smack_known *kp;
323         char *final = NULL;
324
325         for (kp = smack_known; final == NULL && kp != NULL; kp = kp->smk_next) {
326                 if (kp->smk_cipso == NULL)
327                         continue;
328
329                 spin_lock_bh(&kp->smk_cipsolock);
330
331                 if (kp->smk_cipso->smk_level == level &&
332                     memcmp(kp->smk_cipso->smk_catset, cp, SMK_LABELLEN) == 0)
333                         final = kp->smk_known;
334
335                 spin_unlock_bh(&kp->smk_cipsolock);
336         }
337         if (final == NULL)
338                 final = smack_known_huh.smk_known;
339         strncpy(result, final, SMK_MAXLEN);
340         return;
341 }
342
343 /**
344  * smack_to_cipso - find the CIPSO option to go with a Smack label
345  * @smack: a pointer to the smack label in question
346  * @cp: where to put the result
347  *
348  * Returns zero if a value is available, non-zero otherwise.
349  */
350 int smack_to_cipso(const char *smack, struct smack_cipso *cp)
351 {
352         struct smack_known *kp;
353
354         for (kp = smack_known; kp != NULL; kp = kp->smk_next)
355                 if (kp->smk_known == smack ||
356                     strcmp(kp->smk_known, smack) == 0)
357                         break;
358
359         if (kp == NULL || kp->smk_cipso == NULL)
360                 return -ENOENT;
361
362         memcpy(cp, kp->smk_cipso, sizeof(struct smack_cipso));
363         return 0;
364 }