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 }