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