GNU Linux-libre 6.9-gnu
[releases.git] / security / integrity / evm / evm_main.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2005-2010 IBM Corporation
4  *
5  * Author:
6  * Mimi Zohar <zohar@us.ibm.com>
7  * Kylene Hall <kjhall@us.ibm.com>
8  *
9  * File: evm_main.c
10  *      implements evm_inode_setxattr, evm_inode_post_setxattr,
11  *      evm_inode_removexattr, evm_verifyxattr, and evm_inode_set_acl.
12  */
13
14 #define pr_fmt(fmt) "EVM: "fmt
15
16 #include <linux/init.h>
17 #include <linux/audit.h>
18 #include <linux/xattr.h>
19 #include <linux/integrity.h>
20 #include <linux/evm.h>
21 #include <linux/magic.h>
22 #include <linux/posix_acl_xattr.h>
23 #include <linux/lsm_hooks.h>
24
25 #include <crypto/hash.h>
26 #include <crypto/hash_info.h>
27 #include <crypto/utils.h>
28 #include "evm.h"
29
30 int evm_initialized;
31
32 static const char * const integrity_status_msg[] = {
33         "pass", "pass_immutable", "fail", "fail_immutable", "no_label",
34         "no_xattrs", "unknown"
35 };
36 int evm_hmac_attrs;
37
38 static struct xattr_list evm_config_default_xattrnames[] = {
39         {
40          .name = XATTR_NAME_SELINUX,
41          .enabled = IS_ENABLED(CONFIG_SECURITY_SELINUX)
42         },
43         {
44          .name = XATTR_NAME_SMACK,
45          .enabled = IS_ENABLED(CONFIG_SECURITY_SMACK)
46         },
47         {
48          .name = XATTR_NAME_SMACKEXEC,
49          .enabled = IS_ENABLED(CONFIG_EVM_EXTRA_SMACK_XATTRS)
50         },
51         {
52          .name = XATTR_NAME_SMACKTRANSMUTE,
53          .enabled = IS_ENABLED(CONFIG_EVM_EXTRA_SMACK_XATTRS)
54         },
55         {
56          .name = XATTR_NAME_SMACKMMAP,
57          .enabled = IS_ENABLED(CONFIG_EVM_EXTRA_SMACK_XATTRS)
58         },
59         {
60          .name = XATTR_NAME_APPARMOR,
61          .enabled = IS_ENABLED(CONFIG_SECURITY_APPARMOR)
62         },
63         {
64          .name = XATTR_NAME_IMA,
65          .enabled = IS_ENABLED(CONFIG_IMA_APPRAISE)
66         },
67         {
68          .name = XATTR_NAME_CAPS,
69          .enabled = true
70         },
71 };
72
73 LIST_HEAD(evm_config_xattrnames);
74
75 static int evm_fixmode __ro_after_init;
76 static int __init evm_set_fixmode(char *str)
77 {
78         if (strncmp(str, "fix", 3) == 0)
79                 evm_fixmode = 1;
80         else
81                 pr_err("invalid \"%s\" mode", str);
82
83         return 1;
84 }
85 __setup("evm=", evm_set_fixmode);
86
87 static void __init evm_init_config(void)
88 {
89         int i, xattrs;
90
91         xattrs = ARRAY_SIZE(evm_config_default_xattrnames);
92
93         pr_info("Initialising EVM extended attributes:\n");
94         for (i = 0; i < xattrs; i++) {
95                 pr_info("%s%s\n", evm_config_default_xattrnames[i].name,
96                         !evm_config_default_xattrnames[i].enabled ?
97                         " (disabled)" : "");
98                 list_add_tail(&evm_config_default_xattrnames[i].list,
99                               &evm_config_xattrnames);
100         }
101
102 #ifdef CONFIG_EVM_ATTR_FSUUID
103         evm_hmac_attrs |= EVM_ATTR_FSUUID;
104 #endif
105         pr_info("HMAC attrs: 0x%x\n", evm_hmac_attrs);
106 }
107
108 static bool evm_key_loaded(void)
109 {
110         return (bool)(evm_initialized & EVM_KEY_MASK);
111 }
112
113 /*
114  * This function determines whether or not it is safe to ignore verification
115  * errors, based on the ability of EVM to calculate HMACs. If the HMAC key
116  * is not loaded, and it cannot be loaded in the future due to the
117  * EVM_SETUP_COMPLETE initialization flag, allowing an operation despite the
118  * attrs/xattrs being found invalid will not make them valid.
119  */
120 static bool evm_hmac_disabled(void)
121 {
122         if (evm_initialized & EVM_INIT_HMAC)
123                 return false;
124
125         if (!(evm_initialized & EVM_SETUP_COMPLETE))
126                 return false;
127
128         return true;
129 }
130
131 static int evm_find_protected_xattrs(struct dentry *dentry)
132 {
133         struct inode *inode = d_backing_inode(dentry);
134         struct xattr_list *xattr;
135         int error;
136         int count = 0;
137
138         if (!(inode->i_opflags & IOP_XATTR))
139                 return -EOPNOTSUPP;
140
141         list_for_each_entry_lockless(xattr, &evm_config_xattrnames, list) {
142                 error = __vfs_getxattr(dentry, inode, xattr->name, NULL, 0);
143                 if (error < 0) {
144                         if (error == -ENODATA)
145                                 continue;
146                         return error;
147                 }
148                 count++;
149         }
150
151         return count;
152 }
153
154 static int is_unsupported_fs(struct dentry *dentry)
155 {
156         struct inode *inode = d_backing_inode(dentry);
157
158         if (inode->i_sb->s_iflags & SB_I_EVM_UNSUPPORTED) {
159                 pr_info_once("%s not supported\n", inode->i_sb->s_type->name);
160                 return 1;
161         }
162         return 0;
163 }
164
165 /*
166  * evm_verify_hmac - calculate and compare the HMAC with the EVM xattr
167  *
168  * Compute the HMAC on the dentry's protected set of extended attributes
169  * and compare it against the stored security.evm xattr.
170  *
171  * For performance:
172  * - use the previoulsy retrieved xattr value and length to calculate the
173  *   HMAC.)
174  * - cache the verification result in the iint, when available.
175  *
176  * Returns integrity status
177  */
178 static enum integrity_status evm_verify_hmac(struct dentry *dentry,
179                                              const char *xattr_name,
180                                              char *xattr_value,
181                                              size_t xattr_value_len)
182 {
183         struct evm_ima_xattr_data *xattr_data = NULL;
184         struct signature_v2_hdr *hdr;
185         enum integrity_status evm_status = INTEGRITY_PASS;
186         struct evm_digest digest;
187         struct inode *inode = d_backing_inode(dentry);
188         struct evm_iint_cache *iint = evm_iint_inode(inode);
189         int rc, xattr_len, evm_immutable = 0;
190
191         if (iint && (iint->evm_status == INTEGRITY_PASS ||
192                      iint->evm_status == INTEGRITY_PASS_IMMUTABLE))
193                 return iint->evm_status;
194
195         if (is_unsupported_fs(dentry))
196                 return INTEGRITY_UNKNOWN;
197
198         /* if status is not PASS, try to check again - against -ENOMEM */
199
200         /* first need to know the sig type */
201         rc = vfs_getxattr_alloc(&nop_mnt_idmap, dentry, XATTR_NAME_EVM,
202                                 (char **)&xattr_data, 0, GFP_NOFS);
203         if (rc <= 0) {
204                 evm_status = INTEGRITY_FAIL;
205                 if (rc == -ENODATA) {
206                         rc = evm_find_protected_xattrs(dentry);
207                         if (rc > 0)
208                                 evm_status = INTEGRITY_NOLABEL;
209                         else if (rc == 0)
210                                 evm_status = INTEGRITY_NOXATTRS; /* new file */
211                 } else if (rc == -EOPNOTSUPP) {
212                         evm_status = INTEGRITY_UNKNOWN;
213                 }
214                 goto out;
215         }
216
217         xattr_len = rc;
218
219         /* check value type */
220         switch (xattr_data->type) {
221         case EVM_XATTR_HMAC:
222                 if (xattr_len != sizeof(struct evm_xattr)) {
223                         evm_status = INTEGRITY_FAIL;
224                         goto out;
225                 }
226
227                 digest.hdr.algo = HASH_ALGO_SHA1;
228                 rc = evm_calc_hmac(dentry, xattr_name, xattr_value,
229                                    xattr_value_len, &digest);
230                 if (rc)
231                         break;
232                 rc = crypto_memneq(xattr_data->data, digest.digest,
233                                    SHA1_DIGEST_SIZE);
234                 if (rc)
235                         rc = -EINVAL;
236                 break;
237         case EVM_XATTR_PORTABLE_DIGSIG:
238                 evm_immutable = 1;
239                 fallthrough;
240         case EVM_IMA_XATTR_DIGSIG:
241                 /* accept xattr with non-empty signature field */
242                 if (xattr_len <= sizeof(struct signature_v2_hdr)) {
243                         evm_status = INTEGRITY_FAIL;
244                         goto out;
245                 }
246
247                 hdr = (struct signature_v2_hdr *)xattr_data;
248                 digest.hdr.algo = hdr->hash_algo;
249                 rc = evm_calc_hash(dentry, xattr_name, xattr_value,
250                                    xattr_value_len, xattr_data->type, &digest);
251                 if (rc)
252                         break;
253                 rc = integrity_digsig_verify(INTEGRITY_KEYRING_EVM,
254                                         (const char *)xattr_data, xattr_len,
255                                         digest.digest, digest.hdr.length);
256                 if (!rc) {
257                         if (xattr_data->type == EVM_XATTR_PORTABLE_DIGSIG) {
258                                 if (iint)
259                                         iint->flags |= EVM_IMMUTABLE_DIGSIG;
260                                 evm_status = INTEGRITY_PASS_IMMUTABLE;
261                         } else if (!IS_RDONLY(inode) &&
262                                    !(inode->i_sb->s_readonly_remount) &&
263                                    !IS_IMMUTABLE(inode)) {
264                                 evm_update_evmxattr(dentry, xattr_name,
265                                                     xattr_value,
266                                                     xattr_value_len);
267                         }
268                 }
269                 break;
270         default:
271                 rc = -EINVAL;
272                 break;
273         }
274
275         if (rc) {
276                 if (rc == -ENODATA)
277                         evm_status = INTEGRITY_NOXATTRS;
278                 else if (evm_immutable)
279                         evm_status = INTEGRITY_FAIL_IMMUTABLE;
280                 else
281                         evm_status = INTEGRITY_FAIL;
282         }
283         pr_debug("digest: (%d) [%*phN]\n", digest.hdr.length, digest.hdr.length,
284                   digest.digest);
285 out:
286         if (iint)
287                 iint->evm_status = evm_status;
288         kfree(xattr_data);
289         return evm_status;
290 }
291
292 static int evm_protected_xattr_common(const char *req_xattr_name,
293                                       bool all_xattrs)
294 {
295         int namelen;
296         int found = 0;
297         struct xattr_list *xattr;
298
299         namelen = strlen(req_xattr_name);
300         list_for_each_entry_lockless(xattr, &evm_config_xattrnames, list) {
301                 if (!all_xattrs && !xattr->enabled)
302                         continue;
303
304                 if ((strlen(xattr->name) == namelen)
305                     && (strncmp(req_xattr_name, xattr->name, namelen) == 0)) {
306                         found = 1;
307                         break;
308                 }
309                 if (strncmp(req_xattr_name,
310                             xattr->name + XATTR_SECURITY_PREFIX_LEN,
311                             strlen(req_xattr_name)) == 0) {
312                         found = 1;
313                         break;
314                 }
315         }
316
317         return found;
318 }
319
320 int evm_protected_xattr(const char *req_xattr_name)
321 {
322         return evm_protected_xattr_common(req_xattr_name, false);
323 }
324
325 int evm_protected_xattr_if_enabled(const char *req_xattr_name)
326 {
327         return evm_protected_xattr_common(req_xattr_name, true);
328 }
329
330 /**
331  * evm_read_protected_xattrs - read EVM protected xattr names, lengths, values
332  * @dentry: dentry of the read xattrs
333  * @buffer: buffer xattr names, lengths or values are copied to
334  * @buffer_size: size of buffer
335  * @type: n: names, l: lengths, v: values
336  * @canonical_fmt: data format (true: little endian, false: native format)
337  *
338  * Read protected xattr names (separated by |), lengths (u32) or values for a
339  * given dentry and return the total size of copied data. If buffer is NULL,
340  * just return the total size.
341  *
342  * Returns the total size on success, a negative value on error.
343  */
344 int evm_read_protected_xattrs(struct dentry *dentry, u8 *buffer,
345                               int buffer_size, char type, bool canonical_fmt)
346 {
347         struct xattr_list *xattr;
348         int rc, size, total_size = 0;
349
350         list_for_each_entry_lockless(xattr, &evm_config_xattrnames, list) {
351                 rc = __vfs_getxattr(dentry, d_backing_inode(dentry),
352                                     xattr->name, NULL, 0);
353                 if (rc < 0 && rc == -ENODATA)
354                         continue;
355                 else if (rc < 0)
356                         return rc;
357
358                 switch (type) {
359                 case 'n':
360                         size = strlen(xattr->name) + 1;
361                         if (buffer) {
362                                 if (total_size)
363                                         *(buffer + total_size - 1) = '|';
364
365                                 memcpy(buffer + total_size, xattr->name, size);
366                         }
367                         break;
368                 case 'l':
369                         size = sizeof(u32);
370                         if (buffer) {
371                                 if (canonical_fmt)
372                                         rc = (__force int)cpu_to_le32(rc);
373
374                                 *(u32 *)(buffer + total_size) = rc;
375                         }
376                         break;
377                 case 'v':
378                         size = rc;
379                         if (buffer) {
380                                 rc = __vfs_getxattr(dentry,
381                                         d_backing_inode(dentry), xattr->name,
382                                         buffer + total_size,
383                                         buffer_size - total_size);
384                                 if (rc < 0)
385                                         return rc;
386                         }
387                         break;
388                 default:
389                         return -EINVAL;
390                 }
391
392                 total_size += size;
393         }
394
395         return total_size;
396 }
397
398 /**
399  * evm_verifyxattr - verify the integrity of the requested xattr
400  * @dentry: object of the verify xattr
401  * @xattr_name: requested xattr
402  * @xattr_value: requested xattr value
403  * @xattr_value_len: requested xattr value length
404  *
405  * Calculate the HMAC for the given dentry and verify it against the stored
406  * security.evm xattr. For performance, use the xattr value and length
407  * previously retrieved to calculate the HMAC.
408  *
409  * Returns the xattr integrity status.
410  *
411  * This function requires the caller to lock the inode's i_mutex before it
412  * is executed.
413  */
414 enum integrity_status evm_verifyxattr(struct dentry *dentry,
415                                       const char *xattr_name,
416                                       void *xattr_value, size_t xattr_value_len)
417 {
418         if (!evm_key_loaded() || !evm_protected_xattr(xattr_name))
419                 return INTEGRITY_UNKNOWN;
420
421         if (is_unsupported_fs(dentry))
422                 return INTEGRITY_UNKNOWN;
423
424         return evm_verify_hmac(dentry, xattr_name, xattr_value,
425                                  xattr_value_len);
426 }
427 EXPORT_SYMBOL_GPL(evm_verifyxattr);
428
429 /*
430  * evm_verify_current_integrity - verify the dentry's metadata integrity
431  * @dentry: pointer to the affected dentry
432  *
433  * Verify and return the dentry's metadata integrity. The exceptions are
434  * before EVM is initialized or in 'fix' mode.
435  */
436 static enum integrity_status evm_verify_current_integrity(struct dentry *dentry)
437 {
438         struct inode *inode = d_backing_inode(dentry);
439
440         if (!evm_key_loaded() || !S_ISREG(inode->i_mode) || evm_fixmode)
441                 return INTEGRITY_PASS;
442         return evm_verify_hmac(dentry, NULL, NULL, 0);
443 }
444
445 /*
446  * evm_xattr_change - check if passed xattr value differs from current value
447  * @idmap: idmap of the mount
448  * @dentry: pointer to the affected dentry
449  * @xattr_name: requested xattr
450  * @xattr_value: requested xattr value
451  * @xattr_value_len: requested xattr value length
452  *
453  * Check if passed xattr value differs from current value.
454  *
455  * Returns 1 if passed xattr value differs from current value, 0 otherwise.
456  */
457 static int evm_xattr_change(struct mnt_idmap *idmap,
458                             struct dentry *dentry, const char *xattr_name,
459                             const void *xattr_value, size_t xattr_value_len)
460 {
461         char *xattr_data = NULL;
462         int rc = 0;
463
464         rc = vfs_getxattr_alloc(&nop_mnt_idmap, dentry, xattr_name, &xattr_data,
465                                 0, GFP_NOFS);
466         if (rc < 0) {
467                 rc = 1;
468                 goto out;
469         }
470
471         if (rc == xattr_value_len)
472                 rc = !!memcmp(xattr_value, xattr_data, rc);
473         else
474                 rc = 1;
475
476 out:
477         kfree(xattr_data);
478         return rc;
479 }
480
481 /*
482  * evm_protect_xattr - protect the EVM extended attribute
483  *
484  * Prevent security.evm from being modified or removed without the
485  * necessary permissions or when the existing value is invalid.
486  *
487  * The posix xattr acls are 'system' prefixed, which normally would not
488  * affect security.evm.  An interesting side affect of writing posix xattr
489  * acls is their modifying of the i_mode, which is included in security.evm.
490  * For posix xattr acls only, permit security.evm, even if it currently
491  * doesn't exist, to be updated unless the EVM signature is immutable.
492  */
493 static int evm_protect_xattr(struct mnt_idmap *idmap,
494                              struct dentry *dentry, const char *xattr_name,
495                              const void *xattr_value, size_t xattr_value_len)
496 {
497         enum integrity_status evm_status;
498
499         if (strcmp(xattr_name, XATTR_NAME_EVM) == 0) {
500                 if (!capable(CAP_SYS_ADMIN))
501                         return -EPERM;
502                 if (is_unsupported_fs(dentry))
503                         return -EPERM;
504         } else if (!evm_protected_xattr(xattr_name)) {
505                 if (!posix_xattr_acl(xattr_name))
506                         return 0;
507                 if (is_unsupported_fs(dentry))
508                         return 0;
509
510                 evm_status = evm_verify_current_integrity(dentry);
511                 if ((evm_status == INTEGRITY_PASS) ||
512                     (evm_status == INTEGRITY_NOXATTRS))
513                         return 0;
514                 goto out;
515         } else if (is_unsupported_fs(dentry))
516                 return 0;
517
518         evm_status = evm_verify_current_integrity(dentry);
519         if (evm_status == INTEGRITY_NOXATTRS) {
520                 struct evm_iint_cache *iint;
521
522                 /* Exception if the HMAC is not going to be calculated. */
523                 if (evm_hmac_disabled())
524                         return 0;
525
526                 iint = evm_iint_inode(d_backing_inode(dentry));
527                 if (iint && (iint->flags & EVM_NEW_FILE))
528                         return 0;
529
530                 /* exception for pseudo filesystems */
531                 if (dentry->d_sb->s_magic == TMPFS_MAGIC
532                     || dentry->d_sb->s_magic == SYSFS_MAGIC)
533                         return 0;
534
535                 integrity_audit_msg(AUDIT_INTEGRITY_METADATA,
536                                     dentry->d_inode, dentry->d_name.name,
537                                     "update_metadata",
538                                     integrity_status_msg[evm_status],
539                                     -EPERM, 0);
540         }
541 out:
542         /* Exception if the HMAC is not going to be calculated. */
543         if (evm_hmac_disabled() && (evm_status == INTEGRITY_NOLABEL ||
544             evm_status == INTEGRITY_UNKNOWN))
545                 return 0;
546
547         /*
548          * Writing other xattrs is safe for portable signatures, as portable
549          * signatures are immutable and can never be updated.
550          */
551         if (evm_status == INTEGRITY_FAIL_IMMUTABLE)
552                 return 0;
553
554         if (evm_status == INTEGRITY_PASS_IMMUTABLE &&
555             !evm_xattr_change(idmap, dentry, xattr_name, xattr_value,
556                               xattr_value_len))
557                 return 0;
558
559         if (evm_status != INTEGRITY_PASS &&
560             evm_status != INTEGRITY_PASS_IMMUTABLE)
561                 integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry),
562                                     dentry->d_name.name, "appraise_metadata",
563                                     integrity_status_msg[evm_status],
564                                     -EPERM, 0);
565         return evm_status == INTEGRITY_PASS ? 0 : -EPERM;
566 }
567
568 /**
569  * evm_inode_setxattr - protect the EVM extended attribute
570  * @idmap: idmap of the mount
571  * @dentry: pointer to the affected dentry
572  * @xattr_name: pointer to the affected extended attribute name
573  * @xattr_value: pointer to the new extended attribute value
574  * @xattr_value_len: pointer to the new extended attribute value length
575  * @flags: flags to pass into filesystem operations
576  *
577  * Before allowing the 'security.evm' protected xattr to be updated,
578  * verify the existing value is valid.  As only the kernel should have
579  * access to the EVM encrypted key needed to calculate the HMAC, prevent
580  * userspace from writing HMAC value.  Writing 'security.evm' requires
581  * requires CAP_SYS_ADMIN privileges.
582  */
583 static int evm_inode_setxattr(struct mnt_idmap *idmap, struct dentry *dentry,
584                               const char *xattr_name, const void *xattr_value,
585                               size_t xattr_value_len, int flags)
586 {
587         const struct evm_ima_xattr_data *xattr_data = xattr_value;
588
589         /* Policy permits modification of the protected xattrs even though
590          * there's no HMAC key loaded
591          */
592         if (evm_initialized & EVM_ALLOW_METADATA_WRITES)
593                 return 0;
594
595         if (strcmp(xattr_name, XATTR_NAME_EVM) == 0) {
596                 if (!xattr_value_len)
597                         return -EINVAL;
598                 if (xattr_data->type != EVM_IMA_XATTR_DIGSIG &&
599                     xattr_data->type != EVM_XATTR_PORTABLE_DIGSIG)
600                         return -EPERM;
601         }
602         return evm_protect_xattr(idmap, dentry, xattr_name, xattr_value,
603                                  xattr_value_len);
604 }
605
606 /**
607  * evm_inode_removexattr - protect the EVM extended attribute
608  * @idmap: idmap of the mount
609  * @dentry: pointer to the affected dentry
610  * @xattr_name: pointer to the affected extended attribute name
611  *
612  * Removing 'security.evm' requires CAP_SYS_ADMIN privileges and that
613  * the current value is valid.
614  */
615 static int evm_inode_removexattr(struct mnt_idmap *idmap, struct dentry *dentry,
616                                  const char *xattr_name)
617 {
618         /* Policy permits modification of the protected xattrs even though
619          * there's no HMAC key loaded
620          */
621         if (evm_initialized & EVM_ALLOW_METADATA_WRITES)
622                 return 0;
623
624         return evm_protect_xattr(idmap, dentry, xattr_name, NULL, 0);
625 }
626
627 #ifdef CONFIG_FS_POSIX_ACL
628 static int evm_inode_set_acl_change(struct mnt_idmap *idmap,
629                                     struct dentry *dentry, const char *name,
630                                     struct posix_acl *kacl)
631 {
632         int rc;
633
634         umode_t mode;
635         struct inode *inode = d_backing_inode(dentry);
636
637         if (!kacl)
638                 return 1;
639
640         rc = posix_acl_update_mode(idmap, inode, &mode, &kacl);
641         if (rc || (inode->i_mode != mode))
642                 return 1;
643
644         return 0;
645 }
646 #else
647 static inline int evm_inode_set_acl_change(struct mnt_idmap *idmap,
648                                            struct dentry *dentry,
649                                            const char *name,
650                                            struct posix_acl *kacl)
651 {
652         return 0;
653 }
654 #endif
655
656 /**
657  * evm_inode_set_acl - protect the EVM extended attribute from posix acls
658  * @idmap: idmap of the idmapped mount
659  * @dentry: pointer to the affected dentry
660  * @acl_name: name of the posix acl
661  * @kacl: pointer to the posix acls
662  *
663  * Prevent modifying posix acls causing the EVM HMAC to be re-calculated
664  * and 'security.evm' xattr updated, unless the existing 'security.evm' is
665  * valid.
666  *
667  * Return: zero on success, -EPERM on failure.
668  */
669 static int evm_inode_set_acl(struct mnt_idmap *idmap, struct dentry *dentry,
670                              const char *acl_name, struct posix_acl *kacl)
671 {
672         enum integrity_status evm_status;
673
674         /* Policy permits modification of the protected xattrs even though
675          * there's no HMAC key loaded
676          */
677         if (evm_initialized & EVM_ALLOW_METADATA_WRITES)
678                 return 0;
679
680         evm_status = evm_verify_current_integrity(dentry);
681         if ((evm_status == INTEGRITY_PASS) ||
682             (evm_status == INTEGRITY_NOXATTRS))
683                 return 0;
684
685         /* Exception if the HMAC is not going to be calculated. */
686         if (evm_hmac_disabled() && (evm_status == INTEGRITY_NOLABEL ||
687             evm_status == INTEGRITY_UNKNOWN))
688                 return 0;
689
690         /*
691          * Writing other xattrs is safe for portable signatures, as portable
692          * signatures are immutable and can never be updated.
693          */
694         if (evm_status == INTEGRITY_FAIL_IMMUTABLE)
695                 return 0;
696
697         if (evm_status == INTEGRITY_PASS_IMMUTABLE &&
698             !evm_inode_set_acl_change(idmap, dentry, acl_name, kacl))
699                 return 0;
700
701         if (evm_status != INTEGRITY_PASS_IMMUTABLE)
702                 integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry),
703                                     dentry->d_name.name, "appraise_metadata",
704                                     integrity_status_msg[evm_status],
705                                     -EPERM, 0);
706         return -EPERM;
707 }
708
709 /**
710  * evm_inode_remove_acl - Protect the EVM extended attribute from posix acls
711  * @idmap: idmap of the mount
712  * @dentry: pointer to the affected dentry
713  * @acl_name: name of the posix acl
714  *
715  * Prevent removing posix acls causing the EVM HMAC to be re-calculated
716  * and 'security.evm' xattr updated, unless the existing 'security.evm' is
717  * valid.
718  *
719  * Return: zero on success, -EPERM on failure.
720  */
721 static int evm_inode_remove_acl(struct mnt_idmap *idmap, struct dentry *dentry,
722                                 const char *acl_name)
723 {
724         return evm_inode_set_acl(idmap, dentry, acl_name, NULL);
725 }
726
727 static void evm_reset_status(struct inode *inode)
728 {
729         struct evm_iint_cache *iint;
730
731         iint = evm_iint_inode(inode);
732         if (iint)
733                 iint->evm_status = INTEGRITY_UNKNOWN;
734 }
735
736 /**
737  * evm_revalidate_status - report whether EVM status re-validation is necessary
738  * @xattr_name: pointer to the affected extended attribute name
739  *
740  * Report whether callers of evm_verifyxattr() should re-validate the
741  * EVM status.
742  *
743  * Return true if re-validation is necessary, false otherwise.
744  */
745 bool evm_revalidate_status(const char *xattr_name)
746 {
747         if (!evm_key_loaded())
748                 return false;
749
750         /* evm_inode_post_setattr() passes NULL */
751         if (!xattr_name)
752                 return true;
753
754         if (!evm_protected_xattr(xattr_name) && !posix_xattr_acl(xattr_name) &&
755             strcmp(xattr_name, XATTR_NAME_EVM))
756                 return false;
757
758         return true;
759 }
760
761 /**
762  * evm_inode_post_setxattr - update 'security.evm' to reflect the changes
763  * @dentry: pointer to the affected dentry
764  * @xattr_name: pointer to the affected extended attribute name
765  * @xattr_value: pointer to the new extended attribute value
766  * @xattr_value_len: pointer to the new extended attribute value length
767  * @flags: flags to pass into filesystem operations
768  *
769  * Update the HMAC stored in 'security.evm' to reflect the change.
770  *
771  * No need to take the i_mutex lock here, as this function is called from
772  * __vfs_setxattr_noperm().  The caller of which has taken the inode's
773  * i_mutex lock.
774  */
775 static void evm_inode_post_setxattr(struct dentry *dentry,
776                                     const char *xattr_name,
777                                     const void *xattr_value,
778                                     size_t xattr_value_len,
779                                     int flags)
780 {
781         if (!evm_revalidate_status(xattr_name))
782                 return;
783
784         evm_reset_status(dentry->d_inode);
785
786         if (!strcmp(xattr_name, XATTR_NAME_EVM))
787                 return;
788
789         if (!(evm_initialized & EVM_INIT_HMAC))
790                 return;
791
792         if (is_unsupported_fs(dentry))
793                 return;
794
795         evm_update_evmxattr(dentry, xattr_name, xattr_value, xattr_value_len);
796 }
797
798 /**
799  * evm_inode_post_set_acl - Update the EVM extended attribute from posix acls
800  * @dentry: pointer to the affected dentry
801  * @acl_name: name of the posix acl
802  * @kacl: pointer to the posix acls
803  *
804  * Update the 'security.evm' xattr with the EVM HMAC re-calculated after setting
805  * posix acls.
806  */
807 static void evm_inode_post_set_acl(struct dentry *dentry, const char *acl_name,
808                                    struct posix_acl *kacl)
809 {
810         return evm_inode_post_setxattr(dentry, acl_name, NULL, 0, 0);
811 }
812
813 /**
814  * evm_inode_post_removexattr - update 'security.evm' after removing the xattr
815  * @dentry: pointer to the affected dentry
816  * @xattr_name: pointer to the affected extended attribute name
817  *
818  * Update the HMAC stored in 'security.evm' to reflect removal of the xattr.
819  *
820  * No need to take the i_mutex lock here, as this function is called from
821  * vfs_removexattr() which takes the i_mutex.
822  */
823 static void evm_inode_post_removexattr(struct dentry *dentry,
824                                        const char *xattr_name)
825 {
826         if (!evm_revalidate_status(xattr_name))
827                 return;
828
829         evm_reset_status(dentry->d_inode);
830
831         if (!strcmp(xattr_name, XATTR_NAME_EVM))
832                 return;
833
834         if (!(evm_initialized & EVM_INIT_HMAC))
835                 return;
836
837         evm_update_evmxattr(dentry, xattr_name, NULL, 0);
838 }
839
840 /**
841  * evm_inode_post_remove_acl - Update the EVM extended attribute from posix acls
842  * @idmap: idmap of the mount
843  * @dentry: pointer to the affected dentry
844  * @acl_name: name of the posix acl
845  *
846  * Update the 'security.evm' xattr with the EVM HMAC re-calculated after
847  * removing posix acls.
848  */
849 static inline void evm_inode_post_remove_acl(struct mnt_idmap *idmap,
850                                              struct dentry *dentry,
851                                              const char *acl_name)
852 {
853         evm_inode_post_removexattr(dentry, acl_name);
854 }
855
856 static int evm_attr_change(struct mnt_idmap *idmap,
857                            struct dentry *dentry, struct iattr *attr)
858 {
859         struct inode *inode = d_backing_inode(dentry);
860         unsigned int ia_valid = attr->ia_valid;
861
862         if (!i_uid_needs_update(idmap, attr, inode) &&
863             !i_gid_needs_update(idmap, attr, inode) &&
864             (!(ia_valid & ATTR_MODE) || attr->ia_mode == inode->i_mode))
865                 return 0;
866
867         return 1;
868 }
869
870 /**
871  * evm_inode_setattr - prevent updating an invalid EVM extended attribute
872  * @idmap: idmap of the mount
873  * @dentry: pointer to the affected dentry
874  * @attr: iattr structure containing the new file attributes
875  *
876  * Permit update of file attributes when files have a valid EVM signature,
877  * except in the case of them having an immutable portable signature.
878  */
879 static int evm_inode_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
880                              struct iattr *attr)
881 {
882         unsigned int ia_valid = attr->ia_valid;
883         enum integrity_status evm_status;
884
885         /* Policy permits modification of the protected attrs even though
886          * there's no HMAC key loaded
887          */
888         if (evm_initialized & EVM_ALLOW_METADATA_WRITES)
889                 return 0;
890
891         if (is_unsupported_fs(dentry))
892                 return 0;
893
894         if (!(ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)))
895                 return 0;
896
897         evm_status = evm_verify_current_integrity(dentry);
898         /*
899          * Writing attrs is safe for portable signatures, as portable signatures
900          * are immutable and can never be updated.
901          */
902         if ((evm_status == INTEGRITY_PASS) ||
903             (evm_status == INTEGRITY_NOXATTRS) ||
904             (evm_status == INTEGRITY_FAIL_IMMUTABLE) ||
905             (evm_hmac_disabled() && (evm_status == INTEGRITY_NOLABEL ||
906              evm_status == INTEGRITY_UNKNOWN)))
907                 return 0;
908
909         if (evm_status == INTEGRITY_PASS_IMMUTABLE &&
910             !evm_attr_change(idmap, dentry, attr))
911                 return 0;
912
913         integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry),
914                             dentry->d_name.name, "appraise_metadata",
915                             integrity_status_msg[evm_status], -EPERM, 0);
916         return -EPERM;
917 }
918
919 /**
920  * evm_inode_post_setattr - update 'security.evm' after modifying metadata
921  * @idmap: idmap of the idmapped mount
922  * @dentry: pointer to the affected dentry
923  * @ia_valid: for the UID and GID status
924  *
925  * For now, update the HMAC stored in 'security.evm' to reflect UID/GID
926  * changes.
927  *
928  * This function is called from notify_change(), which expects the caller
929  * to lock the inode's i_mutex.
930  */
931 static void evm_inode_post_setattr(struct mnt_idmap *idmap,
932                                    struct dentry *dentry, int ia_valid)
933 {
934         if (!evm_revalidate_status(NULL))
935                 return;
936
937         evm_reset_status(dentry->d_inode);
938
939         if (!(evm_initialized & EVM_INIT_HMAC))
940                 return;
941
942         if (is_unsupported_fs(dentry))
943                 return;
944
945         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
946                 evm_update_evmxattr(dentry, NULL, NULL, 0);
947 }
948
949 static int evm_inode_copy_up_xattr(const char *name)
950 {
951         if (strcmp(name, XATTR_NAME_EVM) == 0)
952                 return 1; /* Discard */
953         return -EOPNOTSUPP;
954 }
955
956 /*
957  * evm_inode_init_security - initializes security.evm HMAC value
958  */
959 int evm_inode_init_security(struct inode *inode, struct inode *dir,
960                             const struct qstr *qstr, struct xattr *xattrs,
961                             int *xattr_count)
962 {
963         struct evm_xattr *xattr_data;
964         struct xattr *xattr, *evm_xattr;
965         bool evm_protected_xattrs = false;
966         int rc;
967
968         if (!(evm_initialized & EVM_INIT_HMAC) || !xattrs)
969                 return 0;
970
971         /*
972          * security_inode_init_security() makes sure that the xattrs array is
973          * contiguous, there is enough space for security.evm, and that there is
974          * a terminator at the end of the array.
975          */
976         for (xattr = xattrs; xattr->name; xattr++) {
977                 if (evm_protected_xattr(xattr->name))
978                         evm_protected_xattrs = true;
979         }
980
981         /* EVM xattr not needed. */
982         if (!evm_protected_xattrs)
983                 return 0;
984
985         evm_xattr = lsm_get_xattr_slot(xattrs, xattr_count);
986         /*
987          * Array terminator (xattr name = NULL) must be the first non-filled
988          * xattr slot.
989          */
990         WARN_ONCE(evm_xattr != xattr,
991                   "%s: xattrs terminator is not the first non-filled slot\n",
992                   __func__);
993
994         xattr_data = kzalloc(sizeof(*xattr_data), GFP_NOFS);
995         if (!xattr_data)
996                 return -ENOMEM;
997
998         xattr_data->data.type = EVM_XATTR_HMAC;
999         rc = evm_init_hmac(inode, xattrs, xattr_data->digest);
1000         if (rc < 0)
1001                 goto out;
1002
1003         evm_xattr->value = xattr_data;
1004         evm_xattr->value_len = sizeof(*xattr_data);
1005         evm_xattr->name = XATTR_EVM_SUFFIX;
1006         return 0;
1007 out:
1008         kfree(xattr_data);
1009         return rc;
1010 }
1011 EXPORT_SYMBOL_GPL(evm_inode_init_security);
1012
1013 static int evm_inode_alloc_security(struct inode *inode)
1014 {
1015         struct evm_iint_cache *iint = evm_iint_inode(inode);
1016
1017         /* Called by security_inode_alloc(), it cannot be NULL. */
1018         iint->flags = 0UL;
1019         iint->evm_status = INTEGRITY_UNKNOWN;
1020
1021         return 0;
1022 }
1023
1024 static void evm_file_release(struct file *file)
1025 {
1026         struct inode *inode = file_inode(file);
1027         struct evm_iint_cache *iint = evm_iint_inode(inode);
1028         fmode_t mode = file->f_mode;
1029
1030         if (!S_ISREG(inode->i_mode) || !(mode & FMODE_WRITE))
1031                 return;
1032
1033         if (iint && atomic_read(&inode->i_writecount) == 1)
1034                 iint->flags &= ~EVM_NEW_FILE;
1035 }
1036
1037 static void evm_post_path_mknod(struct mnt_idmap *idmap, struct dentry *dentry)
1038 {
1039         struct inode *inode = d_backing_inode(dentry);
1040         struct evm_iint_cache *iint = evm_iint_inode(inode);
1041
1042         if (!S_ISREG(inode->i_mode))
1043                 return;
1044
1045         if (iint)
1046                 iint->flags |= EVM_NEW_FILE;
1047 }
1048
1049 #ifdef CONFIG_EVM_LOAD_X509
1050 void __init evm_load_x509(void)
1051 {
1052         int rc;
1053
1054         rc = integrity_load_x509(INTEGRITY_KEYRING_EVM, CONFIG_EVM_X509_PATH);
1055         if (!rc)
1056                 evm_initialized |= EVM_INIT_X509;
1057 }
1058 #endif
1059
1060 static int __init init_evm(void)
1061 {
1062         int error;
1063         struct list_head *pos, *q;
1064
1065         evm_init_config();
1066
1067         error = integrity_init_keyring(INTEGRITY_KEYRING_EVM);
1068         if (error)
1069                 goto error;
1070
1071         error = evm_init_secfs();
1072         if (error < 0) {
1073                 pr_info("Error registering secfs\n");
1074                 goto error;
1075         }
1076
1077 error:
1078         if (error != 0) {
1079                 if (!list_empty(&evm_config_xattrnames)) {
1080                         list_for_each_safe(pos, q, &evm_config_xattrnames)
1081                                 list_del(pos);
1082                 }
1083         }
1084
1085         return error;
1086 }
1087
1088 static struct security_hook_list evm_hooks[] __ro_after_init = {
1089         LSM_HOOK_INIT(inode_setattr, evm_inode_setattr),
1090         LSM_HOOK_INIT(inode_post_setattr, evm_inode_post_setattr),
1091         LSM_HOOK_INIT(inode_copy_up_xattr, evm_inode_copy_up_xattr),
1092         LSM_HOOK_INIT(inode_setxattr, evm_inode_setxattr),
1093         LSM_HOOK_INIT(inode_post_setxattr, evm_inode_post_setxattr),
1094         LSM_HOOK_INIT(inode_set_acl, evm_inode_set_acl),
1095         LSM_HOOK_INIT(inode_post_set_acl, evm_inode_post_set_acl),
1096         LSM_HOOK_INIT(inode_remove_acl, evm_inode_remove_acl),
1097         LSM_HOOK_INIT(inode_post_remove_acl, evm_inode_post_remove_acl),
1098         LSM_HOOK_INIT(inode_removexattr, evm_inode_removexattr),
1099         LSM_HOOK_INIT(inode_post_removexattr, evm_inode_post_removexattr),
1100         LSM_HOOK_INIT(inode_init_security, evm_inode_init_security),
1101         LSM_HOOK_INIT(inode_alloc_security, evm_inode_alloc_security),
1102         LSM_HOOK_INIT(file_release, evm_file_release),
1103         LSM_HOOK_INIT(path_post_mknod, evm_post_path_mknod),
1104 };
1105
1106 static const struct lsm_id evm_lsmid = {
1107         .name = "evm",
1108         .id = LSM_ID_EVM,
1109 };
1110
1111 static int __init init_evm_lsm(void)
1112 {
1113         security_add_hooks(evm_hooks, ARRAY_SIZE(evm_hooks), &evm_lsmid);
1114         return 0;
1115 }
1116
1117 struct lsm_blob_sizes evm_blob_sizes __ro_after_init = {
1118         .lbs_inode = sizeof(struct evm_iint_cache),
1119         .lbs_xattr_count = 1,
1120 };
1121
1122 DEFINE_LSM(evm) = {
1123         .name = "evm",
1124         .init = init_evm_lsm,
1125         .order = LSM_ORDER_LAST,
1126         .blobs = &evm_blob_sizes,
1127 };
1128
1129 late_initcall(init_evm);