Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / security / selinux / ss / services.c
1 /*
2  * Implementation of the security services.
3  *
4  * Authors : Stephen Smalley, <sds@epoch.ncsc.mil>
5  *           James Morris <jmorris@redhat.com>
6  *
7  * Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
8  *
9  *      Support for enhanced MLS infrastructure.
10  *      Support for context based audit filters.
11  *
12  * Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com>
13  *
14  *      Added conditional policy language extensions
15  *
16  * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
17  * Copyright (C) 2003 - 2004 Tresys Technology, LLC
18  * Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
19  *      This program is free software; you can redistribute it and/or modify
20  *      it under the terms of the GNU General Public License as published by
21  *      the Free Software Foundation, version 2.
22  */
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/string.h>
26 #include <linux/spinlock.h>
27 #include <linux/errno.h>
28 #include <linux/in.h>
29 #include <linux/sched.h>
30 #include <linux/audit.h>
31 #include <linux/mutex.h>
32
33 #include "flask.h"
34 #include "avc.h"
35 #include "avc_ss.h"
36 #include "security.h"
37 #include "context.h"
38 #include "policydb.h"
39 #include "sidtab.h"
40 #include "services.h"
41 #include "conditional.h"
42 #include "mls.h"
43
44 extern void selnl_notify_policyload(u32 seqno);
45 unsigned int policydb_loaded_version;
46
47 static DEFINE_RWLOCK(policy_rwlock);
48 #define POLICY_RDLOCK read_lock(&policy_rwlock)
49 #define POLICY_WRLOCK write_lock_irq(&policy_rwlock)
50 #define POLICY_RDUNLOCK read_unlock(&policy_rwlock)
51 #define POLICY_WRUNLOCK write_unlock_irq(&policy_rwlock)
52
53 static DEFINE_MUTEX(load_mutex);
54 #define LOAD_LOCK mutex_lock(&load_mutex)
55 #define LOAD_UNLOCK mutex_unlock(&load_mutex)
56
57 static struct sidtab sidtab;
58 struct policydb policydb;
59 int ss_initialized = 0;
60
61 /*
62  * The largest sequence number that has been used when
63  * providing an access decision to the access vector cache.
64  * The sequence number only changes when a policy change
65  * occurs.
66  */
67 static u32 latest_granting = 0;
68
69 /* Forward declaration. */
70 static int context_struct_to_string(struct context *context, char **scontext,
71                                     u32 *scontext_len);
72
73 /*
74  * Return the boolean value of a constraint expression
75  * when it is applied to the specified source and target
76  * security contexts.
77  *
78  * xcontext is a special beast...  It is used by the validatetrans rules
79  * only.  For these rules, scontext is the context before the transition,
80  * tcontext is the context after the transition, and xcontext is the context
81  * of the process performing the transition.  All other callers of
82  * constraint_expr_eval should pass in NULL for xcontext.
83  */
84 static int constraint_expr_eval(struct context *scontext,
85                                 struct context *tcontext,
86                                 struct context *xcontext,
87                                 struct constraint_expr *cexpr)
88 {
89         u32 val1, val2;
90         struct context *c;
91         struct role_datum *r1, *r2;
92         struct mls_level *l1, *l2;
93         struct constraint_expr *e;
94         int s[CEXPR_MAXDEPTH];
95         int sp = -1;
96
97         for (e = cexpr; e; e = e->next) {
98                 switch (e->expr_type) {
99                 case CEXPR_NOT:
100                         BUG_ON(sp < 0);
101                         s[sp] = !s[sp];
102                         break;
103                 case CEXPR_AND:
104                         BUG_ON(sp < 1);
105                         sp--;
106                         s[sp] &= s[sp+1];
107                         break;
108                 case CEXPR_OR:
109                         BUG_ON(sp < 1);
110                         sp--;
111                         s[sp] |= s[sp+1];
112                         break;
113                 case CEXPR_ATTR:
114                         if (sp == (CEXPR_MAXDEPTH-1))
115                                 return 0;
116                         switch (e->attr) {
117                         case CEXPR_USER:
118                                 val1 = scontext->user;
119                                 val2 = tcontext->user;
120                                 break;
121                         case CEXPR_TYPE:
122                                 val1 = scontext->type;
123                                 val2 = tcontext->type;
124                                 break;
125                         case CEXPR_ROLE:
126                                 val1 = scontext->role;
127                                 val2 = tcontext->role;
128                                 r1 = policydb.role_val_to_struct[val1 - 1];
129                                 r2 = policydb.role_val_to_struct[val2 - 1];
130                                 switch (e->op) {
131                                 case CEXPR_DOM:
132                                         s[++sp] = ebitmap_get_bit(&r1->dominates,
133                                                                   val2 - 1);
134                                         continue;
135                                 case CEXPR_DOMBY:
136                                         s[++sp] = ebitmap_get_bit(&r2->dominates,
137                                                                   val1 - 1);
138                                         continue;
139                                 case CEXPR_INCOMP:
140                                         s[++sp] = ( !ebitmap_get_bit(&r1->dominates,
141                                                                      val2 - 1) &&
142                                                     !ebitmap_get_bit(&r2->dominates,
143                                                                      val1 - 1) );
144                                         continue;
145                                 default:
146                                         break;
147                                 }
148                                 break;
149                         case CEXPR_L1L2:
150                                 l1 = &(scontext->range.level[0]);
151                                 l2 = &(tcontext->range.level[0]);
152                                 goto mls_ops;
153                         case CEXPR_L1H2:
154                                 l1 = &(scontext->range.level[0]);
155                                 l2 = &(tcontext->range.level[1]);
156                                 goto mls_ops;
157                         case CEXPR_H1L2:
158                                 l1 = &(scontext->range.level[1]);
159                                 l2 = &(tcontext->range.level[0]);
160                                 goto mls_ops;
161                         case CEXPR_H1H2:
162                                 l1 = &(scontext->range.level[1]);
163                                 l2 = &(tcontext->range.level[1]);
164                                 goto mls_ops;
165                         case CEXPR_L1H1:
166                                 l1 = &(scontext->range.level[0]);
167                                 l2 = &(scontext->range.level[1]);
168                                 goto mls_ops;
169                         case CEXPR_L2H2:
170                                 l1 = &(tcontext->range.level[0]);
171                                 l2 = &(tcontext->range.level[1]);
172                                 goto mls_ops;
173 mls_ops:
174                         switch (e->op) {
175                         case CEXPR_EQ:
176                                 s[++sp] = mls_level_eq(l1, l2);
177                                 continue;
178                         case CEXPR_NEQ:
179                                 s[++sp] = !mls_level_eq(l1, l2);
180                                 continue;
181                         case CEXPR_DOM:
182                                 s[++sp] = mls_level_dom(l1, l2);
183                                 continue;
184                         case CEXPR_DOMBY:
185                                 s[++sp] = mls_level_dom(l2, l1);
186                                 continue;
187                         case CEXPR_INCOMP:
188                                 s[++sp] = mls_level_incomp(l2, l1);
189                                 continue;
190                         default:
191                                 BUG();
192                                 return 0;
193                         }
194                         break;
195                         default:
196                                 BUG();
197                                 return 0;
198                         }
199
200                         switch (e->op) {
201                         case CEXPR_EQ:
202                                 s[++sp] = (val1 == val2);
203                                 break;
204                         case CEXPR_NEQ:
205                                 s[++sp] = (val1 != val2);
206                                 break;
207                         default:
208                                 BUG();
209                                 return 0;
210                         }
211                         break;
212                 case CEXPR_NAMES:
213                         if (sp == (CEXPR_MAXDEPTH-1))
214                                 return 0;
215                         c = scontext;
216                         if (e->attr & CEXPR_TARGET)
217                                 c = tcontext;
218                         else if (e->attr & CEXPR_XTARGET) {
219                                 c = xcontext;
220                                 if (!c) {
221                                         BUG();
222                                         return 0;
223                                 }
224                         }
225                         if (e->attr & CEXPR_USER)
226                                 val1 = c->user;
227                         else if (e->attr & CEXPR_ROLE)
228                                 val1 = c->role;
229                         else if (e->attr & CEXPR_TYPE)
230                                 val1 = c->type;
231                         else {
232                                 BUG();
233                                 return 0;
234                         }
235
236                         switch (e->op) {
237                         case CEXPR_EQ:
238                                 s[++sp] = ebitmap_get_bit(&e->names, val1 - 1);
239                                 break;
240                         case CEXPR_NEQ:
241                                 s[++sp] = !ebitmap_get_bit(&e->names, val1 - 1);
242                                 break;
243                         default:
244                                 BUG();
245                                 return 0;
246                         }
247                         break;
248                 default:
249                         BUG();
250                         return 0;
251                 }
252         }
253
254         BUG_ON(sp != 0);
255         return s[0];
256 }
257
258 /*
259  * Compute access vectors based on a context structure pair for
260  * the permissions in a particular class.
261  */
262 static int context_struct_compute_av(struct context *scontext,
263                                      struct context *tcontext,
264                                      u16 tclass,
265                                      u32 requested,
266                                      struct av_decision *avd)
267 {
268         struct constraint_node *constraint;
269         struct role_allow *ra;
270         struct avtab_key avkey;
271         struct avtab_node *node;
272         struct class_datum *tclass_datum;
273         struct ebitmap *sattr, *tattr;
274         struct ebitmap_node *snode, *tnode;
275         unsigned int i, j;
276
277         /*
278          * Remap extended Netlink classes for old policy versions.
279          * Do this here rather than socket_type_to_security_class()
280          * in case a newer policy version is loaded, allowing sockets
281          * to remain in the correct class.
282          */
283         if (policydb_loaded_version < POLICYDB_VERSION_NLCLASS)
284                 if (tclass >= SECCLASS_NETLINK_ROUTE_SOCKET &&
285                     tclass <= SECCLASS_NETLINK_DNRT_SOCKET)
286                         tclass = SECCLASS_NETLINK_SOCKET;
287
288         if (!tclass || tclass > policydb.p_classes.nprim) {
289                 printk(KERN_ERR "security_compute_av:  unrecognized class %d\n",
290                        tclass);
291                 return -EINVAL;
292         }
293         tclass_datum = policydb.class_val_to_struct[tclass - 1];
294
295         /*
296          * Initialize the access vectors to the default values.
297          */
298         avd->allowed = 0;
299         avd->decided = 0xffffffff;
300         avd->auditallow = 0;
301         avd->auditdeny = 0xffffffff;
302         avd->seqno = latest_granting;
303
304         /*
305          * If a specific type enforcement rule was defined for
306          * this permission check, then use it.
307          */
308         avkey.target_class = tclass;
309         avkey.specified = AVTAB_AV;
310         sattr = &policydb.type_attr_map[scontext->type - 1];
311         tattr = &policydb.type_attr_map[tcontext->type - 1];
312         ebitmap_for_each_bit(sattr, snode, i) {
313                 if (!ebitmap_node_get_bit(snode, i))
314                         continue;
315                 ebitmap_for_each_bit(tattr, tnode, j) {
316                         if (!ebitmap_node_get_bit(tnode, j))
317                                 continue;
318                         avkey.source_type = i + 1;
319                         avkey.target_type = j + 1;
320                         for (node = avtab_search_node(&policydb.te_avtab, &avkey);
321                              node != NULL;
322                              node = avtab_search_node_next(node, avkey.specified)) {
323                                 if (node->key.specified == AVTAB_ALLOWED)
324                                         avd->allowed |= node->datum.data;
325                                 else if (node->key.specified == AVTAB_AUDITALLOW)
326                                         avd->auditallow |= node->datum.data;
327                                 else if (node->key.specified == AVTAB_AUDITDENY)
328                                         avd->auditdeny &= node->datum.data;
329                         }
330
331                         /* Check conditional av table for additional permissions */
332                         cond_compute_av(&policydb.te_cond_avtab, &avkey, avd);
333
334                 }
335         }
336
337         /*
338          * Remove any permissions prohibited by a constraint (this includes
339          * the MLS policy).
340          */
341         constraint = tclass_datum->constraints;
342         while (constraint) {
343                 if ((constraint->permissions & (avd->allowed)) &&
344                     !constraint_expr_eval(scontext, tcontext, NULL,
345                                           constraint->expr)) {
346                         avd->allowed = (avd->allowed) & ~(constraint->permissions);
347                 }
348                 constraint = constraint->next;
349         }
350
351         /*
352          * If checking process transition permission and the
353          * role is changing, then check the (current_role, new_role)
354          * pair.
355          */
356         if (tclass == SECCLASS_PROCESS &&
357             (avd->allowed & (PROCESS__TRANSITION | PROCESS__DYNTRANSITION)) &&
358             scontext->role != tcontext->role) {
359                 for (ra = policydb.role_allow; ra; ra = ra->next) {
360                         if (scontext->role == ra->role &&
361                             tcontext->role == ra->new_role)
362                                 break;
363                 }
364                 if (!ra)
365                         avd->allowed = (avd->allowed) & ~(PROCESS__TRANSITION |
366                                                         PROCESS__DYNTRANSITION);
367         }
368
369         return 0;
370 }
371
372 static int security_validtrans_handle_fail(struct context *ocontext,
373                                            struct context *ncontext,
374                                            struct context *tcontext,
375                                            u16 tclass)
376 {
377         char *o = NULL, *n = NULL, *t = NULL;
378         u32 olen, nlen, tlen;
379
380         if (context_struct_to_string(ocontext, &o, &olen) < 0)
381                 goto out;
382         if (context_struct_to_string(ncontext, &n, &nlen) < 0)
383                 goto out;
384         if (context_struct_to_string(tcontext, &t, &tlen) < 0)
385                 goto out;
386         audit_log(current->audit_context, GFP_ATOMIC, AUDIT_SELINUX_ERR,
387                   "security_validate_transition:  denied for"
388                   " oldcontext=%s newcontext=%s taskcontext=%s tclass=%s",
389                   o, n, t, policydb.p_class_val_to_name[tclass-1]);
390 out:
391         kfree(o);
392         kfree(n);
393         kfree(t);
394
395         if (!selinux_enforcing)
396                 return 0;
397         return -EPERM;
398 }
399
400 int security_validate_transition(u32 oldsid, u32 newsid, u32 tasksid,
401                                  u16 tclass)
402 {
403         struct context *ocontext;
404         struct context *ncontext;
405         struct context *tcontext;
406         struct class_datum *tclass_datum;
407         struct constraint_node *constraint;
408         int rc = 0;
409
410         if (!ss_initialized)
411                 return 0;
412
413         POLICY_RDLOCK;
414
415         /*
416          * Remap extended Netlink classes for old policy versions.
417          * Do this here rather than socket_type_to_security_class()
418          * in case a newer policy version is loaded, allowing sockets
419          * to remain in the correct class.
420          */
421         if (policydb_loaded_version < POLICYDB_VERSION_NLCLASS)
422                 if (tclass >= SECCLASS_NETLINK_ROUTE_SOCKET &&
423                     tclass <= SECCLASS_NETLINK_DNRT_SOCKET)
424                         tclass = SECCLASS_NETLINK_SOCKET;
425
426         if (!tclass || tclass > policydb.p_classes.nprim) {
427                 printk(KERN_ERR "security_validate_transition:  "
428                        "unrecognized class %d\n", tclass);
429                 rc = -EINVAL;
430                 goto out;
431         }
432         tclass_datum = policydb.class_val_to_struct[tclass - 1];
433
434         ocontext = sidtab_search(&sidtab, oldsid);
435         if (!ocontext) {
436                 printk(KERN_ERR "security_validate_transition: "
437                        " unrecognized SID %d\n", oldsid);
438                 rc = -EINVAL;
439                 goto out;
440         }
441
442         ncontext = sidtab_search(&sidtab, newsid);
443         if (!ncontext) {
444                 printk(KERN_ERR "security_validate_transition: "
445                        " unrecognized SID %d\n", newsid);
446                 rc = -EINVAL;
447                 goto out;
448         }
449
450         tcontext = sidtab_search(&sidtab, tasksid);
451         if (!tcontext) {
452                 printk(KERN_ERR "security_validate_transition: "
453                        " unrecognized SID %d\n", tasksid);
454                 rc = -EINVAL;
455                 goto out;
456         }
457
458         constraint = tclass_datum->validatetrans;
459         while (constraint) {
460                 if (!constraint_expr_eval(ocontext, ncontext, tcontext,
461                                           constraint->expr)) {
462                         rc = security_validtrans_handle_fail(ocontext, ncontext,
463                                                              tcontext, tclass);
464                         goto out;
465                 }
466                 constraint = constraint->next;
467         }
468
469 out:
470         POLICY_RDUNLOCK;
471         return rc;
472 }
473
474 /**
475  * security_compute_av - Compute access vector decisions.
476  * @ssid: source security identifier
477  * @tsid: target security identifier
478  * @tclass: target security class
479  * @requested: requested permissions
480  * @avd: access vector decisions
481  *
482  * Compute a set of access vector decisions based on the
483  * SID pair (@ssid, @tsid) for the permissions in @tclass.
484  * Return -%EINVAL if any of the parameters are invalid or %0
485  * if the access vector decisions were computed successfully.
486  */
487 int security_compute_av(u32 ssid,
488                         u32 tsid,
489                         u16 tclass,
490                         u32 requested,
491                         struct av_decision *avd)
492 {
493         struct context *scontext = NULL, *tcontext = NULL;
494         int rc = 0;
495
496         if (!ss_initialized) {
497                 avd->allowed = 0xffffffff;
498                 avd->decided = 0xffffffff;
499                 avd->auditallow = 0;
500                 avd->auditdeny = 0xffffffff;
501                 avd->seqno = latest_granting;
502                 return 0;
503         }
504
505         POLICY_RDLOCK;
506
507         scontext = sidtab_search(&sidtab, ssid);
508         if (!scontext) {
509                 printk(KERN_ERR "security_compute_av:  unrecognized SID %d\n",
510                        ssid);
511                 rc = -EINVAL;
512                 goto out;
513         }
514         tcontext = sidtab_search(&sidtab, tsid);
515         if (!tcontext) {
516                 printk(KERN_ERR "security_compute_av:  unrecognized SID %d\n",
517                        tsid);
518                 rc = -EINVAL;
519                 goto out;
520         }
521
522         rc = context_struct_compute_av(scontext, tcontext, tclass,
523                                        requested, avd);
524 out:
525         POLICY_RDUNLOCK;
526         return rc;
527 }
528
529 /*
530  * Write the security context string representation of
531  * the context structure `context' into a dynamically
532  * allocated string of the correct size.  Set `*scontext'
533  * to point to this string and set `*scontext_len' to
534  * the length of the string.
535  */
536 static int context_struct_to_string(struct context *context, char **scontext, u32 *scontext_len)
537 {
538         char *scontextp;
539
540         *scontext = NULL;
541         *scontext_len = 0;
542
543         /* Compute the size of the context. */
544         *scontext_len += strlen(policydb.p_user_val_to_name[context->user - 1]) + 1;
545         *scontext_len += strlen(policydb.p_role_val_to_name[context->role - 1]) + 1;
546         *scontext_len += strlen(policydb.p_type_val_to_name[context->type - 1]) + 1;
547         *scontext_len += mls_compute_context_len(context);
548
549         /* Allocate space for the context; caller must free this space. */
550         scontextp = kmalloc(*scontext_len, GFP_ATOMIC);
551         if (!scontextp) {
552                 return -ENOMEM;
553         }
554         *scontext = scontextp;
555
556         /*
557          * Copy the user name, role name and type name into the context.
558          */
559         sprintf(scontextp, "%s:%s:%s",
560                 policydb.p_user_val_to_name[context->user - 1],
561                 policydb.p_role_val_to_name[context->role - 1],
562                 policydb.p_type_val_to_name[context->type - 1]);
563         scontextp += strlen(policydb.p_user_val_to_name[context->user - 1]) +
564                      1 + strlen(policydb.p_role_val_to_name[context->role - 1]) +
565                      1 + strlen(policydb.p_type_val_to_name[context->type - 1]);
566
567         mls_sid_to_context(context, &scontextp);
568
569         *scontextp = 0;
570
571         return 0;
572 }
573
574 #include "initial_sid_to_string.h"
575
576 /**
577  * security_sid_to_context - Obtain a context for a given SID.
578  * @sid: security identifier, SID
579  * @scontext: security context
580  * @scontext_len: length in bytes
581  *
582  * Write the string representation of the context associated with @sid
583  * into a dynamically allocated string of the correct size.  Set @scontext
584  * to point to this string and set @scontext_len to the length of the string.
585  */
586 int security_sid_to_context(u32 sid, char **scontext, u32 *scontext_len)
587 {
588         struct context *context;
589         int rc = 0;
590
591         if (!ss_initialized) {
592                 if (sid <= SECINITSID_NUM) {
593                         char *scontextp;
594
595                         *scontext_len = strlen(initial_sid_to_string[sid]) + 1;
596                         scontextp = kmalloc(*scontext_len,GFP_ATOMIC);
597                         if (!scontextp) {
598                                 rc = -ENOMEM;
599                                 goto out;
600                         }
601                         strcpy(scontextp, initial_sid_to_string[sid]);
602                         *scontext = scontextp;
603                         goto out;
604                 }
605                 printk(KERN_ERR "security_sid_to_context:  called before initial "
606                        "load_policy on unknown SID %d\n", sid);
607                 rc = -EINVAL;
608                 goto out;
609         }
610         POLICY_RDLOCK;
611         context = sidtab_search(&sidtab, sid);
612         if (!context) {
613                 printk(KERN_ERR "security_sid_to_context:  unrecognized SID "
614                        "%d\n", sid);
615                 rc = -EINVAL;
616                 goto out_unlock;
617         }
618         rc = context_struct_to_string(context, scontext, scontext_len);
619 out_unlock:
620         POLICY_RDUNLOCK;
621 out:
622         return rc;
623
624 }
625
626 static int security_context_to_sid_core(char *scontext, u32 scontext_len, u32 *sid, u32 def_sid)
627 {
628         char *scontext2;
629         struct context context;
630         struct role_datum *role;
631         struct type_datum *typdatum;
632         struct user_datum *usrdatum;
633         char *scontextp, *p, oldc;
634         int rc = 0;
635
636         if (!ss_initialized) {
637                 int i;
638
639                 for (i = 1; i < SECINITSID_NUM; i++) {
640                         if (!strcmp(initial_sid_to_string[i], scontext)) {
641                                 *sid = i;
642                                 goto out;
643                         }
644                 }
645                 *sid = SECINITSID_KERNEL;
646                 goto out;
647         }
648         *sid = SECSID_NULL;
649
650         /* Copy the string so that we can modify the copy as we parse it.
651            The string should already by null terminated, but we append a
652            null suffix to the copy to avoid problems with the existing
653            attr package, which doesn't view the null terminator as part
654            of the attribute value. */
655         scontext2 = kmalloc(scontext_len+1,GFP_KERNEL);
656         if (!scontext2) {
657                 rc = -ENOMEM;
658                 goto out;
659         }
660         memcpy(scontext2, scontext, scontext_len);
661         scontext2[scontext_len] = 0;
662
663         context_init(&context);
664         *sid = SECSID_NULL;
665
666         POLICY_RDLOCK;
667
668         /* Parse the security context. */
669
670         rc = -EINVAL;
671         scontextp = (char *) scontext2;
672
673         /* Extract the user. */
674         p = scontextp;
675         while (*p && *p != ':')
676                 p++;
677
678         if (*p == 0)
679                 goto out_unlock;
680
681         *p++ = 0;
682
683         usrdatum = hashtab_search(policydb.p_users.table, scontextp);
684         if (!usrdatum)
685                 goto out_unlock;
686
687         context.user = usrdatum->value;
688
689         /* Extract role. */
690         scontextp = p;
691         while (*p && *p != ':')
692                 p++;
693
694         if (*p == 0)
695                 goto out_unlock;
696
697         *p++ = 0;
698
699         role = hashtab_search(policydb.p_roles.table, scontextp);
700         if (!role)
701                 goto out_unlock;
702         context.role = role->value;
703
704         /* Extract type. */
705         scontextp = p;
706         while (*p && *p != ':')
707                 p++;
708         oldc = *p;
709         *p++ = 0;
710
711         typdatum = hashtab_search(policydb.p_types.table, scontextp);
712         if (!typdatum)
713                 goto out_unlock;
714
715         context.type = typdatum->value;
716
717         rc = mls_context_to_sid(oldc, &p, &context, &sidtab, def_sid);
718         if (rc)
719                 goto out_unlock;
720
721         if ((p - scontext2) < scontext_len) {
722                 rc = -EINVAL;
723                 goto out_unlock;
724         }
725
726         /* Check the validity of the new context. */
727         if (!policydb_context_isvalid(&policydb, &context)) {
728                 rc = -EINVAL;
729                 goto out_unlock;
730         }
731         /* Obtain the new sid. */
732         rc = sidtab_context_to_sid(&sidtab, &context, sid);
733 out_unlock:
734         POLICY_RDUNLOCK;
735         context_destroy(&context);
736         kfree(scontext2);
737 out:
738         return rc;
739 }
740
741 /**
742  * security_context_to_sid - Obtain a SID for a given security context.
743  * @scontext: security context
744  * @scontext_len: length in bytes
745  * @sid: security identifier, SID
746  *
747  * Obtains a SID associated with the security context that
748  * has the string representation specified by @scontext.
749  * Returns -%EINVAL if the context is invalid, -%ENOMEM if insufficient
750  * memory is available, or 0 on success.
751  */
752 int security_context_to_sid(char *scontext, u32 scontext_len, u32 *sid)
753 {
754         return security_context_to_sid_core(scontext, scontext_len,
755                                             sid, SECSID_NULL);
756 }
757
758 /**
759  * security_context_to_sid_default - Obtain a SID for a given security context,
760  * falling back to specified default if needed.
761  *
762  * @scontext: security context
763  * @scontext_len: length in bytes
764  * @sid: security identifier, SID
765  * @def_sid: default SID to assign on errror
766  *
767  * Obtains a SID associated with the security context that
768  * has the string representation specified by @scontext.
769  * The default SID is passed to the MLS layer to be used to allow
770  * kernel labeling of the MLS field if the MLS field is not present
771  * (for upgrading to MLS without full relabel).
772  * Returns -%EINVAL if the context is invalid, -%ENOMEM if insufficient
773  * memory is available, or 0 on success.
774  */
775 int security_context_to_sid_default(char *scontext, u32 scontext_len, u32 *sid, u32 def_sid)
776 {
777         return security_context_to_sid_core(scontext, scontext_len,
778                                             sid, def_sid);
779 }
780
781 static int compute_sid_handle_invalid_context(
782         struct context *scontext,
783         struct context *tcontext,
784         u16 tclass,
785         struct context *newcontext)
786 {
787         char *s = NULL, *t = NULL, *n = NULL;
788         u32 slen, tlen, nlen;
789
790         if (context_struct_to_string(scontext, &s, &slen) < 0)
791                 goto out;
792         if (context_struct_to_string(tcontext, &t, &tlen) < 0)
793                 goto out;
794         if (context_struct_to_string(newcontext, &n, &nlen) < 0)
795                 goto out;
796         audit_log(current->audit_context, GFP_ATOMIC, AUDIT_SELINUX_ERR,
797                   "security_compute_sid:  invalid context %s"
798                   " for scontext=%s"
799                   " tcontext=%s"
800                   " tclass=%s",
801                   n, s, t, policydb.p_class_val_to_name[tclass-1]);
802 out:
803         kfree(s);
804         kfree(t);
805         kfree(n);
806         if (!selinux_enforcing)
807                 return 0;
808         return -EACCES;
809 }
810
811 static int security_compute_sid(u32 ssid,
812                                 u32 tsid,
813                                 u16 tclass,
814                                 u32 specified,
815                                 u32 *out_sid)
816 {
817         struct context *scontext = NULL, *tcontext = NULL, newcontext;
818         struct role_trans *roletr = NULL;
819         struct avtab_key avkey;
820         struct avtab_datum *avdatum;
821         struct avtab_node *node;
822         int rc = 0;
823
824         if (!ss_initialized) {
825                 switch (tclass) {
826                 case SECCLASS_PROCESS:
827                         *out_sid = ssid;
828                         break;
829                 default:
830                         *out_sid = tsid;
831                         break;
832                 }
833                 goto out;
834         }
835
836         POLICY_RDLOCK;
837
838         scontext = sidtab_search(&sidtab, ssid);
839         if (!scontext) {
840                 printk(KERN_ERR "security_compute_sid:  unrecognized SID %d\n",
841                        ssid);
842                 rc = -EINVAL;
843                 goto out_unlock;
844         }
845         tcontext = sidtab_search(&sidtab, tsid);
846         if (!tcontext) {
847                 printk(KERN_ERR "security_compute_sid:  unrecognized SID %d\n",
848                        tsid);
849                 rc = -EINVAL;
850                 goto out_unlock;
851         }
852
853         context_init(&newcontext);
854
855         /* Set the user identity. */
856         switch (specified) {
857         case AVTAB_TRANSITION:
858         case AVTAB_CHANGE:
859                 /* Use the process user identity. */
860                 newcontext.user = scontext->user;
861                 break;
862         case AVTAB_MEMBER:
863                 /* Use the related object owner. */
864                 newcontext.user = tcontext->user;
865                 break;
866         }
867
868         /* Set the role and type to default values. */
869         switch (tclass) {
870         case SECCLASS_PROCESS:
871                 /* Use the current role and type of process. */
872                 newcontext.role = scontext->role;
873                 newcontext.type = scontext->type;
874                 break;
875         default:
876                 /* Use the well-defined object role. */
877                 newcontext.role = OBJECT_R_VAL;
878                 /* Use the type of the related object. */
879                 newcontext.type = tcontext->type;
880         }
881
882         /* Look for a type transition/member/change rule. */
883         avkey.source_type = scontext->type;
884         avkey.target_type = tcontext->type;
885         avkey.target_class = tclass;
886         avkey.specified = specified;
887         avdatum = avtab_search(&policydb.te_avtab, &avkey);
888
889         /* If no permanent rule, also check for enabled conditional rules */
890         if(!avdatum) {
891                 node = avtab_search_node(&policydb.te_cond_avtab, &avkey);
892                 for (; node != NULL; node = avtab_search_node_next(node, specified)) {
893                         if (node->key.specified & AVTAB_ENABLED) {
894                                 avdatum = &node->datum;
895                                 break;
896                         }
897                 }
898         }
899
900         if (avdatum) {
901                 /* Use the type from the type transition/member/change rule. */
902                 newcontext.type = avdatum->data;
903         }
904
905         /* Check for class-specific changes. */
906         switch (tclass) {
907         case SECCLASS_PROCESS:
908                 if (specified & AVTAB_TRANSITION) {
909                         /* Look for a role transition rule. */
910                         for (roletr = policydb.role_tr; roletr;
911                              roletr = roletr->next) {
912                                 if (roletr->role == scontext->role &&
913                                     roletr->type == tcontext->type) {
914                                         /* Use the role transition rule. */
915                                         newcontext.role = roletr->new_role;
916                                         break;
917                                 }
918                         }
919                 }
920                 break;
921         default:
922                 break;
923         }
924
925         /* Set the MLS attributes.
926            This is done last because it may allocate memory. */
927         rc = mls_compute_sid(scontext, tcontext, tclass, specified, &newcontext);
928         if (rc)
929                 goto out_unlock;
930
931         /* Check the validity of the context. */
932         if (!policydb_context_isvalid(&policydb, &newcontext)) {
933                 rc = compute_sid_handle_invalid_context(scontext,
934                                                         tcontext,
935                                                         tclass,
936                                                         &newcontext);
937                 if (rc)
938                         goto out_unlock;
939         }
940         /* Obtain the sid for the context. */
941         rc = sidtab_context_to_sid(&sidtab, &newcontext, out_sid);
942 out_unlock:
943         POLICY_RDUNLOCK;
944         context_destroy(&newcontext);
945 out:
946         return rc;
947 }
948
949 /**
950  * security_transition_sid - Compute the SID for a new subject/object.
951  * @ssid: source security identifier
952  * @tsid: target security identifier
953  * @tclass: target security class
954  * @out_sid: security identifier for new subject/object
955  *
956  * Compute a SID to use for labeling a new subject or object in the
957  * class @tclass based on a SID pair (@ssid, @tsid).
958  * Return -%EINVAL if any of the parameters are invalid, -%ENOMEM
959  * if insufficient memory is available, or %0 if the new SID was
960  * computed successfully.
961  */
962 int security_transition_sid(u32 ssid,
963                             u32 tsid,
964                             u16 tclass,
965                             u32 *out_sid)
966 {
967         return security_compute_sid(ssid, tsid, tclass, AVTAB_TRANSITION, out_sid);
968 }
969
970 /**
971  * security_member_sid - Compute the SID for member selection.
972  * @ssid: source security identifier
973  * @tsid: target security identifier
974  * @tclass: target security class
975  * @out_sid: security identifier for selected member
976  *
977  * Compute a SID to use when selecting a member of a polyinstantiated
978  * object of class @tclass based on a SID pair (@ssid, @tsid).
979  * Return -%EINVAL if any of the parameters are invalid, -%ENOMEM
980  * if insufficient memory is available, or %0 if the SID was
981  * computed successfully.
982  */
983 int security_member_sid(u32 ssid,
984                         u32 tsid,
985                         u16 tclass,
986                         u32 *out_sid)
987 {
988         return security_compute_sid(ssid, tsid, tclass, AVTAB_MEMBER, out_sid);
989 }
990
991 /**
992  * security_change_sid - Compute the SID for object relabeling.
993  * @ssid: source security identifier
994  * @tsid: target security identifier
995  * @tclass: target security class
996  * @out_sid: security identifier for selected member
997  *
998  * Compute a SID to use for relabeling an object of class @tclass
999  * based on a SID pair (@ssid, @tsid).
1000  * Return -%EINVAL if any of the parameters are invalid, -%ENOMEM
1001  * if insufficient memory is available, or %0 if the SID was
1002  * computed successfully.
1003  */
1004 int security_change_sid(u32 ssid,
1005                         u32 tsid,
1006                         u16 tclass,
1007                         u32 *out_sid)
1008 {
1009         return security_compute_sid(ssid, tsid, tclass, AVTAB_CHANGE, out_sid);
1010 }
1011
1012 /*
1013  * Verify that each permission that is defined under the
1014  * existing policy is still defined with the same value
1015  * in the new policy.
1016  */
1017 static int validate_perm(void *key, void *datum, void *p)
1018 {
1019         struct hashtab *h;
1020         struct perm_datum *perdatum, *perdatum2;
1021         int rc = 0;
1022
1023
1024         h = p;
1025         perdatum = datum;
1026
1027         perdatum2 = hashtab_search(h, key);
1028         if (!perdatum2) {
1029                 printk(KERN_ERR "security:  permission %s disappeared",
1030                        (char *)key);
1031                 rc = -ENOENT;
1032                 goto out;
1033         }
1034         if (perdatum->value != perdatum2->value) {
1035                 printk(KERN_ERR "security:  the value of permission %s changed",
1036                        (char *)key);
1037                 rc = -EINVAL;
1038         }
1039 out:
1040         return rc;
1041 }
1042
1043 /*
1044  * Verify that each class that is defined under the
1045  * existing policy is still defined with the same
1046  * attributes in the new policy.
1047  */
1048 static int validate_class(void *key, void *datum, void *p)
1049 {
1050         struct policydb *newp;
1051         struct class_datum *cladatum, *cladatum2;
1052         int rc;
1053
1054         newp = p;
1055         cladatum = datum;
1056
1057         cladatum2 = hashtab_search(newp->p_classes.table, key);
1058         if (!cladatum2) {
1059                 printk(KERN_ERR "security:  class %s disappeared\n",
1060                        (char *)key);
1061                 rc = -ENOENT;
1062                 goto out;
1063         }
1064         if (cladatum->value != cladatum2->value) {
1065                 printk(KERN_ERR "security:  the value of class %s changed\n",
1066                        (char *)key);
1067                 rc = -EINVAL;
1068                 goto out;
1069         }
1070         if ((cladatum->comdatum && !cladatum2->comdatum) ||
1071             (!cladatum->comdatum && cladatum2->comdatum)) {
1072                 printk(KERN_ERR "security:  the inherits clause for the access "
1073                        "vector definition for class %s changed\n", (char *)key);
1074                 rc = -EINVAL;
1075                 goto out;
1076         }
1077         if (cladatum->comdatum) {
1078                 rc = hashtab_map(cladatum->comdatum->permissions.table, validate_perm,
1079                                  cladatum2->comdatum->permissions.table);
1080                 if (rc) {
1081                         printk(" in the access vector definition for class "
1082                                "%s\n", (char *)key);
1083                         goto out;
1084                 }
1085         }
1086         rc = hashtab_map(cladatum->permissions.table, validate_perm,
1087                          cladatum2->permissions.table);
1088         if (rc)
1089                 printk(" in access vector definition for class %s\n",
1090                        (char *)key);
1091 out:
1092         return rc;
1093 }
1094
1095 /* Clone the SID into the new SID table. */
1096 static int clone_sid(u32 sid,
1097                      struct context *context,
1098                      void *arg)
1099 {
1100         struct sidtab *s = arg;
1101
1102         return sidtab_insert(s, sid, context);
1103 }
1104
1105 static inline int convert_context_handle_invalid_context(struct context *context)
1106 {
1107         int rc = 0;
1108
1109         if (selinux_enforcing) {
1110                 rc = -EINVAL;
1111         } else {
1112                 char *s;
1113                 u32 len;
1114
1115                 context_struct_to_string(context, &s, &len);
1116                 printk(KERN_ERR "security:  context %s is invalid\n", s);
1117                 kfree(s);
1118         }
1119         return rc;
1120 }
1121
1122 struct convert_context_args {
1123         struct policydb *oldp;
1124         struct policydb *newp;
1125 };
1126
1127 /*
1128  * Convert the values in the security context
1129  * structure `c' from the values specified
1130  * in the policy `p->oldp' to the values specified
1131  * in the policy `p->newp'.  Verify that the
1132  * context is valid under the new policy.
1133  */
1134 static int convert_context(u32 key,
1135                            struct context *c,
1136                            void *p)
1137 {
1138         struct convert_context_args *args;
1139         struct context oldc;
1140         struct role_datum *role;
1141         struct type_datum *typdatum;
1142         struct user_datum *usrdatum;
1143         char *s;
1144         u32 len;
1145         int rc;
1146
1147         args = p;
1148
1149         rc = context_cpy(&oldc, c);
1150         if (rc)
1151                 goto out;
1152
1153         rc = -EINVAL;
1154
1155         /* Convert the user. */
1156         usrdatum = hashtab_search(args->newp->p_users.table,
1157                                   args->oldp->p_user_val_to_name[c->user - 1]);
1158         if (!usrdatum) {
1159                 goto bad;
1160         }
1161         c->user = usrdatum->value;
1162
1163         /* Convert the role. */
1164         role = hashtab_search(args->newp->p_roles.table,
1165                               args->oldp->p_role_val_to_name[c->role - 1]);
1166         if (!role) {
1167                 goto bad;
1168         }
1169         c->role = role->value;
1170
1171         /* Convert the type. */
1172         typdatum = hashtab_search(args->newp->p_types.table,
1173                                   args->oldp->p_type_val_to_name[c->type - 1]);
1174         if (!typdatum) {
1175                 goto bad;
1176         }
1177         c->type = typdatum->value;
1178
1179         rc = mls_convert_context(args->oldp, args->newp, c);
1180         if (rc)
1181                 goto bad;
1182
1183         /* Check the validity of the new context. */
1184         if (!policydb_context_isvalid(args->newp, c)) {
1185                 rc = convert_context_handle_invalid_context(&oldc);
1186                 if (rc)
1187                         goto bad;
1188         }
1189
1190         context_destroy(&oldc);
1191 out:
1192         return rc;
1193 bad:
1194         context_struct_to_string(&oldc, &s, &len);
1195         context_destroy(&oldc);
1196         printk(KERN_ERR "security:  invalidating context %s\n", s);
1197         kfree(s);
1198         goto out;
1199 }
1200
1201 extern void selinux_complete_init(void);
1202
1203 /**
1204  * security_load_policy - Load a security policy configuration.
1205  * @data: binary policy data
1206  * @len: length of data in bytes
1207  *
1208  * Load a new set of security policy configuration data,
1209  * validate it and convert the SID table as necessary.
1210  * This function will flush the access vector cache after
1211  * loading the new policy.
1212  */
1213 int security_load_policy(void *data, size_t len)
1214 {
1215         struct policydb oldpolicydb, newpolicydb;
1216         struct sidtab oldsidtab, newsidtab;
1217         struct convert_context_args args;
1218         u32 seqno;
1219         int rc = 0;
1220         struct policy_file file = { data, len }, *fp = &file;
1221
1222         LOAD_LOCK;
1223
1224         if (!ss_initialized) {
1225                 avtab_cache_init();
1226                 if (policydb_read(&policydb, fp)) {
1227                         LOAD_UNLOCK;
1228                         avtab_cache_destroy();
1229                         return -EINVAL;
1230                 }
1231                 if (policydb_load_isids(&policydb, &sidtab)) {
1232                         LOAD_UNLOCK;
1233                         policydb_destroy(&policydb);
1234                         avtab_cache_destroy();
1235                         return -EINVAL;
1236                 }
1237                 policydb_loaded_version = policydb.policyvers;
1238                 ss_initialized = 1;
1239                 seqno = ++latest_granting;
1240                 LOAD_UNLOCK;
1241                 selinux_complete_init();
1242                 avc_ss_reset(seqno);
1243                 selnl_notify_policyload(seqno);
1244                 return 0;
1245         }
1246
1247 #if 0
1248         sidtab_hash_eval(&sidtab, "sids");
1249 #endif
1250
1251         if (policydb_read(&newpolicydb, fp)) {
1252                 LOAD_UNLOCK;
1253                 return -EINVAL;
1254         }
1255
1256         sidtab_init(&newsidtab);
1257
1258         /* Verify that the existing classes did not change. */
1259         if (hashtab_map(policydb.p_classes.table, validate_class, &newpolicydb)) {
1260                 printk(KERN_ERR "security:  the definition of an existing "
1261                        "class changed\n");
1262                 rc = -EINVAL;
1263                 goto err;
1264         }
1265
1266         /* Clone the SID table. */
1267         sidtab_shutdown(&sidtab);
1268         if (sidtab_map(&sidtab, clone_sid, &newsidtab)) {
1269                 rc = -ENOMEM;
1270                 goto err;
1271         }
1272
1273         /* Convert the internal representations of contexts
1274            in the new SID table and remove invalid SIDs. */
1275         args.oldp = &policydb;
1276         args.newp = &newpolicydb;
1277         sidtab_map_remove_on_error(&newsidtab, convert_context, &args);
1278
1279         /* Save the old policydb and SID table to free later. */
1280         memcpy(&oldpolicydb, &policydb, sizeof policydb);
1281         sidtab_set(&oldsidtab, &sidtab);
1282
1283         /* Install the new policydb and SID table. */
1284         POLICY_WRLOCK;
1285         memcpy(&policydb, &newpolicydb, sizeof policydb);
1286         sidtab_set(&sidtab, &newsidtab);
1287         seqno = ++latest_granting;
1288         policydb_loaded_version = policydb.policyvers;
1289         POLICY_WRUNLOCK;
1290         LOAD_UNLOCK;
1291
1292         /* Free the old policydb and SID table. */
1293         policydb_destroy(&oldpolicydb);
1294         sidtab_destroy(&oldsidtab);
1295
1296         avc_ss_reset(seqno);
1297         selnl_notify_policyload(seqno);
1298
1299         return 0;
1300
1301 err:
1302         LOAD_UNLOCK;
1303         sidtab_destroy(&newsidtab);
1304         policydb_destroy(&newpolicydb);
1305         return rc;
1306
1307 }
1308
1309 /**
1310  * security_port_sid - Obtain the SID for a port.
1311  * @domain: communication domain aka address family
1312  * @type: socket type
1313  * @protocol: protocol number
1314  * @port: port number
1315  * @out_sid: security identifier
1316  */
1317 int security_port_sid(u16 domain,
1318                       u16 type,
1319                       u8 protocol,
1320                       u16 port,
1321                       u32 *out_sid)
1322 {
1323         struct ocontext *c;
1324         int rc = 0;
1325
1326         POLICY_RDLOCK;
1327
1328         c = policydb.ocontexts[OCON_PORT];
1329         while (c) {
1330                 if (c->u.port.protocol == protocol &&
1331                     c->u.port.low_port <= port &&
1332                     c->u.port.high_port >= port)
1333                         break;
1334                 c = c->next;
1335         }
1336
1337         if (c) {
1338                 if (!c->sid[0]) {
1339                         rc = sidtab_context_to_sid(&sidtab,
1340                                                    &c->context[0],
1341                                                    &c->sid[0]);
1342                         if (rc)
1343                                 goto out;
1344                 }
1345                 *out_sid = c->sid[0];
1346         } else {
1347                 *out_sid = SECINITSID_PORT;
1348         }
1349
1350 out:
1351         POLICY_RDUNLOCK;
1352         return rc;
1353 }
1354
1355 /**
1356  * security_netif_sid - Obtain the SID for a network interface.
1357  * @name: interface name
1358  * @if_sid: interface SID
1359  * @msg_sid: default SID for received packets
1360  */
1361 int security_netif_sid(char *name,
1362                        u32 *if_sid,
1363                        u32 *msg_sid)
1364 {
1365         int rc = 0;
1366         struct ocontext *c;
1367
1368         POLICY_RDLOCK;
1369
1370         c = policydb.ocontexts[OCON_NETIF];
1371         while (c) {
1372                 if (strcmp(name, c->u.name) == 0)
1373                         break;
1374                 c = c->next;
1375         }
1376
1377         if (c) {
1378                 if (!c->sid[0] || !c->sid[1]) {
1379                         rc = sidtab_context_to_sid(&sidtab,
1380                                                   &c->context[0],
1381                                                   &c->sid[0]);
1382                         if (rc)
1383                                 goto out;
1384                         rc = sidtab_context_to_sid(&sidtab,
1385                                                    &c->context[1],
1386                                                    &c->sid[1]);
1387                         if (rc)
1388                                 goto out;
1389                 }
1390                 *if_sid = c->sid[0];
1391                 *msg_sid = c->sid[1];
1392         } else {
1393                 *if_sid = SECINITSID_NETIF;
1394                 *msg_sid = SECINITSID_NETMSG;
1395         }
1396
1397 out:
1398         POLICY_RDUNLOCK;
1399         return rc;
1400 }
1401
1402 static int match_ipv6_addrmask(u32 *input, u32 *addr, u32 *mask)
1403 {
1404         int i, fail = 0;
1405
1406         for(i = 0; i < 4; i++)
1407                 if(addr[i] != (input[i] & mask[i])) {
1408                         fail = 1;
1409                         break;
1410                 }
1411
1412         return !fail;
1413 }
1414
1415 /**
1416  * security_node_sid - Obtain the SID for a node (host).
1417  * @domain: communication domain aka address family
1418  * @addrp: address
1419  * @addrlen: address length in bytes
1420  * @out_sid: security identifier
1421  */
1422 int security_node_sid(u16 domain,
1423                       void *addrp,
1424                       u32 addrlen,
1425                       u32 *out_sid)
1426 {
1427         int rc = 0;
1428         struct ocontext *c;
1429
1430         POLICY_RDLOCK;
1431
1432         switch (domain) {
1433         case AF_INET: {
1434                 u32 addr;
1435
1436                 if (addrlen != sizeof(u32)) {
1437                         rc = -EINVAL;
1438                         goto out;
1439                 }
1440
1441                 addr = *((u32 *)addrp);
1442
1443                 c = policydb.ocontexts[OCON_NODE];
1444                 while (c) {
1445                         if (c->u.node.addr == (addr & c->u.node.mask))
1446                                 break;
1447                         c = c->next;
1448                 }
1449                 break;
1450         }
1451
1452         case AF_INET6:
1453                 if (addrlen != sizeof(u64) * 2) {
1454                         rc = -EINVAL;
1455                         goto out;
1456                 }
1457                 c = policydb.ocontexts[OCON_NODE6];
1458                 while (c) {
1459                         if (match_ipv6_addrmask(addrp, c->u.node6.addr,
1460                                                 c->u.node6.mask))
1461                                 break;
1462                         c = c->next;
1463                 }
1464                 break;
1465
1466         default:
1467                 *out_sid = SECINITSID_NODE;
1468                 goto out;
1469         }
1470
1471         if (c) {
1472                 if (!c->sid[0]) {
1473                         rc = sidtab_context_to_sid(&sidtab,
1474                                                    &c->context[0],
1475                                                    &c->sid[0]);
1476                         if (rc)
1477                                 goto out;
1478                 }
1479                 *out_sid = c->sid[0];
1480         } else {
1481                 *out_sid = SECINITSID_NODE;
1482         }
1483
1484 out:
1485         POLICY_RDUNLOCK;
1486         return rc;
1487 }
1488
1489 #define SIDS_NEL 25
1490
1491 /**
1492  * security_get_user_sids - Obtain reachable SIDs for a user.
1493  * @fromsid: starting SID
1494  * @username: username
1495  * @sids: array of reachable SIDs for user
1496  * @nel: number of elements in @sids
1497  *
1498  * Generate the set of SIDs for legal security contexts
1499  * for a given user that can be reached by @fromsid.
1500  * Set *@sids to point to a dynamically allocated
1501  * array containing the set of SIDs.  Set *@nel to the
1502  * number of elements in the array.
1503  */
1504
1505 int security_get_user_sids(u32 fromsid,
1506                            char *username,
1507                            u32 **sids,
1508                            u32 *nel)
1509 {
1510         struct context *fromcon, usercon;
1511         u32 *mysids, *mysids2, sid;
1512         u32 mynel = 0, maxnel = SIDS_NEL;
1513         struct user_datum *user;
1514         struct role_datum *role;
1515         struct av_decision avd;
1516         struct ebitmap_node *rnode, *tnode;
1517         int rc = 0, i, j;
1518
1519         if (!ss_initialized) {
1520                 *sids = NULL;
1521                 *nel = 0;
1522                 goto out;
1523         }
1524
1525         POLICY_RDLOCK;
1526
1527         fromcon = sidtab_search(&sidtab, fromsid);
1528         if (!fromcon) {
1529                 rc = -EINVAL;
1530                 goto out_unlock;
1531         }
1532
1533         user = hashtab_search(policydb.p_users.table, username);
1534         if (!user) {
1535                 rc = -EINVAL;
1536                 goto out_unlock;
1537         }
1538         usercon.user = user->value;
1539
1540         mysids = kcalloc(maxnel, sizeof(*mysids), GFP_ATOMIC);
1541         if (!mysids) {
1542                 rc = -ENOMEM;
1543                 goto out_unlock;
1544         }
1545
1546         ebitmap_for_each_bit(&user->roles, rnode, i) {
1547                 if (!ebitmap_node_get_bit(rnode, i))
1548                         continue;
1549                 role = policydb.role_val_to_struct[i];
1550                 usercon.role = i+1;
1551                 ebitmap_for_each_bit(&role->types, tnode, j) {
1552                         if (!ebitmap_node_get_bit(tnode, j))
1553                                 continue;
1554                         usercon.type = j+1;
1555
1556                         if (mls_setup_user_range(fromcon, user, &usercon))
1557                                 continue;
1558
1559                         rc = context_struct_compute_av(fromcon, &usercon,
1560                                                        SECCLASS_PROCESS,
1561                                                        PROCESS__TRANSITION,
1562                                                        &avd);
1563                         if (rc ||  !(avd.allowed & PROCESS__TRANSITION))
1564                                 continue;
1565                         rc = sidtab_context_to_sid(&sidtab, &usercon, &sid);
1566                         if (rc) {
1567                                 kfree(mysids);
1568                                 goto out_unlock;
1569                         }
1570                         if (mynel < maxnel) {
1571                                 mysids[mynel++] = sid;
1572                         } else {
1573                                 maxnel += SIDS_NEL;
1574                                 mysids2 = kcalloc(maxnel, sizeof(*mysids2), GFP_ATOMIC);
1575                                 if (!mysids2) {
1576                                         rc = -ENOMEM;
1577                                         kfree(mysids);
1578                                         goto out_unlock;
1579                                 }
1580                                 memcpy(mysids2, mysids, mynel * sizeof(*mysids2));
1581                                 kfree(mysids);
1582                                 mysids = mysids2;
1583                                 mysids[mynel++] = sid;
1584                         }
1585                 }
1586         }
1587
1588         *sids = mysids;
1589         *nel = mynel;
1590
1591 out_unlock:
1592         POLICY_RDUNLOCK;
1593 out:
1594         return rc;
1595 }
1596
1597 /**
1598  * security_genfs_sid - Obtain a SID for a file in a filesystem
1599  * @fstype: filesystem type
1600  * @path: path from root of mount
1601  * @sclass: file security class
1602  * @sid: SID for path
1603  *
1604  * Obtain a SID to use for a file in a filesystem that
1605  * cannot support xattr or use a fixed labeling behavior like
1606  * transition SIDs or task SIDs.
1607  */
1608 int security_genfs_sid(const char *fstype,
1609                        char *path,
1610                        u16 sclass,
1611                        u32 *sid)
1612 {
1613         int len;
1614         struct genfs *genfs;
1615         struct ocontext *c;
1616         int rc = 0, cmp = 0;
1617
1618         POLICY_RDLOCK;
1619
1620         for (genfs = policydb.genfs; genfs; genfs = genfs->next) {
1621                 cmp = strcmp(fstype, genfs->fstype);
1622                 if (cmp <= 0)
1623                         break;
1624         }
1625
1626         if (!genfs || cmp) {
1627                 *sid = SECINITSID_UNLABELED;
1628                 rc = -ENOENT;
1629                 goto out;
1630         }
1631
1632         for (c = genfs->head; c; c = c->next) {
1633                 len = strlen(c->u.name);
1634                 if ((!c->v.sclass || sclass == c->v.sclass) &&
1635                     (strncmp(c->u.name, path, len) == 0))
1636                         break;
1637         }
1638
1639         if (!c) {
1640                 *sid = SECINITSID_UNLABELED;
1641                 rc = -ENOENT;
1642                 goto out;
1643         }
1644
1645         if (!c->sid[0]) {
1646                 rc = sidtab_context_to_sid(&sidtab,
1647                                            &c->context[0],
1648                                            &c->sid[0]);
1649                 if (rc)
1650                         goto out;
1651         }
1652
1653         *sid = c->sid[0];
1654 out:
1655         POLICY_RDUNLOCK;
1656         return rc;
1657 }
1658
1659 /**
1660  * security_fs_use - Determine how to handle labeling for a filesystem.
1661  * @fstype: filesystem type
1662  * @behavior: labeling behavior
1663  * @sid: SID for filesystem (superblock)
1664  */
1665 int security_fs_use(
1666         const char *fstype,
1667         unsigned int *behavior,
1668         u32 *sid)
1669 {
1670         int rc = 0;
1671         struct ocontext *c;
1672
1673         POLICY_RDLOCK;
1674
1675         c = policydb.ocontexts[OCON_FSUSE];
1676         while (c) {
1677                 if (strcmp(fstype, c->u.name) == 0)
1678                         break;
1679                 c = c->next;
1680         }
1681
1682         if (c) {
1683                 *behavior = c->v.behavior;
1684                 if (!c->sid[0]) {
1685                         rc = sidtab_context_to_sid(&sidtab,
1686                                                    &c->context[0],
1687                                                    &c->sid[0]);
1688                         if (rc)
1689                                 goto out;
1690                 }
1691                 *sid = c->sid[0];
1692         } else {
1693                 rc = security_genfs_sid(fstype, "/", SECCLASS_DIR, sid);
1694                 if (rc) {
1695                         *behavior = SECURITY_FS_USE_NONE;
1696                         rc = 0;
1697                 } else {
1698                         *behavior = SECURITY_FS_USE_GENFS;
1699                 }
1700         }
1701
1702 out:
1703         POLICY_RDUNLOCK;
1704         return rc;
1705 }
1706
1707 int security_get_bools(int *len, char ***names, int **values)
1708 {
1709         int i, rc = -ENOMEM;
1710
1711         POLICY_RDLOCK;
1712         *names = NULL;
1713         *values = NULL;
1714
1715         *len = policydb.p_bools.nprim;
1716         if (!*len) {
1717                 rc = 0;
1718                 goto out;
1719         }
1720
1721        *names = kcalloc(*len, sizeof(char*), GFP_ATOMIC);
1722         if (!*names)
1723                 goto err;
1724
1725        *values = kcalloc(*len, sizeof(int), GFP_ATOMIC);
1726         if (!*values)
1727                 goto err;
1728
1729         for (i = 0; i < *len; i++) {
1730                 size_t name_len;
1731                 (*values)[i] = policydb.bool_val_to_struct[i]->state;
1732                 name_len = strlen(policydb.p_bool_val_to_name[i]) + 1;
1733                (*names)[i] = kmalloc(sizeof(char) * name_len, GFP_ATOMIC);
1734                 if (!(*names)[i])
1735                         goto err;
1736                 strncpy((*names)[i], policydb.p_bool_val_to_name[i], name_len);
1737                 (*names)[i][name_len - 1] = 0;
1738         }
1739         rc = 0;
1740 out:
1741         POLICY_RDUNLOCK;
1742         return rc;
1743 err:
1744         if (*names) {
1745                 for (i = 0; i < *len; i++)
1746                         kfree((*names)[i]);
1747         }
1748         kfree(*values);
1749         goto out;
1750 }
1751
1752
1753 int security_set_bools(int len, int *values)
1754 {
1755         int i, rc = 0;
1756         int lenp, seqno = 0;
1757         struct cond_node *cur;
1758
1759         POLICY_WRLOCK;
1760
1761         lenp = policydb.p_bools.nprim;
1762         if (len != lenp) {
1763                 rc = -EFAULT;
1764                 goto out;
1765         }
1766
1767         for (i = 0; i < len; i++) {
1768                 if (!!values[i] != policydb.bool_val_to_struct[i]->state) {
1769                         audit_log(current->audit_context, GFP_ATOMIC,
1770                                 AUDIT_MAC_CONFIG_CHANGE,
1771                                 "bool=%s val=%d old_val=%d auid=%u",
1772                                 policydb.p_bool_val_to_name[i],
1773                                 !!values[i],
1774                                 policydb.bool_val_to_struct[i]->state,
1775                                 audit_get_loginuid(current->audit_context));
1776                 }
1777                 if (values[i]) {
1778                         policydb.bool_val_to_struct[i]->state = 1;
1779                 } else {
1780                         policydb.bool_val_to_struct[i]->state = 0;
1781                 }
1782         }
1783
1784         for (cur = policydb.cond_list; cur != NULL; cur = cur->next) {
1785                 rc = evaluate_cond_node(&policydb, cur);
1786                 if (rc)
1787                         goto out;
1788         }
1789
1790         seqno = ++latest_granting;
1791
1792 out:
1793         POLICY_WRUNLOCK;
1794         if (!rc) {
1795                 avc_ss_reset(seqno);
1796                 selnl_notify_policyload(seqno);
1797         }
1798         return rc;
1799 }
1800
1801 int security_get_bool_value(int bool)
1802 {
1803         int rc = 0;
1804         int len;
1805
1806         POLICY_RDLOCK;
1807
1808         len = policydb.p_bools.nprim;
1809         if (bool >= len) {
1810                 rc = -EFAULT;
1811                 goto out;
1812         }
1813
1814         rc = policydb.bool_val_to_struct[bool]->state;
1815 out:
1816         POLICY_RDUNLOCK;
1817         return rc;
1818 }
1819
1820 struct selinux_audit_rule {
1821         u32 au_seqno;
1822         struct context au_ctxt;
1823 };
1824
1825 void selinux_audit_rule_free(struct selinux_audit_rule *rule)
1826 {
1827         if (rule) {
1828                 context_destroy(&rule->au_ctxt);
1829                 kfree(rule);
1830         }
1831 }
1832
1833 int selinux_audit_rule_init(u32 field, u32 op, char *rulestr,
1834                             struct selinux_audit_rule **rule)
1835 {
1836         struct selinux_audit_rule *tmprule;
1837         struct role_datum *roledatum;
1838         struct type_datum *typedatum;
1839         struct user_datum *userdatum;
1840         int rc = 0;
1841
1842         *rule = NULL;
1843
1844         if (!ss_initialized)
1845                 return -ENOTSUPP;
1846
1847         switch (field) {
1848         case AUDIT_SE_USER:
1849         case AUDIT_SE_ROLE:
1850         case AUDIT_SE_TYPE:
1851                 /* only 'equals' and 'not equals' fit user, role, and type */
1852                 if (op != AUDIT_EQUAL && op != AUDIT_NOT_EQUAL)
1853                         return -EINVAL;
1854                 break;
1855         case AUDIT_SE_SEN:
1856         case AUDIT_SE_CLR:
1857                 /* we do not allow a range, indicated by the presense of '-' */
1858                 if (strchr(rulestr, '-'))
1859                         return -EINVAL;
1860                 break;
1861         default:
1862                 /* only the above fields are valid */
1863                 return -EINVAL;
1864         }
1865
1866         tmprule = kzalloc(sizeof(struct selinux_audit_rule), GFP_KERNEL);
1867         if (!tmprule)
1868                 return -ENOMEM;
1869
1870         context_init(&tmprule->au_ctxt);
1871
1872         POLICY_RDLOCK;
1873
1874         tmprule->au_seqno = latest_granting;
1875
1876         switch (field) {
1877         case AUDIT_SE_USER:
1878                 userdatum = hashtab_search(policydb.p_users.table, rulestr);
1879                 if (!userdatum)
1880                         rc = -EINVAL;
1881                 else
1882                         tmprule->au_ctxt.user = userdatum->value;
1883                 break;
1884         case AUDIT_SE_ROLE:
1885                 roledatum = hashtab_search(policydb.p_roles.table, rulestr);
1886                 if (!roledatum)
1887                         rc = -EINVAL;
1888                 else
1889                         tmprule->au_ctxt.role = roledatum->value;
1890                 break;
1891         case AUDIT_SE_TYPE:
1892                 typedatum = hashtab_search(policydb.p_types.table, rulestr);
1893                 if (!typedatum)
1894                         rc = -EINVAL;
1895                 else
1896                         tmprule->au_ctxt.type = typedatum->value;
1897                 break;
1898         case AUDIT_SE_SEN:
1899         case AUDIT_SE_CLR:
1900                 rc = mls_from_string(rulestr, &tmprule->au_ctxt, GFP_ATOMIC);
1901                 break;
1902         }
1903
1904         POLICY_RDUNLOCK;
1905
1906         if (rc) {
1907                 selinux_audit_rule_free(tmprule);
1908                 tmprule = NULL;
1909         }
1910
1911         *rule = tmprule;
1912
1913         return rc;
1914 }
1915
1916 int selinux_audit_rule_match(u32 ctxid, u32 field, u32 op,
1917                              struct selinux_audit_rule *rule,
1918                              struct audit_context *actx)
1919 {
1920         struct context *ctxt;
1921         struct mls_level *level;
1922         int match = 0;
1923
1924         if (!rule) {
1925                 audit_log(actx, GFP_ATOMIC, AUDIT_SELINUX_ERR,
1926                           "selinux_audit_rule_match: missing rule\n");
1927                 return -ENOENT;
1928         }
1929
1930         POLICY_RDLOCK;
1931
1932         if (rule->au_seqno < latest_granting) {
1933                 audit_log(actx, GFP_ATOMIC, AUDIT_SELINUX_ERR,
1934                           "selinux_audit_rule_match: stale rule\n");
1935                 match = -ESTALE;
1936                 goto out;
1937         }
1938
1939         ctxt = sidtab_search(&sidtab, ctxid);
1940         if (!ctxt) {
1941                 audit_log(actx, GFP_ATOMIC, AUDIT_SELINUX_ERR,
1942                           "selinux_audit_rule_match: unrecognized SID %d\n",
1943                           ctxid);
1944                 match = -ENOENT;
1945                 goto out;
1946         }
1947
1948         /* a field/op pair that is not caught here will simply fall through
1949            without a match */
1950         switch (field) {
1951         case AUDIT_SE_USER:
1952                 switch (op) {
1953                 case AUDIT_EQUAL:
1954                         match = (ctxt->user == rule->au_ctxt.user);
1955                         break;
1956                 case AUDIT_NOT_EQUAL:
1957                         match = (ctxt->user != rule->au_ctxt.user);
1958                         break;
1959                 }
1960                 break;
1961         case AUDIT_SE_ROLE:
1962                 switch (op) {
1963                 case AUDIT_EQUAL:
1964                         match = (ctxt->role == rule->au_ctxt.role);
1965                         break;
1966                 case AUDIT_NOT_EQUAL:
1967                         match = (ctxt->role != rule->au_ctxt.role);
1968                         break;
1969                 }
1970                 break;
1971         case AUDIT_SE_TYPE:
1972                 switch (op) {
1973                 case AUDIT_EQUAL:
1974                         match = (ctxt->type == rule->au_ctxt.type);
1975                         break;
1976                 case AUDIT_NOT_EQUAL:
1977                         match = (ctxt->type != rule->au_ctxt.type);
1978                         break;
1979                 }
1980                 break;
1981         case AUDIT_SE_SEN:
1982         case AUDIT_SE_CLR:
1983                 level = (field == AUDIT_SE_SEN ?
1984                          &ctxt->range.level[0] : &ctxt->range.level[1]);
1985                 switch (op) {
1986                 case AUDIT_EQUAL:
1987                         match = mls_level_eq(&rule->au_ctxt.range.level[0],
1988                                              level);
1989                         break;
1990                 case AUDIT_NOT_EQUAL:
1991                         match = !mls_level_eq(&rule->au_ctxt.range.level[0],
1992                                               level);
1993                         break;
1994                 case AUDIT_LESS_THAN:
1995                         match = (mls_level_dom(&rule->au_ctxt.range.level[0],
1996                                                level) &&
1997                                  !mls_level_eq(&rule->au_ctxt.range.level[0],
1998                                                level));
1999                         break;
2000                 case AUDIT_LESS_THAN_OR_EQUAL:
2001                         match = mls_level_dom(&rule->au_ctxt.range.level[0],
2002                                               level);
2003                         break;
2004                 case AUDIT_GREATER_THAN:
2005                         match = (mls_level_dom(level,
2006                                               &rule->au_ctxt.range.level[0]) &&
2007                                  !mls_level_eq(level,
2008                                                &rule->au_ctxt.range.level[0]));
2009                         break;
2010                 case AUDIT_GREATER_THAN_OR_EQUAL:
2011                         match = mls_level_dom(level,
2012                                               &rule->au_ctxt.range.level[0]);
2013                         break;
2014                 }
2015         }
2016
2017 out:
2018         POLICY_RDUNLOCK;
2019         return match;
2020 }
2021
2022 static int (*aurule_callback)(void) = NULL;
2023
2024 static int aurule_avc_callback(u32 event, u32 ssid, u32 tsid,
2025                                u16 class, u32 perms, u32 *retained)
2026 {
2027         int err = 0;
2028
2029         if (event == AVC_CALLBACK_RESET && aurule_callback)
2030                 err = aurule_callback();
2031         return err;
2032 }
2033
2034 static int __init aurule_init(void)
2035 {
2036         int err;
2037
2038         err = avc_add_callback(aurule_avc_callback, AVC_CALLBACK_RESET,
2039                                SECSID_NULL, SECSID_NULL, SECCLASS_NULL, 0);
2040         if (err)
2041                 panic("avc_add_callback() failed, error %d\n", err);
2042
2043         return err;
2044 }
2045 __initcall(aurule_init);
2046
2047 void selinux_audit_set_callback(int (*callback)(void))
2048 {
2049         aurule_callback = callback;
2050 }