security/integrity/evm/evm_main.c

   1 /*
   2  * Copyright (C) 2005-2010 IBM Corporation
   3  *
   4  * Author:
   5  * Mimi Zohar <zohar@us.ibm.com>
   6  * Kylene Hall <kjhall@us.ibm.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, version 2 of the License.
  11  *
  12  * File: evm_main.c
  13  *      implements evm_inode_setxattr, evm_inode_post_setxattr,
  14  *      evm_inode_removexattr, and evm_verifyxattr
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/crypto.h>
  19 #include <linux/xattr.h>
  20 #include <linux/integrity.h>
  21 #include <linux/evm.h>
  22 #include <crypto/hash.h>
  23 #include "evm.h"
  24
  25 int evm_initialized;
  26
  27 char *evm_hmac = "hmac(sha1)";
  28 char *evm_hash = "sha1";
  29
  30 char *evm_config_xattrnames[] = {
  31 #ifdef CONFIG_SECURITY_SELINUX
  32         XATTR_NAME_SELINUX,
  33 #endif
  34 #ifdef CONFIG_SECURITY_SMACK
  35         XATTR_NAME_SMACK,
  36 #endif
  37 #ifdef CONFIG_IMA_APPRAISE
  38         XATTR_NAME_IMA,
  39 #endif
  40         XATTR_NAME_CAPS,
  41         NULL
  42 };
  43
  44 static int evm_fixmode;
  45 static int __init evm_set_fixmode(char *str)
  46 {
  47         if (strncmp(str, "fix", 3) == 0)
  48                 evm_fixmode = 1;
  49         return 0;
  50 }
  51 __setup("evm=", evm_set_fixmode);
  52
  53 static int evm_find_protected_xattrs(struct dentry *dentry)
  54 {
  55         struct inode *inode = dentry->d_inode;
  56         char **xattr;
  57         int error;
  58         int count = 0;
  59
  60         if (!inode->i_op || !inode->i_op->getxattr)
  61                 return -EOPNOTSUPP;
  62
  63         for (xattr = evm_config_xattrnames; *xattr != NULL; xattr++) {
  64                 error = inode->i_op->getxattr(dentry, *xattr, NULL, 0);
  65                 if (error < 0) {
  66                         if (error == -ENODATA)
  67                                 continue;
  68                         return error;
  69                 }
  70                 count++;
  71         }
  72
  73         return count;
  74 }
  75
  76 /*
  77  * evm_verify_hmac - calculate and compare the HMAC with the EVM xattr
  78  *
  79  * Compute the HMAC on the dentry's protected set of extended attributes
  80  * and compare it against the stored security.evm xattr.
  81  *
  82  * For performance:
  83  * - use the previoulsy retrieved xattr value and length to calculate the
  84  *   HMAC.)
  85  * - cache the verification result in the iint, when available.
  86  *
  87  * Returns integrity status
  88  */
  89 static enum integrity_status evm_verify_hmac(struct dentry *dentry,
  90                                              const char *xattr_name,
  91                                              char *xattr_value,
  92                                              size_t xattr_value_len,
  93                                              struct integrity_iint_cache *iint)
  94 {
  95         struct evm_ima_xattr_data *xattr_data = NULL;
  96         struct evm_ima_xattr_data calc;
  97         enum integrity_status evm_status = INTEGRITY_PASS;
  98         int rc, xattr_len;
  99
 100         if (iint && iint->evm_status == INTEGRITY_PASS)
 101                 return iint->evm_status;
 102
 103         /* if status is not PASS, try to check again - against -ENOMEM */
 104
 105         /* first need to know the sig type */
 106         rc = vfs_getxattr_alloc(dentry, XATTR_NAME_EVM, (char **)&xattr_data, 0,
 107                                 GFP_NOFS);
 108         if (rc <= 0) {
 109                 if (rc == 0)
 110                         evm_status = INTEGRITY_FAIL; /* empty */
 111                 else if (rc == -ENODATA) {
 112                         rc = evm_find_protected_xattrs(dentry);
 113                         if (rc > 0)
 114                                 evm_status = INTEGRITY_NOLABEL;
 115                         else if (rc == 0)
 116                                 evm_status = INTEGRITY_NOXATTRS; /* new file */
 117                 }
 118                 goto out;
 119         }
 120
 121         xattr_len = rc - 1;
 122
 123         /* check value type */
 124         switch (xattr_data->type) {
 125         case EVM_XATTR_HMAC:
 126                 rc = evm_calc_hmac(dentry, xattr_name, xattr_value,
 127                                    xattr_value_len, calc.digest);
 128                 if (rc)
 129                         break;
 130                 rc = memcmp(xattr_data->digest, calc.digest,
 131                             sizeof(calc.digest));
 132                 if (rc)
 133                         rc = -EINVAL;
 134                 break;
 135         case EVM_IMA_XATTR_DIGSIG:
 136                 rc = evm_calc_hash(dentry, xattr_name, xattr_value,
 137                                 xattr_value_len, calc.digest);
 138                 if (rc)
 139                         break;
 140                 rc = integrity_digsig_verify(INTEGRITY_KEYRING_EVM,
 141                                         xattr_data->digest, xattr_len,
 142                                         calc.digest, sizeof(calc.digest));
 143                 if (!rc) {
 144                         /* we probably want to replace rsa with hmac here */
 145                         evm_update_evmxattr(dentry, xattr_name, xattr_value,
 146                                    xattr_value_len);
 147                 }
 148                 break;
 149         default:
 150                 rc = -EINVAL;
 151                 break;
 152         }
 153
 154         if (rc)
 155                 evm_status = (rc == -ENODATA) ?
 156                                 INTEGRITY_NOXATTRS : INTEGRITY_FAIL;
 157 out:
 158         if (iint)
 159                 iint->evm_status = evm_status;
 160         kfree(xattr_data);
 161         return evm_status;
 162 }
 163
 164 static int evm_protected_xattr(const char *req_xattr_name)
 165 {
 166         char **xattrname;
 167         int namelen;
 168         int found = 0;
 169
 170         namelen = strlen(req_xattr_name);
 171         for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++) {
 172                 if ((strlen(*xattrname) == namelen)
 173                     && (strncmp(req_xattr_name, *xattrname, namelen) == 0)) {
 174                         found = 1;
 175                         break;
 176                 }
 177                 if (strncmp(req_xattr_name,
 178                             *xattrname + XATTR_SECURITY_PREFIX_LEN,
 179                             strlen(req_xattr_name)) == 0) {
 180                         found = 1;
 181                         break;
 182                 }
 183         }
 184         return found;
 185 }
 186
 187 /**
 188  * evm_verifyxattr - verify the integrity of the requested xattr
 189  * @dentry: object of the verify xattr
 190  * @xattr_name: requested xattr
 191  * @xattr_value: requested xattr value
 192  * @xattr_value_len: requested xattr value length
 193  *
 194  * Calculate the HMAC for the given dentry and verify it against the stored
 195  * security.evm xattr. For performance, use the xattr value and length
 196  * previously retrieved to calculate the HMAC.
 197  *
 198  * Returns the xattr integrity status.
 199  *
 200  * This function requires the caller to lock the inode's i_mutex before it
 201  * is executed.
 202  */
 203 enum integrity_status evm_verifyxattr(struct dentry *dentry,
 204                                       const char *xattr_name,
 205                                       void *xattr_value, size_t xattr_value_len,
 206                                       struct integrity_iint_cache *iint)
 207 {
 208         if (!evm_initialized || !evm_protected_xattr(xattr_name))
 209                 return INTEGRITY_UNKNOWN;
 210
 211         if (!iint) {
 212                 iint = integrity_iint_find(dentry->d_inode);
 213                 if (!iint)
 214                         return INTEGRITY_UNKNOWN;
 215         }
 216         return evm_verify_hmac(dentry, xattr_name, xattr_value,
 217                                  xattr_value_len, iint);
 218 }
 219 EXPORT_SYMBOL_GPL(evm_verifyxattr);
 220
 221 /*
 222  * evm_verify_current_integrity - verify the dentry's metadata integrity
 223  * @dentry: pointer to the affected dentry
 224  *
 225  * Verify and return the dentry's metadata integrity. The exceptions are
 226  * before EVM is initialized or in 'fix' mode.
 227  */
 228 static enum integrity_status evm_verify_current_integrity(struct dentry *dentry)
 229 {
 230         struct inode *inode = dentry->d_inode;
 231
 232         if (!evm_initialized || !S_ISREG(inode->i_mode) || evm_fixmode)
 233                 return 0;
 234         return evm_verify_hmac(dentry, NULL, NULL, 0, NULL);
 235 }
 236
 237 /*
 238  * evm_protect_xattr - protect the EVM extended attribute
 239  *
 240  * Prevent security.evm from being modified or removed without the
 241  * necessary permissions or when the existing value is invalid.
 242  *
 243  * The posix xattr acls are 'system' prefixed, which normally would not
 244  * affect security.evm.  An interesting side affect of writing posix xattr
 245  * acls is their modifying of the i_mode, which is included in security.evm.
 246  * For posix xattr acls only, permit security.evm, even if it currently
 247  * doesn't exist, to be updated.
 248  */
 249 static int evm_protect_xattr(struct dentry *dentry, const char *xattr_name,
 250                              const void *xattr_value, size_t xattr_value_len)
 251 {
 252         enum integrity_status evm_status;
 253
 254         if (strcmp(xattr_name, XATTR_NAME_EVM) == 0) {
 255                 if (!capable(CAP_SYS_ADMIN))
 256                         return -EPERM;
 257         } else if (!evm_protected_xattr(xattr_name)) {
 258                 if (!posix_xattr_acl(xattr_name))
 259                         return 0;
 260                 evm_status = evm_verify_current_integrity(dentry);
 261                 if ((evm_status == INTEGRITY_PASS) ||
 262                     (evm_status == INTEGRITY_NOXATTRS))
 263                         return 0;
 264                 return -EPERM;
 265         }
 266         evm_status = evm_verify_current_integrity(dentry);
 267         return evm_status == INTEGRITY_PASS ? 0 : -EPERM;
 268 }
 269
 270 /**
 271  * evm_inode_setxattr - protect the EVM extended attribute
 272  * @dentry: pointer to the affected dentry
 273  * @xattr_name: pointer to the affected extended attribute name
 274  * @xattr_value: pointer to the new extended attribute value
 275  * @xattr_value_len: pointer to the new extended attribute value length
 276  *
 277  * Updating 'security.evm' requires CAP_SYS_ADMIN privileges and that
 278  * the current value is valid.
 279  */
 280 int evm_inode_setxattr(struct dentry *dentry, const char *xattr_name,
 281                        const void *xattr_value, size_t xattr_value_len)
 282 {
 283         return evm_protect_xattr(dentry, xattr_name, xattr_value,
 284                                  xattr_value_len);
 285 }
 286
 287 /**
 288  * evm_inode_removexattr - protect the EVM extended attribute
 289  * @dentry: pointer to the affected dentry
 290  * @xattr_name: pointer to the affected extended attribute name
 291  *
 292  * Removing 'security.evm' requires CAP_SYS_ADMIN privileges and that
 293  * the current value is valid.
 294  */
 295 int evm_inode_removexattr(struct dentry *dentry, const char *xattr_name)
 296 {
 297         return evm_protect_xattr(dentry, xattr_name, NULL, 0);
 298 }
 299
 300 /**
 301  * evm_inode_post_setxattr - update 'security.evm' to reflect the changes
 302  * @dentry: pointer to the affected dentry
 303  * @xattr_name: pointer to the affected extended attribute name
 304  * @xattr_value: pointer to the new extended attribute value
 305  * @xattr_value_len: pointer to the new extended attribute value length
 306  *
 307  * Update the HMAC stored in 'security.evm' to reflect the change.
 308  *
 309  * No need to take the i_mutex lock here, as this function is called from
 310  * __vfs_setxattr_noperm().  The caller of which has taken the inode's
 311  * i_mutex lock.
 312  */
 313 void evm_inode_post_setxattr(struct dentry *dentry, const char *xattr_name,
 314                              const void *xattr_value, size_t xattr_value_len)
 315 {
 316         if (!evm_initialized || (!evm_protected_xattr(xattr_name)
 317                                  && !posix_xattr_acl(xattr_name)))
 318                 return;
 319
 320         evm_update_evmxattr(dentry, xattr_name, xattr_value, xattr_value_len);
 321         return;
 322 }
 323
 324 /**
 325  * evm_inode_post_removexattr - update 'security.evm' after removing the xattr
 326  * @dentry: pointer to the affected dentry
 327  * @xattr_name: pointer to the affected extended attribute name
 328  *
 329  * Update the HMAC stored in 'security.evm' to reflect removal of the xattr.
 330  */
 331 void evm_inode_post_removexattr(struct dentry *dentry, const char *xattr_name)
 332 {
 333         struct inode *inode = dentry->d_inode;
 334
 335         if (!evm_initialized || !evm_protected_xattr(xattr_name))
 336                 return;
 337
 338         mutex_lock(&inode->i_mutex);
 339         evm_update_evmxattr(dentry, xattr_name, NULL, 0);
 340         mutex_unlock(&inode->i_mutex);
 341         return;
 342 }
 343
 344 /**
 345  * evm_inode_setattr - prevent updating an invalid EVM extended attribute
 346  * @dentry: pointer to the affected dentry
 347  */
 348 int evm_inode_setattr(struct dentry *dentry, struct iattr *attr)
 349 {
 350         unsigned int ia_valid = attr->ia_valid;
 351         enum integrity_status evm_status;
 352
 353         if (!(ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)))
 354                 return 0;
 355         evm_status = evm_verify_current_integrity(dentry);
 356         if ((evm_status == INTEGRITY_PASS) ||
 357             (evm_status == INTEGRITY_NOXATTRS))
 358                 return 0;
 359         return -EPERM;
 360 }
 361
 362 /**
 363  * evm_inode_post_setattr - update 'security.evm' after modifying metadata
 364  * @dentry: pointer to the affected dentry
 365  * @ia_valid: for the UID and GID status
 366  *
 367  * For now, update the HMAC stored in 'security.evm' to reflect UID/GID
 368  * changes.
 369  *
 370  * This function is called from notify_change(), which expects the caller
 371  * to lock the inode's i_mutex.
 372  */
 373 void evm_inode_post_setattr(struct dentry *dentry, int ia_valid)
 374 {
 375         if (!evm_initialized)
 376                 return;
 377
 378         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
 379                 evm_update_evmxattr(dentry, NULL, NULL, 0);
 380         return;
 381 }
 382
 383 /*
 384  * evm_inode_init_security - initializes security.evm
 385  */
 386 int evm_inode_init_security(struct inode *inode,
 387                                  const struct xattr *lsm_xattr,
 388                                  struct xattr *evm_xattr)
 389 {
 390         struct evm_ima_xattr_data *xattr_data;
 391         int rc;
 392
 393         if (!evm_initialized || !evm_protected_xattr(lsm_xattr->name))
 394                 return 0;
 395
 396         xattr_data = kzalloc(sizeof(*xattr_data), GFP_NOFS);
 397         if (!xattr_data)
 398                 return -ENOMEM;
 399
 400         xattr_data->type = EVM_XATTR_HMAC;
 401         rc = evm_init_hmac(inode, lsm_xattr, xattr_data->digest);
 402         if (rc < 0)
 403                 goto out;
 404
 405         evm_xattr->value = xattr_data;
 406         evm_xattr->value_len = sizeof(*xattr_data);
 407         evm_xattr->name = kstrdup(XATTR_EVM_SUFFIX, GFP_NOFS);
 408         return 0;
 409 out:
 410         kfree(xattr_data);
 411         return rc;
 412 }
 413 EXPORT_SYMBOL_GPL(evm_inode_init_security);
 414
 415 static int __init init_evm(void)
 416 {
 417         int error;
 418
 419         error = evm_init_secfs();
 420         if (error < 0) {
 421                 printk(KERN_INFO "EVM: Error registering secfs\n");
 422                 goto err;
 423         }
 424
 425         return 0;
 426 err:
 427         return error;
 428 }
 429
 430 static void __exit cleanup_evm(void)
 431 {
 432         evm_cleanup_secfs();
 433         if (hmac_tfm)
 434                 crypto_free_shash(hmac_tfm);
 435         if (hash_tfm)
 436                 crypto_free_shash(hash_tfm);
 437 }
 438
 439 /*
 440  * evm_display_config - list the EVM protected security extended attributes
 441  */
 442 static int __init evm_display_config(void)
 443 {
 444         char **xattrname;
 445
 446         for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++)
 447                 printk(KERN_INFO "EVM: %s\n", *xattrname);
 448         return 0;
 449 }
 450
 451 pure_initcall(evm_display_config);
 452 late_initcall(init_evm);
 453
 454 MODULE_DESCRIPTION("Extended Verification Module");
 455 MODULE_LICENSE("GPL");