security/integrity/evm/evm_secfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2010 IBM Corporation
   4  *
   5  * Authors:
   6  * Mimi Zohar <zohar@us.ibm.com>
   7  *
   8  * File: evm_secfs.c
   9  *      - Used to signal when key is on keyring
  10  *      - Get the key and enable EVM
  11  */
  12
  13 #include <linux/audit.h>
  14 #include <linux/uaccess.h>
  15 #include <linux/init.h>
  16 #include <linux/mutex.h>
  17 #include "evm.h"
  18
  19 static struct dentry *evm_dir;
  20 static struct dentry *evm_init_tpm;
  21 static struct dentry *evm_symlink;
  22
  23 #ifdef CONFIG_EVM_ADD_XATTRS
  24 static struct dentry *evm_xattrs;
  25 static DEFINE_MUTEX(xattr_list_mutex);
  26 static int evm_xattrs_locked;
  27 #endif
  28
  29 /**
  30  * evm_read_key - read() for <securityfs>/evm
  31  *
  32  * @filp: file pointer, not actually used
  33  * @buf: where to put the result
  34  * @count: maximum to send along
  35  * @ppos: where to start
  36  *
  37  * Returns number of bytes read or error code, as appropriate
  38  */
  39 static ssize_t evm_read_key(struct file *filp, char __user *buf,
  40                             size_t count, loff_t *ppos)
  41 {
  42         char temp[80];
  43         ssize_t rc;
  44
  45         if (*ppos != 0)
  46                 return 0;
  47
  48         sprintf(temp, "%d", (evm_initialized & ~EVM_SETUP_COMPLETE));
  49         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
  50
  51         return rc;
  52 }
  53
  54 /**
  55  * evm_write_key - write() for <securityfs>/evm
  56  * @file: file pointer, not actually used
  57  * @buf: where to get the data from
  58  * @count: bytes sent
  59  * @ppos: where to start
  60  *
  61  * Used to signal that key is on the kernel key ring.
  62  * - get the integrity hmac key from the kernel key ring
  63  * - create list of hmac protected extended attributes
  64  * Returns number of bytes written or error code, as appropriate
  65  */
  66 static ssize_t evm_write_key(struct file *file, const char __user *buf,
  67                              size_t count, loff_t *ppos)
  68 {
  69         unsigned int i;
  70         int ret;
  71
  72         if (!capable(CAP_SYS_ADMIN) || (evm_initialized & EVM_SETUP_COMPLETE))
  73                 return -EPERM;
  74
  75         ret = kstrtouint_from_user(buf, count, 0, &i);
  76
  77         if (ret)
  78                 return ret;
  79
  80         /* Reject invalid values */
  81         if (!i || (i & ~EVM_INIT_MASK) != 0)
  82                 return -EINVAL;
  83
  84         /*
  85          * Don't allow a request to enable metadata writes if
  86          * an HMAC key is loaded.
  87          */
  88         if ((i & EVM_ALLOW_METADATA_WRITES) &&
  89             (evm_initialized & EVM_INIT_HMAC) != 0)
  90                 return -EPERM;
  91
  92         if (i & EVM_INIT_HMAC) {
  93                 ret = evm_init_key();
  94                 if (ret != 0)
  95                         return ret;
  96                 /* Forbid further writes after the symmetric key is loaded */
  97                 i |= EVM_SETUP_COMPLETE;
  98         }
  99
 100         evm_initialized |= i;
 101
 102         /* Don't allow protected metadata modification if a symmetric key
 103          * is loaded
 104          */
 105         if (evm_initialized & EVM_INIT_HMAC)
 106                 evm_initialized &= ~(EVM_ALLOW_METADATA_WRITES);
 107
 108         return count;
 109 }
 110
 111 static const struct file_operations evm_key_ops = {
 112         .read           = evm_read_key,
 113         .write          = evm_write_key,
 114 };
 115
 116 #ifdef CONFIG_EVM_ADD_XATTRS
 117 /**
 118  * evm_read_xattrs - read() for <securityfs>/evm_xattrs
 119  *
 120  * @filp: file pointer, not actually used
 121  * @buf: where to put the result
 122  * @count: maximum to send along
 123  * @ppos: where to start
 124  *
 125  * Returns number of bytes read or error code, as appropriate
 126  */
 127 static ssize_t evm_read_xattrs(struct file *filp, char __user *buf,
 128                                size_t count, loff_t *ppos)
 129 {
 130         char *temp;
 131         int offset = 0;
 132         ssize_t rc, size = 0;
 133         struct xattr_list *xattr;
 134
 135         if (*ppos != 0)
 136                 return 0;
 137
 138         rc = mutex_lock_interruptible(&xattr_list_mutex);
 139         if (rc)
 140                 return -ERESTARTSYS;
 141
 142         list_for_each_entry(xattr, &evm_config_xattrnames, list) {
 143                 if (!xattr->enabled)
 144                         continue;
 145
 146                 size += strlen(xattr->name) + 1;
 147         }
 148
 149         temp = kmalloc(size + 1, GFP_KERNEL);
 150         if (!temp) {
 151                 mutex_unlock(&xattr_list_mutex);
 152                 return -ENOMEM;
 153         }
 154
 155         list_for_each_entry(xattr, &evm_config_xattrnames, list) {
 156                 if (!xattr->enabled)
 157                         continue;
 158
 159                 sprintf(temp + offset, "%s\n", xattr->name);
 160                 offset += strlen(xattr->name) + 1;
 161         }
 162
 163         mutex_unlock(&xattr_list_mutex);
 164         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
 165
 166         kfree(temp);
 167
 168         return rc;
 169 }
 170
 171 /**
 172  * evm_write_xattrs - write() for <securityfs>/evm_xattrs
 173  * @file: file pointer, not actually used
 174  * @buf: where to get the data from
 175  * @count: bytes sent
 176  * @ppos: where to start
 177  *
 178  * Returns number of bytes written or error code, as appropriate
 179  */
 180 static ssize_t evm_write_xattrs(struct file *file, const char __user *buf,
 181                                 size_t count, loff_t *ppos)
 182 {
 183         int len, err;
 184         struct xattr_list *xattr, *tmp;
 185         struct audit_buffer *ab;
 186         struct iattr newattrs;
 187         struct inode *inode;
 188
 189         if (!capable(CAP_SYS_ADMIN) || evm_xattrs_locked)
 190                 return -EPERM;
 191
 192         if (*ppos != 0)
 193                 return -EINVAL;
 194
 195         if (count > XATTR_NAME_MAX)
 196                 return -E2BIG;
 197
 198         ab = audit_log_start(audit_context(), GFP_KERNEL,
 199                              AUDIT_INTEGRITY_EVM_XATTR);
 200         if (!ab && IS_ENABLED(CONFIG_AUDIT))
 201                 return -ENOMEM;
 202
 203         xattr = kmalloc(sizeof(struct xattr_list), GFP_KERNEL);
 204         if (!xattr) {
 205                 err = -ENOMEM;
 206                 goto out;
 207         }
 208
 209         xattr->enabled = true;
 210         xattr->name = memdup_user_nul(buf, count);
 211         if (IS_ERR(xattr->name)) {
 212                 err = PTR_ERR(xattr->name);
 213                 xattr->name = NULL;
 214                 goto out;
 215         }
 216
 217         /* Remove any trailing newline */
 218         len = strlen(xattr->name);
 219         if (len && xattr->name[len-1] == '\n')
 220                 xattr->name[len-1] = '\0';
 221
 222         audit_log_format(ab, "xattr=");
 223         audit_log_untrustedstring(ab, xattr->name);
 224
 225         if (strcmp(xattr->name, ".") == 0) {
 226                 evm_xattrs_locked = 1;
 227                 newattrs.ia_mode = S_IFREG | 0440;
 228                 newattrs.ia_valid = ATTR_MODE;
 229                 inode = evm_xattrs->d_inode;
 230                 inode_lock(inode);
 231                 err = simple_setattr(&nop_mnt_idmap, evm_xattrs, &newattrs);
 232                 inode_unlock(inode);
 233                 if (!err)
 234                         err = count;
 235                 goto out;
 236         }
 237
 238         if (strncmp(xattr->name, XATTR_SECURITY_PREFIX,
 239                     XATTR_SECURITY_PREFIX_LEN) != 0) {
 240                 err = -EINVAL;
 241                 goto out;
 242         }
 243
 244         /*
 245          * xattr_list_mutex guards against races in evm_read_xattrs().
 246          * Entries are only added to the evm_config_xattrnames list
 247          * and never deleted. Therefore, the list is traversed
 248          * using list_for_each_entry_lockless() without holding
 249          * the mutex in evm_calc_hmac_or_hash(), evm_find_protected_xattrs()
 250          * and evm_protected_xattr().
 251          */
 252         mutex_lock(&xattr_list_mutex);
 253         list_for_each_entry(tmp, &evm_config_xattrnames, list) {
 254                 if (strcmp(xattr->name, tmp->name) == 0) {
 255                         err = -EEXIST;
 256                         if (!tmp->enabled) {
 257                                 tmp->enabled = true;
 258                                 err = count;
 259                         }
 260                         mutex_unlock(&xattr_list_mutex);
 261                         goto out;
 262                 }
 263         }
 264         list_add_tail_rcu(&xattr->list, &evm_config_xattrnames);
 265         mutex_unlock(&xattr_list_mutex);
 266
 267         audit_log_format(ab, " res=0");
 268         audit_log_end(ab);
 269         return count;
 270 out:
 271         audit_log_format(ab, " res=%d", (err < 0) ? err : 0);
 272         audit_log_end(ab);
 273         if (xattr) {
 274                 kfree(xattr->name);
 275                 kfree(xattr);
 276         }
 277         return err;
 278 }
 279
 280 static const struct file_operations evm_xattr_ops = {
 281         .read           = evm_read_xattrs,
 282         .write          = evm_write_xattrs,
 283 };
 284
 285 static int evm_init_xattrs(void)
 286 {
 287         evm_xattrs = securityfs_create_file("evm_xattrs", 0660, evm_dir, NULL,
 288                                             &evm_xattr_ops);
 289         if (!evm_xattrs || IS_ERR(evm_xattrs))
 290                 return -EFAULT;
 291
 292         return 0;
 293 }
 294 #else
 295 static int evm_init_xattrs(void)
 296 {
 297         return 0;
 298 }
 299 #endif
 300
 301 int __init evm_init_secfs(void)
 302 {
 303         int error = 0;
 304
 305         evm_dir = securityfs_create_dir("evm", integrity_dir);
 306         if (!evm_dir || IS_ERR(evm_dir))
 307                 return -EFAULT;
 308
 309         evm_init_tpm = securityfs_create_file("evm", 0660,
 310                                               evm_dir, NULL, &evm_key_ops);
 311         if (!evm_init_tpm || IS_ERR(evm_init_tpm)) {
 312                 error = -EFAULT;
 313                 goto out;
 314         }
 315
 316         evm_symlink = securityfs_create_symlink("evm", NULL,
 317                                                 "integrity/evm/evm", NULL);
 318         if (!evm_symlink || IS_ERR(evm_symlink)) {
 319                 error = -EFAULT;
 320                 goto out;
 321         }
 322
 323         if (evm_init_xattrs() != 0) {
 324                 error = -EFAULT;
 325                 goto out;
 326         }
 327
 328         return 0;
 329 out:
 330         securityfs_remove(evm_symlink);
 331         securityfs_remove(evm_init_tpm);
 332         securityfs_remove(evm_dir);
 333         return error;
 334 }