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 } 335