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 my 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         if (capable(CAP_MAC_OVERRIDE))
 172                 return 0;
 173
 174         return rc;
 175 }
 176
 177 static DEFINE_MUTEX(smack_known_lock);
 178
 179 /**
 180  * smk_import_entry - import a label, return the list entry
 181  * @string: a text string that might be a Smack label
 182  * @len: the maximum size, or zero if it is NULL terminated.
 183  *
 184  * Returns a pointer to the entry in the label list that
 185  * matches the passed string, adding it if necessary.
 186  */
 187 struct smack_known *smk_import_entry(const char *string, int len)
 188 {
 189         struct smack_known *skp;
 190         char smack[SMK_LABELLEN];
 191         int found;
 192         int i;
 193
 194         if (len <= 0 || len > SMK_MAXLEN)
 195                 len = SMK_MAXLEN;
 196
 197         for (i = 0, found = 0; i < SMK_LABELLEN; i++) {
 198                 if (found)
 199                         smack[i] = '\0';
 200                 else if (i >= len || string[i] > '~' || string[i] <= ' ' ||
 201                          string[i] == '/') {
 202                         smack[i] = '\0';
 203                         found = 1;
 204                 } else
 205                         smack[i] = string[i];
 206         }
 207
 208         if (smack[0] == '\0')
 209                 return NULL;
 210
 211         mutex_lock(&smack_known_lock);
 212
 213         for (skp = smack_known; skp != NULL; skp = skp->smk_next)
 214                 if (strncmp(skp->smk_known, smack, SMK_MAXLEN) == 0)
 215                         break;
 216
 217         if (skp == NULL) {
 218                 skp = kzalloc(sizeof(struct smack_known), GFP_KERNEL);
 219                 if (skp != NULL) {
 220                         skp->smk_next = smack_known;
 221                         strncpy(skp->smk_known, smack, SMK_MAXLEN);
 222                         skp->smk_secid = smack_next_secid++;
 223                         skp->smk_cipso = NULL;
 224                         spin_lock_init(&skp->smk_cipsolock);
 225                         /*
 226                          * Make sure that the entry is actually
 227                          * filled before putting it on the list.
 228                          */
 229                         smp_mb();
 230                         smack_known = skp;
 231                 }
 232         }
 233
 234         mutex_unlock(&smack_known_lock);
 235
 236         return skp;
 237 }
 238
 239 /**
 240  * smk_import - import a smack label
 241  * @string: a text string that might be a Smack label
 242  * @len: the maximum size, or zero if it is NULL terminated.
 243  *
 244  * Returns a pointer to the label in the label list that
 245  * matches the passed string, adding it if necessary.
 246  */
 247 char *smk_import(const char *string, int len)
 248 {
 249         struct smack_known *skp;
 250
 251         skp = smk_import_entry(string, len);
 252         if (skp == NULL)
 253                 return NULL;
 254         return skp->smk_known;
 255 }
 256
 257 /**
 258  * smack_from_secid - find the Smack label associated with a secid
 259  * @secid: an integer that might be associated with a Smack label
 260  *
 261  * Returns a pointer to the appropraite Smack label if there is one,
 262  * otherwise a pointer to the invalid Smack label.
 263  */
 264 char *smack_from_secid(const u32 secid)
 265 {
 266         struct smack_known *skp;
 267
 268         for (skp = smack_known; skp != NULL; skp = skp->smk_next)
 269                 if (skp->smk_secid == secid)
 270                         return skp->smk_known;
 271
 272         /*
 273          * If we got this far someone asked for the translation
 274          * of a secid that is not on the list.
 275          */
 276         return smack_known_invalid.smk_known;
 277 }
 278
 279 /**
 280  * smack_to_secid - find the secid associated with a Smack label
 281  * @smack: the Smack label
 282  *
 283  * Returns the appropriate secid if there is one,
 284  * otherwise 0
 285  */
 286 u32 smack_to_secid(const char *smack)
 287 {
 288         struct smack_known *skp;
 289
 290         for (skp = smack_known; skp != NULL; skp = skp->smk_next)
 291                 if (strncmp(skp->smk_known, smack, SMK_MAXLEN) == 0)
 292                         return skp->smk_secid;
 293         return 0;
 294 }
 295
 296 /**
 297  * smack_from_cipso - find the Smack label associated with a CIPSO option
 298  * @level: Bell & LaPadula level from the network
 299  * @cp: Bell & LaPadula categories from the network
 300  * @result: where to put the Smack value
 301  *
 302  * This is a simple lookup in the label table.
 303  *
 304  * This is an odd duck as far as smack handling goes in that
 305  * it sends back a copy of the smack label rather than a pointer
 306  * to the master list. This is done because it is possible for
 307  * a foreign host to send a smack label that is new to this
 308  * machine and hence not on the list. That would not be an
 309  * issue except that adding an entry to the master list can't
 310  * be done at that point.
 311  */
 312 void smack_from_cipso(u32 level, char *cp, char *result)
 313 {
 314         struct smack_known *kp;
 315         char *final = NULL;
 316
 317         for (kp = smack_known; final == NULL && kp != NULL; kp = kp->smk_next) {
 318                 if (kp->smk_cipso == NULL)
 319                         continue;
 320
 321                 spin_lock_bh(&kp->smk_cipsolock);
 322
 323                 if (kp->smk_cipso->smk_level == level &&
 324                     memcmp(kp->smk_cipso->smk_catset, cp, SMK_LABELLEN) == 0)
 325                         final = kp->smk_known;
 326
 327                 spin_unlock_bh(&kp->smk_cipsolock);
 328         }
 329         if (final == NULL)
 330                 final = smack_known_huh.smk_known;
 331         strncpy(result, final, SMK_MAXLEN);
 332         return;
 333 }
 334
 335 /**
 336  * smack_to_cipso - find the CIPSO option to go with a Smack label
 337  * @smack: a pointer to the smack label in question
 338  * @cp: where to put the result
 339  *
 340  * Returns zero if a value is available, non-zero otherwise.
 341  */
 342 int smack_to_cipso(const char *smack, struct smack_cipso *cp)
 343 {
 344         struct smack_known *kp;
 345
 346         for (kp = smack_known; kp != NULL; kp = kp->smk_next)
 347                 if (kp->smk_known == smack ||
 348                     strcmp(kp->smk_known, smack) == 0)
 349                         break;
 350
 351         if (kp == NULL || kp->smk_cipso == NULL)
 352                 return -ENOENT;
 353
 354         memcpy(cp, kp->smk_cipso, sizeof(struct smack_cipso));
 355         return 0;
 356 }