Skip to contentSkip to conversation

Integrity Policy Enforcement LSM (IPE)

RFC PATCH Superseded Fan Wu 4 participants 38 messages Jan 30, 2024 – Feb 6, 2024

Subsystems (11)
Documentation VFS Block layer Kbuild +7 more subsystems

v12 of 20 Superseded Latest is v20 →

lore
Share & tools
lore

Fan Wu

author
#0 lore raw

v12 cover Integrity Policy Enforcement LSM (IPE)

Overview:
---------

IPE is a Linux Security Module which takes a complimentary approach to access control. Whereas existing mandatory access control mechanisms base their decisions on labels and paths, IPE instead determines whether or not an operation should be allowed based on immutable security properties of the system component the operation is being performed on.

IPE itself does not mandate how the security property should be evaluated, but relies on an extensible set of external property providers to evaluate the component. IPE makes its decision based on reference values for the selected properties, specified in the IPE policy.

The reference values represent the value that the policy writer and the local system administrator (based on the policy signature) trust for the system to accomplish the desired tasks.

One such provider is for example dm-verity, which is able to represent the integrity property of a partition (its immutable state) with a digest.

IPE is compiled under CONFIG_SECURITY_IPE.

Use Cases
---------

IPE works best in fixed-function devices: Devices in which their purpose is clearly defined and not supposed to be changed (e.g. network firewall device in a data center, an IoT device, etcetera), where all software and configuration is built and provisioned by the system owner.

IPE is a long-way off for use in general-purpose computing: the Linux community as a whole tends to follow a decentralized trust model, known as the web of trust, which IPE has no support for as of yet. There are exceptions, such as the case where a Linux distribution vendor trusts only their own keys, where IPE can successfully be used to enforce the trust requirement.

Additionally, while most packages are signed today, the files inside the packages (for instance, the executables), tend to be unsigned. This makes it difficult to utilize IPE in systems where a package manager is expected to be functional, without major changes to the package manager and ecosystem behind it.

DIGLIM[1] is a system that when combined with IPE, could be used to enable general purpose computing scenarios.

Policy:
-------

IPE policy is a plain-text policy composed of multiple statements over several lines. There is one required line, at the top of the policy, indicating the policy name, and the policy version, for instance:

policy_name=Ex_Policy policy_version=0.0.0

The policy version indicates the current version of the policy. This is used to prevent roll-back of policy to potentially insecure previous versions of the policy.

The next portion of IPE policy, are rules. Rules are formed by key=value pairs, known as properties. IPE rules require two keys: "action", which determines what IPE does when it encounters a match against the policy and "op", which determines when that rule should be evaluated.

Thus, a minimal rule is:

op=EXECUTE action=ALLOW

This example rule will allow any execution. A rule is required to have the "op" property as the first token of a rule, and the "action" as the last token of the rule.

Additional properties are used to restrict attributes about the files being evaluated. These properties are intended to be deterministic attributes that are resident in the kernel.

For example:

op=EXECUTE dmverity_signature=FALSE action=DENY

This rule with property dmverity_signature will deny any file not from a signed dmverity volume to be executed.

All available properties for IPE described in the documentation patch of this series.

Rules are evaluated top-to-bottom. As a result, any revocation rules, or denies should be placed early in the file to ensure that these rules are evaluated before a rule with "action=ALLOW" is hit.

Any unknown syntax in IPE policy will result in a fatal error to parse the policy.

Additionally, a DEFAULT operation must be set for all understood operations within IPE. For policies to remain completely forwards compatible, it is recommended that users add a "DEFAULT action=ALLOW" and override the defaults on a per-operation basis.

For more information about the policy syntax, see the kernel documentation page.

Early Usermode Protection:
--------------------------

IPE can be provided with a policy at startup to load and enforce. This is intended to be a minimal policy to get the system to a state where userspace is setup and ready to receive commands, at which point a policy can be deployed via securityfs. This "boot policy" can be specified via the config, SECURITY_IPE_BOOT_POLICY, which accepts a path to a plain-text version of the IPE policy to apply. This policy will be compiled into the kernel. If not specified, IPE will be disabled until a policy is deployed and activated through the method above.

Policy Examples:
----------------

Allow all:

policy_name=Allow_All policy_version=0.0.0
DEFAULT action=ALLOW

Allow only initramfs:

policy_name=Allow_All_Initramfs policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE boot_verified=TRUE action=ALLOW

Allow any signed dm-verity volume and the initramfs:

policy_name=AllowSignedAndInitramfs policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE boot_verified=TRUE action=ALLOW
op=EXECUTE dmverity_signature=TRUE action=ALLOW

Prohibit execution from a specific dm-verity volume, while allowing all signed volumes and the initramfs:

policy_name=ProhibitSingleVolume policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE dmverity_roothash=sha256:401fcec5944823ae12f62726e8184407a5fa9599783f030dec146938 action=DENY op=EXECUTE boot_verified=TRUE action=ALLOW
op=EXECUTE dmverity_signature=TRUE action=ALLOW

Allow only a specific dm-verity volume:

policy_name=AllowSpecific policy_version=0.0.0
DEFAULT action=DENY

op=EXECUTE dmverity_roothash=sha256:401fcec5944823ae12f62726e8184407a5fa9599783f030dec146938 action=ALLOW

Allow any signed fs-verity file

policy_name=AllowSignedFSVerity policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE fsverity_signature=TRUE action=ALLOW

Deny a specific fs-verity file:

policy_name=ProhibitSpecificFSVF policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE fsverity_digest=sha256:fd88f2b8824e197f850bf4c5109bea5cf0ee38104f710843bb72da796ba5af9e action=DENY op=EXECUTE boot_verified=TRUE action=ALLOW
op=EXECUTE dmverity_signature=TRUE action=ALLOW

Deploying Policies:
-------------------

First sign a plain text policy, with a certificate that is present in the SYSTEM_TRUSTED_KEYRING of your test machine. Through openssl, the signing can be done via:

  openssl smime -sign -in "$MY_POLICY" -signer "$MY_CERTIFICATE" \
    -inkey "$MY_PRIVATE_KEY" -outform der -noattr -nodetach \
    -out "$MY_POLICY.p7s"

Then, simply cat the file into the IPE's "new_policy" securityfs node:

cat "$MY_POLICY.p7s" > /sys/kernel/security/ipe/new_policy

The policy should now be present under the policies/ subdirectory, under its "policy_name" attribute.

The policy is now present in the kernel and can be marked as active, via the securityfs node:

echo 1 > "/sys/kernel/security/ipe/$MY_POLICY_NAME/active"

This will now mark the policy as active and the system will be enforcing $MY_POLICY_NAME.

There is one requirement when marking a policy as active, the policy_version attribute must either increase, or remain the same as the currently running policy.

Policies can be updated via:

  cat "$MY_UPDATED_POLICY.p7s" > \
    "/sys/kernel/security/ipe/policies/$MY_POLICY_NAME/update"

Additionally, policies can be deleted via the "delete" securityfs node. Simply write "1" to the corresponding node in the policy folder:

echo 1 > "/sys/kernel/security/ipe/policies/$MY_POLICY_NAME/delete"

There is only one requirement to delete policies, the policy being deleted must not be the active policy.

NOTE: Any securityfs write to IPE's nodes will require CAP_MAC_ADMIN.

Integrations:
-------------

This patch series adds support for fsverity via digest and signature (fsverity_signature and fsverity_digest), dm-verity by digest and signature (dmverity_signature and dmverity_roothash), and trust for the initramfs (boot_verified).

Please see the documentation patch for more information about the integrations available.

Testing:
--------

KUnit Tests are available. Recommended kunitconfig:

CONFIG_KUNIT=y
CONFIG_SECURITY=y
CONFIG_SECURITYFS=y
CONFIG_PKCS7_MESSAGE_PARSER=y
CONFIG_SYSTEM_DATA_VERIFICATION=y
CONFIG_FS_VERITY=y
CONFIG_FS_VERITY_BUILTIN_SIGNATURES=y
CONFIG_BLOCK=y
CONFIG_MD=y
CONFIG_BLK_DEV_DM=y
CONFIG_DM_VERITY=y
CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG=y
CONFIG_NET=y
CONFIG_AUDIT=y
CONFIG_AUDITSYSCALL=y
CONFIG_BLK_DEV_INITRD=y

CONFIG_SECURITY_IPE=y
CONFIG_IPE_PROP_DM_VERITY=y
CONFIG_IPE_PROP_FS_VERITY=y
CONFIG_SECURITY_IPE_KUNIT_TEST=y

Simply run:

make ARCH=um mrproper
./tools/testing/kunit/kunit.py run --kunitconfig <path/to/config>

And the tests will execute and report the result.

In addition, IPE has a python based integration
test suite https://github.com/microsoft/ipe/tree/test-suite that can test both user interfaces and enforcement functionalities.

Documentation:
--------------

There is both documentation available on github at
https://microsoft.github.io/ipe, and Documentation in this patch series, to be added in-tree.

Known Gaps:
-----------

IPE has two known gaps:

1. IPE cannot verify the integrity of anonymous executable memory, such as the trampolines created by gcc closures and libffi (<3.4.2), or JIT'd code. Unfortunately, as this is dynamically generated code, there is no way for IPE to ensure the integrity of this code to form a trust basis. In all cases, the return result for these operations will be whatever the admin configures the DEFAULT action for "EXECUTE".

2. IPE cannot verify the integrity of interpreted languages' programs when these scripts invoked via ``<interpreter> <file>``. This is because the way interpreters execute these files, the scripts themselves are not evaluated as executable code through one of IPE's hooks. Interpreters can be enlightened to the usage of IPE by trying to mmap a file into executable memory (+X), after opening the file and responding to the error code appropriately. This also applies to included files, or high value files, such as configuration files of critical system components.

Appendix:
---------

A. IPE Github Repository: https://github.com/microsoft/ipe
B. IPE Users' Guide: Documentation/admin-guide/LSM/ipe.rst

References:
-----------

1: https://lore.kernel.org/bpf/[email protected]/

FAQ:
----

Q: What is the difference between IMA and IPE?

A: See the documentation patch for more on this topic.

Previous Postings
-----------------

v1: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/all/[email protected]/
v3: https://lore.kernel.org/all/[email protected]/
v4: https://lore.kernel.org/all/[email protected]/
v5: https://lore.kernel.org/all/[email protected]/
v6: https://lore.kernel.org/all/[email protected]/
v7: https://lore.kernel.org/all/1634151995-16266-1-git-send-email-deven.desai@linux.microsoft.com/
v8: https://lore.kernel.org/all/1654714889-26728-1-git-send-email-deven.desai@linux.microsoft.com/
v9: https://lore.kernel.org/lkml/[email protected]/
v10: https://lore.kernel.org/lkml/[email protected]/
v11: https://lore.kernel.org/lkml/[email protected]/

Changelog:
----------

v2:
Split the second patch of the previous series into two. Minor corrections in the cover-letter and documentation comments regarding CAP_MAC_ADMIN checks in IPE.

v3:
Address various comments by Jann Horn. Highlights:
Switch various audit allocators to GFP_KERNEL. Utilize rcu_access_pointer() in various locations. Strip out the caching system for properties
Strip comments from headers
Move functions around in patches
Remove kernel command line parameters
Reconcile the race condition on the delete node for policy by
expanding the policy critical section.

Address a few comments by Jonathan Corbet around the documentation
pages for IPE.

Fix an issue with the initialization of IPE policy with a "-0"
version, caused by not initializing the hlist entries before freeing.

v4:
Address a concern around IPE's behavior with unknown syntax.
Specifically, make any unknown syntax a fatal error instead of a warning, as suggested by Mickaël Salaün.
Introduce a new securityfs node, $securityfs/ipe/property_config,
which provides a listing of what properties are enabled by the kernel and their versions. This allows usermode to predict what policies should be allowed.
Strip some comments from c files that I missed.
Clarify some documentation comments around 'boot_verified'.
While this currently does not functionally change the property itself, the distinction is important when IPE can enforce verified reads. Additionally, 'KERNEL_READ' was omitted from the documentation. This has been corrected.
Change SecurityFS and SHA1 to a reverse dependency.
Update the cover-letter with the updated behavior of unknown syntax. Remove all sysctls, making an equivalent function in securityfs. Rework the active/delete mechanism to be a node under the policy in
$securityfs/ipe/policies.
The kernel command line parameters ipe.enforce and ipe.success_audit
have returned as this functionality is no longer exposed through sysfs.

v5:
Correct some grammatical errors reported by Randy Dunlap. Fix some warnings reported by kernel test bot.
Change convention around security_bdev_setsecurity. -ENOSYS
is now expected if an LSM does not implement a particular @name, as suggested by Casey Schaufler.
Minor string corrections related to the move from sysfs to securityfs Correct a spelling of an #ifdef for the permissive argument. Add the kernel parameters re-added to the documentation. Fix a minor bug where the mode being audited on permissive switch
was the original mode, not the mode being swapped to.
Cleanup doc comments, fix some whitespace alignment issues.

v6:
Change if statement condition in security_bdev_setsecurity to be
more concise, as suggested by Casey Schaufler and Al Viro
Drop the 6th patch in the series, "dm-verity move signature check..."
due to numerous issues, and it ultimately providing no real value.
Fix the patch tree - the previous iteration appears to have been in a
torn state (patches 8+9 were merged). This has since been corrected.

v7:
* Reword cover letter to more accurate convey IPE's purpose and latest updates.
* Refactor series to:
1. Support a context structure, enabling:
1. Easier Testing via KUNIT
2. A better architecture for future designs
2. Make parser code cleaner
* Move patch 01/12 to [14/16] of the series
* Split up patch 02/12 into four parts:
1. context creation [01/16]
2. audit [07/16]
3. evaluation loop [03/16]
4. access control hooks [05/16]
5. permissive mode [08/16]
* Split up patch 03/12 into two parts:
1. parser [02/16]
2. userspace interface [04/16]
* Reword and refactor patch 04/12 to [09/16]
* Squash patch 05/12, 07/12, 09/12 to [10/16]
* Squash patch 08/12, 10/12 to [11/16]
* Change audit records to MAC region (14XX) from Integrity region (18XX)
* Add FSVerity Support
* Interface changes:
1. "raw" was renamed to "pkcs7" and made read only
2. "raw"'s write functionality (update a policy) moved to "update"
3. introduced "version", "policy_name" nodes.
4. "content" renamed to "policy"
5. The boot policy can now be updated like any other policy.
* Add additional developer-level documentation
* Update admin-guide docs to reflect changes.
* Kunit tests
* Dropped CONFIG_SECURITY_IPE_PERMISSIVE_SWITCH - functionality can easily come later with a small patch.
* Use partition0 for block_device for dm-verity patch

v8:
* Add changelog information to individual commits
* A large number of changes to the audit patch.
* split fs/ & security/ changes to two separate patches.
* split block/, security/ & drivers/md/ changes to separate patches.
* Add some historical context to what lead to the creation of IPE in the documentation patch.
* Cover-letter changes suggested by Roberto Sassu.

v9:
* Rewrite IPE parser to use kernel match_table parser.
* Adapt existing IPE properties to the new parser.
* Remove ipe_context, quote policy syntax, kernel_read for simplicity.
* Add new function in the security file system to delete IPE policy.
* Make IPE audit builtin and change several audit formats.
* Make boot_verified property builtin

v10:
* Address various code style/format issues
* Correct the rcu locking for active policy
* Fix memleak bugs in the parser, optimize the parser per upstream feedback
* Adding new audit events for IPE and update audit formats
* Make the dmverity property auto selected
* Adding more context in the commit messages

v11:
* Address various code style/format issues
* Add finalize hook to device mapper
* move the security hook for dm-verity to the new device mapper finalize hook

v12:
* Address locking issues
* Change the implementation of boot_verified to trust initramfs only
* Update audit format for IPE decision events
* Refactor code for lsm_id
* Add IPE test suite link

Deven Bowers (13):
security: add ipe lsm
ipe: add policy parser
ipe: add evaluation loop
ipe: add LSM hooks on execution and kernel read
ipe: add userspace interface
uapi|audit|ipe: add ipe auditing support
ipe: add permissive toggle
block|security: add LSM blob to block_device
dm verity: consume root hash digest and signature data via LSM hook
ipe: add support for dm-verity as a trust provider
scripts: add boot policy generation program
ipe: kunit test for parser
documentation: add ipe documentation

Fan Wu (7):
initramfs|security: Add security hook to initramfs unpack
ipe: introduce 'boot_verified' as a trust provider
security: add new securityfs delete function
dm verity: set DM_TARGET_SINGLETON feature flag
dm: add finalize hook to target_type
fsverity: consume builtin signature via LSM hook
ipe: enable support for fs-verity as a trust provider

 Documentation/admin-guide/LSM/index.rst       |   1 +
 Documentation/admin-guide/LSM/ipe.rst         | 761 ++++++++++++++++++
 .../admin-guide/kernel-parameters.txt         |  12 +
 Documentation/security/index.rst              |   1 +
 Documentation/security/ipe.rst                | 444 ++++++++++
 MAINTAINERS                                   |  10 +
 block/bdev.c                                  |   7 +
 drivers/md/dm-verity-target.c                 |  73 +-
 drivers/md/dm-verity.h                        |   6 +
 drivers/md/dm.c                               |  12 +
 fs/verity/fsverity_private.h                  |   2 +-
 fs/verity/open.c                              |  26 +-
 include/linux/blk_types.h                     |   3 +
 include/linux/device-mapper.h                 |   7 +
 include/linux/dm-verity.h                     |  19 +
 include/linux/fsverity.h                      |   2 +
 include/linux/lsm_hook_defs.h                 |   9 +
 include/linux/lsm_hooks.h                     |   1 +
 include/linux/security.h                      |  33 +
 include/uapi/linux/audit.h                    |   3 +
 include/uapi/linux/lsm.h                      |   1 +
 init/initramfs.c                              |   3 +
 scripts/Makefile                              |   1 +
 scripts/ipe/Makefile                          |   2 +
 scripts/ipe/polgen/.gitignore                 |   2 +
 scripts/ipe/polgen/Makefile                   |   5 +
 scripts/ipe/polgen/polgen.c                   | 145 ++++
 security/Kconfig                              |  11 +-
 security/Makefile                             |   1 +
 security/inode.c                              |  25 +
 security/ipe/.gitignore                       |   2 +
 security/ipe/Kconfig                          |  75 ++
 security/ipe/Makefile                         |  31 +
 security/ipe/audit.c                          | 293 +++++++
 security/ipe/audit.h                          |  19 +
 security/ipe/digest.c                         | 120 +++
 security/ipe/digest.h                         |  26 +
 security/ipe/eval.c                           | 405 ++++++++++
 security/ipe/eval.h                           |  68 ++
 security/ipe/fs.c                             | 247 ++++++
 security/ipe/fs.h                             |  16 +
 security/ipe/hooks.c                          | 288 +++++++
 security/ipe/hooks.h                          |  55 ++
 security/ipe/ipe.c                            | 104 +++
 security/ipe/ipe.h                            |  28 +
 security/ipe/policy.c                         | 229 ++++++
 security/ipe/policy.h                         | 100 +++
 security/ipe/policy_fs.c                      | 469 +++++++++++
 security/ipe/policy_parser.c                  | 554 +++++++++++++
 security/ipe/policy_parser.h                  |  11 +
 security/ipe/policy_tests.c                   | 294 +++++++
 security/security.c                           | 114 ++-
 52 files changed, 5167 insertions(+), 9 deletions(-)
 create mode 100644 Documentation/admin-guide/LSM/ipe.rst
 create mode 100644 Documentation/security/ipe.rst
 create mode 100644 include/linux/dm-verity.h
 create mode 100644 scripts/ipe/Makefile
 create mode 100644 scripts/ipe/polgen/.gitignore
 create mode 100644 scripts/ipe/polgen/Makefile
 create mode 100644 scripts/ipe/polgen/polgen.c
 create mode 100644 security/ipe/.gitignore
 create mode 100644 security/ipe/Kconfig
 create mode 100644 security/ipe/Makefile
 create mode 100644 security/ipe/audit.c
 create mode 100644 security/ipe/audit.h
 create mode 100644 security/ipe/digest.c
 create mode 100644 security/ipe/digest.h
 create mode 100644 security/ipe/eval.c
 create mode 100644 security/ipe/eval.h
 create mode 100644 security/ipe/fs.c
 create mode 100644 security/ipe/fs.h
 create mode 100644 security/ipe/hooks.c
 create mode 100644 security/ipe/hooks.h
 create mode 100644 security/ipe/ipe.c
 create mode 100644 security/ipe/ipe.h
 create mode 100644 security/ipe/policy.c
 create mode 100644 security/ipe/policy.h
 create mode 100644 security/ipe/policy_fs.c
 create mode 100644 security/ipe/policy_parser.c
 create mode 100644 security/ipe/policy_parser.h
 create mode 100644 security/ipe/policy_tests.c

--
2.43.0

author
#1 lore raw

RFC PATCH v12 1/20 security: add ipe lsm

From: Deven Bowers <[email protected]>

Integrity Policy Enforcement (IPE) is an LSM that provides an complimentary approach to Mandatory Access Control than existing LSMs today.

Existing LSMs have centered around the concept of access to a resource should be controlled by the current user's credentials. IPE's approach, is that access to a resource should be controlled by the system's trust of a current resource.

The basis of this approach is defining a global policy to specify which resource can be trusted.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations
+ Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+ Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record, reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation into a separate commit from the evaluation loop and audit system, for easier review.

+ Introduce the concept of an ipe_context, a scoped way to introduce execution policies, used initially for allowing for kunit tests in isolation.

v8:
+ Follow lsmname_hook_name convention for lsm hooks.
+ Move LSM blob accessors to ipe.c and mark LSM blobs as static.

v9:
+ Remove ipe_context for simplification

v10:
+ Add github url

v11:
+ Correct github url
+ Move ipe before bpf

v12:
+ Switch to use lsm_id instead of string for lsm name

---
 MAINTAINERS              |  7 +++++++
 include/uapi/linux/lsm.h |  1 +
 security/Kconfig         | 11 ++++++-----
 security/Makefile        |  1 +
 security/ipe/Kconfig     | 17 +++++++++++++++++
 security/ipe/Makefile    |  9 +++++++++
 security/ipe/ipe.c       | 41 ++++++++++++++++++++++++++++++++++++++++
 security/ipe/ipe.h       | 16 ++++++++++++++++
 security/security.c      |  3 ++-
 9 files changed, 100 insertions(+), 6 deletions(-)
 create mode 100644 security/ipe/Kconfig
 create mode 100644 security/ipe/Makefile
 create mode 100644 security/ipe/ipe.c
 create mode 100644 security/ipe/ipe.h
MAINTAINERS +7 -0
index 8999497011a2..51464982297b 100644
@@ -10644,6 +10644,13 @@ T:	git git://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git
 F:	security/integrity/
 F:	security/integrity/ima/
 
+INTEGRITY POLICY ENFORCEMENT (IPE)
+M:	Fan Wu <[email protected]>
+L:	[email protected]
+S:	Supported
+T:	git https://github.com/microsoft/ipe.git
+F:	security/ipe/
+
 INTEL 810/815 FRAMEBUFFER DRIVER
 M:	Antonino Daplas <[email protected]>
 L:	[email protected]
include/uapi/linux/lsm.h +1 -0
index f8aef9ade549..43e2fb32745a 100644
@@ -62,6 +62,7 @@ struct lsm_ctx {
 #define LSM_ID_LOCKDOWN		108
 #define LSM_ID_BPF		109
 #define LSM_ID_LANDLOCK		110
+#define LSM_ID_IPE		111
 
 /*
  * LSM_ATTR_XXX definitions identify different LSM attributes
security/Kconfig +6 -5
index 52c9af08ad35..cc7adfbb6b96 100644
@@ -194,6 +194,7 @@ source "security/yama/Kconfig"
 source "security/safesetid/Kconfig"
 source "security/lockdown/Kconfig"
 source "security/landlock/Kconfig"
+source "security/ipe/Kconfig"
 
 source "security/integrity/Kconfig"
 
@@ -233,11 +234,11 @@ endchoice
 
 config LSM
 	string "Ordered list of enabled LSMs"
-	default "landlock,lockdown,yama,loadpin,safesetid,smack,selinux,tomoyo,apparmor,bpf" if DEFAULT_SECURITY_SMACK
-	default "landlock,lockdown,yama,loadpin,safesetid,apparmor,selinux,smack,tomoyo,bpf" if DEFAULT_SECURITY_APPARMOR
-	default "landlock,lockdown,yama,loadpin,safesetid,tomoyo,bpf" if DEFAULT_SECURITY_TOMOYO
-	default "landlock,lockdown,yama,loadpin,safesetid,bpf" if DEFAULT_SECURITY_DAC
-	default "landlock,lockdown,yama,loadpin,safesetid,selinux,smack,tomoyo,apparmor,bpf"
+	default "landlock,lockdown,yama,loadpin,safesetid,smack,selinux,tomoyo,apparmor,ipe,bpf" if DEFAULT_SECURITY_SMACK
+	default "landlock,lockdown,yama,loadpin,safesetid,apparmor,selinux,smack,tomoyo,ipe,bpf" if DEFAULT_SECURITY_APPARMOR
+	default "landlock,lockdown,yama,loadpin,safesetid,tomoyo,ipe,bpf" if DEFAULT_SECURITY_TOMOYO
+	default "landlock,lockdown,yama,loadpin,safesetid,ipe,bpf" if DEFAULT_SECURITY_DAC
+	default "landlock,lockdown,yama,loadpin,safesetid,selinux,smack,tomoyo,apparmor,ipe,bpf"
 	help
 	  A comma-separated list of LSMs, in initialization order.
 	  Any LSMs left off this list, except for those with order
security/Makefile +1 -0
index 59f238490665..cc0982214b84 100644
@@ -25,6 +25,7 @@ obj-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown/
 obj-$(CONFIG_CGROUPS)			+= device_cgroup.o
 obj-$(CONFIG_BPF_LSM)			+= bpf/
 obj-$(CONFIG_SECURITY_LANDLOCK)		+= landlock/
+obj-$(CONFIG_SECURITY_IPE)		+= ipe/
 
 # Object integrity file lists
 obj-$(CONFIG_INTEGRITY)			+= integrity/
security/ipe/Kconfig new file +17 -0
new file mode 100644
index 000000000000..e4875fb04883
@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: GPL-2.0-only
+#
+# Integrity Policy Enforcement (IPE) configuration
+#
+
+menuconfig SECURITY_IPE
+	bool "Integrity Policy Enforcement (IPE)"
+	depends on SECURITY && SECURITYFS
+	select PKCS7_MESSAGE_PARSER
+	select SYSTEM_DATA_VERIFICATION
+	help
+	  This option enables the Integrity Policy Enforcement LSM
+	  allowing users to define a policy to enforce a trust-based access
+	  control. A key feature of IPE is a customizable policy to allow
+	  admins to reconfigure trust requirements on the fly.
+
+	  If unsure, answer N.
security/ipe/Makefile new file +9 -0
new file mode 100644
index 000000000000..f7a80d0f18f8
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (C) Microsoft Corporation. All rights reserved.
+#
+# Makefile for building the IPE module as part of the kernel tree.
+#
+
+obj-$(CONFIG_SECURITY_IPE) += \
+	ipe.o \
security/ipe/ipe.c new file +41 -0

41 lines not on this page · raw message

security/ipe/ipe.h new file +16 -0
new file mode 100644
index 000000000000..a1c68d0fc2e0
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef _IPE_H
+#define _IPE_H
+
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+#define pr_fmt(fmt) "IPE: " fmt
+
+#include <linux/lsm_hooks.h>
+
+#endif /* _IPE_H */
security/security.c +2 -1
index 0144a98d3712..ddf2e69cf8f2 100644
@@ -50,7 +50,8 @@
 	(IS_ENABLED(CONFIG_SECURITY_SAFESETID) ? 1 : 0) + \
 	(IS_ENABLED(CONFIG_SECURITY_LOCKDOWN_LSM) ? 1 : 0) + \
 	(IS_ENABLED(CONFIG_BPF_LSM) ? 1 : 0) + \
-	(IS_ENABLED(CONFIG_SECURITY_LANDLOCK) ? 1 : 0))
+	(IS_ENABLED(CONFIG_SECURITY_LANDLOCK) ? 1 : 0) + \
+	(IS_ENABLED(CONFIG_SECURITY_IPE) ? 1 : 0))
 
 /*
  * These are descriptions of the reasons that can be passed to the
Signature · 1 line
2.43.0
author
#2 lore raw

RFC PATCH v12 2/20 ipe: add policy parser

In reply to Fan Wu

From: Deven Bowers <[email protected]>

IPE's interpretation of the what the user trusts is accomplished through its policy. IPE's design is to not provide support for a single trust provider, but to support multiple providers to enable the end-user to choose the best one to seek their needs.

This requires the policy to be rather flexible and modular so that integrity providers, like fs-verity, dm-verity, dm-integrity, or some other system, can plug into the policy with minimal code changes.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move policy load and activation audit event to 03/12
+ Fix a potential panic when a policy failed to load.
+ use pr_warn for a failure to parse instead of an audit record
+ Remove comments from headers
+ Add lockdep assertions to ipe_update_active_policy and ipe_activate_policy
+ Fix up warnings with checkpatch --strict
+ Use file_ns_capable for CAP_MAC_ADMIN for securityfs nodes.
+ Use memdup_user instead of kzalloc+simple_write_to_buffer.
+ Remove strict_parse command line parameter, as it is added by the sysctl command line.
+ Prefix extern variables with ipe_

v4:
+ Remove securityfs to reverse-dependency
+ Add SHA1 reverse dependency.
+ Add versioning scheme for IPE properties, and associated interface to query the versioning scheme.
+ Cause a parser to always return an error on unknown syntax.
+ Remove strict_parse option
+ Change active_policy interface from sysctl, to securityfs, and change scheme.

v5:
+ Cause an error if a default action is not defined for each operation.
+ Minor function renames

v6:
+ No changes

v7:
+ Further split parser and userspace interface into two separate commits, for easier review.
+ Refactor policy parser to make code cleaner via introducing a more modular design, for easier extension of policy, and easier review.

v8:
+ remove unnecessary pr_info emission on parser loading
+ add explicit newline to the pr_err emitted when a parser fails to load.

v9:
+ switch to match table to parse policy
+ remove quote syntax and KERNEL_READ operation

v10:
+ Fix memory leaks in parser
+ Fix typos and change code styles

v11:
+ Fix code style issues

v12:
+ Add __always_unused to an unused parameter
+ Simplify error case handling

---
 security/ipe/Makefile        |   2 +
 security/ipe/policy.c        | 101 ++++++++
 security/ipe/policy.h        |  83 ++++++
 security/ipe/policy_parser.c | 487 +++++++++++++++++++++++++++++++++++
 security/ipe/policy_parser.h |  11 +
 5 files changed, 684 insertions(+)
 create mode 100644 security/ipe/policy.c
 create mode 100644 security/ipe/policy.h
 create mode 100644 security/ipe/policy_parser.c
 create mode 100644 security/ipe/policy_parser.h
security/ipe/Makefile +2 -0
index f7a80d0f18f8..c09aec4904f2 100644
@@ -7,3 +7,5 @@
 
 obj-$(CONFIG_SECURITY_IPE) += \
 	ipe.o \
+	policy.o \
+	policy_parser.o \
security/ipe/policy.c new file +101 -0

101 lines not on this page · raw message

security/ipe/policy.h new file +83 -0

83 lines not on this page · raw message

security/ipe/policy_parser.c new file +487 -0

487 lines not on this page · raw message

security/ipe/policy_parser.h new file +11 -0
new file mode 100644
index 000000000000..2b744103d06a
@@ -0,0 +1,11 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+#ifndef _IPE_POLICY_PARSER_H
+#define _IPE_POLICY_PARSER_H
+
+int parse_policy(struct ipe_policy *p);
+void free_parsed_policy(struct ipe_parsed_policy *p);
+
+#endif /* _IPE_POLICY_PARSER_H */
Signature · 1 line
2.43.0
author
#3 lore raw

RFC PATCH v12 3/20 ipe: add evaluation loop

In reply to Fan Wu

From: Deven Bowers <[email protected]>

IPE must have a centralized function to evaluate incoming callers against IPE's policy. This iteration of the policy for against the rules for that specific caller is known as the evaluation loop.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record,
+ reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation into a separate commit from the evaluation loop and audit system, for easier review.
+ Propagating changes to support the new ipe_context structure in the evaluation loop.

v8:
+ Remove ipe_hook enumeration; hooks can be correlated via syscall record.

v9:
+ Remove ipe_context related code and simplify the evaluation loop.

v10:
+ Split eval part and boot_verified part

v11:
+ Fix code style issues

v12:
+ Correct an rcu_read_unlock usage
+ Add a WARN to unknown op during evaluation

---
 security/ipe/Makefile |   1 +
 security/ipe/eval.c   | 100 ++++++++++++++++++++++++++++++++++++++++++
 security/ipe/eval.h   |  24 ++++++++++
 3 files changed, 125 insertions(+)
 create mode 100644 security/ipe/eval.c
 create mode 100644 security/ipe/eval.h
security/ipe/Makefile +1 -0
index c09aec4904f2..57fe922cf1fc 100644
@@ -6,6 +6,7 @@
 #
 
 obj-$(CONFIG_SECURITY_IPE) += \
+	eval.o \
 	ipe.o \
 	policy.o \
 	policy_parser.o \
security/ipe/eval.c new file +100 -0

100 lines not on this page · raw message

security/ipe/eval.h new file +24 -0
new file mode 100644
index 000000000000..6b434515968f
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef _IPE_EVAL_H
+#define _IPE_EVAL_H
+
+#include <linux/file.h>
+#include <linux/types.h>
+
+#include "policy.h"
+
+extern struct ipe_policy __rcu *ipe_active_policy;
+
+struct ipe_eval_ctx {
+	enum ipe_op_type op;
+
+	const struct file *file;
+};
+
+int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx);
+
+#endif /* _IPE_EVAL_H */
Signature · 1 line
2.43.0
author
#4 lore raw

RFC PATCH v12 4/20 ipe: add LSM hooks on execution and kernel read

In reply to Fan Wu

From: Deven Bowers <[email protected]>

IPE's initial goal is to control both execution and the loading of kernel modules based on the system's definition of trust. It accomplishes this by plugging into the security hooks for bprm_check_security, file_mprotect, mmap_file, kernel_load_data, and kernel_read_data.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations
+ Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+ Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record, reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation, the audit system, the evaluation loop and access control hooks into separate commits.

v8:
+ Rename hook functions to follow the lsmname_hook_name convention
+ Remove ipe_hook enumeration, can be derived from correlation with syscall audit record.

v9:
+ Minor changes for adapting to the new parser

v10:
+ Remove @reqprot part

v11:
+ Fix code style issues

v12:
+ Correct WARN usages

---
 security/ipe/Makefile |   1 +
 security/ipe/eval.c   |  14 ++++
 security/ipe/eval.h   |   3 +
 security/ipe/hooks.c  | 183 ++++++++++++++++++++++++++++++++++++++++++
 security/ipe/hooks.h  |  25 ++++++
 security/ipe/ipe.c    |   6 ++
 6 files changed, 232 insertions(+)
 create mode 100644 security/ipe/hooks.c
 create mode 100644 security/ipe/hooks.h
security/ipe/Makefile +1 -0
index 57fe922cf1fc..d7f2870d7c09 100644
@@ -7,6 +7,7 @@
 
 obj-$(CONFIG_SECURITY_IPE) += \
 	eval.o \
+	hooks.o \
 	ipe.o \
 	policy.o \
 	policy_parser.o \
security/ipe/eval.c +14 -0
index af56815ed0fa..4f425afffcad 100644
@@ -16,6 +16,20 @@
 
 struct ipe_policy __rcu *ipe_active_policy;
 
+/**
+ * build_eval_ctx - Build an evaluation context.
+ * @ctx: Supplies a pointer to the context to be populated.
+ * @file: Supplies a pointer to the file to associated with the evaluation.
+ * @op: Supplies the IPE policy operation associated with the evaluation.
+ */
+void build_eval_ctx(struct ipe_eval_ctx *ctx,
+		    const struct file *file,
+		    enum ipe_op_type op)
+{
+	ctx->file = file;
+	ctx->op = op;
+}
+
 /**
  * evaluate_property - Analyze @ctx against a property.
  * @ctx: Supplies a pointer to the context to be evaluated.
security/ipe/eval.h +3 -0
index 6b434515968f..cfdf3c8dfe8a 100644
@@ -11,6 +11,8 @@
 
 #include "policy.h"
 
+#define IPE_EVAL_CTX_INIT ((struct ipe_eval_ctx){ 0 })
+
 extern struct ipe_policy __rcu *ipe_active_policy;
 
 struct ipe_eval_ctx {
@@ -19,6 +21,7 @@ struct ipe_eval_ctx {
 	const struct file *file;
 };
 
+void build_eval_ctx(struct ipe_eval_ctx *ctx, const struct file *file, enum ipe_op_type op);
 int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx);
 
 #endif /* _IPE_EVAL_H */
security/ipe/hooks.c new file +183 -0

183 lines not on this page · raw message

security/ipe/hooks.h new file +25 -0
new file mode 100644
index 000000000000..23205452f758
@@ -0,0 +1,25 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+#ifndef _IPE_HOOKS_H
+#define _IPE_HOOKS_H
+
+#include <linux/fs.h>
+#include <linux/binfmts.h>
+#include <linux/security.h>
+
+int ipe_bprm_check_security(struct linux_binprm *bprm);
+
+int ipe_mmap_file(struct file *f, unsigned long reqprot, unsigned long prot,
+		  unsigned long flags);
+
+int ipe_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
+		      unsigned long prot);
+
+int ipe_kernel_read_file(struct file *file, enum kernel_read_file_id id,
+			 bool contents);
+
+int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents);
+
+#endif /* _IPE_HOOKS_H */
security/ipe/ipe.c +6 -0
index b013aed15e73..22bd95116087 100644
@@ -5,6 +5,7 @@
 #include <uapi/linux/lsm.h>
 
 #include "ipe.h"
+#include "hooks.h"
 
 static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
 };
@@ -15,6 +16,11 @@ static const struct lsm_id ipe_lsmid = {
 };
 
 static struct security_hook_list ipe_hooks[] __ro_after_init = {
+	LSM_HOOK_INIT(bprm_check_security, ipe_bprm_check_security),
+	LSM_HOOK_INIT(mmap_file, ipe_mmap_file),
+	LSM_HOOK_INIT(file_mprotect, ipe_file_mprotect),
+	LSM_HOOK_INIT(kernel_read_file, ipe_kernel_read_file),
+	LSM_HOOK_INIT(kernel_load_data, ipe_kernel_load_data),
 };
 
 /**
Signature · 1 line
2.43.0
#5 lore raw

Re: [RFC PATCH v12 04/20] ipe: add LSM hooks on execution and kernel read

kernel test robot noticed the following build warnings:

Hi Fan,

[This is a private test report for your RFC patch.] kernel test robot noticed the following build warnings:

[auto build test WARNING on axboe-block/for-next]
[also build test WARNING on lwn/docs-next linus/master v6.8-rc2 next-20240202] [cannot apply to device-mapper-dm/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Fan-Wu/security-add-ipe-lsm/20240131-064224
base:   https://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git for-next
patch link:    https://lore.kernel.org/r/1706654228-17180-5-git-send-email-wufan%40linux.microsoft.com
patch subject: [RFC PATCH v12 04/20] ipe: add LSM hooks on execution and kernel read
config: loongarch-allmodconfig (https://download.01.org/0day-ci/archive/20240202/[email protected]/config)
compiler: loongarch64-linux-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240202/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All warnings (new ones prefixed by >>):

>> security/ipe/hooks.c:51: warning: Function parameter or struct member '__always_unused' not described in 'ipe_mmap_file'
   security/ipe/hooks.c:51: warning: Excess function parameter 'reqprot' description in 'ipe_mmap_file'
>> security/ipe/hooks.c:79: warning: Function parameter or struct member '__always_unused' not described in 'ipe_file_mprotect'

security/ipe/hooks.c:79: warning: Excess function parameter 'reqprot' description in 'ipe_file_mprotect'

vim +51 security/ipe/hooks.c

33
34 /**
35 * ipe_mmap_file - ipe security hook function for mmap check.
36 * @f: File being mmap'd. Can be NULL in the case of anonymous memory.
37 * @reqprot: The requested protection on the mmap, passed from usermode.
38 * @prot: The effective protection on the mmap, resolved from reqprot and
39 * system configuration.
40 * @flags: Unused.
41 *
42 * This hook is called when a file is loaded through the mmap
43 * family of system calls.
44 *
45 * Return:
46 * * 0 - OK
47 * * !0 - Error
48 */
49 int ipe_mmap_file(struct file *f, unsigned long reqprot __always_unused,
50 unsigned long prot, unsigned long flags)

  > 51	{
    52		struct ipe_eval_ctx ctx = IPE_EVAL_CTX_INIT;
    53	
    54		if (prot & PROT_EXEC) {
    55			build_eval_ctx(&ctx, f, IPE_OP_EXEC);
    56			return ipe_evaluate_event(&ctx);
    57		}
    58	
    59		return 0;
    60	}
    61	
    62	/**
    63	 * ipe_file_mprotect - ipe security hook function for mprotect check.
    64	 * @vma: Existing virtual memory area created by mmap or similar.
    65	 * @reqprot: The requested protection on the mmap, passed from usermode.
    66	 * @prot: The effective protection on the mmap, resolved from reqprot and
    67	 *	  system configuration.
    68	 *
    69	 * This LSM hook is called when a mmap'd region of memory is changing
    70	 * its protections via mprotect.
    71	 *
    72	 * Return:
    73	 * * 0	- OK
    74	 * * !0	- Error
    75	 */
    76	int ipe_file_mprotect(struct vm_area_struct *vma,
    77			      unsigned long reqprot __always_unused,
    78			      unsigned long prot)
  > 79	{
    80		struct ipe_eval_ctx ctx = IPE_EVAL_CTX_INIT;
    81	
    82		/* Already Executable */
    83		if (vma->vm_flags & VM_EXEC)
    84			return 0;
    85	
    86		if (prot & PROT_EXEC) {
    87			build_eval_ctx(&ctx, vma->vm_file, IPE_OP_EXEC);
    88			return ipe_evaluate_event(&ctx);
    89		}
    90	
    91		return 0;
    92	}
    93	
Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
author
#6 lore raw

RFC PATCH v12 5/20 initramfs|security: Add security hook to initramfs unpack

In reply to Fan Wu

This patch introduces a new hook to notify security system that the content of initramfs has been unpacked into the rootfs.

Upon receiving this notification, the security system can activate a policy to allow only files that originated from the initramfs to execute or load into kernel during the early stages of booting.

This approach is crucial for minimizing the attack surface by ensuring that only trusted files from the initramfs are operational in the critical boot phase.

---
v1-v11:
+ Not present

v12:
+ Introduced

---
 include/linux/lsm_hook_defs.h |  4 ++++
 include/linux/security.h      | 10 ++++++++++
 init/initramfs.c              |  3 +++
 security/security.c           | 12 ++++++++++++
 4 files changed, 29 insertions(+)
include/linux/lsm_hook_defs.h +4 -0
index 185924c56378..b247388786a9 100644
@@ -425,3 +425,7 @@ LSM_HOOK(int, 0, uring_override_creds, const struct cred *new)
 LSM_HOOK(int, 0, uring_sqpoll, void)
 LSM_HOOK(int, 0, uring_cmd, struct io_uring_cmd *ioucmd)
 #endif /* CONFIG_IO_URING */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+LSM_HOOK(void, LSM_RET_VOID, unpack_initramfs_security, void)
+#endif /* CONFIG_BLK_DEV_INITRD */
include/linux/security.h +10 -0
index d0eb20f90b26..1545c69edc1b 100644
@@ -2167,4 +2167,14 @@ static inline int security_uring_cmd(struct io_uring_cmd *ioucmd)
 #endif /* CONFIG_SECURITY */
 #endif /* CONFIG_IO_URING */
 
+#ifdef CONFIG_BLK_DEV_INITRD
+#ifdef CONFIG_SECURITY
+extern void security_unpack_initramfs(void);
+#else
+static inline void security_unpack_initramfs(void)
+{
+}
+#endif /* CONFIG_SECURITY */
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 #endif /* ! __LINUX_SECURITY_H */
init/initramfs.c +3 -0
index 76deb48c38cb..075a5794cde5 100644
@@ -18,6 +18,7 @@
 #include <linux/init_syscalls.h>
 #include <linux/task_work.h>
 #include <linux/umh.h>
+#include <linux/security.h>
 
 static __initdata bool csum_present;
 static __initdata u32 io_csum;
@@ -720,6 +721,8 @@ static void __init do_populate_rootfs(void *unused, async_cookie_t cookie)
 #endif
 	}
 
+	security_unpack_initramfs();
+
 done:
 	/*
 	 * If the initrd region is overlapped with crashkernel reserved region,
security/security.c +12 -0
index ddf2e69cf8f2..2a527d4c69bc 100644
@@ -5581,3 +5581,15 @@ int security_uring_cmd(struct io_uring_cmd *ioucmd)
 	return call_int_hook(uring_cmd, 0, ioucmd);
 }
 #endif /* CONFIG_IO_URING */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * security_unpack_initramfs() - Notify LSM that initramfs has been loaded
+ *
+ * Tells the LSM the initramfs has been unpacked into the rootfs.
+ */
+void security_unpack_initramfs(void)
+{
+	call_void_hook(unpack_initramfs_security);
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
Signature · 1 line
2.43.0
maintainer
#7 lore raw

Re: [PATCH RFC v12 5/20] initramfs|security: Add security hook to initramfs unpack

Quoted 31 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

This patch introduces a new hook to notify security system that the content of initramfs has been unpacked into the rootfs.

Upon receiving this notification, the security system can activate a policy to allow only files that originated from the initramfs to execute or load into kernel during the early stages of booting.

This approach is crucial for minimizing the attack surface by ensuring that only trusted files from the initramfs are operational in the critical boot phase.

---
v1-v11:
+ Not present

v12:
+ Introduced

---
 include/linux/lsm_hook_defs.h |  4 ++++
 include/linux/security.h      | 10 ++++++++++
 init/initramfs.c              |  3 +++
 security/security.c           | 12 ++++++++++++
 4 files changed, 29 insertions(+)
include/linux/lsm_hook_defs.h +0 -0
index 185924c56378..b247388786a9 100644

include/linux/lsm_hook_defs.h LSM_HOOK(int, 0, uring_override_creds, const struct cred *new) · line 431

Quoted 7 lines
include/linux/lsm_hook_defs.h +4 -0
@@ -425,3 +425,7 @@ LSM_HOOK(int, 0, uring_override_creds, const struct cred *new)
 LSM_HOOK(int, 0, uring_sqpoll, void)
 LSM_HOOK(int, 0, uring_cmd, struct io_uring_cmd *ioucmd)
 #endif /* CONFIG_IO_URING */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+LSM_HOOK(void, LSM_RET_VOID, unpack_initramfs_security, void)
+#endif /* CONFIG_BLK_DEV_INITRD */

Let's just call it "unpack_initramfs", the "_security" part is somewhat implied since we are talking about a LSM hook ;)

Quoted 13 lines
init/initramfs.c +1 -0
index 76deb48c38cb..075a5794cde5 100644
@@ -18,6 +18,7 @@
 #include <linux/init_syscalls.h>
 #include <linux/task_work.h>
 #include <linux/umh.h>
+#include <linux/security.h>
 
 static __initdata bool csum_present;
 static __initdata u32 io_csum;

init/initramfs.c static void __init do_populate_rootfs(void *unused, async_cookie_t cookie) · line 724

Quoted 4 lines
init/initramfs.c +1 -0
@@ -720,6 +721,8 @@ static void __init do_populate_rootfs(void *unused, async_cookie_t cookie)
 #endif
 	}
 
+	security_unpack_initramfs();

Given the caller, what do you think of changing the hook name to "security_initramfs_populated()"? I think this not only matches up better with the caller, "do_populate_rootfs()", but since in using the past tense we help indicate that this hook happens *after* the rootfs is populated with the initramfs data.

Quoted 25 lines
init/initramfs.c +0 -0
 done:
 	/*
 	 * If the initrd region is overlapped with crashkernel reserved region,
security/security.c +12 -0
index ddf2e69cf8f2..2a527d4c69bc 100644
@@ -5581,3 +5581,15 @@ int security_uring_cmd(struct io_uring_cmd *ioucmd)
 	return call_int_hook(uring_cmd, 0, ioucmd);
 }
 #endif /* CONFIG_IO_URING */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * security_unpack_initramfs() - Notify LSM that initramfs has been loaded
+ *
+ * Tells the LSM the initramfs has been unpacked into the rootfs.
+ */
+void security_unpack_initramfs(void)
+{
+	call_void_hook(unpack_initramfs_security);
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
Signature · 1 line
2.43.0

--
paul-moore.com

author
#8 lore raw

Re: [PATCH RFC v12 5/20] initramfs|security: Add security hook to initramfs unpack

Quoted 59 lines · Paul Moore
Quoted 31 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

This patch introduces a new hook to notify security system that the content of initramfs has been unpacked into the rootfs.

Upon receiving this notification, the security system can activate a policy to allow only files that originated from the initramfs to execute or load into kernel during the early stages of booting.

This approach is crucial for minimizing the attack surface by ensuring that only trusted files from the initramfs are operational in the critical boot phase.

---
v1-v11:
+ Not present

v12:
+ Introduced

---
  include/linux/lsm_hook_defs.h |  4 ++++
  include/linux/security.h      | 10 ++++++++++
  init/initramfs.c              |  3 +++
  security/security.c           | 12 ++++++++++++
  4 files changed, 29 insertions(+)
include/linux/lsm_hook_defs.h +0 -0
index 185924c56378..b247388786a9 100644

include/linux/lsm_hook_defs.h LSM_HOOK(int, 0, uring_override_creds, const struct cred *new) · line 431

Quoted 7 lines
include/linux/lsm_hook_defs.h +4 -0
@@ -425,3 +425,7 @@ LSM_HOOK(int, 0, uring_override_creds, const struct cred *new)
  LSM_HOOK(int, 0, uring_sqpoll, void)
  LSM_HOOK(int, 0, uring_cmd, struct io_uring_cmd *ioucmd)
  #endif /* CONFIG_IO_URING */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+LSM_HOOK(void, LSM_RET_VOID, unpack_initramfs_security, void)
+#endif /* CONFIG_BLK_DEV_INITRD */

Let's just call it "unpack_initramfs", the "_security" part is somewhat implied since we are talking about a LSM hook ;)

Quoted 16 lines
init/initramfs.c +1 -0
index 76deb48c38cb..075a5794cde5 100644
@@ -18,6 +18,7 @@
  #include <linux/init_syscalls.h>
  #include <linux/task_work.h>
  #include <linux/umh.h>
+#include <linux/security.h>
 
  static __initdata bool csum_present;
  static __initdata u32 io_csum;
@@ -720,6 +721,8 @@ static void __init do_populate_rootfs(void *unused, async_cookie_t cookie)
  #endif
  	}
 
Quoted 8 lines

init/initramfs.c static void __init do_populate_rootfs(void *unused, async_cookie_t cookie) · line 724

Quoted 1 line
init/initramfs.c +1 -0
+	security_unpack_initramfs();

Given the caller, what do you think of changing the hook name to "security_initramfs_populated()"? I think this not only matches up better with the caller, "do_populate_rootfs()", but since in using the past tense we help indicate that this hook happens *after* the rootfs is populated with the initramfs data.

Yeah, I agree this sounds better. I will update this part.

-Fan

Quoted 28 lines
Quoted 25 lines
init/initramfs.c +0 -0
  done:
  	/*
  	 * If the initrd region is overlapped with crashkernel reserved region,
security/security.c +12 -0
index ddf2e69cf8f2..2a527d4c69bc 100644
@@ -5581,3 +5581,15 @@ int security_uring_cmd(struct io_uring_cmd *ioucmd)
  	return call_int_hook(uring_cmd, 0, ioucmd);
  }
  #endif /* CONFIG_IO_URING */
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * security_unpack_initramfs() - Notify LSM that initramfs has been loaded
+ *
+ * Tells the LSM the initramfs has been unpacked into the rootfs.
+ */
+void security_unpack_initramfs(void)
+{
+	call_void_hook(unpack_initramfs_security);
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
Signature · 1 line
2.43.0

--
paul-moore.com

author
#9 lore raw

RFC PATCH v12 6/20 ipe: introduce 'boot_verified' as a trust provider

In reply to Fan Wu

IPE is designed to provide system level trust guarantees, this usually implies that trust starts from bootup with a hardware root of trust, which validates the bootloader. After this, the bootloader verifies the kernel and the initramfs.

As there's no currently supported integrity method for initramfs, and it's typically already verified by the bootloader. This patch introduces a new IPE property boot_verified which allows author of IPE policy to indicate trust for files from initramfs.

The implementation of this feature utilizes the newly added unpack_initramfs hook. This hook marks the superblock of the rootfs after the initramfs has been unpacked into it.

Since the rootfs is never unmounted during system operation, it is advised to switch to a different policy that doesn't rely on the boot_verified property after the real rootfs is in charge. This ensures that the trust policies remain relevant and effective throughout the system's operation.

---
v2:
+No Changes

v3:
+ Remove useless caching system
+ Move ipe_load_properties to this match
+ Minor changes from checkpatch --strict warnings

v4:
+ Remove comments from headers that was missed previously.
+ Grammatical corrections.

v5:
+ No significant changes

v6:
+ No changes

v7:
+ Reword and refactor patch 04/12 to [09/16], based on changes in
the underlying system.
+ Add common audit function for boolean values
+ Use common audit function as implementation.

v8:
+ No changes

v9:
+ No changes

v10:
+ Replace struct file with struct super_block

v11:
+ Fix code style issues

v12:
+ Switch to use unpack_initramfs hook and security blob

---
 security/ipe/eval.c          | 68 +++++++++++++++++++++++++++++++++++-
 security/ipe/eval.h          |  9 +++++
 security/ipe/hooks.c         |  8 +++++
 security/ipe/hooks.h         |  4 +++
 security/ipe/ipe.c           | 14 ++++++++
 security/ipe/ipe.h           |  3 ++
 security/ipe/policy.h        |  2 ++
 security/ipe/policy_parser.c | 37 +++++++++++++++++++-
 8 files changed, 143 insertions(+), 2 deletions(-)
security/ipe/eval.c +67 -1
index 4f425afffcad..546bbc52a071 100644
@@ -16,6 +16,24 @@
 
 struct ipe_policy __rcu *ipe_active_policy;
 
+#define FILE_SUPERBLOCK(f) ((f)->f_path.mnt->mnt_sb)
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * build_ipe_sb_ctx - Build from_initramfs field of an evaluation context.
+ * @ctx: Supplies a pointer to the context to be populated.
+ * @file: Supplies the file struct of the file triggered IPE event.
+ */
+static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
+{
+	ctx->from_initramfs = ipe_sb(FILE_SUPERBLOCK(file))->is_initramfs;
+}
+#else
+static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
+{
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 /**
  * build_eval_ctx - Build an evaluation context.
  * @ctx: Supplies a pointer to the context to be populated.
@@ -28,8 +46,49 @@ void build_eval_ctx(struct ipe_eval_ctx *ctx,
 {
 	ctx->file = file;
 	ctx->op = op;
+
+	if (file)
+		build_ipe_sb_ctx(ctx, file);
+}
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * evaluate_boot_verified_true - Evaluate @ctx for the boot verified property.
+ * @ctx: Supplies a pointer to the context being evaluated.
+ *
+ * Return:
+ * * true	- The current @ctx match the @p
+ * * false	- The current @ctx doesn't match the @p
+ */
+static bool evaluate_boot_verified_true(const struct ipe_eval_ctx *const ctx)
+{
+	return ctx->from_initramfs;
 }
 
+/**
+ * evaluate_boot_verified_false - Evaluate @ctx for the boot verified property.
+ * @ctx: Supplies a pointer to the context being evaluated.
+ *
+ * Return:
+ * * true	- The current @ctx match the @p
+ * * false	- The current @ctx doesn't match the @p
+ */
+static bool evaluate_boot_verified_false(const struct ipe_eval_ctx *const ctx)
+{
+	return !evaluate_boot_verified_true(ctx);
+}
+#else
+static bool evaluate_boot_verified_true(const struct ipe_eval_ctx *const ctx)
+{
+	return false;
+}
+
+static bool evaluate_boot_verified_false(const struct ipe_eval_ctx *const ctx)
+{
+	return false;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 /**
  * evaluate_property - Analyze @ctx against a property.
  * @ctx: Supplies a pointer to the context to be evaluated.
@@ -42,7 +101,14 @@ void build_eval_ctx(struct ipe_eval_ctx *ctx,
 static bool evaluate_property(const struct ipe_eval_ctx *const ctx,
 			      struct ipe_prop *p)
 {
-	return false;
+	switch (p->type) {
+	case IPE_PROP_BOOT_VERIFIED_FALSE:
+		return evaluate_boot_verified_false(ctx);
+	case IPE_PROP_BOOT_VERIFIED_TRUE:
+		return evaluate_boot_verified_true(ctx);
+	default:
+		return false;
+	}
 }
 
 /**
security/ipe/eval.h +9 -0
index cfdf3c8dfe8a..7d79fdb63bbf 100644
@@ -15,10 +15,19 @@
 
 extern struct ipe_policy __rcu *ipe_active_policy;
 
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb {
+	bool is_initramfs;
+};
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 struct ipe_eval_ctx {
 	enum ipe_op_type op;
 
 	const struct file *file;
+#ifdef CONFIG_BLK_DEV_INITRD
+	bool from_initramfs;
+#endif /* CONFIG_BLK_DEV_INITRD */
 };
 
 void build_eval_ctx(struct ipe_eval_ctx *ctx, const struct file *file, enum ipe_op_type op);
security/ipe/hooks.c +8 -0
index 3aec88c074e1..8ee105bf7bad 100644
@@ -4,6 +4,7 @@
  */
 
 #include <linux/fs.h>
+#include <linux/fs_struct.h>
 #include <linux/types.h>
 #include <linux/binfmts.h>
 #include <linux/mman.h>
@@ -181,3 +182,10 @@ int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents)
 	build_eval_ctx(&ctx, NULL, op);
 	return ipe_evaluate_event(&ctx);
 }
+
+#ifdef CONFIG_BLK_DEV_INITRD
+void ipe_unpack_initramfs(void)
+{
+	ipe_sb(current->fs->root.mnt->mnt_sb)->is_initramfs = true;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
security/ipe/hooks.h +4 -0
index 23205452f758..3b1bb0a6e89c 100644
@@ -22,4 +22,8 @@ int ipe_kernel_read_file(struct file *file, enum kernel_read_file_id id,
 
 int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents);
 
+#ifdef CONFIG_BLK_DEV_INITRD
+void ipe_unpack_initramfs(void);
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 #endif /* _IPE_HOOKS_H */
security/ipe/ipe.c +14 -0
index 22bd95116087..ed3acf6174d8 100644
@@ -5,9 +5,13 @@
 #include <uapi/linux/lsm.h>
 
 #include "ipe.h"
+#include "eval.h"
 #include "hooks.h"
 
 static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	.lbs_superblock = sizeof(struct ipe_sb),
+#endif /* CONFIG_BLK_DEV_INITRD */
 };
 
 static const struct lsm_id ipe_lsmid = {
@@ -15,12 +19,22 @@ static const struct lsm_id ipe_lsmid = {
 	.id = LSM_ID_IPE,
 };
 
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb *ipe_sb(const struct super_block *sb)
+{
+	return sb->s_security + ipe_blobs.lbs_superblock;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 static struct security_hook_list ipe_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(bprm_check_security, ipe_bprm_check_security),
 	LSM_HOOK_INIT(mmap_file, ipe_mmap_file),
 	LSM_HOOK_INIT(file_mprotect, ipe_file_mprotect),
 	LSM_HOOK_INIT(kernel_read_file, ipe_kernel_read_file),
 	LSM_HOOK_INIT(kernel_load_data, ipe_kernel_load_data),
+#ifdef CONFIG_BLK_DEV_INITRD
+	LSM_HOOK_INIT(unpack_initramfs_security, ipe_unpack_initramfs),
+#endif /* CONFIG_BLK_DEV_INITRD */
 };
 
 /**
security/ipe/ipe.h +3 -0
index a1c68d0fc2e0..f1e7c3222b6d 100644
@@ -12,5 +12,8 @@
 #define pr_fmt(fmt) "IPE: " fmt
 
 #include <linux/lsm_hooks.h>
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb *ipe_sb(const struct super_block *sb);
+#endif /* CONFIG_BLK_DEV_INITRD */
 
 #endif /* _IPE_H */
security/ipe/policy.h +2 -0
index fb906f41522b..fb48024bb63e 100644
@@ -30,6 +30,8 @@ enum ipe_action_type {
 #define IPE_ACTION_INVALID __IPE_ACTION_MAX
 
 enum ipe_prop_type {
+	IPE_PROP_BOOT_VERIFIED_FALSE,
+	IPE_PROP_BOOT_VERIFIED_TRUE,
 	__IPE_PROP_MAX
 };
 
security/ipe/policy_parser.c +36 -1
index 612839b405f4..cce15f0eb645 100644
@@ -265,6 +265,14 @@ static enum ipe_action_type parse_action(char *t)
 	return match_token(t, action_tokens, args);
 }
 
+static const match_table_t property_tokens = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	{IPE_PROP_BOOT_VERIFIED_FALSE,	"boot_verified=FALSE"},
+	{IPE_PROP_BOOT_VERIFIED_TRUE,	"boot_verified=TRUE"},
+#endif /* CONFIG_BLK_DEV_INITRD */
+	{IPE_PROP_INVALID,		NULL}
+};
+
 /**
  * parse_property - Parse the property type given a token string.
  * @t: Supplies the token string to be parsed.
@@ -277,7 +285,34 @@ static enum ipe_action_type parse_action(char *t)
  */
 static int parse_property(char *t, struct ipe_rule *r)
 {
-	return -EBADMSG;
+	substring_t args[MAX_OPT_ARGS];
+	struct ipe_prop *p = NULL;
+	int rc = 0;
+	int token;
+
+	p = kzalloc(sizeof(*p), GFP_KERNEL);
+	if (!p)
+		return -ENOMEM;
+
+	token = match_token(t, property_tokens, args);
+
+	switch (token) {
+	case IPE_PROP_BOOT_VERIFIED_FALSE:
+	case IPE_PROP_BOOT_VERIFIED_TRUE:
+		p->type = token;
+		break;
+	default:
+		rc = -EBADMSG;
+		break;
+	}
+	if (rc)
+		goto err;
+	list_add_tail(&p->next, &r->props);
+
+	return rc;
+err:
+	kfree(p);
+	return rc;
 }
 
 /**
Signature · 1 line
2.43.0
maintainer
#10 lore raw

Re: [PATCH RFC v12 6/20] ipe: introduce 'boot_verified' as a trust provider

Quoted 15 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

IPE is designed to provide system level trust guarantees, this usually implies that trust starts from bootup with a hardware root of trust, which validates the bootloader. After this, the bootloader verifies the kernel and the initramfs.

As there's no currently supported integrity method for initramfs, and it's typically already verified by the bootloader. This patch introduces a new IPE property boot_verified which allows author of IPE policy to indicate trust for files from initramfs.

The implementation of this feature utilizes the newly added unpack_initramfs hook. This hook marks the superblock of the rootfs after the initramfs has been unpacked into it.

Quoted 5 lines

Since the rootfs is never unmounted during system operation, it is advised to switch to a different policy that doesn't rely on the boot_verified property after the real rootfs is in charge. This ensures that the trust policies remain relevant and effective throughout the system's operation.

To be clear, most (all?) init systems cleanup the initial rootfs and mount another filesystem on top of it during the boot process, correct? That should probably be mentioned in the commit description, perhaps with references to the pivot_root(2) and switch_root(8) docs.

While I don't disagree with your recommendation above, I do believe it is unnecessarily scary sounding.

Quoted 41 lines

---
v2:
+No Changes

v3:
+ Remove useless caching system
+ Move ipe_load_properties to this match
+ Minor changes from checkpatch --strict warnings

v4:
+ Remove comments from headers that was missed previously.
+ Grammatical corrections.

v5:
+ No significant changes

v6:
+ No changes

v7:
+ Reword and refactor patch 04/12 to [09/16], based on changes in
the underlying system.
+ Add common audit function for boolean values
+ Use common audit function as implementation.

v8:
+ No changes

v9:
+ No changes

v10:
+ Replace struct file with struct super_block

v11:
+ Fix code style issues

v12:
+ Switch to use unpack_initramfs hook and security blob

Quoted 10 lines
---
 security/ipe/eval.c          | 68 +++++++++++++++++++++++++++++++++++-
 security/ipe/eval.h          |  9 +++++
 security/ipe/hooks.c         |  8 +++++
 security/ipe/hooks.h         |  4 +++
 security/ipe/ipe.c           | 14 ++++++++
 security/ipe/ipe.h           |  3 ++
 security/ipe/policy.h        |  2 ++
 security/ipe/policy_parser.c | 37 +++++++++++++++++++-
 8 files changed, 143 insertions(+), 2 deletions(-)

More comments below, but one thing I wanted to mention at the top is that I believe there is too much conditional compilation depending on the state of CONFIG_BLK_DEV_INITRD. While there is noting wrong about this from a correctness perspective, I believe the reality is that the vast majority of systems these days are built with this enabled, and having all these pre-processor checks adds to the complexity of the code. Additional comments about this below ...

Quoted 15 lines
security/ipe/eval.c +7 -0
index 4f425afffcad..546bbc52a071 100644
@@ -16,6 +16,24 @@
 
 struct ipe_policy __rcu *ipe_active_policy;
 
+#define FILE_SUPERBLOCK(f) ((f)->f_path.mnt->mnt_sb)
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * build_ipe_sb_ctx - Build from_initramfs field of an evaluation context.
+ * @ctx: Supplies a pointer to the context to be populated.
+ * @file: Supplies the file struct of the file triggered IPE event.

security/ipe/eval.c line 35

Quoted 10 lines
security/ipe/eval.c +10 -0
+ */
+static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
+{
+	ctx->from_initramfs = ipe_sb(FILE_SUPERBLOCK(file))->is_initramfs;
+}
+#else
+static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
+{
+}
+#endif /* CONFIG_BLK_DEV_INITRD */

If you move the @file NULL check into build_ipe_sb_ctx() you can save a comparison in the !CONFIG_BLK_DEV_INITRD case:

#ifdef CONFIG_BLK_DEV_INITRD
void build(...)
{
if (file)

    ctx->initramfs = ipe_sb(file);
  else
    ctx->initramfs = false;
}

#else
void build(...)
{
ctx->initramfs = false;
}
#endif

NOTE: see my comment below about always enabling the initramfs boolean in @ipe_eval_ctx and other structs.

security/ipe/eval.c void build_eval_ctx(struct ipe_eval_ctx *ctx, · line 52

Quoted 11 lines
security/ipe/eval.c +4 -0
 /**
  * build_eval_ctx - Build an evaluation context.
  * @ctx: Supplies a pointer to the context to be populated.
@@ -28,8 +46,49 @@ void build_eval_ctx(struct ipe_eval_ctx *ctx,
 {
 	ctx->file = file;
 	ctx->op = op;
+
+	if (file)
+		build_ipe_sb_ctx(ctx, file);
+}

See my comment above regarding the @file NULL check.

Quoted 27 lines
security/ipe/eval.c +25 -0
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * evaluate_boot_verified_true - Evaluate @ctx for the boot verified property.
+ * @ctx: Supplies a pointer to the context being evaluated.
+ *
+ * Return:
+ * * true	- The current @ctx match the @p
+ * * false	- The current @ctx doesn't match the @p
+ */
+static bool evaluate_boot_verified_true(const struct ipe_eval_ctx *const ctx)
+{
+	return ctx->from_initramfs;
 }
 
+/**
+ * evaluate_boot_verified_false - Evaluate @ctx for the boot verified property.
+ * @ctx: Supplies a pointer to the context being evaluated.
+ *
+ * Return:
+ * * true	- The current @ctx match the @p
+ * * false	- The current @ctx doesn't match the @p
+ */
+static bool evaluate_boot_verified_false(const struct ipe_eval_ctx *const ctx)
+{
+	return !evaluate_boot_verified_true(ctx);
+}
+#else

security/ipe/eval.c void build_eval_ctx(struct ipe_eval_ctx *ctx, · line 90

Quoted 10 lines
security/ipe/eval.c +10 -0
+static bool evaluate_boot_verified_true(const struct ipe_eval_ctx *const ctx)
+{
+	return false;
+}
+
+static bool evaluate_boot_verified_false(const struct ipe_eval_ctx *const ctx)
+{
+	return false;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */

That is a lot of lines of code just to check a single boolean value. I understand the layers of abstraction, but this looks a bit excessive to me. Assuming you agree with the other comments in this email regarding always including an initramfs flag in @ipe_eval_ctx, I think you could reduce all of the above into one single line function as shown below, and just negate it as needed in evaluate_property().

static bool evaluate_boot_verified(ctx)
{
return ctx->initramfs;
}

security/ipe/eval.c void build_eval_ctx(struct ipe_eval_ctx *ctx, · line 108

Quoted 13 lines
security/ipe/eval.c +5 -1
 /**
  * evaluate_property - Analyze @ctx against a property.
  * @ctx: Supplies a pointer to the context to be evaluated.
@@ -42,7 +101,14 @@ void build_eval_ctx(struct ipe_eval_ctx *ctx,
 static bool evaluate_property(const struct ipe_eval_ctx *const ctx,
 			      struct ipe_prop *p)
 {
-	return false;
+	switch (p->type) {
+	case IPE_PROP_BOOT_VERIFIED_FALSE:
+		return evaluate_boot_verified_false(ctx);
+	case IPE_PROP_BOOT_VERIFIED_TRUE:
+		return evaluate_boot_verified_true(ctx);

According to my comment above:

  case IPE_PROP_BOOT_VERIFIED_FALSE:
    return !evaludate_boot_verified(ctx);
  case IPE_PROP_BOOT_VERIFIED_TRUE:
    return evaludate_boot_verified(ctx);
Quoted 11 lines
security/ipe/eval.c +3 -0
+	default:
+		return false;
+	}
 }
 
 /**
security/ipe/eval.h +0 -0
index cfdf3c8dfe8a..7d79fdb63bbf 100644

security/ipe/eval.h line 21

Quoted 7 lines
security/ipe/eval.h +4 -0
@@ -15,10 +15,19 @@
 
 extern struct ipe_policy __rcu *ipe_active_policy;
 
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb {
+	bool is_initramfs;
+}

You've already got a function named "ipe_sb()", I would suggest saving us all some headaches by renaming the above to "ipe_superblock" or something similar. The point is to not have a struct and a function with the same name.

I also think you can shorten the field name to "initramfs", it's defined as a boolean flag so I'm not sure the "is_" prefix lends any useful hints but does make for longer lines, more typing, etc.

security/ipe/eval.h line 31

Quoted 10 lines
security/ipe/eval.h +5 -0
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 struct ipe_eval_ctx {
 	enum ipe_op_type op;
 
 	const struct file *file;
+#ifdef CONFIG_BLK_DEV_INITRD
+	bool from_initramfs;
+#endif /* CONFIG_BLK_DEV_INITRD */
 };

I suppose I understand the desire to make the @from_initramfs conditional to potentially reduce the size of @ipe_eval_ctx when it is not needed, however, I believe in the vast majority of systems we are going to see CONFIG_BLK_DEV_INITRD enabled so I believe this adds a lot extra code noise for little practical benefit.

Similarly to ipe_sb::is_initramfs, I think you can rename this field to "initramfs" and we would all be better for the change.

Quoted 43 lines
security/ipe/eval.h +0 -0
 void build_eval_ctx(struct ipe_eval_ctx *ctx, const struct file *file, enum ipe_op_type op);
security/ipe/hooks.c +8 -0
index 3aec88c074e1..8ee105bf7bad 100644
@@ -4,6 +4,7 @@
  */
 
 #include <linux/fs.h>
+#include <linux/fs_struct.h>
 #include <linux/types.h>
 #include <linux/binfmts.h>
 #include <linux/mman.h>
@@ -181,3 +182,10 @@ int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents)
 	build_eval_ctx(&ctx, NULL, op);
 	return ipe_evaluate_event(&ctx);
 }
+
+#ifdef CONFIG_BLK_DEV_INITRD
+void ipe_unpack_initramfs(void)
+{
+	ipe_sb(current->fs->root.mnt->mnt_sb)->is_initramfs = true;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
security/ipe/hooks.h +4 -0
index 23205452f758..3b1bb0a6e89c 100644
@@ -22,4 +22,8 @@ int ipe_kernel_read_file(struct file *file, enum kernel_read_file_id id,
 
 int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents);
 
+#ifdef CONFIG_BLK_DEV_INITRD
+void ipe_unpack_initramfs(void);
+#endif /* CONFIG_BLK_DEV_INITRD */
+
 #endif /* _IPE_HOOKS_H */
security/ipe/ipe.c +0 -0
index 22bd95116087..ed3acf6174d8 100644
@@ -5,9 +5,13 @@
 #include <uapi/linux/lsm.h>

security/ipe/ipe.c line 15

Quoted 10 lines
security/ipe/ipe.c +4 -0
 
 #include "ipe.h"
+#include "eval.h"
 #include "hooks.h"
 
 static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	.lbs_superblock = sizeof(struct ipe_sb),
+#endif /* CONFIG_BLK_DEV_INITRD */
 };

I would drop the CONFIG_BLK_DEV_INITRD conditional above for reasons already mentioned, it's also not like a running system has that many superblocks allocated. The increase in memory usage should be trivial.

security/ipe/ipe.c static const struct lsm_id ipe_lsmid = { · line 27

Quoted 11 lines
security/ipe/ipe.c +6 -0
 static const struct lsm_id ipe_lsmid = {
@@ -15,12 +19,22 @@ static const struct lsm_id ipe_lsmid = {
 	.id = LSM_ID_IPE,
 };
 
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb *ipe_sb(const struct super_block *sb)
+{
+	return sb->s_security + ipe_blobs.lbs_superblock;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */

If we always have an IPE slot in the superblock's security blob, there is not need to make the above conditional.

Quoted 43 lines
security/ipe/ipe.c +3 -0
 static struct security_hook_list ipe_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(bprm_check_security, ipe_bprm_check_security),
 	LSM_HOOK_INIT(mmap_file, ipe_mmap_file),
 	LSM_HOOK_INIT(file_mprotect, ipe_file_mprotect),
 	LSM_HOOK_INIT(kernel_read_file, ipe_kernel_read_file),
 	LSM_HOOK_INIT(kernel_load_data, ipe_kernel_load_data),
+#ifdef CONFIG_BLK_DEV_INITRD
+	LSM_HOOK_INIT(unpack_initramfs_security, ipe_unpack_initramfs),
+#endif /* CONFIG_BLK_DEV_INITRD */
 };
 
 /**
security/ipe/ipe.h +3 -0
index a1c68d0fc2e0..f1e7c3222b6d 100644
@@ -12,5 +12,8 @@
 #define pr_fmt(fmt) "IPE: " fmt
 
 #include <linux/lsm_hooks.h>
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb *ipe_sb(const struct super_block *sb);
+#endif /* CONFIG_BLK_DEV_INITRD */
 
 #endif /* _IPE_H */
security/ipe/policy.h +2 -0
index fb906f41522b..fb48024bb63e 100644
@@ -30,6 +30,8 @@ enum ipe_action_type {
 #define IPE_ACTION_INVALID __IPE_ACTION_MAX
 
 enum ipe_prop_type {
+	IPE_PROP_BOOT_VERIFIED_FALSE,
+	IPE_PROP_BOOT_VERIFIED_TRUE,
 	__IPE_PROP_MAX
 };
 
security/ipe/policy_parser.c +0 -0
index 612839b405f4..cce15f0eb645 100644

security/ipe/policy_parser.c static enum ipe_action_type parse_action(char *t) · line 272

Quoted 8 lines
security/ipe/policy_parser.c +5 -0
@@ -265,6 +265,14 @@ static enum ipe_action_type parse_action(char *t)
 	return match_token(t, action_tokens, args);
 }
 
+static const match_table_t property_tokens = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	{IPE_PROP_BOOT_VERIFIED_FALSE,	"boot_verified=FALSE"},
+	{IPE_PROP_BOOT_VERIFIED_TRUE,	"boot_verified=TRUE"},
+#endif /* CONFIG_BLK_DEV_INITRD */

You want the "boot_verified" field to be part of the IPE policy regardless of the state of CONFIG_BLK_DEV_INITRD, yes? On a system without _INITRD the TRUE case would never trigger, only the FALSE case, which seems like the Right Thing.

It just seems wrong to me to have the policy grammar change depending on what the kernel supports, it seems like IPE should parse and enforce the policy regardless of the kernel's config, with the understanding that some rules might never be satisfied as it would be impossible for a given kernel config, e.g. "boot_verified=TRUE" on a non-initramfs system.

I probably should have thought of this sooner, but I believe the same applies to the dm-verity and fs-verity policy tokens.

Quoted 44 lines
security/ipe/policy_parser.c +31 -1
+	{IPE_PROP_INVALID,		NULL}
+};
+
 /**
  * parse_property - Parse the property type given a token string.
  * @t: Supplies the token string to be parsed.
@@ -277,7 +285,34 @@ static enum ipe_action_type parse_action(char *t)
  */
 static int parse_property(char *t, struct ipe_rule *r)
 {
-	return -EBADMSG;
+	substring_t args[MAX_OPT_ARGS];
+	struct ipe_prop *p = NULL;
+	int rc = 0;
+	int token;
+
+	p = kzalloc(sizeof(*p), GFP_KERNEL);
+	if (!p)
+		return -ENOMEM;
+
+	token = match_token(t, property_tokens, args);
+
+	switch (token) {
+	case IPE_PROP_BOOT_VERIFIED_FALSE:
+	case IPE_PROP_BOOT_VERIFIED_TRUE:
+		p->type = token;
+		break;
+	default:
+		rc = -EBADMSG;
+		break;
+	}
+	if (rc)
+		goto err;
+	list_add_tail(&p->next, &r->props);
+
+	return rc;
+err:
+	kfree(p);
+	return rc;
 }
 
 /**
Signature · 1 line
2.43.0

--
paul-moore.com

author
#11 lore raw

Re: [PATCH RFC v12 6/20] ipe: introduce 'boot_verified' as a trust provider

Quoted 22 lines · Paul Moore
Quoted 15 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

IPE is designed to provide system level trust guarantees, this usually implies that trust starts from bootup with a hardware root of trust, which validates the bootloader. After this, the bootloader verifies the kernel and the initramfs.

As there's no currently supported integrity method for initramfs, and it's typically already verified by the bootloader. This patch introduces a new IPE property boot_verified which allows author of IPE policy to indicate trust for files from initramfs.

The implementation of this feature utilizes the newly added unpack_initramfs hook. This hook marks the superblock of the rootfs after the initramfs has been unpacked into it.

Quoted 5 lines

Since the rootfs is never unmounted during system operation, it is advised to switch to a different policy that doesn't rely on the boot_verified property after the real rootfs is in charge. This ensures that the trust policies remain relevant and effective throughout the system's operation.

Quoted 8 lines

To be clear, most (all?) init systems cleanup the initial rootfs and mount another filesystem on top of it during the boot process, correct? That should probably be mentioned in the commit description, perhaps with references to the pivot_root(2) and switch_root(8) docs.

While I don't disagree with your recommendation above, I do believe it is unnecessarily scary sounding.

I agree more details/references will be helpful. I will rewrite the commit message.

Quoted 52 lines
Quoted 41 lines

---
v2:
+No Changes

v3:
+ Remove useless caching system
+ Move ipe_load_properties to this match
+ Minor changes from checkpatch --strict warnings

v4:
+ Remove comments from headers that was missed previously.
+ Grammatical corrections.

v5:
+ No significant changes

v6:
+ No changes

v7:
+ Reword and refactor patch 04/12 to [09/16], based on changes in
the underlying system.
+ Add common audit function for boolean values
+ Use common audit function as implementation.

v8:
+ No changes

v9:
+ No changes

v10:
+ Replace struct file with struct super_block

v11:
+ Fix code style issues

v12:
+ Switch to use unpack_initramfs hook and security blob

Quoted 10 lines
---
  security/ipe/eval.c          | 68 +++++++++++++++++++++++++++++++++++-
  security/ipe/eval.h          |  9 +++++
  security/ipe/hooks.c         |  8 +++++
  security/ipe/hooks.h         |  4 +++
  security/ipe/ipe.c           | 14 ++++++++
  security/ipe/ipe.h           |  3 ++
  security/ipe/policy.h        |  2 ++
  security/ipe/policy_parser.c | 37 +++++++++++++++++++-
  8 files changed, 143 insertions(+), 2 deletions(-)
Quoted 8 lines

More comments below, but one thing I wanted to mention at the top is that I believe there is too much conditional compilation depending on the state of CONFIG_BLK_DEV_INITRD. While there is noting wrong about this from a correctness perspective, I believe the reality is that the vast majority of systems these days are built with this enabled, and having all these pre-processor checks adds to the complexity of the code. Additional comments about this below ...

Yes, removing the dependency on the switch can significantly simplify the code. I will refactor the code accordingly.

Quoted 42 lines
Quoted 15 lines
security/ipe/eval.c +7 -0
index 4f425afffcad..546bbc52a071 100644
@@ -16,6 +16,24 @@
 
  struct ipe_policy __rcu *ipe_active_policy;
 
+#define FILE_SUPERBLOCK(f) ((f)->f_path.mnt->mnt_sb)
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * build_ipe_sb_ctx - Build from_initramfs field of an evaluation context.
+ * @ctx: Supplies a pointer to the context to be populated.
+ * @file: Supplies the file struct of the file triggered IPE event.

security/ipe/eval.c line 35

Quoted 10 lines
security/ipe/eval.c +10 -0
+ */
+static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
+{
+	ctx->from_initramfs = ipe_sb(FILE_SUPERBLOCK(file))->is_initramfs;
+}
+#else
+static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
+{
+}
+#endif /* CONFIG_BLK_DEV_INITRD */

If you move the @file NULL check into build_ipe_sb_ctx() you can save a comparison in the !CONFIG_BLK_DEV_INITRD case:

#ifdef CONFIG_BLK_DEV_INITRD
void build(...)

{
   if (file)
     ctx->initramfs = ipe_sb(file);
   else
     ctx->initramfs = false;
}
#else
void build(...)
{
   ctx->initramfs = false;
}
Quoted 2 lines

#endif

I agree this can save a comparision if we only have sb_ctx. But there are bdev_ctx(for dm-verity) and inode_ctx(for fsverity) will be introduced later. So I still think the NULL check should be done at the current place. (also the save won't exist if we are always enabling the initramfs boolean)

Quoted 83 lines

NOTE: see my comment below about always enabling the initramfs boolean in @ipe_eval_ctx and other structs.

security/ipe/eval.c void build_eval_ctx(struct ipe_eval_ctx *ctx, · line 52

Quoted 11 lines
security/ipe/eval.c +4 -0
  /**
   * build_eval_ctx - Build an evaluation context.
   * @ctx: Supplies a pointer to the context to be populated.
@@ -28,8 +46,49 @@ void build_eval_ctx(struct ipe_eval_ctx *ctx,
  {
  	ctx->file = file;
  	ctx->op = op;
+
+	if (file)
+		build_ipe_sb_ctx(ctx, file);
+}

See my comment above regarding the @file NULL check.

Quoted 27 lines
security/ipe/eval.c +25 -0
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * evaluate_boot_verified_true - Evaluate @ctx for the boot verified property.
+ * @ctx: Supplies a pointer to the context being evaluated.
+ *
+ * Return:
+ * * true	- The current @ctx match the @p
+ * * false	- The current @ctx doesn't match the @p
+ */
+static bool evaluate_boot_verified_true(const struct ipe_eval_ctx *const ctx)
+{
+	return ctx->from_initramfs;
  }
 
+/**
+ * evaluate_boot_verified_false - Evaluate @ctx for the boot verified property.
+ * @ctx: Supplies a pointer to the context being evaluated.
+ *
+ * Return:
+ * * true	- The current @ctx match the @p
+ * * false	- The current @ctx doesn't match the @p
+ */
+static bool evaluate_boot_verified_false(const struct ipe_eval_ctx *const ctx)
+{
+	return !evaluate_boot_verified_true(ctx);
+}
+#else

security/ipe/eval.c void build_eval_ctx(struct ipe_eval_ctx *ctx, · line 90

Quoted 10 lines
security/ipe/eval.c +10 -0
+static bool evaluate_boot_verified_true(const struct ipe_eval_ctx *const ctx)
+{
+	return false;
+}
+
+static bool evaluate_boot_verified_false(const struct ipe_eval_ctx *const ctx)
+{
+	return false;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */

That is a lot of lines of code just to check a single boolean value. I understand the layers of abstraction, but this looks a bit excessive to me. Assuming you agree with the other comments in this email regarding always including an initramfs flag in @ipe_eval_ctx, I think you could reduce all of the above into one single line function as shown below, and just negate it as needed in evaluate_property().

static bool evaluate_boot_verified(ctx)

{
   return ctx->initramfs;
}

security/ipe/eval.c void build_eval_ctx(struct ipe_eval_ctx *ctx, · line 108

Quoted 13 lines
security/ipe/eval.c +5 -1
  /**
   * evaluate_property - Analyze @ctx against a property.
   * @ctx: Supplies a pointer to the context to be evaluated.
@@ -42,7 +101,14 @@ void build_eval_ctx(struct ipe_eval_ctx *ctx,
  static bool evaluate_property(const struct ipe_eval_ctx *const ctx,
  			      struct ipe_prop *p)
  {
-	return false;
+	switch (p->type) {
+	case IPE_PROP_BOOT_VERIFIED_FALSE:
+		return evaluate_boot_verified_false(ctx);
+	case IPE_PROP_BOOT_VERIFIED_TRUE:
+		return evaluate_boot_verified_true(ctx);

According to my comment above:

Quoted 5 lines
   case IPE_PROP_BOOT_VERIFIED_FALSE:
     return !evaludate_boot_verified(ctx);
   case IPE_PROP_BOOT_VERIFIED_TRUE:
     return evaludate_boot_verified(ctx);

This looks better, I will update this part accordingly.

Quoted 45 lines
Quoted 11 lines
security/ipe/eval.c +3 -0
+	default:
+		return false;
+	}
  }
 
  /**
security/ipe/eval.h +0 -0
index cfdf3c8dfe8a..7d79fdb63bbf 100644

security/ipe/eval.h line 21

Quoted 7 lines
security/ipe/eval.h +4 -0
@@ -15,10 +15,19 @@
 
  extern struct ipe_policy __rcu *ipe_active_policy;
 
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb {
+	bool is_initramfs;
+}

You've already got a function named "ipe_sb()", I would suggest saving us all some headaches by renaming the above to "ipe_superblock" or something similar. The point is to not have a struct and a function with the same name.

I also think you can shorten the field name to "initramfs", it's defined as a boolean flag so I'm not sure the "is_" prefix lends any useful hints but does make for longer lines, more typing, etc.

security/ipe/eval.h line 31

Quoted 10 lines
security/ipe/eval.h +5 -0
+#endif /* CONFIG_BLK_DEV_INITRD */
+
  struct ipe_eval_ctx {
  	enum ipe_op_type op;
 
  	const struct file *file;
+#ifdef CONFIG_BLK_DEV_INITRD
+	bool from_initramfs;
+#endif /* CONFIG_BLK_DEV_INITRD */
  };

I suppose I understand the desire to make the @from_initramfs conditional to potentially reduce the size of @ipe_eval_ctx when it is not needed, however, I believe in the vast majority of systems we are going to see CONFIG_BLK_DEV_INITRD enabled so I believe this adds a lot extra code noise for little practical benefit.

Quoted 3 lines

Similarly to ipe_sb::is_initramfs, I think you can rename this field to "initramfs" and we would all be better for the change.

Sure, I can change the name and remove the KCONFIG dependency.

Quoted 138 lines
Quoted 43 lines
security/ipe/eval.h +0 -0
  void build_eval_ctx(struct ipe_eval_ctx *ctx, const struct file *file, enum ipe_op_type op);
security/ipe/hooks.c +8 -0
index 3aec88c074e1..8ee105bf7bad 100644
@@ -4,6 +4,7 @@
   */
 
  #include <linux/fs.h>
+#include <linux/fs_struct.h>
  #include <linux/types.h>
  #include <linux/binfmts.h>
  #include <linux/mman.h>
@@ -181,3 +182,10 @@ int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents)
  	build_eval_ctx(&ctx, NULL, op);
  	return ipe_evaluate_event(&ctx);
  }
+
+#ifdef CONFIG_BLK_DEV_INITRD
+void ipe_unpack_initramfs(void)
+{
+	ipe_sb(current->fs->root.mnt->mnt_sb)->is_initramfs = true;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
security/ipe/hooks.h +4 -0
index 23205452f758..3b1bb0a6e89c 100644
@@ -22,4 +22,8 @@ int ipe_kernel_read_file(struct file *file, enum kernel_read_file_id id,
 
  int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents);
 
+#ifdef CONFIG_BLK_DEV_INITRD
+void ipe_unpack_initramfs(void);
+#endif /* CONFIG_BLK_DEV_INITRD */
+
  #endif /* _IPE_HOOKS_H */
security/ipe/ipe.c +0 -0
index 22bd95116087..ed3acf6174d8 100644
@@ -5,9 +5,13 @@
  #include <uapi/linux/lsm.h>

security/ipe/ipe.c line 15

Quoted 10 lines
security/ipe/ipe.c +4 -0
 
  #include "ipe.h"
+#include "eval.h"
  #include "hooks.h"
 
  static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	.lbs_superblock = sizeof(struct ipe_sb),
+#endif /* CONFIG_BLK_DEV_INITRD */
  };

I would drop the CONFIG_BLK_DEV_INITRD conditional above for reasons already mentioned, it's also not like a running system has that many superblocks allocated. The increase in memory usage should be trivial.

security/ipe/ipe.c static const struct lsm_id ipe_lsmid = { · line 27

Quoted 11 lines
security/ipe/ipe.c +6 -0
  static const struct lsm_id ipe_lsmid = {
@@ -15,12 +19,22 @@ static const struct lsm_id ipe_lsmid = {
  	.id = LSM_ID_IPE,
  };
 
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb *ipe_sb(const struct super_block *sb)
+{
+	return sb->s_security + ipe_blobs.lbs_superblock;
+}
+#endif /* CONFIG_BLK_DEV_INITRD */

If we always have an IPE slot in the superblock's security blob, there is not need to make the above conditional.

Quoted 43 lines
security/ipe/ipe.c +3 -0
  static struct security_hook_list ipe_hooks[] __ro_after_init = {
  	LSM_HOOK_INIT(bprm_check_security, ipe_bprm_check_security),
  	LSM_HOOK_INIT(mmap_file, ipe_mmap_file),
  	LSM_HOOK_INIT(file_mprotect, ipe_file_mprotect),
  	LSM_HOOK_INIT(kernel_read_file, ipe_kernel_read_file),
  	LSM_HOOK_INIT(kernel_load_data, ipe_kernel_load_data),
+#ifdef CONFIG_BLK_DEV_INITRD
+	LSM_HOOK_INIT(unpack_initramfs_security, ipe_unpack_initramfs),
+#endif /* CONFIG_BLK_DEV_INITRD */
  };
 
  /**
security/ipe/ipe.h +3 -0
index a1c68d0fc2e0..f1e7c3222b6d 100644
@@ -12,5 +12,8 @@
  #define pr_fmt(fmt) "IPE: " fmt
 
  #include <linux/lsm_hooks.h>
+#ifdef CONFIG_BLK_DEV_INITRD
+struct ipe_sb *ipe_sb(const struct super_block *sb);
+#endif /* CONFIG_BLK_DEV_INITRD */
 
  #endif /* _IPE_H */
security/ipe/policy.h +2 -0
index fb906f41522b..fb48024bb63e 100644
@@ -30,6 +30,8 @@ enum ipe_action_type {
  #define IPE_ACTION_INVALID __IPE_ACTION_MAX
 
  enum ipe_prop_type {
+	IPE_PROP_BOOT_VERIFIED_FALSE,
+	IPE_PROP_BOOT_VERIFIED_TRUE,
  	__IPE_PROP_MAX
  };
 
security/ipe/policy_parser.c +0 -0
index 612839b405f4..cce15f0eb645 100644

security/ipe/policy_parser.c static enum ipe_action_type parse_action(char *t) · line 272

Quoted 8 lines
security/ipe/policy_parser.c +5 -0
@@ -265,6 +265,14 @@ static enum ipe_action_type parse_action(char *t)
  	return match_token(t, action_tokens, args);
  }
 
+static const match_table_t property_tokens = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	{IPE_PROP_BOOT_VERIFIED_FALSE,	"boot_verified=FALSE"},
+	{IPE_PROP_BOOT_VERIFIED_TRUE,	"boot_verified=TRUE"},
+#endif /* CONFIG_BLK_DEV_INITRD */

You want the "boot_verified" field to be part of the IPE policy regardless of the state of CONFIG_BLK_DEV_INITRD, yes? On a system without _INITRD the TRUE case would never trigger, only the FALSE case, which seems like the Right Thing.

It just seems wrong to me to have the policy grammar change depending on what the kernel supports, it seems like IPE should parse and enforce the policy regardless of the kernel's config, with the understanding that some rules might never be satisfied as it would be impossible for a given kernel config, e.g. "boot_verified=TRUE" on a non-initramfs system.

Quoted 3 lines

I probably should have thought of this sooner, but I believe the same applies to the dm-verity and fs-verity policy tokens.

This sounds reasonable to me. I will change the parser to make the policy grammar not depending on any kernel config.

Thanks,
Fan

Quoted 47 lines
Quoted 44 lines
security/ipe/policy_parser.c +31 -1
+	{IPE_PROP_INVALID,		NULL}
+};
+
  /**
   * parse_property - Parse the property type given a token string.
   * @t: Supplies the token string to be parsed.
@@ -277,7 +285,34 @@ static enum ipe_action_type parse_action(char *t)
   */
  static int parse_property(char *t, struct ipe_rule *r)
  {
-	return -EBADMSG;
+	substring_t args[MAX_OPT_ARGS];
+	struct ipe_prop *p = NULL;
+	int rc = 0;
+	int token;
+
+	p = kzalloc(sizeof(*p), GFP_KERNEL);
+	if (!p)
+		return -ENOMEM;
+
+	token = match_token(t, property_tokens, args);
+
+	switch (token) {
+	case IPE_PROP_BOOT_VERIFIED_FALSE:
+	case IPE_PROP_BOOT_VERIFIED_TRUE:
+		p->type = token;
+		break;
+	default:
+		rc = -EBADMSG;
+		break;
+	}
+	if (rc)
+		goto err;
+	list_add_tail(&p->next, &r->props);
+
+	return rc;
+err:
+	kfree(p);
+	return rc;
  }
 
  /**
Signature · 1 line
2.43.0

--
paul-moore.com

author
#12 lore raw

RFC PATCH v12 7/20 security: add new securityfs delete function

In reply to Fan Wu

When deleting a directory in the security file system, the existing securityfs_remove requires the directory to be empty, otherwise it will do nothing. This leads to a potential risk that the security file system might be in an unclean state when the intended deletion did not happen.

This commit introduces a new function securityfs_recursive_remove to recursively delete a directory without leaving an unclean state.

---
v1-v8:
+ Not present

v9:
+ Introduced

v10:
+ No changes

v11:
+ Fix code style issues

v12:
+ No changes

---
 include/linux/security.h |  1 +
 security/inode.c         | 25 +++++++++++++++++++++++++
 2 files changed, 26 insertions(+)
include/linux/security.h +1 -0
index 1545c69edc1b..e994ac9cda91 100644
@@ -2029,6 +2029,7 @@ struct dentry *securityfs_create_symlink(const char *name,
 					 const char *target,
 					 const struct inode_operations *iops);
 extern void securityfs_remove(struct dentry *dentry);
+extern void securityfs_recursive_remove(struct dentry *dentry);
 
 #else /* CONFIG_SECURITYFS */
 
security/inode.c +25 -0
index 9e7cde913667..f21847badb7d 100644
@@ -313,6 +313,31 @@ void securityfs_remove(struct dentry *dentry)
 }
 EXPORT_SYMBOL_GPL(securityfs_remove);
 
+static void remove_one(struct dentry *victim)
+{
+	simple_release_fs(&mount, &mount_count);
+}
+
+/**
+ * securityfs_recursive_remove - recursively removes a file or directory
+ *
+ * @dentry: a pointer to a the dentry of the file or directory to be removed.
+ *
+ * This function recursively removes a file or directory in securityfs that was
+ * previously created with a call to another securityfs function (like
+ * securityfs_create_file() or variants thereof.)
+ */
+void securityfs_recursive_remove(struct dentry *dentry)
+{
+	if (IS_ERR_OR_NULL(dentry))
+		return;
+
+	simple_pin_fs(&fs_type, &mount, &mount_count);
+	simple_recursive_removal(dentry, remove_one);
+	simple_release_fs(&mount, &mount_count);
+}
+EXPORT_SYMBOL_GPL(securityfs_recursive_remove);
+
 #ifdef CONFIG_SECURITY
 static struct dentry *lsm_dentry;
 static ssize_t lsm_read(struct file *filp, char __user *buf, size_t count,
Signature · 1 line
2.43.0
author
#13 lore raw

RFC PATCH v12 8/20 ipe: add userspace interface

In reply to Fan Wu

From: Deven Bowers <[email protected]>

As is typical with LSMs, IPE uses securityfs as its interface with userspace. for a complete list of the interfaces and the respective inputs/outputs, please see the documentation under admin-guide/LSM/ipe.rst

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move policy load and activation audit event to 03/12
+ Fix a potential panic when a policy failed to load.
+ use pr_warn for a failure to parse instead of an audit record
+ Remove comments from headers
+ Add lockdep assertions to ipe_update_active_policy and ipe_activate_policy
+ Fix up warnings with checkpatch --strict
+ Use file_ns_capable for CAP_MAC_ADMIN for securityfs nodes.
+ Use memdup_user instead of kzalloc+simple_write_to_buffer.
+ Remove strict_parse command line parameter, as it is added by the sysctl command line.
+ Prefix extern variables with ipe_

v4:
+ Remove securityfs to reverse-dependency
+ Add SHA1 reverse dependency.
+ Add versioning scheme for IPE properties, and associated interface to query the versioning scheme.
+ Cause a parser to always return an error on unknown syntax.
+ Remove strict_parse option
+ Change active_policy interface from sysctl, to securityfs, and change scheme.

v5:
+ Cause an error if a default action is not defined for each operation.
+ Minor function renames

v6:
+ No changes

v7:
+ Propagating changes to support the new ipe_context structure in the evaluation loop.

+ Further split the parser and userspace interface changes into separate commits.

+ "raw" was renamed to "pkcs7" and made read only
+ "raw"'s write functionality (update a policy) moved to "update"
+ introduced "version", "policy_name" nodes.
+ "content" renamed to "policy"
+ changes to allow the compiled-in policy to be treated identical to deployed-after-the-fact policies.

v8:
+ Prevent securityfs initialization if the LSM is disabled

v9:
+ Switch to securityfs_recursive_remove for policy folder deletion

v10:
+ Simplify and correct concurrency
+ Fix typos

v11:
+ Correct code comments

v12:
+ Correct locking and remove redundant code

---
 security/ipe/Makefile    |   2 +
 security/ipe/fs.c        | 101 +++++++++
 security/ipe/fs.h        |  16 ++
 security/ipe/ipe.c       |   3 +
 security/ipe/ipe.h       |   2 +
 security/ipe/policy.c    | 123 ++++++++++
 security/ipe/policy.h    |   9 +
 security/ipe/policy_fs.c | 469 +++++++++++++++++++++++++++++++++++++++
 8 files changed, 725 insertions(+)
 create mode 100644 security/ipe/fs.c
 create mode 100644 security/ipe/fs.h
 create mode 100644 security/ipe/policy_fs.c
security/ipe/Makefile +2 -0
index d7f2870d7c09..cfbed03a8885 100644
@@ -8,6 +8,8 @@
 obj-$(CONFIG_SECURITY_IPE) += \
 	eval.o \
 	hooks.o \
+	fs.o \
 	ipe.o \
 	policy.o \
+	policy_fs.o \
 	policy_parser.o \
security/ipe/fs.c new file +101 -0

101 lines not on this page · raw message

security/ipe/fs.h new file +16 -0
new file mode 100644
index 000000000000..c1fc0ca4ae93
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef _IPE_FS_H
+#define _IPE_FS_H
+
+#include "policy.h"
+
+extern struct dentry *policy_root __ro_after_init;
+
+int ipe_new_policyfs_node(struct ipe_policy *p);
+void ipe_del_policyfs_node(struct ipe_policy *p);
+
+#endif /* _IPE_FS_H */
security/ipe/ipe.c +3 -0
index ed3acf6174d8..034ee8cd6802 100644
@@ -8,6 +8,8 @@
 #include "eval.h"
 #include "hooks.h"
 
+bool ipe_enabled;
+
 static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
 #ifdef CONFIG_BLK_DEV_INITRD
 	.lbs_superblock = sizeof(struct ipe_sb),
@@ -50,6 +52,7 @@ static struct security_hook_list ipe_hooks[] __ro_after_init = {
 static int __init ipe_init(void)
 {
 	security_add_hooks(ipe_hooks, ARRAY_SIZE(ipe_hooks), &ipe_lsmid);
+	ipe_enabled = true;
 
 	return 0;
 }
security/ipe/ipe.h +2 -0
index f1e7c3222b6d..1862c710dab8 100644
@@ -16,4 +16,6 @@
 struct ipe_sb *ipe_sb(const struct super_block *sb);
 #endif /* CONFIG_BLK_DEV_INITRD */
 
+extern bool ipe_enabled;
+
 #endif /* _IPE_H */
security/ipe/policy.c +123 -0

147 lines not on this page · raw message

security/ipe/policy.h +9 -0
index fb48024bb63e..060ffdbc62d6 100644
@@ -7,6 +7,7 @@
 
 #include <linux/list.h>
 #include <linux/types.h>
+#include <linux/fs.h>
 
 enum ipe_op_type {
 	IPE_OP_EXEC = 0,
@@ -76,10 +77,18 @@ struct ipe_policy {
 	size_t textlen;
 
 	struct ipe_parsed_policy *parsed;
+
+	struct dentry *policyfs;
 };
 
 struct ipe_policy *ipe_new_policy(const char *text, size_t textlen,
 				  const char *pkcs7, size_t pkcs7len);
 void ipe_free_policy(struct ipe_policy *pol);
+struct ipe_policy *ipe_update_policy(struct inode *root,
+				     const char *text,
+				     size_t textlen, const char *pkcs7,
+				     size_t pkcs7len);
+int ipe_set_active_pol(const struct ipe_policy *p);
+extern struct mutex ipe_policy_lock;
 
 #endif /* _IPE_POLICY_H */
security/ipe/policy_fs.c new file +469 -0

469 lines not on this page · raw message

Signature · 1 line
2.43.0
maintainer
#14 lore raw

Re: [PATCH RFC v12 8/20] ipe: add userspace interface

Quoted 90 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

As is typical with LSMs, IPE uses securityfs as its interface with userspace. for a complete list of the interfaces and the respective inputs/outputs, please see the documentation under admin-guide/LSM/ipe.rst

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move policy load and activation audit event to 03/12
+ Fix a potential panic when a policy failed to load.
+ use pr_warn for a failure to parse instead of an audit record
+ Remove comments from headers
+ Add lockdep assertions to ipe_update_active_policy and ipe_activate_policy
+ Fix up warnings with checkpatch --strict
+ Use file_ns_capable for CAP_MAC_ADMIN for securityfs nodes.
+ Use memdup_user instead of kzalloc+simple_write_to_buffer.
+ Remove strict_parse command line parameter, as it is added by the sysctl command line.
+ Prefix extern variables with ipe_

v4:
+ Remove securityfs to reverse-dependency
+ Add SHA1 reverse dependency.
+ Add versioning scheme for IPE properties, and associated interface to query the versioning scheme.
+ Cause a parser to always return an error on unknown syntax.
+ Remove strict_parse option
+ Change active_policy interface from sysctl, to securityfs, and change scheme.

v5:
+ Cause an error if a default action is not defined for each operation.
+ Minor function renames

v6:
+ No changes

v7:
+ Propagating changes to support the new ipe_context structure in the evaluation loop.

+ Further split the parser and userspace interface changes into separate commits.

+ "raw" was renamed to "pkcs7" and made read only
+ "raw"'s write functionality (update a policy) moved to "update"
+ introduced "version", "policy_name" nodes.
+ "content" renamed to "policy"
+ changes to allow the compiled-in policy to be treated identical to deployed-after-the-fact policies.

v8:
+ Prevent securityfs initialization if the LSM is disabled

v9:
+ Switch to securityfs_recursive_remove for policy folder deletion

v10:
+ Simplify and correct concurrency
+ Fix typos

v11:
+ Correct code comments

v12:
+ Correct locking and remove redundant code

---
 security/ipe/Makefile    |   2 +
 security/ipe/fs.c        | 101 +++++++++
 security/ipe/fs.h        |  16 ++
 security/ipe/ipe.c       |   3 +
 security/ipe/ipe.h       |   2 +
 security/ipe/policy.c    | 123 ++++++++++
 security/ipe/policy.h    |   9 +
 security/ipe/policy_fs.c | 469 +++++++++++++++++++++++++++++++++++++++
 8 files changed, 725 insertions(+)
 create mode 100644 security/ipe/fs.c
 create mode 100644 security/ipe/fs.h
 create mode 100644 security/ipe/policy_fs.c

...

Quoted 42 lines
security/ipe/policy.c +34 -0
index f22a576a6d68..61fea3e38e11 100644
@@ -43,6 +71,68 @@ static int set_pkcs7_data(void *ctx, const void *data, size_t len,
 	return 0;
 }
 
+/**
+ * ipe_update_policy - parse a new policy and replace old with it.
+ * @root: Supplies a pointer to the securityfs inode saved the policy.
+ * @text: Supplies a pointer to the plain text policy.
+ * @textlen: Supplies the length of @text.
+ * @pkcs7: Supplies a pointer to a buffer containing a pkcs7 message.
+ * @pkcs7len: Supplies the length of @pkcs7len.
+ *
+ * @text/@textlen is mutually exclusive with @pkcs7/@pkcs7len - see
+ * ipe_new_policy.
+ *
+ * Context: Requires root->i_rwsem to be held.
+ * Return:
+ * * !IS_ERR	- The existing policy saved in the inode before update
+ * * -ENOENT	- Policy doesn't exist
+ * * -EINVAL	- New policy is invalid
+ */
+struct ipe_policy *ipe_update_policy(struct inode *root,
+				     const char *text, size_t textlen,
+				     const char *pkcs7, size_t pkcs7len)
+{
+	int rc = 0;
+	struct ipe_policy *old, *ap, *new = NULL;
+
+	old = (struct ipe_policy *)root->i_private;
+	if (!old)
+		return ERR_PTR(-ENOENT);
+
+	new = ipe_new_policy(text, textlen, pkcs7, pkcs7len);
+	if (IS_ERR(new))
+		return new;
+
+	if (strcmp(new->parsed->name, old->parsed->name)) {
+		rc = -EINVAL;

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 117

Quoted 10 lines
security/ipe/policy.c +10 -0
+		goto err;
+	}
+
+	if (ver_to_u64(old) > ver_to_u64(new)) {
+		rc = -EINVAL;
+		goto err;
+	}
+
+	root->i_private = new;
+	swap(new->policyfs, old->policyfs);

Should the swap() take place with @ipe_policy_lock held?

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 125

Quoted 7 lines
security/ipe/policy.c +7 -0
+	mutex_lock(&ipe_policy_lock);
+	ap = rcu_dereference_protected(ipe_active_policy,
+				       lockdep_is_held(&ipe_policy_lock));
+	if (old == ap) {
+		rcu_assign_pointer(ipe_active_policy, new);
+		mutex_unlock(&ipe_policy_lock);
+		synchronize_rcu();

I'm guessing you are forcing a synchronize_rcu() here because you are free()'ing @old in the caller, yes? Looking at the code, I only see one caller, update_policy(). With only one caller, why not free @old directly in ipe_update_policy()? Do you see others callers that would do something different?

Quoted 37 lines
security/ipe/policy.c +30 -0
+	} else {
+		mutex_unlock(&ipe_policy_lock);
+	}
+
+	return old;
+err:
+	ipe_free_policy(new);
+	return ERR_PTR(rc);
+}
+
 /**
  * ipe_new_policy - Allocate and parse an ipe_policy structure.
  *
@@ -99,3 +189,36 @@ struct ipe_policy *ipe_new_policy(const char *text, size_t textlen,
 	ipe_free_policy(new);
 	return ERR_PTR(rc);
 }
+
+/**
+ * ipe_set_active_pol - Make @p the active policy.
+ * @p: Supplies a pointer to the policy to make active.
+ *
+ * Context: Requires root->i_rwsem, which i_private has the policy, to be held.
+ * Return:
+ * * !IS_ERR	- Success
+ * * -EINVAL	- New active policy version is invalid
+ */
+int ipe_set_active_pol(const struct ipe_policy *p)
+{
+	struct ipe_policy *ap = NULL;
+
+	mutex_lock(&ipe_policy_lock);
+
+	ap = rcu_dereference_protected(ipe_active_policy,
+				       lockdep_is_held(&ipe_policy_lock));
+	if (ap == p) {
+		mutex_unlock(&ipe_policy_lock);

security/ipe/policy.c struct ipe_policy *ipe_new_policy(const char *text, size_t textlen, · line 221

Quoted 10 lines
security/ipe/policy.c +10 -0
+		return 0;
+	}
+	if (ap && ver_to_u64(ap) > ver_to_u64(p)) {
+		mutex_unlock(&ipe_policy_lock);
+		return -EINVAL;
+	}
+
+	rcu_assign_pointer(ipe_active_policy, p);
+	mutex_unlock(&ipe_policy_lock);
+	synchronize_rcu();

Why do you need the synchronize_rcu() call here?

security/ipe/policy.c struct ipe_policy *ipe_new_policy(const char *text, size_t textlen, · line 223

Quoted 2 lines
security/ipe/policy.c +2 -0
+	return 0;
+}

--
paul-moore.com

author
#15 lore raw

Re: [PATCH RFC v12 8/20] ipe: add userspace interface

Quoted 140 lines · Paul Moore
Quoted 90 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

As is typical with LSMs, IPE uses securityfs as its interface with userspace. for a complete list of the interfaces and the respective inputs/outputs, please see the documentation under admin-guide/LSM/ipe.rst

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move policy load and activation audit event to 03/12
+ Fix a potential panic when a policy failed to load.
+ use pr_warn for a failure to parse instead of an audit record
+ Remove comments from headers
+ Add lockdep assertions to ipe_update_active_policy and ipe_activate_policy
+ Fix up warnings with checkpatch --strict
+ Use file_ns_capable for CAP_MAC_ADMIN for securityfs nodes.
+ Use memdup_user instead of kzalloc+simple_write_to_buffer.
+ Remove strict_parse command line parameter, as it is added by the sysctl command line.
+ Prefix extern variables with ipe_

v4:
+ Remove securityfs to reverse-dependency
+ Add SHA1 reverse dependency.
+ Add versioning scheme for IPE properties, and associated interface to query the versioning scheme.
+ Cause a parser to always return an error on unknown syntax.
+ Remove strict_parse option
+ Change active_policy interface from sysctl, to securityfs, and change scheme.

v5:
+ Cause an error if a default action is not defined for each operation.
+ Minor function renames

v6:
+ No changes

v7:
+ Propagating changes to support the new ipe_context structure in the evaluation loop.

+ Further split the parser and userspace interface changes into separate commits.

+ "raw" was renamed to "pkcs7" and made read only
+ "raw"'s write functionality (update a policy) moved to "update"
+ introduced "version", "policy_name" nodes.
+ "content" renamed to "policy"
+ changes to allow the compiled-in policy to be treated identical to deployed-after-the-fact policies.

v8:
+ Prevent securityfs initialization if the LSM is disabled

v9:
+ Switch to securityfs_recursive_remove for policy folder deletion

v10:
+ Simplify and correct concurrency
+ Fix typos

v11:
+ Correct code comments

v12:
+ Correct locking and remove redundant code

---
  security/ipe/Makefile    |   2 +
  security/ipe/fs.c        | 101 +++++++++
  security/ipe/fs.h        |  16 ++
  security/ipe/ipe.c       |   3 +
  security/ipe/ipe.h       |   2 +
  security/ipe/policy.c    | 123 ++++++++++
  security/ipe/policy.h    |   9 +
  security/ipe/policy_fs.c | 469 +++++++++++++++++++++++++++++++++++++++
  8 files changed, 725 insertions(+)

create mode 100644 security/ipe/fs.c
create mode 100644 security/ipe/fs.h
create mode 100644 security/ipe/policy_fs.c

...

Quoted 46 lines
security/ipe/policy.c +38 -0
index f22a576a6d68..61fea3e38e11 100644
@@ -43,6 +71,68 @@ static int set_pkcs7_data(void *ctx, const void *data, size_t len,
  	return 0;
  }
 
+/**
+ * ipe_update_policy - parse a new policy and replace old with it.
+ * @root: Supplies a pointer to the securityfs inode saved the policy.
+ * @text: Supplies a pointer to the plain text policy.
+ * @textlen: Supplies the length of @text.
+ * @pkcs7: Supplies a pointer to a buffer containing a pkcs7 message.
+ * @pkcs7len: Supplies the length of @pkcs7len.
+ *
+ * @text/@textlen is mutually exclusive with @pkcs7/@pkcs7len - see
+ * ipe_new_policy.
+ *
+ * Context: Requires root->i_rwsem to be held.
+ * Return:
+ * * !IS_ERR	- The existing policy saved in the inode before update
+ * * -ENOENT	- Policy doesn't exist
+ * * -EINVAL	- New policy is invalid
+ */
+struct ipe_policy *ipe_update_policy(struct inode *root,
+				     const char *text, size_t textlen,
+				     const char *pkcs7, size_t pkcs7len)
+{
+	int rc = 0;
+	struct ipe_policy *old, *ap, *new = NULL;
+
+	old = (struct ipe_policy *)root->i_private;
+	if (!old)
+		return ERR_PTR(-ENOENT);
+
+	new = ipe_new_policy(text, textlen, pkcs7, pkcs7len);
+	if (IS_ERR(new))
+		return new;
+
+	if (strcmp(new->parsed->name, old->parsed->name)) {
+		rc = -EINVAL;
+		goto err;
+	}
+
+	if (ver_to_u64(old) > ver_to_u64(new)) {
Quoted 9 lines

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 117

Quoted 6 lines
security/ipe/policy.c +6 -0
+		rc = -EINVAL;
+		goto err;
+	}
+
+	root->i_private = new;
+	swap(new->policyfs, old->policyfs);

Should the swap() take place with @ipe_policy_lock held?

I think we are safe here because root->i_rwsem is held. Other two operations set_active and delete are also depending on the inode lock.

Quoted 5 lines
Quoted 5 lines
security/ipe/policy.c +5 -0
+	mutex_lock(&ipe_policy_lock);
+	ap = rcu_dereference_protected(ipe_active_policy,
+				       lockdep_is_held(&ipe_policy_lock));
+	if (old == ap) {
+		rcu_assign_pointer(ipe_active_policy, new);
Quoted 9 lines

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 124

Quoted 2 lines
security/ipe/policy.c +2 -0
+		mutex_unlock(&ipe_policy_lock);
+		synchronize_rcu();

I'm guessing you are forcing a synchronize_rcu() here because you are free()'ing @old in the caller, yes? Looking at the code, I only see one caller, update_policy(). With only one caller, why not free @old directly in ipe_update_policy()? Do you see others callers that would do something different?

The call of synchronize_rcu() is because we are updating the current active policy so we need to set the new policy as active.

I do agree we can free the old inside this function.

Quoted 56 lines
Quoted 37 lines
security/ipe/policy.c +30 -0
+	} else {
+		mutex_unlock(&ipe_policy_lock);
+	}
+
+	return old;
+err:
+	ipe_free_policy(new);
+	return ERR_PTR(rc);
+}
+
  /**
   * ipe_new_policy - Allocate and parse an ipe_policy structure.
   *
@@ -99,3 +189,36 @@ struct ipe_policy *ipe_new_policy(const char *text, size_t textlen,
  	ipe_free_policy(new);
  	return ERR_PTR(rc);
  }
+
+/**
+ * ipe_set_active_pol - Make @p the active policy.
+ * @p: Supplies a pointer to the policy to make active.
+ *
+ * Context: Requires root->i_rwsem, which i_private has the policy, to be held.
+ * Return:
+ * * !IS_ERR	- Success
+ * * -EINVAL	- New active policy version is invalid
+ */
+int ipe_set_active_pol(const struct ipe_policy *p)
+{
+	struct ipe_policy *ap = NULL;
+
+	mutex_lock(&ipe_policy_lock);
+
+	ap = rcu_dereference_protected(ipe_active_policy,
+				       lockdep_is_held(&ipe_policy_lock));
+	if (ap == p) {
+		mutex_unlock(&ipe_policy_lock);

security/ipe/policy.c struct ipe_policy *ipe_new_policy(const char *text, size_t textlen, · line 221

Quoted 10 lines
security/ipe/policy.c +10 -0
+		return 0;
+	}
+	if (ap && ver_to_u64(ap) > ver_to_u64(p)) {
+		mutex_unlock(&ipe_policy_lock);
+		return -EINVAL;
+	}
+
+	rcu_assign_pointer(ipe_active_policy, p);
+	mutex_unlock(&ipe_policy_lock);
+	synchronize_rcu();

Why do you need the synchronize_rcu() call here?

security/ipe/policy.c struct ipe_policy *ipe_new_policy(const char *text, size_t textlen, · line 223

Quoted 2 lines
security/ipe/policy.c +2 -0
+	return 0;
+}

--
paul-moore.com

maintainer
#16 lore raw

Re: [PATCH RFC v12 8/20] ipe: add userspace interface

Quoted 160 lines · Fan Wu
Quoted 140 lines · Paul Moore
Quoted 90 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

As is typical with LSMs, IPE uses securityfs as its interface with userspace. for a complete list of the interfaces and the respective inputs/outputs, please see the documentation under admin-guide/LSM/ipe.rst

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move policy load and activation audit event to 03/12
+ Fix a potential panic when a policy failed to load.
+ use pr_warn for a failure to parse instead of an audit record
+ Remove comments from headers
+ Add lockdep assertions to ipe_update_active_policy and ipe_activate_policy
+ Fix up warnings with checkpatch --strict
+ Use file_ns_capable for CAP_MAC_ADMIN for securityfs nodes.
+ Use memdup_user instead of kzalloc+simple_write_to_buffer.
+ Remove strict_parse command line parameter, as it is added by the sysctl command line.
+ Prefix extern variables with ipe_

v4:
+ Remove securityfs to reverse-dependency
+ Add SHA1 reverse dependency.
+ Add versioning scheme for IPE properties, and associated interface to query the versioning scheme.
+ Cause a parser to always return an error on unknown syntax.
+ Remove strict_parse option
+ Change active_policy interface from sysctl, to securityfs, and change scheme.

v5:
+ Cause an error if a default action is not defined for each operation.
+ Minor function renames

v6:
+ No changes

v7:
+ Propagating changes to support the new ipe_context structure in the evaluation loop.

+ Further split the parser and userspace interface changes into separate commits.

+ "raw" was renamed to "pkcs7" and made read only
+ "raw"'s write functionality (update a policy) moved to "update"
+ introduced "version", "policy_name" nodes.
+ "content" renamed to "policy"
+ changes to allow the compiled-in policy to be treated identical to deployed-after-the-fact policies.

v8:
+ Prevent securityfs initialization if the LSM is disabled

v9:
+ Switch to securityfs_recursive_remove for policy folder deletion

v10:
+ Simplify and correct concurrency
+ Fix typos

v11:
+ Correct code comments

v12:
+ Correct locking and remove redundant code

---
  security/ipe/Makefile    |   2 +
  security/ipe/fs.c        | 101 +++++++++
  security/ipe/fs.h        |  16 ++
  security/ipe/ipe.c       |   3 +
  security/ipe/ipe.h       |   2 +
  security/ipe/policy.c    | 123 ++++++++++
  security/ipe/policy.h    |   9 +
  security/ipe/policy_fs.c | 469 +++++++++++++++++++++++++++++++++++++++
  8 files changed, 725 insertions(+)

create mode 100644 security/ipe/fs.c
create mode 100644 security/ipe/fs.h
create mode 100644 security/ipe/policy_fs.c

...

Quoted 46 lines
security/ipe/policy.c +38 -0
index f22a576a6d68..61fea3e38e11 100644
@@ -43,6 +71,68 @@ static int set_pkcs7_data(void *ctx, const void *data, size_t len,
     return 0;
  }
 
+/**
+ * ipe_update_policy - parse a new policy and replace old with it.
+ * @root: Supplies a pointer to the securityfs inode saved the policy.
+ * @text: Supplies a pointer to the plain text policy.
+ * @textlen: Supplies the length of @text.
+ * @pkcs7: Supplies a pointer to a buffer containing a pkcs7 message.
+ * @pkcs7len: Supplies the length of @pkcs7len.
+ *
+ * @text/@textlen is mutually exclusive with @pkcs7/@pkcs7len - see
+ * ipe_new_policy.
+ *
+ * Context: Requires root->i_rwsem to be held.
+ * Return:
+ * * !IS_ERR        - The existing policy saved in the inode before update
+ * * -ENOENT        - Policy doesn't exist
+ * * -EINVAL        - New policy is invalid
+ */
+struct ipe_policy *ipe_update_policy(struct inode *root,
+                                 const char *text, size_t textlen,
+                                 const char *pkcs7, size_t pkcs7len)
+{
+    int rc = 0;
+    struct ipe_policy *old, *ap, *new = NULL;
+
+    old = (struct ipe_policy *)root->i_private;
+    if (!old)
+            return ERR_PTR(-ENOENT);
+
+    new = ipe_new_policy(text, textlen, pkcs7, pkcs7len);
+    if (IS_ERR(new))
+            return new;
+
+    if (strcmp(new->parsed->name, old->parsed->name)) {
+            rc = -EINVAL;
+            goto err;
+    }
+
+    if (ver_to_u64(old) > ver_to_u64(new)) {
Quoted 9 lines

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 117

Quoted 6 lines
security/ipe/policy.c +6 -0
+            rc = -EINVAL;
+            goto err;
+    }
+
+    root->i_private = new;
+    swap(new->policyfs, old->policyfs);

Should the swap() take place with @ipe_policy_lock held?

I think we are safe here because root->i_rwsem is held. Other two operations set_active and delete are also depending on the inode lock.

Quoted 8 lines
Quoted 7 lines
security/ipe/policy.c +7 -0
+    mutex_lock(&ipe_policy_lock);
+    ap = rcu_dereference_protected(ipe_active_policy,
+                                   lockdep_is_held(&ipe_policy_lock));
+    if (old == ap) {
+            rcu_assign_pointer(ipe_active_policy, new);
+            mutex_unlock(&ipe_policy_lock);
+            synchronize_rcu();
Quoted 8 lines
Quoted 6 lines

I'm guessing you are forcing a synchronize_rcu() here because you are free()'ing @old in the caller, yes? Looking at the code, I only see one caller, update_policy(). With only one caller, why not free @old directly in ipe_update_policy()? Do you see others callers that would do something different?

The call of synchronize_rcu() is because we are updating the current active policy so we need to set the new policy as active.

Unless I'm mistaken, a syncronize_rcu() call only ensures that the current task will see the updated value by waiting until all current RCU critical sections have finished. Given the mutex involved here I don't believe this is necessary, but please correct me if I'm wrong.

Signature · 1 line
paul-moore.com
author
#17 lore raw

Re: [PATCH RFC v12 8/20] ipe: add userspace interface

Quoted 167 lines · Paul Moore
Quoted 166 lines · Fan Wu
Quoted 140 lines · Paul Moore
Quoted 90 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

As is typical with LSMs, IPE uses securityfs as its interface with userspace. for a complete list of the interfaces and the respective inputs/outputs, please see the documentation under admin-guide/LSM/ipe.rst

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move policy load and activation audit event to 03/12
+ Fix a potential panic when a policy failed to load.
+ use pr_warn for a failure to parse instead of an audit record
+ Remove comments from headers
+ Add lockdep assertions to ipe_update_active_policy and ipe_activate_policy
+ Fix up warnings with checkpatch --strict
+ Use file_ns_capable for CAP_MAC_ADMIN for securityfs nodes.
+ Use memdup_user instead of kzalloc+simple_write_to_buffer.
+ Remove strict_parse command line parameter, as it is added by the sysctl command line.
+ Prefix extern variables with ipe_

v4:
+ Remove securityfs to reverse-dependency
+ Add SHA1 reverse dependency.
+ Add versioning scheme for IPE properties, and associated interface to query the versioning scheme.
+ Cause a parser to always return an error on unknown syntax.
+ Remove strict_parse option
+ Change active_policy interface from sysctl, to securityfs, and change scheme.

v5:
+ Cause an error if a default action is not defined for each operation.
+ Minor function renames

v6:
+ No changes

v7:
+ Propagating changes to support the new ipe_context structure in the evaluation loop.

+ Further split the parser and userspace interface changes into separate commits.

+ "raw" was renamed to "pkcs7" and made read only
+ "raw"'s write functionality (update a policy) moved to "update"
+ introduced "version", "policy_name" nodes.
+ "content" renamed to "policy"
+ changes to allow the compiled-in policy to be treated identical to deployed-after-the-fact policies.

v8:
+ Prevent securityfs initialization if the LSM is disabled

v9:
+ Switch to securityfs_recursive_remove for policy folder deletion

v10:
+ Simplify and correct concurrency
+ Fix typos

v11:
+ Correct code comments

v12:
+ Correct locking and remove redundant code

---
   security/ipe/Makefile    |   2 +
   security/ipe/fs.c        | 101 +++++++++
   security/ipe/fs.h        |  16 ++
   security/ipe/ipe.c       |   3 +
   security/ipe/ipe.h       |   2 +
   security/ipe/policy.c    | 123 ++++++++++
   security/ipe/policy.h    |   9 +
   security/ipe/policy_fs.c | 469 +++++++++++++++++++++++++++++++++++++++
   8 files changed, 725 insertions(+)

create mode 100644 security/ipe/fs.c
create mode 100644 security/ipe/fs.h
create mode 100644 security/ipe/policy_fs.c

...

Quoted 46 lines
security/ipe/policy.c +38 -0
index f22a576a6d68..61fea3e38e11 100644
@@ -43,6 +71,68 @@ static int set_pkcs7_data(void *ctx, const void *data, size_t len,
      return 0;
   }
 
+/**
+ * ipe_update_policy - parse a new policy and replace old with it.
+ * @root: Supplies a pointer to the securityfs inode saved the policy.
+ * @text: Supplies a pointer to the plain text policy.
+ * @textlen: Supplies the length of @text.
+ * @pkcs7: Supplies a pointer to a buffer containing a pkcs7 message.
+ * @pkcs7len: Supplies the length of @pkcs7len.
+ *
+ * @text/@textlen is mutually exclusive with @pkcs7/@pkcs7len - see
+ * ipe_new_policy.
+ *
+ * Context: Requires root->i_rwsem to be held.
+ * Return:
+ * * !IS_ERR        - The existing policy saved in the inode before update
+ * * -ENOENT        - Policy doesn't exist
+ * * -EINVAL        - New policy is invalid
+ */
+struct ipe_policy *ipe_update_policy(struct inode *root,
+                                 const char *text, size_t textlen,
+                                 const char *pkcs7, size_t pkcs7len)
+{
+    int rc = 0;
+    struct ipe_policy *old, *ap, *new = NULL;
+
+    old = (struct ipe_policy *)root->i_private;
+    if (!old)
+            return ERR_PTR(-ENOENT);
+
+    new = ipe_new_policy(text, textlen, pkcs7, pkcs7len);
+    if (IS_ERR(new))
+            return new;
+
+    if (strcmp(new->parsed->name, old->parsed->name)) {
+            rc = -EINVAL;
+            goto err;
+    }
+
+    if (ver_to_u64(old) > ver_to_u64(new)) {
Quoted 9 lines

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 117

Quoted 6 lines
security/ipe/policy.c +6 -0
+            rc = -EINVAL;
+            goto err;
+    }
+
+    root->i_private = new;
+    swap(new->policyfs, old->policyfs);

Should the swap() take place with @ipe_policy_lock held?

I think we are safe here because root->i_rwsem is held. Other two operations set_active and delete are also depending on the inode lock.

Quoted 14 lines

security/ipe/policy.c static int set_pkcs7_data(void *ctx, const void *data, size_t len, · line 125

Quoted 7 lines
security/ipe/policy.c +7 -0
+    mutex_lock(&ipe_policy_lock);
+    ap = rcu_dereference_protected(ipe_active_policy,
+                                   lockdep_is_held(&ipe_policy_lock));
+    if (old == ap) {
+            rcu_assign_pointer(ipe_active_policy, new);
+            mutex_unlock(&ipe_policy_lock);
+            synchronize_rcu();

I'm guessing you are forcing a synchronize_rcu() here because you are free()'ing @old in the caller, yes? Looking at the code, I only see one caller, update_policy(). With only one caller, why not free @old directly in ipe_update_policy()? Do you see others callers that would do something different?

Quoted 8 lines
Quoted 2 lines

The call of synchronize_rcu() is because we are updating the current active policy so we need to set the new policy as active.

Unless I'm mistaken, a syncronize_rcu() call only ensures that the current task will see the updated value by waiting until all current RCU critical sections have finished. Given the mutex involved here I don't believe this is necessary, but please correct me if I'm wrong.

Sorry for the confusion. I think your previous comment was right, the call of synchronize_rcu() is to free the old one. And I should put the free of old just after the synchronize_rcu() call.

Thanks,
Fan

author
#18 lore raw

RFC PATCH v12 9/20 uapi|audit|ipe: add ipe auditing support

In reply to Fan Wu

From: Deven Bowers <[email protected]>

Users of IPE require a way to identify when and why an operation fails, allowing them to both respond to violations of policy and be notified of potentially malicious actions on their systems with respect to IPE itself.

This patch introduces 3 new audit events.

AUDIT_IPE_ACCESS(1420) indicates the result of an IPE policy evaluation of a resource.
AUDIT_IPE_CONFIG_CHANGE(1421) indicates the current active IPE policy has been changed to another loaded policy. AUDIT_IPE_POLICY_LOAD(1422) indicates a new IPE policy has been loaded into the kernel.

This patch also adds support for success auditing, allowing users to identify why an allow decision was made for a resource. However, it is recommended to use this option with caution, as it is quite noisy.

Here are some examples of the new audit record types:

AUDIT_IPE_ACCESS(1420):

audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
pid=297 comm="sh" path="/root/vol/bin/hello" dev="tmpfs" ino=3897 rule="op=EXECUTE boot_verified=TRUE action=ALLOW"

audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
pid=299 comm="sh" path="/mnt/ipe/bin/hello" dev="dm-0" ino=2 rule="DEFAULT action=DENY"

audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
pid=300 path="/tmp/tmpdp2h1lub/deny/bin/hello" dev="tmpfs"
ino=131 rule="DEFAULT action=DENY"

The above three records were generated when the active IPE policy only allows binaries from the initramfs to run. The three identical hello binary were placed at different locations, only the first hello from the rootfs(initramfs) was allowed.

Field ipe_op followed by the IPE operation name associated with the log.

Field ipe_hook followed by the name of the LSM hook that triggered the IPE event.

Field enforcing followed by the enforcement state of IPE. (it will be introduced in the next commit)

Field pid followed by the pid of the process that triggered the IPE event.

Field comm followed by the command line program name of the process that triggered the IPE event.

Field path followed by the file's path name.

Field dev followed by the device name as found in /dev where the file is from.
Note that for device mappers it will use the name dm-X instead of the name in /dev/mapper.
For a file in a temp file system, which is not from a device, it will use tmpfs for the field.
The implementation of this part is following another existing use case LSM_AUDIT_DATA_INODE in security/lsm_audit.c

Field ino followed by the file's inode number.

Field rule followed by the IPE rule made the access decision. The whole rule must be audited because the decision is based on the combination of all property conditions in the rule.

Along with the syscall audit event, user can know why a blocked happened. For example:

    audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
      pid=2138 comm="bash" path="/mnt/ipe/bin/hello" dev="dm-0"
      ino=2 rule="DEFAULT action=DENY"
    audit[1956]: SYSCALL arch=c000003e syscall=59
      success=no exit=-13 a0=556790138df0 a1=556790135390 a2=5567901338b0
      a3=ab2a41a67f4f1f4e items=1 ppid=147 pid=1956 auid=4294967295 uid=0
      gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=pts0
      ses=4294967295 comm="bash" exe="/usr/bin/bash" key=(null)

The above two records showed bash used execve to run "hello" and got blocked by IPE. Note that the IPE records are always prior to a SYSCALL record.

AUDIT_IPE_CONFIG_CHANGE(1421):

    audit: AUDIT1421
      old_active_pol_name="Allow_All" old_active_pol_version=0.0.0
      old_policy_digest=sha256:E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649
      new_active_pol_name="boot_verified" new_active_pol_version=0.0.0
      new_policy_digest=sha256:820EEA5B40CA42B51F68962354BA083122A20BB846F
      auid=4294967295 ses=4294967295 lsm=ipe res=1

The above record showed the current IPE active policy switch from Allow_All to boot_verified along with the version and the hash digest of the two policies. Note IPE can only have one policy active at a time, all access decision evaluation is based on the current active policy.
The normal procedure to deploy a policy is loading the policy to deploy into the kernel first, then switch the active policy to it.

AUDIT_IPE_POLICY_LOAD(1422):

    audit: AUDIT1422 policy_name="boot_verified" policy_version=0.0.0
      policy_digest=sha256:820EEA5B40CA42B51F68962354BA083122A20BB846F2676
      auid=4294967295 ses=4294967295 lsm=ipe res=1

The above record showed a new policy has been loaded into the kernel with the policy name, policy version and policy hash.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations
+ Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+ Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record, reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation, the audit system, the evaluation loop, and access control hooks into separate patches.
+ Further split audit system patch into two separate patches; one for include/uapi, and the usage of the new defines.
+ Split out the permissive functionality into another separate patch, for easier review.
+ Correct misuse of audit_log_n_untrusted string to audit_log_format
+ Use get_task_comm instead of comm directly.
+ Quote certain audit values
+ Remove unnecessary help text on choice options - these were previously indented at the wrong level
+ Correct a stale string constant (ctx_ns_enforce to ctx_enforce)

v8:

+ Change dependency for CONFIG_AUDIT to CONFIG_AUDITSYSCALL
+ Drop ctx_* prefix
+ Reuse, where appropriate, the audit fields from the field

    dictionary. This transforms:
      ctx_pathname  -> path
      ctx_ino       -> ino
      ctx_dev       -> dev

+ Add audit records and event examples to commit description.
+ Remove new_audit_ctx, replace with audit_log_start. All data that would provided by new_audit_ctx is already present in the syscall audit record, that is always emitted on these actions. The audit records should be correlated as such.
+ Change audit types:
+ AUDIT_TRUST_RESULT -> AUDIT_IPE_ACCESS
+ This prevents overloading of the AVC type.
+ AUDIT_TRUST_POLICY_ACTIVATE -> AUDIT_MAC_CONFIG_CHANGE
+ AUDIT_TRUST_POLICY_LOAD -> AUDIT_MAC_POLICY_LOAD
+ There were no significant difference in meaning between these types.

+ Remove enforcing parameter passed from the context structure for AUDIT_IPE_ACCESS.
+ This field can be inferred from the SYSCALL audit event, based on the success field.

+ Remove all fields already captured in the syscall record. "hook", an IPE specific field, can be determined via the syscall field in the syscall record itself, so it has been removed.
+ ino, path, and dev in IPE's record refer to the subject of the syscall, while the syscall record refers to the calling process.

+ remove IPE prefix from policy load/policy activation events
+ fix a bug wherein a policy change audit record was not fired when updating a policy

v9:
+ Merge the AUDIT_IPE_ACCESS definition with the audit support commit
+ Change the audit format of policy load and switch
+ Remove the ipe audit kernel switch

v10:
+ Create AUDIT_IPE_CONFIG_CHANGE and AUDIT_IPE_POLICY_LOAD
+ Change field names per upstream feedback

v11:
+ Fix style issues

v12:
+ Add ipe_op, ipe_hook, and enforcing fields to AUDIT_IPE_ACCESS

---
 include/uapi/linux/audit.h |   3 +
 security/ipe/Kconfig       |   2 +-
 security/ipe/Makefile      |   1 +
 security/ipe/audit.c       | 212 +++++++++++++++++++++++++++++++++++++
 security/ipe/audit.h       |  18 ++++
 security/ipe/eval.c        |  44 ++++++--
 security/ipe/eval.h        |  13 ++-
 security/ipe/fs.c          |  70 ++++++++++++
 security/ipe/hooks.c       |  10 +-
 security/ipe/hooks.h       |  11 ++
 security/ipe/policy.c      |   5 +
 11 files changed, 372 insertions(+), 17 deletions(-)
 create mode 100644 security/ipe/audit.c
 create mode 100644 security/ipe/audit.h
include/uapi/linux/audit.h +3 -0
index d676ed2b246e..75e21a135483 100644
@@ -143,6 +143,9 @@
 #define AUDIT_MAC_UNLBL_STCDEL	1417	/* NetLabel: del a static label */
 #define AUDIT_MAC_CALIPSO_ADD	1418	/* NetLabel: add CALIPSO DOI entry */
 #define AUDIT_MAC_CALIPSO_DEL	1419	/* NetLabel: del CALIPSO DOI entry */
+#define AUDIT_IPE_ACCESS	1420	/* IPE denial or grant */
+#define AUDIT_IPE_CONFIG_CHANGE	1421	/* IPE config change */
+#define AUDIT_IPE_POLICY_LOAD	1422	/* IPE policy load */
 
 #define AUDIT_FIRST_KERN_ANOM_MSG   1700
 #define AUDIT_LAST_KERN_ANOM_MSG    1799
security/ipe/Kconfig +1 -1
index e4875fb04883..ac4d558e69d5 100644
@@ -5,7 +5,7 @@
 
 menuconfig SECURITY_IPE
 	bool "Integrity Policy Enforcement (IPE)"
-	depends on SECURITY && SECURITYFS
+	depends on SECURITY && SECURITYFS && AUDIT && AUDITSYSCALL
 	select PKCS7_MESSAGE_PARSER
 	select SYSTEM_DATA_VERIFICATION
 	help
security/ipe/Makefile +1 -0
index cfbed03a8885..2279eaa3cea3 100644
@@ -13,3 +13,4 @@ obj-$(CONFIG_SECURITY_IPE) += \
 	policy.o \
 	policy_fs.o \
 	policy_parser.o \
+	audit.o \
security/ipe/audit.c new file +212 -0

212 lines not on this page · raw message

security/ipe/audit.h new file +18 -0
new file mode 100644
index 000000000000..0ff5a06808de
@@ -0,0 +1,18 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef _IPE_AUDIT_H
+#define _IPE_AUDIT_H
+
+#include "policy.h"
+
+void ipe_audit_match(const struct ipe_eval_ctx *const ctx,
+		     enum ipe_match match_type,
+		     enum ipe_action_type act, const struct ipe_rule *const r);
+void ipe_audit_policy_load(const struct ipe_policy *const p);
+void ipe_audit_policy_activation(const struct ipe_policy *const op,
+				 const struct ipe_policy *const np);
+
+#endif /* _IPE_AUDIT_H */
security/ipe/eval.c +34 -10

95 lines not on this page · raw message

security/ipe/eval.h +12 -1
index 7d79fdb63bbf..0be9aadec9f8 100644
@@ -10,10 +10,12 @@
 #include <linux/types.h>
 
 #include "policy.h"
+#include "hooks.h"
 
 #define IPE_EVAL_CTX_INIT ((struct ipe_eval_ctx){ 0 })
 
 extern struct ipe_policy __rcu *ipe_active_policy;
+extern bool success_audit;
 
 #ifdef CONFIG_BLK_DEV_INITRD
 struct ipe_sb {
@@ -23,6 +25,7 @@ struct ipe_sb {
 
 struct ipe_eval_ctx {
 	enum ipe_op_type op;
+	enum ipe_hook_type hook;
 
 	const struct file *file;
 #ifdef CONFIG_BLK_DEV_INITRD
@@ -30,7 +33,15 @@ struct ipe_eval_ctx {
 #endif /* CONFIG_BLK_DEV_INITRD */
 };
 
-void build_eval_ctx(struct ipe_eval_ctx *ctx, const struct file *file, enum ipe_op_type op);
+enum ipe_match {
+	IPE_MATCH_RULE = 0,
+	IPE_MATCH_TABLE,
+	IPE_MATCH_GLOBAL,
+	__IPE_MATCH_MAX
+};
+
+void build_eval_ctx(struct ipe_eval_ctx *ctx, const struct file *file,
+		    enum ipe_op_type op, enum ipe_hook_type hook);
 int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx);
 
 #endif /* _IPE_EVAL_H */
security/ipe/fs.c +70 -0

105 lines not on this page · raw message

security/ipe/hooks.c +5 -5
index 8ee105bf7bad..ab762865a671 100644
@@ -28,7 +28,7 @@ int ipe_bprm_check_security(struct linux_binprm *bprm)
 {
 	struct ipe_eval_ctx ctx = IPE_EVAL_CTX_INIT;
 
-	build_eval_ctx(&ctx, bprm->file, IPE_OP_EXEC);
+	build_eval_ctx(&ctx, bprm->file, IPE_OP_EXEC, IPE_HOOK_BPRM_CHECK);
 	return ipe_evaluate_event(&ctx);
 }
 
@@ -53,7 +53,7 @@ int ipe_mmap_file(struct file *f, unsigned long reqprot __always_unused,
 	struct ipe_eval_ctx ctx = IPE_EVAL_CTX_INIT;
 
 	if (prot & PROT_EXEC) {
-		build_eval_ctx(&ctx, f, IPE_OP_EXEC);
+		build_eval_ctx(&ctx, f, IPE_OP_EXEC, IPE_HOOK_MMAP);
 		return ipe_evaluate_event(&ctx);
 	}
 
@@ -85,7 +85,7 @@ int ipe_file_mprotect(struct vm_area_struct *vma,
 		return 0;
 
 	if (prot & PROT_EXEC) {
-		build_eval_ctx(&ctx, vma->vm_file, IPE_OP_EXEC);
+		build_eval_ctx(&ctx, vma->vm_file, IPE_OP_EXEC, IPE_HOOK_MPROTECT);
 		return ipe_evaluate_event(&ctx);
 	}
 
@@ -135,7 +135,7 @@ int ipe_kernel_read_file(struct file *file, enum kernel_read_file_id id,
 		WARN(1, "no rule setup for kernel_read_file enum %d", id);
 	}
 
-	build_eval_ctx(&ctx, file, op);
+	build_eval_ctx(&ctx, file, op, IPE_HOOK_KERNEL_READ);
 	return ipe_evaluate_event(&ctx);
 }
 
@@ -179,7 +179,7 @@ int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents)
 		WARN(1, "no rule setup for kernel_load_data enum %d", id);
 	}
 
-	build_eval_ctx(&ctx, NULL, op);
+	build_eval_ctx(&ctx, NULL, op, IPE_HOOK_KERNEL_LOAD);
 	return ipe_evaluate_event(&ctx);
 }
 
security/ipe/hooks.h +11 -0
index 3b1bb0a6e89c..55fc0e35c13d 100644
@@ -9,6 +9,17 @@
 #include <linux/binfmts.h>
 #include <linux/security.h>
 
+enum ipe_hook_type {
+	IPE_HOOK_BPRM_CHECK = 0,
+	IPE_HOOK_MMAP,
+	IPE_HOOK_MPROTECT,
+	IPE_HOOK_KERNEL_READ,
+	IPE_HOOK_KERNEL_LOAD,
+	__IPE_HOOK_MAX
+};
+
+#define IPE_HOOK_INVALID __IPE_HOOK_MAX
+
 int ipe_bprm_check_security(struct linux_binprm *bprm);
 
 int ipe_mmap_file(struct file *f, unsigned long reqprot, unsigned long prot,
security/ipe/policy.c +5 -0
index 61fea3e38e11..a5e5173a6c46 100644
@@ -11,6 +11,7 @@
 #include "fs.h"
 #include "policy.h"
 #include "policy_parser.h"
+#include "audit.h"
 
 /* lock for synchronizing writers across ipe policy */
 DEFINE_MUTEX(ipe_policy_lock);
@@ -115,6 +116,7 @@ struct ipe_policy *ipe_update_policy(struct inode *root,
 
 	root->i_private = new;
 	swap(new->policyfs, old->policyfs);
+	ipe_audit_policy_load(new);
 
 	mutex_lock(&ipe_policy_lock);
 	ap = rcu_dereference_protected(ipe_active_policy,
@@ -123,6 +125,7 @@ struct ipe_policy *ipe_update_policy(struct inode *root,
 		rcu_assign_pointer(ipe_active_policy, new);
 		mutex_unlock(&ipe_policy_lock);
 		synchronize_rcu();
+		ipe_audit_policy_activation(old, new);
 	} else {
 		mutex_unlock(&ipe_policy_lock);
 	}
@@ -220,5 +223,7 @@ int ipe_set_active_pol(const struct ipe_policy *p)
 	mutex_unlock(&ipe_policy_lock);
 	synchronize_rcu();
 
+	ipe_audit_policy_activation(ap, p);
+
 	return 0;
 }
Signature · 1 line
2.43.0
maintainer
#19 lore raw

Re: [PATCH RFC v12 9/20] uapi|audit|ipe: add ipe auditing support

Quoted 231 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

Users of IPE require a way to identify when and why an operation fails, allowing them to both respond to violations of policy and be notified of potentially malicious actions on their systems with respect to IPE itself.

This patch introduces 3 new audit events.

AUDIT_IPE_ACCESS(1420) indicates the result of an IPE policy evaluation of a resource.
AUDIT_IPE_CONFIG_CHANGE(1421) indicates the current active IPE policy has been changed to another loaded policy. AUDIT_IPE_POLICY_LOAD(1422) indicates a new IPE policy has been loaded into the kernel.

This patch also adds support for success auditing, allowing users to identify why an allow decision was made for a resource. However, it is recommended to use this option with caution, as it is quite noisy.

Here are some examples of the new audit record types:

AUDIT_IPE_ACCESS(1420):

audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
pid=297 comm="sh" path="/root/vol/bin/hello" dev="tmpfs" ino=3897 rule="op=EXECUTE boot_verified=TRUE action=ALLOW"

audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
pid=299 comm="sh" path="/mnt/ipe/bin/hello" dev="dm-0" ino=2 rule="DEFAULT action=DENY"

audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
pid=300 path="/tmp/tmpdp2h1lub/deny/bin/hello" dev="tmpfs"
ino=131 rule="DEFAULT action=DENY"

The above three records were generated when the active IPE policy only allows binaries from the initramfs to run. The three identical hello binary were placed at different locations, only the first hello from the rootfs(initramfs) was allowed.

Field ipe_op followed by the IPE operation name associated with the log.

Field ipe_hook followed by the name of the LSM hook that triggered the IPE event.

Field enforcing followed by the enforcement state of IPE. (it will be introduced in the next commit)

Field pid followed by the pid of the process that triggered the IPE event.

Field comm followed by the command line program name of the process that triggered the IPE event.

Field path followed by the file's path name.

Field dev followed by the device name as found in /dev where the file is from.
Note that for device mappers it will use the name dm-X instead of the name in /dev/mapper.
For a file in a temp file system, which is not from a device, it will use tmpfs for the field.
The implementation of this part is following another existing use case LSM_AUDIT_DATA_INODE in security/lsm_audit.c

Field ino followed by the file's inode number.

Field rule followed by the IPE rule made the access decision. The whole rule must be audited because the decision is based on the combination of all property conditions in the rule.

Along with the syscall audit event, user can know why a blocked happened. For example:

    audit: AUDIT1420 ipe_op=EXECUTE ipe_hook=BPRM_CHECK enforcing=1
      pid=2138 comm="bash" path="/mnt/ipe/bin/hello" dev="dm-0"
      ino=2 rule="DEFAULT action=DENY"
    audit[1956]: SYSCALL arch=c000003e syscall=59
      success=no exit=-13 a0=556790138df0 a1=556790135390 a2=5567901338b0
      a3=ab2a41a67f4f1f4e items=1 ppid=147 pid=1956 auid=4294967295 uid=0
      gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=pts0
      ses=4294967295 comm="bash" exe="/usr/bin/bash" key=(null)

The above two records showed bash used execve to run "hello" and got blocked by IPE. Note that the IPE records are always prior to a SYSCALL record.

AUDIT_IPE_CONFIG_CHANGE(1421):

    audit: AUDIT1421
      old_active_pol_name="Allow_All" old_active_pol_version=0.0.0
      old_policy_digest=sha256:E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649
      new_active_pol_name="boot_verified" new_active_pol_version=0.0.0
      new_policy_digest=sha256:820EEA5B40CA42B51F68962354BA083122A20BB846F
      auid=4294967295 ses=4294967295 lsm=ipe res=1

The above record showed the current IPE active policy switch from Allow_All to boot_verified along with the version and the hash digest of the two policies. Note IPE can only have one policy active at a time, all access decision evaluation is based on the current active policy.
The normal procedure to deploy a policy is loading the policy to deploy into the kernel first, then switch the active policy to it.

AUDIT_IPE_POLICY_LOAD(1422):

    audit: AUDIT1422 policy_name="boot_verified" policy_version=0.0.0
      policy_digest=sha256:820EEA5B40CA42B51F68962354BA083122A20BB846F2676
      auid=4294967295 ses=4294967295 lsm=ipe res=1

The above record showed a new policy has been loaded into the kernel with the policy name, policy version and policy hash.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations
+ Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+ Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record, reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation, the audit system, the evaluation loop, and access control hooks into separate patches.
+ Further split audit system patch into two separate patches; one for include/uapi, and the usage of the new defines.
+ Split out the permissive functionality into another separate patch, for easier review.
+ Correct misuse of audit_log_n_untrusted string to audit_log_format
+ Use get_task_comm instead of comm directly.
+ Quote certain audit values
+ Remove unnecessary help text on choice options - these were previously indented at the wrong level
+ Correct a stale string constant (ctx_ns_enforce to ctx_enforce)

v8:

+ Change dependency for CONFIG_AUDIT to CONFIG_AUDITSYSCALL
+ Drop ctx_* prefix
+ Reuse, where appropriate, the audit fields from the field

    dictionary. This transforms:
      ctx_pathname  -> path
      ctx_ino       -> ino
      ctx_dev       -> dev

+ Add audit records and event examples to commit description.
+ Remove new_audit_ctx, replace with audit_log_start. All data that would provided by new_audit_ctx is already present in the syscall audit record, that is always emitted on these actions. The audit records should be correlated as such.
+ Change audit types:
+ AUDIT_TRUST_RESULT -> AUDIT_IPE_ACCESS
+ This prevents overloading of the AVC type.
+ AUDIT_TRUST_POLICY_ACTIVATE -> AUDIT_MAC_CONFIG_CHANGE
+ AUDIT_TRUST_POLICY_LOAD -> AUDIT_MAC_POLICY_LOAD
+ There were no significant difference in meaning between these types.

+ Remove enforcing parameter passed from the context structure for AUDIT_IPE_ACCESS.
+ This field can be inferred from the SYSCALL audit event, based on the success field.

+ Remove all fields already captured in the syscall record. "hook", an IPE specific field, can be determined via the syscall field in the syscall record itself, so it has been removed.
+ ino, path, and dev in IPE's record refer to the subject of the syscall, while the syscall record refers to the calling process.

+ remove IPE prefix from policy load/policy activation events
+ fix a bug wherein a policy change audit record was not fired when updating a policy

v9:
+ Merge the AUDIT_IPE_ACCESS definition with the audit support commit
+ Change the audit format of policy load and switch
+ Remove the ipe audit kernel switch

v10:
+ Create AUDIT_IPE_CONFIG_CHANGE and AUDIT_IPE_POLICY_LOAD
+ Change field names per upstream feedback

v11:
+ Fix style issues

v12:
+ Add ipe_op, ipe_hook, and enforcing fields to AUDIT_IPE_ACCESS

---
 include/uapi/linux/audit.h |   3 +
 security/ipe/Kconfig       |   2 +-
 security/ipe/Makefile      |   1 +
 security/ipe/audit.c       | 212 +++++++++++++++++++++++++++++++++++++
 security/ipe/audit.h       |  18 ++++
 security/ipe/eval.c        |  44 ++++++--
 security/ipe/eval.h        |  13 ++-
 security/ipe/fs.c          |  70 ++++++++++++
 security/ipe/hooks.c       |  10 +-
 security/ipe/hooks.h       |  11 ++
 security/ipe/policy.c      |   5 +
 11 files changed, 372 insertions(+), 17 deletions(-)
 create mode 100644 security/ipe/audit.c
 create mode 100644 security/ipe/audit.h

...

Quoted 50 lines
security/ipe/audit.c new file +44 -0
new file mode 100644
index 000000000000..79b7af25085c
@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#include <linux/slab.h>
+#include <linux/audit.h>
+#include <linux/types.h>
+#include <crypto/hash.h>
+
+#include "ipe.h"
+#include "eval.h"
+#include "hooks.h"
+#include "policy.h"
+#include "audit.h"
+
+#define ACTSTR(x) ((x) == IPE_ACTION_ALLOW ? "ALLOW" : "DENY")
+
+#define IPE_AUDIT_HASH_ALG "sha256"
+
+#define AUDIT_POLICY_LOAD_FMT "policy_name=\"%s\" policy_version=%hu.%hu.%hu "\
+			      "policy_digest=" IPE_AUDIT_HASH_ALG ":"
+#define AUDIT_OLD_ACTIVE_POLICY_FMT "old_active_pol_name=\"%s\" "\
+				    "old_active_pol_version=%hu.%hu.%hu "\
+				    "old_policy_digest=" IPE_AUDIT_HASH_ALG ":"
+#define AUDIT_NEW_ACTIVE_POLICY_FMT "new_active_pol_name=\"%s\" "\
+				    "new_active_pol_version=%hu.%hu.%hu "\
+				    "new_policy_digest=" IPE_AUDIT_HASH_ALG ":"
+
+static const char *const audit_op_names[__IPE_OP_MAX + 1] = {
+	"EXECUTE",
+	"FIRMWARE",
+	"KMODULE",
+	"KEXEC_IMAGE",
+	"KEXEC_INITRAMFS",
+	"POLICY",
+	"X509_CERT",
+	"UNKNOWN",
+};
+
+static const char *const audit_hook_names[__IPE_HOOK_MAX] = {
+	"BPRM_CHECK",
+	"MMAP",
+	"MPROTECT",

security/ipe/audit.c line 54

Quoted 10 lines
security/ipe/audit.c new file +10 -0
+	"KERNEL_READ",
+	"KERNEL_LOAD",
+};
+
+static const char *const audit_prop_names[__IPE_PROP_MAX] = {
+#ifdef CONFIG_BLK_DEV_INITRD
+	"boot_verified=FALSE",
+	"boot_verified=TRUE",
+#endif /* CONFIG_BLK_DEV_INITRD */
+};

I think we can get rid of the preprocessor checks here.

--
paul-moore.com

author
#20 lore raw

RFC PATCH v12 10/20 ipe: add permissive toggle

In reply to Fan Wu

From: Deven Bowers <[email protected]>

IPE, like SELinux, supports a permissive mode. This mode allows policy authors to test and evaluate IPE policy without it effecting their programs. When the mode is changed, a 1404 AUDIT_MAC_STATUS be reported.

This patch adds the following audit records:

    audit: MAC_STATUS enforcing=0 old_enforcing=1 auid=4294967295
      ses=4294967295 enabled=1 old-enabled=1 lsm=ipe res=1
    audit: MAC_STATUS enforcing=1 old_enforcing=0 auid=4294967295
      ses=4294967295 enabled=1 old-enabled=1 lsm=ipe res=1

The audit record only emit when the value from the user input is different from the current enforce value.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations
+ Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+ Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record, reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation into a separate commit from the evaluation loop and audit system, for easier review.
+ Propagating changes to support the new ipe_context structure in the evaluation loop.
+ Split out permissive functionality into a separate patch for easier review.
+ Remove permissive switch compile-time configuration option - this is trivial to add later.

v8:
+ Remove "IPE" prefix from permissive audit record
+ align fields to the linux-audit field dictionary. This causes the following fields to change:
enforce -> permissive

+ Remove duplicated information correlated with syscall record, that will always be present in the audit event.
+ Change audit types:
+ AUDIT_TRUST_STATUS -> AUDIT_MAC_STATUS
+ There is no significant difference in meaning between these types.

v9:
+ Clean up ipe_context related code

v10:
+ Change audit format to comform with the existing format selinux is using
+ Remove the audit record emission during init to align with selinux, which does not perform this action.

v11:
+ Remove redundant code

v12:
+ Remove redundant code

---
 security/ipe/audit.c | 27 ++++++++++++++++--
 security/ipe/audit.h |  1 +
 security/ipe/eval.c  | 11 +++++--
 security/ipe/eval.h  |  1 +
 security/ipe/fs.c    | 68 ++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 104 insertions(+), 4 deletions(-)
security/ipe/audit.c +25 -2
index 79b7af25085c..ed390d32c641 100644
@@ -27,6 +27,9 @@
 				    "new_active_pol_version=%hu.%hu.%hu "\
 				    "new_policy_digest=" IPE_AUDIT_HASH_ALG ":"
 
+#define AUDIT_ENFORCE_CHANGE_FMT "enforcing=%d old_enforcing=%d auid=%u ses=%u "\
+				 "enabled=1 old-enabled=1 lsm=ipe res=1"
+
 static const char *const audit_op_names[__IPE_OP_MAX + 1] = {
 	"EXECUTE",
 	"FIRMWARE",
@@ -95,8 +98,8 @@ void ipe_audit_match(const struct ipe_eval_ctx *const ctx,
 	if (!ab)
 		return;
 
-	audit_log_format(ab, "ipe_op=%s ipe_hook=%s pid=%d comm=",
-			 op, audit_hook_names[ctx->hook],
+	audit_log_format(ab, "ipe_op=%s ipe_hook=%s enforcing=%d pid=%d comm=",
+			 op, audit_hook_names[ctx->hook], READ_ONCE(enforce),
 			 task_tgid_nr(current));
 	audit_log_untrustedstring(ab, get_task_comm(comm, current));
 
@@ -210,3 +213,23 @@ void ipe_audit_policy_load(const struct ipe_policy *const p)
 
 	audit_log_end(ab);
 }
+
+/**
+ * ipe_audit_enforce - Audit a change in IPE's enforcement state.
+ * @new_enforce: The new value enforce to be set.
+ * @old_enforce: The old value currently in enforce.
+ */
+void ipe_audit_enforce(bool new_enforce, bool old_enforce)
+{
+	struct audit_buffer *ab;
+
+	ab = audit_log_start(audit_context(), GFP_KERNEL, AUDIT_MAC_STATUS);
+	if (!ab)
+		return;
+
+	audit_log_format(ab, AUDIT_ENFORCE_CHANGE_FMT, new_enforce, old_enforce,
+			 from_kuid(&init_user_ns, audit_get_loginuid(current)),
+			 audit_get_sessionid(current));
+
+	audit_log_end(ab);
+}
security/ipe/audit.h +1 -0
index 0ff5a06808de..914f001e5286 100644
@@ -14,5 +14,6 @@ void ipe_audit_match(const struct ipe_eval_ctx *const ctx,
 void ipe_audit_policy_load(const struct ipe_policy *const p);
 void ipe_audit_policy_activation(const struct ipe_policy *const op,
 				 const struct ipe_policy *const np);
+void ipe_audit_enforce(bool new_enforce, bool old_enforce);
 
 #endif /* _IPE_AUDIT_H */
security/ipe/eval.c +9 -2
index 85cccc3d0bdf..49338b35f126 100644
@@ -18,6 +18,7 @@
 
 struct ipe_policy __rcu *ipe_active_policy;
 bool success_audit;
+bool enforce = true;
 
 #define FILE_SUPERBLOCK(f) ((f)->f_path.mnt->mnt_sb)
 
@@ -137,6 +138,7 @@ int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx)
 	const struct ipe_rule *rule = NULL;
 	const struct ipe_op_table *rules = NULL;
 	struct ipe_prop *prop = NULL;
+	int rc = 0;
 
 	rcu_read_lock();
 
@@ -189,9 +191,12 @@ int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx)
 	ipe_audit_match(ctx, match_type, action, rule);
 
 	if (action == IPE_ACTION_DENY)
-		return -EACCES;
+		rc = -EACCES;
 
-	return 0;
+	if (!READ_ONCE(enforce))
+		rc = 0;
+
+	return rc;
 }
 
 /* Set the right module name */
@@ -202,3 +207,5 @@ int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx)
 
 module_param(success_audit, bool, 0400);
 MODULE_PARM_DESC(success_audit, "Start IPE with success auditing enabled");
+module_param(enforce, bool, 0400);
+MODULE_PARM_DESC(enforce, "Start IPE in enforce or permissive mode");
security/ipe/eval.h +1 -0
index 0be9aadec9f8..84adf1a0e514 100644
@@ -16,6 +16,7 @@
 
 extern struct ipe_policy __rcu *ipe_active_policy;
 extern bool success_audit;
+extern bool enforce;
 
 #ifdef CONFIG_BLK_DEV_INITRD
 struct ipe_sb {
security/ipe/fs.c +68 -0

98 lines not on this page · raw message

Signature · 1 line
2.43.0
maintainer
#21 lore raw

Re: [PATCH RFC v12 10/20] ipe: add permissive toggle

Quoted 103 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

IPE, like SELinux, supports a permissive mode. This mode allows policy authors to test and evaluate IPE policy without it effecting their programs. When the mode is changed, a 1404 AUDIT_MAC_STATUS be reported.

This patch adds the following audit records:

    audit: MAC_STATUS enforcing=0 old_enforcing=1 auid=4294967295
      ses=4294967295 enabled=1 old-enabled=1 lsm=ipe res=1
    audit: MAC_STATUS enforcing=1 old_enforcing=0 auid=4294967295
      ses=4294967295 enabled=1 old-enabled=1 lsm=ipe res=1

The audit record only emit when the value from the user input is different from the current enforce value.

---
v2:
+ Split evaluation loop, access control hooks, and evaluation loop from policy parser and userspace interface to pass mailing list character limit

v3:
+ Move ipe_load_properties to patch 04.
+ Remove useless 0-initializations
+ Prefix extern variables with ipe_
+ Remove kernel module parameters, as these are exposed through sysctls.
+ Add more prose to the IPE base config option help text.
+ Use GFP_KERNEL for audit_log_start.
+ Remove unnecessary caching system.
+ Remove comments from headers
+ Use rcu_access_pointer for rcu-pointer null check
+ Remove usage of reqprot; use prot only.
+ Move policy load and activation audit event to 03/12

v4:
+ Remove sysctls in favor of securityfs nodes
+ Re-add kernel module parameters, as these are now exposed through securityfs.
+ Refactor property audit loop to a separate function.

v5:
+ fix minor grammatical errors
+ do not group rule by curly-brace in audit record, reconstruct the exact rule.

v6:
+ No changes

v7:
+ Further split lsm creation into a separate commit from the evaluation loop and audit system, for easier review.
+ Propagating changes to support the new ipe_context structure in the evaluation loop.
+ Split out permissive functionality into a separate patch for easier review.
+ Remove permissive switch compile-time configuration option - this is trivial to add later.

v8:
+ Remove "IPE" prefix from permissive audit record
+ align fields to the linux-audit field dictionary. This causes the following fields to change:
enforce -> permissive

+ Remove duplicated information correlated with syscall record, that will always be present in the audit event.
+ Change audit types:
+ AUDIT_TRUST_STATUS -> AUDIT_MAC_STATUS
+ There is no significant difference in meaning between these types.

v9:
+ Clean up ipe_context related code

v10:
+ Change audit format to comform with the existing format selinux is using
+ Remove the audit record emission during init to align with selinux, which does not perform this action.

v11:
+ Remove redundant code

v12:
+ Remove redundant code

---
 security/ipe/audit.c | 27 ++++++++++++++++--
 security/ipe/audit.h |  1 +
 security/ipe/eval.c  | 11 +++++--
 security/ipe/eval.h  |  1 +
 security/ipe/fs.c    | 68 ++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 104 insertions(+), 4 deletions(-)
security/ipe/audit.c +0 -0
index 79b7af25085c..ed390d32c641 100644

security/ipe/audit.c line 31

Quoted 5 lines
security/ipe/audit.c +2 -0
@@ -27,6 +27,9 @@
 				    "new_active_pol_version=%hu.%hu.%hu "\
 				    "new_policy_digest=" IPE_AUDIT_HASH_ALG ":"
 
+#define AUDIT_ENFORCE_CHANGE_FMT "enforcing=%d old_enforcing=%d auid=%u ses=%u "\
+				 "enabled=1 old-enabled=1 lsm=ipe res=1"

It looks like you only ever use this in one place, it would probably be better to skip the macro definition in this case as it can make it easier to have a disconnect between the format string and the data.

Quoted 28 lines
security/ipe/audit.c +12 -2
 static const char *const audit_op_names[__IPE_OP_MAX + 1] = {
 	"EXECUTE",
 	"FIRMWARE",
@@ -95,8 +98,8 @@ void ipe_audit_match(const struct ipe_eval_ctx *const ctx,
 	if (!ab)
 		return;
 
-	audit_log_format(ab, "ipe_op=%s ipe_hook=%s pid=%d comm=",
-			 op, audit_hook_names[ctx->hook],
+	audit_log_format(ab, "ipe_op=%s ipe_hook=%s enforcing=%d pid=%d comm=",
+			 op, audit_hook_names[ctx->hook], READ_ONCE(enforce),
 			 task_tgid_nr(current));
 	audit_log_untrustedstring(ab, get_task_comm(comm, current));
 
@@ -210,3 +213,23 @@ void ipe_audit_policy_load(const struct ipe_policy *const p)
 
 	audit_log_end(ab);
 }
+
+/**
+ * ipe_audit_enforce - Audit a change in IPE's enforcement state.
+ * @new_enforce: The new value enforce to be set.
+ * @old_enforce: The old value currently in enforce.
+ */
+void ipe_audit_enforce(bool new_enforce, bool old_enforce)
+{
+	struct audit_buffer *ab;
+

security/ipe/audit.c void ipe_audit_policy_load(const struct ipe_policy *const p) · line 235

Quoted 10 lines
security/ipe/audit.c +10 -0
+	ab = audit_log_start(audit_context(), GFP_KERNEL, AUDIT_MAC_STATUS);
+	if (!ab)
+		return;
+
+	audit_log_format(ab, AUDIT_ENFORCE_CHANGE_FMT, new_enforce, old_enforce,
+			 from_kuid(&init_user_ns, audit_get_loginuid(current)),
+			 audit_get_sessionid(current));
+
+	audit_log_end(ab);
+}

--
paul-moore.com

author
#22 lore raw

RFC PATCH v12 11/20 block|security: add LSM blob to block_device

In reply to Fan Wu

From: Deven Bowers <[email protected]>

Some block devices have valuable security properties that is only accessible during the creation time.

For example, when creating a dm-verity block device, the dm-verity's roothash and roothash signature, which are extreme important security metadata, are passed to the kernel. However, the roothash will be saved privately in dm-verity, which prevents the seucrity subsystem to easily access that information. Worse, in the current implementation the roothash signature will be discarded after the verification, making it impossible to utilize the roothash signature by the security subsystem.

With this patch, an LSM blob is added to the block_device structure. This enables the security subsystem to store security-sensitive data related to block devices within the security blob. For example, LSM can use the new LSM blob to save the roothash signature of a dm-verity, and LSM can make access decision based on the data inside the signature, like the signer ceritificate.

The implementation follows the same approach used for security blobs in other structures like struct file, struct inode, and struct superblock. The initialization of the security blob occurs after the creation of the struct block_device, performed by the security subsystem. Similarly, the security blob is freed by the security subsystem before the struct block_device is deallocated or freed.

---
v2:
+ No Changes

v3:
+ Minor style changes from checkpatch --strict

v4:
+ No Changes

v5:
+ Allow multiple callers to call security_bdev_setsecurity

v6:
+ Simplify security_bdev_setsecurity break condition

v7:
+ Squash all dm-verity related patches to two patches, the additions to dm-verity/fs, and the consumption of the additions.

v8:
+ Split dm-verity related patches squashed in v7 to 3 commits based on topic:
+ New LSM hook
+ Consumption of hook outside LSM
+ Consumption of hook inside LSM.

+ change return of security_bdev_alloc / security_bdev_setsecurity to LSM_RET_DEFAULT instead of 0.

+ Change return code to -EOPNOTSUPP, bring inline with other setsecurity hooks.

v9:
+ Add Reviewed-by: Casey Schaufler <[email protected]>
+ Remove unlikely when calling LSM hook
+ Make the security field dependent on CONFIG_SECURITY

v10:
+ No changes

v11:
+ No changes

v12:
+ No changes

---
 block/bdev.c                  |  7 +++
 include/linux/blk_types.h     |  3 ++
 include/linux/lsm_hook_defs.h |  5 ++
 include/linux/lsm_hooks.h     |  1 +
 include/linux/security.h      | 22 ++++++++
 security/security.c           | 99 +++++++++++++++++++++++++++++++++++
 6 files changed, 137 insertions(+)
block/bdev.c +7 -0
index e9f1b12bd75c..c3bb5d6a030c 100644
@@ -24,6 +24,7 @@
 #include <linux/pseudo_fs.h>
 #include <linux/uio.h>
 #include <linux/namei.h>
+#include <linux/security.h>
 #include <linux/part_stat.h>
 #include <linux/uaccess.h>
 #include <linux/stat.h>
@@ -307,6 +308,11 @@ static struct inode *bdev_alloc_inode(struct super_block *sb)
 	if (!ei)
 		return NULL;
 	memset(&ei->bdev, 0, sizeof(ei->bdev));
+
+	if (security_bdev_alloc(&ei->bdev)) {
+		kmem_cache_free(bdev_cachep, ei);
+		return NULL;
+	}
 	return &ei->vfs_inode;
 }
 
@@ -316,6 +322,7 @@ static void bdev_free_inode(struct inode *inode)
 
 	free_percpu(bdev->bd_stats);
 	kfree(bdev->bd_meta_info);
+	security_bdev_free(bdev);
 
 	if (!bdev_is_partition(bdev)) {
 		if (bdev->bd_disk && bdev->bd_disk->bdi)
include/linux/blk_types.h +3 -0
index f288c94374b3..339647f8645a 100644
@@ -69,6 +69,9 @@ struct block_device {
 #endif
 	bool			bd_ro_warned;
 	int			bd_writers;
+#ifdef CONFIG_SECURITY
+	void			*security;
+#endif
 	/*
 	 * keep this out-of-line as it's both big and not needed in the fast
 	 * path
include/linux/lsm_hook_defs.h +5 -0
index b247388786a9..480ea4e9892d 100644
@@ -429,3 +429,8 @@ LSM_HOOK(int, 0, uring_cmd, struct io_uring_cmd *ioucmd)
 #ifdef CONFIG_BLK_DEV_INITRD
 LSM_HOOK(void, LSM_RET_VOID, unpack_initramfs_security, void)
 #endif /* CONFIG_BLK_DEV_INITRD */
+
+LSM_HOOK(int, 0, bdev_alloc_security, struct block_device *bdev)
+LSM_HOOK(void, LSM_RET_VOID, bdev_free_security, struct block_device *bdev)
+LSM_HOOK(int, 0, bdev_setsecurity, struct block_device *bdev, const char *name,
+	 const void *value, size_t size)
include/linux/lsm_hooks.h +1 -0
index a2ade0ffe9e7..f1692179aa56 100644
@@ -78,6 +78,7 @@ struct lsm_blob_sizes {
 	int	lbs_msg_msg;
 	int	lbs_task;
 	int	lbs_xattr_count; /* number of xattr slots in new_xattrs array */
+	int	lbs_bdev;
 };
 
 /**
include/linux/security.h +22 -0
index e994ac9cda91..75db557b5786 100644
@@ -496,6 +496,11 @@ int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
 int security_locked_down(enum lockdown_reason what);
 int lsm_fill_user_ctx(struct lsm_ctx __user *uctx, size_t *uctx_len,
 		      void *val, size_t val_len, u64 id, u64 flags);
+int security_bdev_alloc(struct block_device *bdev);
+void security_bdev_free(struct block_device *bdev);
+int security_bdev_setsecurity(struct block_device *bdev,
+			      const char *name, const void *value,
+			      size_t size);
 #else /* CONFIG_SECURITY */
 
 static inline int call_blocking_lsm_notifier(enum lsm_event event, void *data)
@@ -1439,6 +1444,23 @@ static inline int lsm_fill_user_ctx(struct lsm_ctx __user *uctx,
 {
 	return -EOPNOTSUPP;
 }
+
+static inline int security_bdev_alloc(struct block_device *bdev)
+{
+	return 0;
+}
+
+static inline void security_bdev_free(struct block_device *bdev)
+{
+}
+
+static inline int security_bdev_setsecurity(struct block_device *bdev,
+					    const char *name,
+					    const void *value, size_t size)
+{
+	return 0;
+}
+
 #endif	/* CONFIG_SECURITY */
 
 #if defined(CONFIG_SECURITY) && defined(CONFIG_WATCH_QUEUE)
security/security.c +99 -0

129 lines not on this page · raw message

Signature · 1 line
2.43.0
author
#23 lore raw

RFC PATCH v12 12/20 dm verity: set DM_TARGET_SINGLETON feature flag

In reply to Fan Wu

The device-mapper has a flag to mark targets as singleton, which is a required flag for immutable targets. Without this flag, multiple dm-verity targets can be added to a mapped device, which has no practical use cases and will let dm_table_get_immutable_target return NULL. This patch adds the missing flag, restricting only one dm-verity target per mapped device.

---
v1-v10:
+ Not present

v11:
+ Introduced

v12:
+ No changes

---
 drivers/md/dm-verity-target.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/dm-verity-target.c +1 -1
index 14e58ae70521..66a850c02be4 100644
@@ -1507,7 +1507,7 @@ int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest, unsigned i
 
 static struct target_type verity_target = {
 	.name		= "verity",
-	.features	= DM_TARGET_IMMUTABLE,
+	.features	= DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
 	.version	= {1, 9, 0},
 	.module		= THIS_MODULE,
 	.ctr		= verity_ctr,
Signature · 1 line
2.43.0
maintainer
#24 lore raw

Re: [RFC PATCH v12 12/20] dm verity: set DM_TARGET_SINGLETON feature flag

Quoted 39 lines · Fan Wu

The device-mapper has a flag to mark targets as singleton, which is a required flag for immutable targets. Without this flag, multiple dm-verity targets can be added to a mapped device, which has no practical use cases and will let dm_table_get_immutable_target return NULL. This patch adds the missing flag, restricting only one dm-verity target per mapped device.

---
v1-v10:
+ Not present

v11:
+ Introduced

v12:
+ No changes

---
 drivers/md/dm-verity-target.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/dm-verity-target.c +1 -1
index 14e58ae70521..66a850c02be4 100644
@@ -1507,7 +1507,7 @@ int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest, unsigned i
 
 static struct target_type verity_target = {
 	.name		= "verity",
-	.features	= DM_TARGET_IMMUTABLE,
+	.features	= DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
 	.version	= {1, 9, 0},
 	.module		= THIS_MODULE,
 	.ctr		= verity_ctr,
Signature · 1 line
2.43.0

It is true this change will cause dm_table_get_immutable_target() to not return NULL, but: I'm curious how that is meaningful in the context of dm-verity? (given the only caller of dm_table_get_immutable_target() is request-based DM code in DM core.)

Thanks,
Mike

author
#25 lore raw

Re: [RFC PATCH v12 12/20] dm verity: set DM_TARGET_SINGLETON feature flag

Quoted 48 lines · Mike Snitzer
Quoted 39 lines · Fan Wu

The device-mapper has a flag to mark targets as singleton, which is a required flag for immutable targets. Without this flag, multiple dm-verity targets can be added to a mapped device, which has no practical use cases and will let dm_table_get_immutable_target return NULL. This patch adds the missing flag, restricting only one dm-verity target per mapped device.

---
v1-v10:
+ Not present

v11:
+ Introduced

v12:
+ No changes

---
  drivers/md/dm-verity-target.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/dm-verity-target.c +1 -1
index 14e58ae70521..66a850c02be4 100644
@@ -1507,7 +1507,7 @@ int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest, unsigned i
 
  static struct target_type verity_target = {
  	.name		= "verity",
-	.features	= DM_TARGET_IMMUTABLE,
+	.features	= DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
  	.version	= {1, 9, 0},
  	.module		= THIS_MODULE,
  	.ctr		= verity_ctr,
Signature · 1 line
2.43.0

It is true this change will cause dm_table_get_immutable_target() to not return NULL, but: I'm curious how that is meaningful in the context of dm-verity? (given the only caller of dm_table_get_immutable_target() is request-based DM code in DM core.)

Quoted 2 lines

Thanks,
Mike

Sorry for the confusion. The reference of dm_table_get_immutable_target() is only to justify an immutable target should also be a singleton(https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/drivers/md/dm-table.c#n982). It is not directly related to dm-verity.

In the context of dm-verity. I found although veritysetup does ensure the dm-verity target as a singleton, users can still use dmsetup to configure multiple dm-verity targets within a single map table. This leads to a situation where only the first target can be accessed. Therefore to prevent this and similar misuse, I propose introducing DM_TARGET_SINGLETON to allow the kernel to enforce dm-verity targets as singletons.

Thanks,
Fan

author
#26 lore raw

RFC PATCH v12 13/20 dm: add finalize hook to target_type

In reply to Fan Wu

This patch adds a target finalize hook.

The hook is triggered just before activating an inactive table of a mapped device. If it returns an error the __bind get cancelled.

The dm-verity target will use this hook to attach the dm-verity's roothash metadata to the block_device struct of the mapped device.

---
v1-v10:
+ Not present

v11:
+ Introduced

v12:
+ No changes

---
 drivers/md/dm.c               | 12 ++++++++++++
 include/linux/device-mapper.h |  7 +++++++
 2 files changed, 19 insertions(+)
drivers/md/dm.c +12 -0
index 8dcabf84d866..15b46edae49f 100644
@@ -2266,6 +2266,18 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
 		goto out;
 	}
 
+	for (unsigned int i = 0; i < t->num_targets; i++) {
+		struct dm_target *ti = dm_table_get_target(t, i);
+
+		if (ti->type->finalize) {
+			ret = ti->type->finalize(ti);
+			if (ret) {
+				old_map = ERR_PTR(ret);
+				goto out;
+			}
+		}
+	}
+
 	old_map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
 	rcu_assign_pointer(md->map, (void *)t);
 	md->immutable_target_type = dm_table_get_immutable_target_type(t);
include/linux/device-mapper.h +7 -0
index 772ab4d74d94..627400b2d9af 100644
@@ -160,6 +160,12 @@ typedef int (*dm_dax_zero_page_range_fn)(struct dm_target *ti, pgoff_t pgoff,
  */
 typedef size_t (*dm_dax_recovery_write_fn)(struct dm_target *ti, pgoff_t pgoff,
 		void *addr, size_t bytes, struct iov_iter *i);
+/*
+ * Returns:
+ *  < 0 : error
+ *  = 0 : success
+ */
+typedef int (*dm_finalize_fn) (struct dm_target *target);
 
 void dm_error(const char *message);
 
@@ -210,6 +216,7 @@ struct target_type {
 	dm_dax_direct_access_fn direct_access;
 	dm_dax_zero_page_range_fn dax_zero_page_range;
 	dm_dax_recovery_write_fn dax_recovery_write;
+	dm_finalize_fn finalize;
 
 	/* For internal device-mapper use. */
 	struct list_head list;
Signature · 1 line
2.43.0
author
#27 lore raw

RFC PATCH v12 14/20 dm verity: consume root hash digest and signature data via LSM hook

In reply to Fan Wu

From: Deven Bowers <[email protected]>

dm-verity provides a strong guarantee of a block device's integrity. As a generic way to check the integrity of a block device, it provides those integrity guarantees to its higher layers, including the filesystem level.

An LSM that control access to a resource on the system based on the available integrity claims can use this transitive property of dm-verity, by querying the underlying block_device of a particular file.

The digest and signature information need to be stored in the block device to fulfill the next requirement of authorization via LSM policy. This will enable the LSM to perform revocation of devices that are still mounted, prohibiting execution of files that are no longer authorized by the LSM in question.

This patch added two security hook calls in dm-verity to save the dm-verity roothash and the roothash signature to the block device's LSM blobs. The hook calls are depended on CONFIG_IPE_PROP_DM_VERITY, which will be introduced in the next commit.

---
v2:
+ No Changes

v3:
+ No changes

v4:
+ No changes

v5:
+ No changes

v6:
+ Fix an improper cleanup that can result in
a leak

v7:
+ Squash patch 08/12, 10/12 to [11/16]
+ Use part0 for block_device, to retrieve the block_device, when calling security_bdev_setsecurity

v8:
+ Undo squash of 08/12, 10/12 - separating drivers/md/ from security/ & block/
+ Use common-audit function for dmverity_signature.
+ Change implementation for storing the dm-verity digest to use the newly introduced dm_verity_digest structure introduced in patch 14/20.
+ Create new structure, dm_verity_digest, containing digest algorithm, size, and digest itself to pass to the LSM layer. V7 was missing the algorithm.
+ Create an associated public header containing this new structure and the key values for the LSM hook, specific to dm-verity.
+ Additional information added to commit, discussing the layering of the changes and how the information passed will be used.

v9:
+ No changes

v10:
+ No changes

v11:
+ Add an optional field to save signature
+ Move the security hook call to the new finalize hook

v12:
+ No changes

---
 drivers/md/dm-verity-target.c | 71 +++++++++++++++++++++++++++++++++++
 drivers/md/dm-verity.h        |  6 +++
 include/linux/dm-verity.h     | 19 ++++++++++
 3 files changed, 96 insertions(+)
 create mode 100644 include/linux/dm-verity.h
drivers/md/dm-verity-target.c +71 -0
index 66a850c02be4..a07409c680d9 100644
@@ -13,6 +13,7 @@
  * access behavior.
  */
 
+#include "dm-core.h"
 #include "dm-verity.h"
 #include "dm-verity-fec.h"
 #include "dm-verity-verify-sig.h"
@@ -22,6 +23,9 @@
 #include <linux/scatterlist.h>
 #include <linux/string.h>
 #include <linux/jump_label.h>
+#include <linux/security.h>
+#include <linux/dm-verity.h>
+#include <crypto/hash_info.h>
 
 #define DM_MSG_PREFIX			"verity"
 
@@ -956,6 +960,17 @@ static void verity_io_hints(struct dm_target *ti, struct queue_limits *limits)
 	blk_limits_io_min(limits, limits->logical_block_size);
 }
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+static void verity_free_sig(struct dm_verity *v)
+{
+	kfree(v->root_digest_sig);
+}
+#else
+static inline void verity_free_sig(struct dm_verity *v)
+{
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 static void verity_dtr(struct dm_target *ti)
 {
 	struct dm_verity *v = ti->private;
@@ -970,6 +985,7 @@ static void verity_dtr(struct dm_target *ti)
 	kfree(v->salt);
 	kfree(v->root_digest);
 	kfree(v->zero_digest);
+	verity_free_sig(v);
 
 	if (v->tfm)
 		crypto_free_ahash(v->tfm);
@@ -1161,6 +1177,25 @@ static int verity_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v,
 	return r;
 }
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+static int verity_init_sig(struct dm_verity *v, const void *sig,
+			   size_t sig_size)
+{
+	v->sig_size = sig_size;
+	v->root_digest_sig = kmalloc(v->sig_size, GFP_KERNEL);
+	if (!v->root_digest)
+		return -ENOMEM;
+
+	return 0;
+}
+#else
+static inline int verity_init_sig(struct dm_verity *v, const void *sig,
+				  size_t sig_size)
+{
+	return 0;
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 /*
  * Target parameters:
  *	<version>	The current format is version 1.
@@ -1369,6 +1404,13 @@ static int verity_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		ti->error = "Root hash verification failed";
 		goto bad;
 	}
+
+	r = verity_init_sig(v, verify_args.sig, verify_args.sig_size);
+	if (r < 0) {
+		ti->error = "Cannot allocate root digest signature";
+		goto bad;
+	}
+
 	v->hash_per_block_bits =
 		__fls((1 << v->hash_dev_block_bits) / v->digest_size);
 
@@ -1505,6 +1547,32 @@ int dm_verity_get_root_digest(struct dm_target *ti, u8 **root_digest, unsigned i
 	return 0;
 }
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+static int verity_finalize(struct dm_target *ti)
+{
+	struct block_device *bdev;
+	struct dm_verity_digest root_digest;
+	struct dm_verity *v;
+	int r;
+
+	v = ti->private;
+	bdev = dm_table_get_md(ti->table)->disk->part0;
+	root_digest.digest = v->root_digest;
+	root_digest.digest_len = v->digest_size;
+	root_digest.alg = v->alg_name;
+
+	r = security_bdev_setsecurity(bdev, DM_VERITY_ROOTHASH_SEC_NAME, &root_digest,
+				      sizeof(root_digest));
+	if (r)
+		return r;
+
+	return security_bdev_setsecurity(bdev,
+					 DM_VERITY_SIGNATURE_SEC_NAME,
+					 v->root_digest_sig,
+					 v->sig_size);
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 static struct target_type verity_target = {
 	.name		= "verity",
 	.features	= DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
@@ -1517,6 +1585,9 @@ static struct target_type verity_target = {
 	.prepare_ioctl	= verity_prepare_ioctl,
 	.iterate_devices = verity_iterate_devices,
 	.io_hints	= verity_io_hints,
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	.finalize	= verity_finalize,
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 };
 module_dm(verity);
 
drivers/md/dm-verity.h +6 -0
index f9d522c870e6..f41918e251f5 100644
@@ -42,6 +42,9 @@ struct dm_verity {
 	u8 *root_digest;	/* digest of the root block */
 	u8 *salt;		/* salt: its size is salt_size */
 	u8 *zero_digest;	/* digest for a zero block */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	u8 *root_digest_sig;	/* digest signature of the root block */
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 	unsigned int salt_size;
 	sector_t data_start;	/* data offset in 512-byte sectors */
 	sector_t hash_start;	/* hash start in blocks */
@@ -55,6 +58,9 @@ struct dm_verity {
 	bool hash_failed:1;	/* set if hash of any block failed */
 	bool use_tasklet:1;	/* try to verify in tasklet before work-queue */
 	unsigned int digest_size;	/* digest size for the current hash algorithm */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	unsigned int sig_size;	/* digest signature size */
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 	unsigned int ahash_reqsize;/* the size of temporary space for crypto */
 	enum verity_mode mode;	/* mode for handling verification errors */
 	unsigned int corrupted_errs;/* Number of errors for corrupted blocks */
include/linux/dm-verity.h new file +19 -0
new file mode 100644
index 000000000000..7d9753445534
@@ -0,0 +1,19 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef _LINUX_DM_VERITY_H
+#define _LINUX_DM_VERITY_H
+
+#include <linux/types.h>
+#include <crypto/hash_info.h>
+#include <linux/device-mapper.h>
+
+struct dm_verity_digest {
+	const char *alg;
+	const u8 *digest;
+	size_t digest_len;
+};
+
+#define DM_VERITY_SIGNATURE_SEC_NAME DM_NAME	".verity-signature"
+#define DM_VERITY_ROOTHASH_SEC_NAME  DM_NAME	".verity-roothash"
+
+#endif /* _LINUX_DM_VERITY_H */
Signature · 1 line
2.43.0
author
#28 lore raw

RFC PATCH v12 15/20 ipe: add support for dm-verity as a trust provider

In reply to Fan Wu

From: Deven Bowers <[email protected]>

Allows author of IPE policy to indicate trust for a singular dm-verity volume, identified by roothash, through "dmverity_roothash" and all signed dm-verity volumes, through "dmverity_signature".

---
v2:
+ No Changes

v3:
+ No changes

v4:
+ No changes

v5:
+ No changes

v6:
+ Fix an improper cleanup that can result in
a leak

v7:
+ Squash patch 08/12, 10/12 to [11/16]

v8:
+ Undo squash of 08/12, 10/12 - separating drivers/md/ from security/ & block/
+ Use common-audit function for dmverity_signature.
+ Change implementation for storing the dm-verity digest to use the newly introduced dm_verity_digest structure introduced in patch 14/20.

v9:
+ Adapt to the new parser

v10:
+ Select the Kconfig when all dependencies are enabled

v11:
+ No changes

v12:
+ Refactor to use struct digest_info* instead of void*
+ Correct audit format

---
 security/ipe/Kconfig         |  18 ++++++
 security/ipe/Makefile        |   1 +
 security/ipe/audit.c         |  37 ++++++++++-
 security/ipe/digest.c        | 120 +++++++++++++++++++++++++++++++++++
 security/ipe/digest.h        |  26 ++++++++
 security/ipe/eval.c          |  90 +++++++++++++++++++++++++-
 security/ipe/eval.h          |  10 +++
 security/ipe/hooks.c         |  67 +++++++++++++++++++
 security/ipe/hooks.h         |   8 +++
 security/ipe/ipe.c           |  15 +++++
 security/ipe/ipe.h           |   4 ++
 security/ipe/policy.h        |   3 +
 security/ipe/policy_parser.c |  26 +++++++-
 13 files changed, 421 insertions(+), 4 deletions(-)
 create mode 100644 security/ipe/digest.c
 create mode 100644 security/ipe/digest.h
security/ipe/Kconfig +18 -0
index ac4d558e69d5..7afb1ce0cb99 100644
@@ -8,6 +8,7 @@ menuconfig SECURITY_IPE
 	depends on SECURITY && SECURITYFS && AUDIT && AUDITSYSCALL
 	select PKCS7_MESSAGE_PARSER
 	select SYSTEM_DATA_VERIFICATION
+	select IPE_PROP_DM_VERITY if DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
 	help
 	  This option enables the Integrity Policy Enforcement LSM
 	  allowing users to define a policy to enforce a trust-based access
@@ -15,3 +16,20 @@ menuconfig SECURITY_IPE
 	  admins to reconfigure trust requirements on the fly.
 
 	  If unsure, answer N.
+
+if SECURITY_IPE
+menu "IPE Trust Providers"
+
+config IPE_PROP_DM_VERITY
+	bool "Enable support for dm-verity volumes"
+	depends on DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
+	help
+	  This option enables the properties 'dmverity_signature' and
+	  'dmverity_roothash' in IPE policy. These properties evaluates
+	  to TRUE when a file is evaluated against a dm-verity volume
+	  that was mounted with a signed root-hash or the volume's
+	  root hash matches the supplied value in the policy.
+
+endmenu
+
+endif
security/ipe/Makefile +1 -0
index 2279eaa3cea3..66de53687d11 100644
@@ -6,6 +6,7 @@
 #
 
 obj-$(CONFIG_SECURITY_IPE) += \
+	digest.o \
 	eval.o \
 	hooks.o \
 	fs.o \
security/ipe/audit.c +35 -2
index ed390d32c641..a4ad8e888df0 100644
@@ -13,6 +13,7 @@
 #include "hooks.h"
 #include "policy.h"
 #include "audit.h"
+#include "digest.h"
 
 #define ACTSTR(x) ((x) == IPE_ACTION_ALLOW ? "ALLOW" : "DENY")
 
@@ -54,8 +55,30 @@ static const char *const audit_prop_names[__IPE_PROP_MAX] = {
 	"boot_verified=FALSE",
 	"boot_verified=TRUE",
 #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	"dmverity_roothash=",
+	"dmverity_signature=FALSE",
+	"dmverity_signature=TRUE",
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 };
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+/**
+ * audit_dmv_roothash - audit a roothash of a dmverity volume.
+ * @ab: Supplies a pointer to the audit_buffer to append to.
+ * @rh: Supplies a pointer to the digest structure.
+ */
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+	audit_log_format(ab, "%s", audit_prop_names[IPE_PROP_DMV_ROOTHASH]);
+	ipe_digest_audit(ab, rh);
+}
+#else
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 /**
  * audit_rule - audit an IPE policy rule approximation.
  * @ab: Supplies a pointer to the audit_buffer to append to.
@@ -67,8 +90,18 @@ static void audit_rule(struct audit_buffer *ab, const struct ipe_rule *r)
 
 	audit_log_format(ab, " rule=\"%s ", audit_op_names[r->op]);
 
-	list_for_each_entry(ptr, &r->props, next)
-		audit_log_format(ab, "%s ", audit_prop_names[ptr->type]);
+	list_for_each_entry(ptr, &r->props, next) {
+		switch (ptr->type) {
+		case IPE_PROP_DMV_ROOTHASH:
+			audit_dmv_roothash(ab, ptr->value);
+			break;
+		default:
+			audit_log_format(ab, "%s", audit_prop_names[ptr->type]);
+			break;
+		}
+
+		audit_log_format(ab, " ");
+	}
 
 	audit_log_format(ab, "action=%s\"", ACTSTR(r->action));
 }
security/ipe/digest.c new file +120 -0

120 lines not on this page · raw message

security/ipe/digest.h new file +26 -0
new file mode 100644
index 000000000000..13fa67071805
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef _IPE_DIGEST_H
+#define _IPE_DIGEST_H
+
+#include <linux/types.h>
+#include <linux/audit.h>
+
+#include "policy.h"
+
+struct digest_info {
+	const char *alg;
+	const u8 *digest;
+	size_t digest_len;
+};
+
+struct digest_info *ipe_digest_parse(const char *valstr);
+void ipe_digest_free(struct digest_info *digest_info);
+void ipe_digest_audit(struct audit_buffer *ab, const struct digest_info *val);
+bool ipe_digest_eval(const struct digest_info *expected,
+		     const struct digest_info *digest);
+
+#endif /* _IPE_DIGEST_H */
security/ipe/eval.c +89 -1

125 lines not on this page · raw message

security/ipe/eval.h +10 -0
index 84adf1a0e514..2c997d188508 100644
@@ -24,6 +24,13 @@ struct ipe_sb {
 };
 #endif /* CONFIG_BLK_DEV_INITRD */
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+struct ipe_bdev {
+	bool dm_verity_signed;
+	struct digest_info *root_hash;
+};
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 struct ipe_eval_ctx {
 	enum ipe_op_type op;
 	enum ipe_hook_type hook;
@@ -32,6 +39,9 @@ struct ipe_eval_ctx {
 #ifdef CONFIG_BLK_DEV_INITRD
 	bool from_initramfs;
 #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	const struct ipe_bdev *ipe_bdev;
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 };
 
 enum ipe_match {
security/ipe/hooks.c +67 -0

80 lines not on this page · raw message

security/ipe/hooks.h +8 -0
index 55fc0e35c13d..e114d633dcb4 100644
@@ -8,6 +8,7 @@
 #include <linux/fs.h>
 #include <linux/binfmts.h>
 #include <linux/security.h>
+#include <linux/blk_types.h>
 
 enum ipe_hook_type {
 	IPE_HOOK_BPRM_CHECK = 0,
@@ -37,4 +38,11 @@ int ipe_kernel_load_data(enum kernel_load_data_id id, bool contents);
 void ipe_unpack_initramfs(void);
 #endif /* CONFIG_BLK_DEV_INITRD */
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+void ipe_bdev_free_security(struct block_device *bdev);
+
+int ipe_bdev_setsecurity(struct block_device *bdev, const char *key,
+			 const void *value, size_t len);
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 #endif /* _IPE_HOOKS_H */
security/ipe/ipe.c +15 -0
index 034ee8cd6802..27a76aeabf1d 100644
@@ -7,6 +7,7 @@
 #include "ipe.h"
 #include "eval.h"
 #include "hooks.h"
+#include "eval.h"
 
 bool ipe_enabled;
 
@@ -14,6 +15,9 @@ static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
 #ifdef CONFIG_BLK_DEV_INITRD
 	.lbs_superblock = sizeof(struct ipe_sb),
 #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	.lbs_bdev = sizeof(struct ipe_bdev),
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 };
 
 static const struct lsm_id ipe_lsmid = {
@@ -28,6 +32,13 @@ struct ipe_sb *ipe_sb(const struct super_block *sb)
 }
 #endif /* CONFIG_BLK_DEV_INITRD */
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+struct ipe_bdev *ipe_bdev(struct block_device *b)
+{
+	return b->security + ipe_blobs.lbs_bdev;
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 static struct security_hook_list ipe_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(bprm_check_security, ipe_bprm_check_security),
 	LSM_HOOK_INIT(mmap_file, ipe_mmap_file),
@@ -37,6 +48,10 @@ static struct security_hook_list ipe_hooks[] __ro_after_init = {
 #ifdef CONFIG_BLK_DEV_INITRD
 	LSM_HOOK_INIT(unpack_initramfs_security, ipe_unpack_initramfs),
 #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	LSM_HOOK_INIT(bdev_free_security, ipe_bdev_free_security),
+	LSM_HOOK_INIT(bdev_setsecurity, ipe_bdev_setsecurity),
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 };
 
 /**
security/ipe/ipe.h +4 -0
index 1862c710dab8..03dab0dec54a 100644
@@ -18,4 +18,8 @@ struct ipe_sb *ipe_sb(const struct super_block *sb);
 
 extern bool ipe_enabled;
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+struct ipe_bdev *ipe_bdev(struct block_device *b);
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
+
 #endif /* _IPE_H */
security/ipe/policy.h +3 -0
index 060ffdbc62d6..fa59037c3fa4 100644
@@ -33,6 +33,9 @@ enum ipe_action_type {
 enum ipe_prop_type {
 	IPE_PROP_BOOT_VERIFIED_FALSE,
 	IPE_PROP_BOOT_VERIFIED_TRUE,
+	IPE_PROP_DMV_ROOTHASH,
+	IPE_PROP_DMV_SIG_FALSE,
+	IPE_PROP_DMV_SIG_TRUE,
 	__IPE_PROP_MAX
 };
 
security/ipe/policy_parser.c +25 -1
index cce15f0eb645..6cab7eef6052 100644
@@ -11,6 +11,7 @@
 
 #include "policy.h"
 #include "policy_parser.h"
+#include "digest.h"
 
 #define START_COMMENT	'#'
 #define IPE_POLICY_DELIM " \t"
@@ -216,6 +217,7 @@ static void free_rule(struct ipe_rule *r)
 
 	list_for_each_entry_safe(p, t, &r->props, next) {
 		list_del(&p->next);
+		ipe_digest_free(p->value);
 		kfree(p);
 	}
 
@@ -270,6 +272,11 @@ static const match_table_t property_tokens = {
 	{IPE_PROP_BOOT_VERIFIED_FALSE,	"boot_verified=FALSE"},
 	{IPE_PROP_BOOT_VERIFIED_TRUE,	"boot_verified=TRUE"},
 #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	{IPE_PROP_DMV_ROOTHASH,		"dmverity_roothash=%s"},
+	{IPE_PROP_DMV_SIG_FALSE,	"dmverity_signature=FALSE"},
+	{IPE_PROP_DMV_SIG_TRUE,		"dmverity_signature=TRUE"},
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 	{IPE_PROP_INVALID,		NULL}
 };
 
@@ -289,6 +296,7 @@ static int parse_property(char *t, struct ipe_rule *r)
 	struct ipe_prop *p = NULL;
 	int rc = 0;
 	int token;
+	char *dup = NULL;
 
 	p = kzalloc(sizeof(*p), GFP_KERNEL);
 	if (!p)
@@ -297,8 +305,22 @@ static int parse_property(char *t, struct ipe_rule *r)
 	token = match_token(t, property_tokens, args);
 
 	switch (token) {
+	case IPE_PROP_DMV_ROOTHASH:
+		dup = match_strdup(&args[0]);
+		if (!dup) {
+			rc = -ENOMEM;
+			goto err;
+		}
+		p->value = ipe_digest_parse(dup);
+		if (IS_ERR(p->value)) {
+			rc = PTR_ERR(p->value);
+			goto err;
+		}
+		fallthrough;
 	case IPE_PROP_BOOT_VERIFIED_FALSE:
 	case IPE_PROP_BOOT_VERIFIED_TRUE:
+	case IPE_PROP_DMV_SIG_FALSE:
+	case IPE_PROP_DMV_SIG_TRUE:
 		p->type = token;
 		break;
 	default:
@@ -309,10 +331,12 @@ static int parse_property(char *t, struct ipe_rule *r)
 		goto err;
 	list_add_tail(&p->next, &r->props);
 
+out:
+	kfree(dup);
 	return rc;
 err:
 	kfree(p);
-	return rc;
+	goto out;
 }
 
 /**
Signature · 1 line
2.43.0
maintainer
#29 lore raw

Re: [PATCH RFC v12 15/20] ipe: add support for dm-verity as a trust provider

Quoted 139 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

Allows author of IPE policy to indicate trust for a singular dm-verity volume, identified by roothash, through "dmverity_roothash" and all signed dm-verity volumes, through "dmverity_signature".

---
v2:
+ No Changes

v3:
+ No changes

v4:
+ No changes

v5:
+ No changes

v6:
+ Fix an improper cleanup that can result in
a leak

v7:
+ Squash patch 08/12, 10/12 to [11/16]

v8:
+ Undo squash of 08/12, 10/12 - separating drivers/md/ from security/ & block/
+ Use common-audit function for dmverity_signature.
+ Change implementation for storing the dm-verity digest to use the newly introduced dm_verity_digest structure introduced in patch 14/20.

v9:
+ Adapt to the new parser

v10:
+ Select the Kconfig when all dependencies are enabled

v11:
+ No changes

v12:
+ Refactor to use struct digest_info* instead of void*
+ Correct audit format

---
 security/ipe/Kconfig         |  18 ++++++
 security/ipe/Makefile        |   1 +
 security/ipe/audit.c         |  37 ++++++++++-
 security/ipe/digest.c        | 120 +++++++++++++++++++++++++++++++++++
 security/ipe/digest.h        |  26 ++++++++
 security/ipe/eval.c          |  90 +++++++++++++++++++++++++-
 security/ipe/eval.h          |  10 +++
 security/ipe/hooks.c         |  67 +++++++++++++++++++
 security/ipe/hooks.h         |   8 +++
 security/ipe/ipe.c           |  15 +++++
 security/ipe/ipe.h           |   4 ++
 security/ipe/policy.h        |   3 +
 security/ipe/policy_parser.c |  26 +++++++-
 13 files changed, 421 insertions(+), 4 deletions(-)
 create mode 100644 security/ipe/digest.c
 create mode 100644 security/ipe/digest.h
security/ipe/Kconfig +18 -0
index ac4d558e69d5..7afb1ce0cb99 100644
@@ -8,6 +8,7 @@ menuconfig SECURITY_IPE
 	depends on SECURITY && SECURITYFS && AUDIT && AUDITSYSCALL
 	select PKCS7_MESSAGE_PARSER
 	select SYSTEM_DATA_VERIFICATION
+	select IPE_PROP_DM_VERITY if DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
 	help
 	  This option enables the Integrity Policy Enforcement LSM
 	  allowing users to define a policy to enforce a trust-based access
@@ -15,3 +16,20 @@ menuconfig SECURITY_IPE
 	  admins to reconfigure trust requirements on the fly.
 
 	  If unsure, answer N.
+
+if SECURITY_IPE
+menu "IPE Trust Providers"
+
+config IPE_PROP_DM_VERITY
+	bool "Enable support for dm-verity volumes"
+	depends on DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
+	help
+	  This option enables the properties 'dmverity_signature' and
+	  'dmverity_roothash' in IPE policy. These properties evaluates
+	  to TRUE when a file is evaluated against a dm-verity volume
+	  that was mounted with a signed root-hash or the volume's
+	  root hash matches the supplied value in the policy.
+
+endmenu
+
+endif
security/ipe/Makefile +1 -0
index 2279eaa3cea3..66de53687d11 100644
@@ -6,6 +6,7 @@
 #
 
 obj-$(CONFIG_SECURITY_IPE) += \
+	digest.o \
 	eval.o \
 	hooks.o \
 	fs.o \
security/ipe/audit.c +12 -0
index ed390d32c641..a4ad8e888df0 100644
@@ -13,6 +13,7 @@
 #include "hooks.h"
 #include "policy.h"
 #include "audit.h"
+#include "digest.h"
 
 #define ACTSTR(x) ((x) == IPE_ACTION_ALLOW ? "ALLOW" : "DENY")
 
@@ -54,8 +55,30 @@ static const char *const audit_prop_names[__IPE_PROP_MAX] = {
 	"boot_verified=FALSE",
 	"boot_verified=TRUE",
 #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	"dmverity_roothash=",
+	"dmverity_signature=FALSE",
+	"dmverity_signature=TRUE",
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
 };
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+/**
+ * audit_dmv_roothash - audit a roothash of a dmverity volume.
+ * @ab: Supplies a pointer to the audit_buffer to append to.
+ * @rh: Supplies a pointer to the digest structure.
+ */

security/ipe/audit.c static const char *const audit_prop_names[__IPE_PROP_MAX] = { · line 80

Quoted 10 lines
security/ipe/audit.c +10 -0
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+	audit_log_format(ab, "%s", audit_prop_names[IPE_PROP_DMV_ROOTHASH]);
+	ipe_digest_audit(ab, rh);
+}
+#else
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */

I talked about this back in my review of the v11 patchset and I'm guessing you may have missed it ... the problem with the above code is that the fields in an audit record should remain constant, even if there is no data for that particular field. In cases where there is no data to record for a given field, a "?" should be used as the field's value, for example:

dmverify_roothash=?

My guess is that you would want to do something like this:

  #else  /* !CONFIG_IPE_PROP_DM_VERITY */
  static void audit_dmv_roothash(...)
  {
    audit_log_format(ab, "%s=?", audit_prop_names[...]);
  }
  #endif /* CONFIG_IPE_PROP_DM_VERITY */

--
paul-moore.com

author
#30 lore raw

Re: [PATCH RFC v12 15/20] ipe: add support for dm-verity as a trust provider

Quoted 169 lines · Paul Moore
Quoted 139 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

Allows author of IPE policy to indicate trust for a singular dm-verity volume, identified by roothash, through "dmverity_roothash" and all signed dm-verity volumes, through "dmverity_signature".

---
v2:
+ No Changes

v3:
+ No changes

v4:
+ No changes

v5:
+ No changes

v6:
+ Fix an improper cleanup that can result in
a leak

v7:
+ Squash patch 08/12, 10/12 to [11/16]

v8:
+ Undo squash of 08/12, 10/12 - separating drivers/md/ from security/ & block/
+ Use common-audit function for dmverity_signature.
+ Change implementation for storing the dm-verity digest to use the newly introduced dm_verity_digest structure introduced in patch 14/20.

v9:
+ Adapt to the new parser

v10:
+ Select the Kconfig when all dependencies are enabled

v11:
+ No changes

v12:
+ Refactor to use struct digest_info* instead of void*
+ Correct audit format

---
  security/ipe/Kconfig         |  18 ++++++
  security/ipe/Makefile        |   1 +
  security/ipe/audit.c         |  37 ++++++++++-
  security/ipe/digest.c        | 120 +++++++++++++++++++++++++++++++++++
  security/ipe/digest.h        |  26 ++++++++
  security/ipe/eval.c          |  90 +++++++++++++++++++++++++-
  security/ipe/eval.h          |  10 +++
  security/ipe/hooks.c         |  67 +++++++++++++++++++
  security/ipe/hooks.h         |   8 +++
  security/ipe/ipe.c           |  15 +++++
  security/ipe/ipe.h           |   4 ++
  security/ipe/policy.h        |   3 +
  security/ipe/policy_parser.c |  26 +++++++-
  13 files changed, 421 insertions(+), 4 deletions(-)

create mode 100644 security/ipe/digest.c
create mode 100644 security/ipe/digest.h

security/ipe/Kconfig +18 -0
index ac4d558e69d5..7afb1ce0cb99 100644
@@ -8,6 +8,7 @@ menuconfig SECURITY_IPE
  	depends on SECURITY && SECURITYFS && AUDIT && AUDITSYSCALL
  	select PKCS7_MESSAGE_PARSER
  	select SYSTEM_DATA_VERIFICATION
+	select IPE_PROP_DM_VERITY if DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
  	help
  	  This option enables the Integrity Policy Enforcement LSM
  	  allowing users to define a policy to enforce a trust-based access
@@ -15,3 +16,20 @@ menuconfig SECURITY_IPE
  	  admins to reconfigure trust requirements on the fly.
 
  	  If unsure, answer N.
+
+if SECURITY_IPE
+menu "IPE Trust Providers"
+
+config IPE_PROP_DM_VERITY
+	bool "Enable support for dm-verity volumes"
+	depends on DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
+	help
+	  This option enables the properties 'dmverity_signature' and
+	  'dmverity_roothash' in IPE policy. These properties evaluates
+	  to TRUE when a file is evaluated against a dm-verity volume
+	  that was mounted with a signed root-hash or the volume's
+	  root hash matches the supplied value in the policy.
+
+endmenu
+
+endif
security/ipe/Makefile +1 -0
index 2279eaa3cea3..66de53687d11 100644
@@ -6,6 +6,7 @@
  #
 
  obj-$(CONFIG_SECURITY_IPE) += \
+	digest.o \
  	eval.o \
  	hooks.o \
  	fs.o \
security/ipe/audit.c +12 -0
index ed390d32c641..a4ad8e888df0 100644
@@ -13,6 +13,7 @@
  #include "hooks.h"
  #include "policy.h"
  #include "audit.h"
+#include "digest.h"
 
  #define ACTSTR(x) ((x) == IPE_ACTION_ALLOW ? "ALLOW" : "DENY")
 
@@ -54,8 +55,30 @@ static const char *const audit_prop_names[__IPE_PROP_MAX] = {
  	"boot_verified=FALSE",
  	"boot_verified=TRUE",
  #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+	"dmverity_roothash=",
+	"dmverity_signature=FALSE",
+	"dmverity_signature=TRUE",
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
  };
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+/**
+ * audit_dmv_roothash - audit a roothash of a dmverity volume.
+ * @ab: Supplies a pointer to the audit_buffer to append to.
+ * @rh: Supplies a pointer to the digest structure.
+ */

security/ipe/audit.c static const char *const audit_prop_names[__IPE_PROP_MAX] = { · line 80

Quoted 10 lines
security/ipe/audit.c +10 -0
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+	audit_log_format(ab, "%s", audit_prop_names[IPE_PROP_DMV_ROOTHASH]);
+	ipe_digest_audit(ab, rh);
+}
+#else
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */

I talked about this back in my review of the v11 patchset and I'm guessing you may have missed it ... the problem with the above code is that the fields in an audit record should remain constant, even if there is no data for that particular field. In cases where there is no data to record for a given field, a "?" should be used as the field's value, for example:

dmverify_roothash=?

My guess is that you would want to do something like this:

   #else  /* !CONFIG_IPE_PROP_DM_VERITY */
   static void audit_dmv_roothash(...)
   {
     audit_log_format(ab, "%s=?", audit_prop_names[...]);
   }
   #endif /* CONFIG_IPE_PROP_DM_VERITY */
Quoted 2 lines

--
paul-moore.com

These code are used for auditing a policy rule, which the parser will guarantee the property will always have a valid value. The comments might be misleading which sounds like it's auditing a file's state. I will correct them.

Also as we previously discussed, the policy grammar shouldn't depend on any kernel switch so these preprocessor statement will be removed.

However, as an audit record should remain constant, I guess we should do some special treatment to anonymous files? Like audit record for them should include "path=? dev=? ino=?"

Thanks,
Fan

maintainer
#31 lore raw

Re: [PATCH RFC v12 15/20] ipe: add support for dm-verity as a trust provider

Quoted 178 lines · Fan Wu
Quoted 169 lines · Paul Moore
Quoted 139 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

Allows author of IPE policy to indicate trust for a singular dm-verity volume, identified by roothash, through "dmverity_roothash" and all signed dm-verity volumes, through "dmverity_signature".

---
v2:
+ No Changes

v3:
+ No changes

v4:
+ No changes

v5:
+ No changes

v6:
+ Fix an improper cleanup that can result in
a leak

v7:
+ Squash patch 08/12, 10/12 to [11/16]

v8:
+ Undo squash of 08/12, 10/12 - separating drivers/md/ from security/ & block/
+ Use common-audit function for dmverity_signature.
+ Change implementation for storing the dm-verity digest to use the newly introduced dm_verity_digest structure introduced in patch 14/20.

v9:
+ Adapt to the new parser

v10:
+ Select the Kconfig when all dependencies are enabled

v11:
+ No changes

v12:
+ Refactor to use struct digest_info* instead of void*
+ Correct audit format

---
  security/ipe/Kconfig         |  18 ++++++
  security/ipe/Makefile        |   1 +
  security/ipe/audit.c         |  37 ++++++++++-
  security/ipe/digest.c        | 120 +++++++++++++++++++++++++++++++++++
  security/ipe/digest.h        |  26 ++++++++
  security/ipe/eval.c          |  90 +++++++++++++++++++++++++-
  security/ipe/eval.h          |  10 +++
  security/ipe/hooks.c         |  67 +++++++++++++++++++
  security/ipe/hooks.h         |   8 +++
  security/ipe/ipe.c           |  15 +++++
  security/ipe/ipe.h           |   4 ++
  security/ipe/policy.h        |   3 +
  security/ipe/policy_parser.c |  26 +++++++-
  13 files changed, 421 insertions(+), 4 deletions(-)

create mode 100644 security/ipe/digest.c
create mode 100644 security/ipe/digest.h

security/ipe/Kconfig +18 -0
index ac4d558e69d5..7afb1ce0cb99 100644
@@ -8,6 +8,7 @@ menuconfig SECURITY_IPE
     depends on SECURITY && SECURITYFS && AUDIT && AUDITSYSCALL
     select PKCS7_MESSAGE_PARSER
     select SYSTEM_DATA_VERIFICATION
+    select IPE_PROP_DM_VERITY if DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
     help
       This option enables the Integrity Policy Enforcement LSM
       allowing users to define a policy to enforce a trust-based access
@@ -15,3 +16,20 @@ menuconfig SECURITY_IPE
       admins to reconfigure trust requirements on the fly.
 
       If unsure, answer N.
+
+if SECURITY_IPE
+menu "IPE Trust Providers"
+
+config IPE_PROP_DM_VERITY
+    bool "Enable support for dm-verity volumes"
+    depends on DM_VERITY && DM_VERITY_VERIFY_ROOTHASH_SIG
+    help
+      This option enables the properties 'dmverity_signature' and
+      'dmverity_roothash' in IPE policy. These properties evaluates
+      to TRUE when a file is evaluated against a dm-verity volume
+      that was mounted with a signed root-hash or the volume's
+      root hash matches the supplied value in the policy.
+
+endmenu
+
+endif
security/ipe/Makefile +1 -0
index 2279eaa3cea3..66de53687d11 100644
@@ -6,6 +6,7 @@
  #
 
  obj-$(CONFIG_SECURITY_IPE) += \
+    digest.o \
     eval.o \
     hooks.o \
     fs.o \
security/ipe/audit.c +12 -0
index ed390d32c641..a4ad8e888df0 100644
@@ -13,6 +13,7 @@
  #include "hooks.h"
  #include "policy.h"
  #include "audit.h"
+#include "digest.h"
 
  #define ACTSTR(x) ((x) == IPE_ACTION_ALLOW ? "ALLOW" : "DENY")
 
@@ -54,8 +55,30 @@ static const char *const audit_prop_names[__IPE_PROP_MAX] = {
     "boot_verified=FALSE",
     "boot_verified=TRUE",
  #endif /* CONFIG_BLK_DEV_INITRD */
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+    "dmverity_roothash=",
+    "dmverity_signature=FALSE",
+    "dmverity_signature=TRUE",
+#endif /* CONFIG_IPE_PROP_DM_VERITY */
  };
 
+#ifdef CONFIG_IPE_PROP_DM_VERITY
+/**
+ * audit_dmv_roothash - audit a roothash of a dmverity volume.
+ * @ab: Supplies a pointer to the audit_buffer to append to.
+ * @rh: Supplies a pointer to the digest structure.
+ */

security/ipe/audit.c static const char *const audit_prop_names[__IPE_PROP_MAX] = { · line 80

Quoted 10 lines
security/ipe/audit.c +10 -0
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+    audit_log_format(ab, "%s", audit_prop_names[IPE_PROP_DMV_ROOTHASH]);
+    ipe_digest_audit(ab, rh);
+}
+#else
+static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
+{
+}
+#endif /* CONFIG_IPE_PROP_DM_VERITY */

I talked about this back in my review of the v11 patchset and I'm guessing you may have missed it ... the problem with the above code is that the fields in an audit record should remain constant, even if there is no data for that particular field. In cases where there is no data to record for a given field, a "?" should be used as the field's value, for example:

dmverify_roothash=?

My guess is that you would want to do something like this:

   #else  /* !CONFIG_IPE_PROP_DM_VERITY */
   static void audit_dmv_roothash(...)
   {
     audit_log_format(ab, "%s=?", audit_prop_names[...]);
   }
   #endif /* CONFIG_IPE_PROP_DM_VERITY */
Quoted 2 lines

--
paul-moore.com

These code are used for auditing a policy rule, which the parser will guarantee the property will always have a valid value. The comments might be misleading which sounds like it's auditing a file's state. I will correct them.

Quoted 6 lines

Also as we previously discussed, the policy grammar shouldn't depend on any kernel switch so these preprocessor statement will be removed.

However, as an audit record should remain constant, I guess we should do some special treatment to anonymous files? Like audit record for them should include "path=? dev=? ino=?"

Yes, if the record type includes those fields just once, the record type should *always* include those fields.

Signature · 1 line
paul-moore.com
author
#32 lore raw

RFC PATCH v12 16/20 fsverity: consume builtin signature via LSM hook

In reply to Fan Wu

fsverity represents a mechanism to support both integrity and authenticity protection of a file, supporting both signed and unsigned digests.

An LSM which controls access to a resource based on authenticity and integrity of said resource, can then use this data to make an informed decision on the authorization (provided by the LSM's policy) of said claim.

This effectively allows the extension of a policy enforcement layer in LSM for fsverity, allowing for more granular control of how a particular authenticity claim can be used. For example, "all (built-in) signed fsverity files should be allowed to execute, but only these hashes are allowed to be loaded as kernel modules".

This enforcement must be done in kernel space, as a userspace only solution would fail a simple litmus test: Download a self-contained malicious binary that never touches the userspace stack. This binary would still be able to execute.

---
v1-v6:
+ Not present

v7:
Introduced

v8:
+ Split fs/verity/ changes and security/ changes into separate patches
+ Change signature of fsverity_create_info to accept non-const inode
+ Change signature of fsverity_verify_signature to accept non-const inode
+ Don't cast-away const from inode.
+ Digest functionality dropped in favor of:
("fs-verity: define a function to return the integrity protected
file digest")
+ Reworded commit description and title to match changes.
+ Fix a bug wherein no LSM implements the particular fsverity @name (or LSM is disabled), and returns -EOPNOTSUPP, causing errors.

v9:
+ No changes

v10:
+ Rename the signature blob key
+ Cleanup redundant code
+ Make the hook call depends on CONFIG_FS_VERITY_BUILTIN_SIGNATURES

v11:
+ No changes

v12:
+ Add constification to the hook call

---
 fs/verity/fsverity_private.h |  2 +-
 fs/verity/open.c             | 26 +++++++++++++++++++++++++-
 include/linux/fsverity.h     |  2 ++
 3 files changed, 28 insertions(+), 2 deletions(-)
fs/verity/fsverity_private.h +1 -1
index a6a6b2749241..84a3608f2f9b 100644
@@ -118,7 +118,7 @@ int fsverity_init_merkle_tree_params(struct merkle_tree_params *params,
 				     unsigned int log_blocksize,
 				     const u8 *salt, size_t salt_size);
 
-struct fsverity_info *fsverity_create_info(const struct inode *inode,
+struct fsverity_info *fsverity_create_info(struct inode *inode,
 					   struct fsverity_descriptor *desc);
 
 void fsverity_set_info(struct inode *inode, struct fsverity_info *vi);
fs/verity/open.c +25 -1
index 6c31a871b84b..f917023255c8 100644
@@ -8,6 +8,7 @@
 #include "fsverity_private.h"
 
 #include <linux/mm.h>
+#include <linux/security.h>
 #include <linux/slab.h>
 
 static struct kmem_cache *fsverity_info_cachep;
@@ -172,12 +173,28 @@ static int compute_file_digest(const struct fsverity_hash_alg *hash_alg,
 	return err;
 }
 
+#ifdef CONFIG_FS_VERITY_BUILTIN_SIGNATURES
+static int fsverity_inode_setsecurity(struct inode *inode,
+				      const struct fsverity_descriptor *desc)
+{
+	return security_inode_setsecurity(inode, FS_VERITY_INODE_SEC_NAME,
+					  desc->signature,
+					  le32_to_cpu(desc->sig_size), 0);
+}
+#else
+static inline int fsverity_inode_setsecurity(struct inode *inode,
+					     const struct fsverity_descriptor *desc)
+{
+	return 0;
+}
+#endif /* CONFIG_IPE_PROP_FS_VERITY*/
+
 /*
  * Create a new fsverity_info from the given fsverity_descriptor (with optional
  * appended builtin signature), and check the signature if present.  The
  * fsverity_descriptor must have already undergone basic validation.
  */
-struct fsverity_info *fsverity_create_info(const struct inode *inode,
+struct fsverity_info *fsverity_create_info(struct inode *inode,
 					   struct fsverity_descriptor *desc)
 {
 	struct fsverity_info *vi;
@@ -242,6 +259,13 @@ struct fsverity_info *fsverity_create_info(const struct inode *inode,
 		spin_lock_init(&vi->hash_page_init_lock);
 	}
 
+	err = fsverity_inode_setsecurity(inode, desc);
+	if (err == -EOPNOTSUPP)
+		err = 0;
+
+	if (err)
+		goto fail;
+
 	return vi;
 
 fail:
include/linux/fsverity.h +2 -0
index 1eb7eae580be..9666721baf15 100644
@@ -319,4 +319,6 @@ static inline int fsverity_prepare_setattr(struct dentry *dentry,
 	return 0;
 }
 
+#define FS_VERITY_INODE_SEC_NAME "fsverity.builtin-sig"
+
 #endif	/* _LINUX_FSVERITY_H */
Signature · 1 line
2.43.0
author
#33 lore raw

RFC PATCH v12 17/20 ipe: enable support for fs-verity as a trust provider

In reply to Fan Wu

Enable IPE policy authors to indicate trust for a singular fsverity file, identified by the digest information, through "fsverity_digest" and all files using fsverity's builtin signatures via "fsverity_signature".

This enables file-level integrity claims to be expressed in IPE, allowing individual files to be authorized, giving some flexibility for policy authors. Such file-level claims are important to be expressed for enforcing the integrity of packages, as well as address some of the scalability issues in a sole dm-verity based solution (# of loop back devices, etc).

This solution cannot be done in userspace as the minimum threat that IPE should mitigate is an attacker downloads malicious payload with all required dependencies. These dependencies can lack the userspace check, bypassing the protection entirely. A similar attack succeeds if the userspace component is replaced with a version that does not perform the check. As a result, this can only be done in the common entry point - the kernel.

---
v1-v6:
+ Not present

v7:
Introduced

v8:
* Undo squash of 08/12, 10/12 - separating drivers/md/ from security/
* Use common-audit function for fsverity_signature.
+ Change fsverity implementation to use fsverity_get_digest
+ prevent unnecessary copy of fs-verity signature data, instead just check for presence of signature data.
+ Remove free_inode_security hook, as the digest is now acquired at runtime instead of via LSM blob.

v9:
+ Adapt to the new parser

v10:
+ Update the fsverity get digest call

v11:
+ No changes

v12:
+ Fix audit format
+ Simplify property evaluation

---
 security/ipe/Kconfig         |  13 +++++
 security/ipe/audit.c         |  25 ++++++++
 security/ipe/eval.c          | 108 ++++++++++++++++++++++++++++++++++-
 security/ipe/eval.h          |  10 ++++
 security/ipe/hooks.c         |  30 ++++++++++
 security/ipe/hooks.h         |   7 +++
 security/ipe/ipe.c           |  13 +++++
 security/ipe/ipe.h           |   3 +
 security/ipe/policy.h        |   3 +
 security/ipe/policy_parser.c |   8 +++
 10 files changed, 219 insertions(+), 1 deletion(-)
security/ipe/Kconfig +13 -0
index 7afb1ce0cb99..9dd5c4769d79 100644
@@ -30,6 +30,19 @@ config IPE_PROP_DM_VERITY
 	  that was mounted with a signed root-hash or the volume's
 	  root hash matches the supplied value in the policy.
 
+	  If unsure, answer Y.
+
+config IPE_PROP_FS_VERITY
+	bool "Enable property for fs-verity files"
+	depends on FS_VERITY && FS_VERITY_BUILTIN_SIGNATURES
+	help
+	  This option enables the usage of properties "fsverity_signature"
+	  and "fsverity_digest". These properties evaluates to TRUE when
+	  a file is fsverity enabled and with a signed digest or its
+	  diegst matches the supplied value in the policy.
+
+	  if unsure, answer Y.
+
 endmenu
 
 endif
security/ipe/audit.c +25 -0
index a4ad8e888df0..7e3372be3214 100644
@@ -60,6 +60,11 @@ static const char *const audit_prop_names[__IPE_PROP_MAX] = {
 	"dmverity_signature=FALSE",
 	"dmverity_signature=TRUE",
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+	"fsverity_digest=",
+	"fsverity_signature=FALSE",
+	"fsverity_signature=TRUE",
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 };
 
 #ifdef CONFIG_IPE_PROP_DM_VERITY
@@ -79,6 +84,23 @@ static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
 }
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
 
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+/**
+ * audit_fsv_digest - audit a digest of a fsverity file.
+ * @ab: Supplies a pointer to the audit_buffer to append to.
+ * @d: Supplies a pointer to the digest structure.
+ */
+static void audit_fsv_digest(struct audit_buffer *ab, const void *d)
+{
+	audit_log_format(ab, "%s", audit_prop_names[IPE_PROP_FSV_DIGEST]);
+	ipe_digest_audit(ab, d);
+}
+#else
+static void audit_fsv_digest(struct audit_buffer *ab, const void *d)
+{
+}
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
+
 /**
  * audit_rule - audit an IPE policy rule approximation.
  * @ab: Supplies a pointer to the audit_buffer to append to.
@@ -95,6 +117,9 @@ static void audit_rule(struct audit_buffer *ab, const struct ipe_rule *r)
 		case IPE_PROP_DMV_ROOTHASH:
 			audit_dmv_roothash(ab, ptr->value);
 			break;
+		case IPE_PROP_FSV_DIGEST:
+			audit_fsv_digest(ab, ptr->value);
+			break;
 		default:
 			audit_log_format(ab, "%s", audit_prop_names[ptr->type]);
 			break;
security/ipe/eval.c +107 -1

144 lines not on this page · raw message

security/ipe/eval.h +10 -0
index 2c997d188508..d1b3015f4443 100644
@@ -31,6 +31,12 @@ struct ipe_bdev {
 };
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
 
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+struct ipe_inode {
+	bool fs_verity_signed;
+};
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
+
 struct ipe_eval_ctx {
 	enum ipe_op_type op;
 	enum ipe_hook_type hook;
@@ -42,6 +48,10 @@ struct ipe_eval_ctx {
 #ifdef CONFIG_IPE_PROP_DM_VERITY
 	const struct ipe_bdev *ipe_bdev;
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+	const struct inode *ino;
+	const struct ipe_inode *ipe_inode;
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 };
 
 enum ipe_match {
security/ipe/hooks.c +30 -0
index 50c5324dcd92..64c1fa7de9aa 100644
@@ -256,3 +256,33 @@ int ipe_bdev_setsecurity(struct block_device *bdev, const char *key,
 	return -EOPNOTSUPP;
 }
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+/**
+ * ipe_inode_setsecurity - Sets fields of a inode security blob from @key.
+ * @inode: The inode to source the security blob from.
+ * @name: The name representing the information to be stored.
+ * @value: The value to be stored.
+ * @size: The size of @value.
+ * @flags: unused
+ *
+ * Saves fsverity signature & digest into inode security blob
+ *
+ * Return:
+ * * 0	- OK
+ * * !0	- Error
+ */
+int ipe_inode_setsecurity(struct inode *inode, const char *name,
+			  const void *value, size_t size,
+			  int flags)
+{
+	struct ipe_inode *inode_sec = ipe_inode(inode);
+
+	if (!strcmp(name, FS_VERITY_INODE_SEC_NAME)) {
+		inode_sec->fs_verity_signed = size > 0 && value;
+		return 0;
+	}
+
+	return -EOPNOTSUPP;
+}
+#endif /* CONFIG_CONFIG_IPE_PROP_FS_VERITY */
security/ipe/hooks.h +7 -0
index e114d633dcb4..ba3b961cda05 100644
@@ -9,6 +9,7 @@
 #include <linux/binfmts.h>
 #include <linux/security.h>
 #include <linux/blk_types.h>
+#include <linux/fsverity.h>
 
 enum ipe_hook_type {
 	IPE_HOOK_BPRM_CHECK = 0,
@@ -45,4 +46,10 @@ int ipe_bdev_setsecurity(struct block_device *bdev, const char *key,
 			 const void *value, size_t len);
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
 
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+int ipe_inode_setsecurity(struct inode *inode, const char *name,
+			  const void *value, size_t size,
+			  int flags);
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
+
 #endif /* _IPE_HOOKS_H */
security/ipe/ipe.c +13 -0
index 27a76aeabf1d..e1eeb0646bf1 100644
@@ -18,6 +18,9 @@ static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
 #ifdef CONFIG_IPE_PROP_DM_VERITY
 	.lbs_bdev = sizeof(struct ipe_bdev),
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+	.lbs_inode = sizeof(struct ipe_inode),
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 };
 
 static const struct lsm_id ipe_lsmid = {
@@ -39,6 +42,13 @@ struct ipe_bdev *ipe_bdev(struct block_device *b)
 }
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
 
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+struct ipe_inode *ipe_inode(const struct inode *inode)
+{
+	return inode->i_security + ipe_blobs.lbs_inode;
+}
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
+
 static struct security_hook_list ipe_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(bprm_check_security, ipe_bprm_check_security),
 	LSM_HOOK_INIT(mmap_file, ipe_mmap_file),
@@ -52,6 +62,9 @@ static struct security_hook_list ipe_hooks[] __ro_after_init = {
 	LSM_HOOK_INIT(bdev_free_security, ipe_bdev_free_security),
 	LSM_HOOK_INIT(bdev_setsecurity, ipe_bdev_setsecurity),
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+	LSM_HOOK_INIT(inode_setsecurity, ipe_inode_setsecurity),
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 };
 
 /**
security/ipe/ipe.h +3 -0
index 03dab0dec54a..e504e5ae275a 100644
@@ -21,5 +21,8 @@ extern bool ipe_enabled;
 #ifdef CONFIG_IPE_PROP_DM_VERITY
 struct ipe_bdev *ipe_bdev(struct block_device *b);
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+struct ipe_inode *ipe_inode(const struct inode *inode);
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 
 #endif /* _IPE_H */
security/ipe/policy.h +3 -0
index fa59037c3fa4..9fecfc8e42bd 100644
@@ -36,6 +36,9 @@ enum ipe_prop_type {
 	IPE_PROP_DMV_ROOTHASH,
 	IPE_PROP_DMV_SIG_FALSE,
 	IPE_PROP_DMV_SIG_TRUE,
+	IPE_PROP_FSV_DIGEST,
+	IPE_PROP_FSV_SIG_FALSE,
+	IPE_PROP_FSV_SIG_TRUE,
 	__IPE_PROP_MAX
 };
 
security/ipe/policy_parser.c +8 -0
index 6cab7eef6052..5c721e801cd7 100644
@@ -277,6 +277,11 @@ static const match_table_t property_tokens = {
 	{IPE_PROP_DMV_SIG_FALSE,	"dmverity_signature=FALSE"},
 	{IPE_PROP_DMV_SIG_TRUE,		"dmverity_signature=TRUE"},
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+	{IPE_PROP_FSV_DIGEST,		"fsverity_digest=%s"},
+	{IPE_PROP_FSV_SIG_FALSE,	"fsverity_signature=FALSE"},
+	{IPE_PROP_FSV_SIG_TRUE,		"fsverity_signature=TRUE"},
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 	{IPE_PROP_INVALID,		NULL}
 };
 
@@ -306,6 +311,7 @@ static int parse_property(char *t, struct ipe_rule *r)
 
 	switch (token) {
 	case IPE_PROP_DMV_ROOTHASH:
+	case IPE_PROP_FSV_DIGEST:
 		dup = match_strdup(&args[0]);
 		if (!dup) {
 			rc = -ENOMEM;
@@ -321,6 +327,8 @@ static int parse_property(char *t, struct ipe_rule *r)
 	case IPE_PROP_BOOT_VERIFIED_TRUE:
 	case IPE_PROP_DMV_SIG_FALSE:
 	case IPE_PROP_DMV_SIG_TRUE:
+	case IPE_PROP_FSV_SIG_FALSE:
+	case IPE_PROP_FSV_SIG_TRUE:
 		p->type = token;
 		break;
 	default:
Signature · 1 line
2.43.0
maintainer
#34 lore raw

Re: [PATCH RFC v12 17/20] ipe: enable support for fs-verity as a trust provider

Quoted 114 lines · On Jan 30, 2024 Fan Wu <[email protected]> wrote:

Enable IPE policy authors to indicate trust for a singular fsverity file, identified by the digest information, through "fsverity_digest" and all files using fsverity's builtin signatures via "fsverity_signature".

This enables file-level integrity claims to be expressed in IPE, allowing individual files to be authorized, giving some flexibility for policy authors. Such file-level claims are important to be expressed for enforcing the integrity of packages, as well as address some of the scalability issues in a sole dm-verity based solution (# of loop back devices, etc).

This solution cannot be done in userspace as the minimum threat that IPE should mitigate is an attacker downloads malicious payload with all required dependencies. These dependencies can lack the userspace check, bypassing the protection entirely. A similar attack succeeds if the userspace component is replaced with a version that does not perform the check. As a result, this can only be done in the common entry point - the kernel.

---
v1-v6:
+ Not present

v7:
Introduced

v8:
* Undo squash of 08/12, 10/12 - separating drivers/md/ from security/
* Use common-audit function for fsverity_signature.
+ Change fsverity implementation to use fsverity_get_digest
+ prevent unnecessary copy of fs-verity signature data, instead just check for presence of signature data.
+ Remove free_inode_security hook, as the digest is now acquired at runtime instead of via LSM blob.

v9:
+ Adapt to the new parser

v10:
+ Update the fsverity get digest call

v11:
+ No changes

v12:
+ Fix audit format
+ Simplify property evaluation

---
 security/ipe/Kconfig         |  13 +++++
 security/ipe/audit.c         |  25 ++++++++
 security/ipe/eval.c          | 108 ++++++++++++++++++++++++++++++++++-
 security/ipe/eval.h          |  10 ++++
 security/ipe/hooks.c         |  30 ++++++++++
 security/ipe/hooks.h         |   7 +++
 security/ipe/ipe.c           |  13 +++++
 security/ipe/ipe.h           |   3 +
 security/ipe/policy.h        |   3 +
 security/ipe/policy_parser.c |   8 +++
 10 files changed, 219 insertions(+), 1 deletion(-)
security/ipe/Kconfig +13 -0
index 7afb1ce0cb99..9dd5c4769d79 100644
@@ -30,6 +30,19 @@ config IPE_PROP_DM_VERITY
 	  that was mounted with a signed root-hash or the volume's
 	  root hash matches the supplied value in the policy.
 
+	  If unsure, answer Y.
+
+config IPE_PROP_FS_VERITY
+	bool "Enable property for fs-verity files"
+	depends on FS_VERITY && FS_VERITY_BUILTIN_SIGNATURES
+	help
+	  This option enables the usage of properties "fsverity_signature"
+	  and "fsverity_digest". These properties evaluates to TRUE when
+	  a file is fsverity enabled and with a signed digest or its
+	  diegst matches the supplied value in the policy.
+
+	  if unsure, answer Y.
+
 endmenu
 
 endif
security/ipe/audit.c +11 -0
index a4ad8e888df0..7e3372be3214 100644
@@ -60,6 +60,11 @@ static const char *const audit_prop_names[__IPE_PROP_MAX] = {
 	"dmverity_signature=FALSE",
 	"dmverity_signature=TRUE",
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+	"fsverity_digest=",
+	"fsverity_signature=FALSE",
+	"fsverity_signature=TRUE",
+#endif /* CONFIG_IPE_PROP_FS_VERITY */
 };
 
 #ifdef CONFIG_IPE_PROP_DM_VERITY
@@ -79,6 +84,23 @@ static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh)
 }
 #endif /* CONFIG_IPE_PROP_DM_VERITY */
 
+#ifdef CONFIG_IPE_PROP_FS_VERITY
+/**
+ * audit_fsv_digest - audit a digest of a fsverity file.
+ * @ab: Supplies a pointer to the audit_buffer to append to.
+ * @d: Supplies a pointer to the digest structure.
+ */

security/ipe/audit.c static void audit_dmv_roothash(struct audit_buffer *ab, const void *rh) · line 102

Quoted 10 lines
security/ipe/audit.c +10 -0
+static void audit_fsv_digest(struct audit_buffer *ab, const void *d)
+{
+	audit_log_format(ab, "%s", audit_prop_names[IPE_PROP_FSV_DIGEST]);
+	ipe_digest_audit(ab, d);
+}
+#else
+static void audit_fsv_digest(struct audit_buffer *ab, const void *d)
+{
+}
+#endif /* CONFIG_IPE_PROP_FS_VERITY */

The related dm-verify comments also apply here.

--
paul-moore.com

author
#35 lore raw

RFC PATCH v12 18/20 scripts: add boot policy generation program

In reply to Fan Wu

From: Deven Bowers <[email protected]>

Enables an IPE policy to be enforced from kernel start, enabling access control based on trust from kernel startup. This is accomplished by transforming an IPE policy indicated by CONFIG_IPE_BOOT_POLICY into a c-string literal that is parsed at kernel startup as an unsigned policy.

---
v2:
+ No Changes

v3:
+ No Changes

v4:
+ No Changes

v5:
+ No Changes

v6:
+ No Changes

v7:
+ Move from 01/11 to 14/16
+ Don't return errno directly.
+ Make output of script more user-friendly
+ Add escaping for tab and '?'
+ Mark argv pointer const
+ Invert return code check in the boot policy parsing code path.

v8:
+ No significant changes.

v9:
+ No changes

v10:
+ Update the init part code for rcu changes in the eval loop patch

v11:
+ Fix code style issues

v12:
+ No changes

---
 MAINTAINERS                   |   1 +
 scripts/Makefile              |   1 +
 scripts/ipe/Makefile          |   2 +
 scripts/ipe/polgen/.gitignore |   2 +
 scripts/ipe/polgen/Makefile   |   5 ++
 scripts/ipe/polgen/polgen.c   | 145 ++++++++++++++++++++++++++++++++++
 security/ipe/.gitignore       |   2 +
 security/ipe/Kconfig          |  10 +++
 security/ipe/Makefile         |  11 +++
 security/ipe/fs.c             |   8 ++
 security/ipe/ipe.c            |  12 +++
 11 files changed, 199 insertions(+)
 create mode 100644 scripts/ipe/Makefile
 create mode 100644 scripts/ipe/polgen/.gitignore
 create mode 100644 scripts/ipe/polgen/Makefile
 create mode 100644 scripts/ipe/polgen/polgen.c
 create mode 100644 security/ipe/.gitignore
MAINTAINERS +1 -0
index 51464982297b..d2f735eb9875 100644
@@ -10649,6 +10649,7 @@ M:	Fan Wu <[email protected]>
 L:	[email protected]
 S:	Supported
 T:	git https://github.com/microsoft/ipe.git
+F:	scripts/ipe/
 F:	security/ipe/
 
 INTEL 810/815 FRAMEBUFFER DRIVER
scripts/Makefile +1 -0
index 576cf64be667..1dbaf3a49aef 100644
@@ -50,6 +50,7 @@ targets += module.lds
 subdir-$(CONFIG_GCC_PLUGINS) += gcc-plugins
 subdir-$(CONFIG_MODVERSIONS) += genksyms
 subdir-$(CONFIG_SECURITY_SELINUX) += selinux
+subdir-$(CONFIG_SECURITY_IPE) += ipe
 
 # Let clean descend into subdirs
 subdir-	+= basic dtc gdb kconfig mod
scripts/ipe/Makefile new file +2 -0
new file mode 100644
index 000000000000..e87553fbb8d6
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+subdir-y := polgen
scripts/ipe/polgen/.gitignore new file +2 -0
new file mode 100644
index 000000000000..b6f05cf3dc0e
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+polgen
scripts/ipe/polgen/Makefile new file +5 -0
new file mode 100644
index 000000000000..c20456a2f2e9
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0
+hostprogs-always-y	:= polgen
+HOST_EXTRACFLAGS += \
+	-I$(srctree)/include \
+	-I$(srctree)/include/uapi \
scripts/ipe/polgen/polgen.c new file +145 -0

145 lines not on this page · raw message

security/ipe/.gitignore new file +2 -0
new file mode 100644
index 000000000000..07313d3fd74a
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+boot-policy.c
security/ipe/Kconfig +10 -0
index 9dd5c4769d79..a6c5d48dd0a3 100644
@@ -18,6 +18,16 @@ menuconfig SECURITY_IPE
 	  If unsure, answer N.
 
 if SECURITY_IPE
+config IPE_BOOT_POLICY
+	string "Integrity policy to apply on system startup"
+	help
+	  This option specifies a filepath to a IPE policy that is compiled
+	  into the kernel. This policy will be enforced until a policy update
+	  is deployed via the $securityfs/ipe/policies/$policy_name/active
+	  interface.
+
+	  If unsure, leave blank.
+
 menu "IPE Trust Providers"
 
 config IPE_PROP_DM_VERITY
security/ipe/Makefile +11 -0
index 66de53687d11..ce23101b66ba 100644
@@ -5,7 +5,16 @@
 # Makefile for building the IPE module as part of the kernel tree.
 #
 
+quiet_cmd_polgen = IPE_POL $(2)
+      cmd_polgen = scripts/ipe/polgen/polgen security/ipe/boot-policy.c $(2)
+
+targets += boot-policy.c
+
+$(obj)/boot-policy.c: scripts/ipe/polgen/polgen $(CONFIG_IPE_BOOT_POLICY) FORCE
+	$(call if_changed,polgen,$(CONFIG_IPE_BOOT_POLICY))
+
 obj-$(CONFIG_SECURITY_IPE) += \
+	boot-policy.o \
 	digest.o \
 	eval.o \
 	hooks.o \
@@ -15,3 +24,5 @@ obj-$(CONFIG_SECURITY_IPE) += \
 	policy_fs.o \
 	policy_parser.o \
 	audit.o \
+
+clean-files := boot-policy.c \
security/ipe/fs.c +8 -0
index b16d87443a3b..8af6e39f9914 100644
@@ -190,6 +190,7 @@ static const struct file_operations enforce_fops = {
 static int __init ipe_init_securityfs(void)
 {
 	int rc = 0;
+	struct ipe_policy *ap;
 
 	if (!ipe_enabled)
 		return -EOPNOTSUPP;
@@ -220,6 +221,13 @@ static int __init ipe_init_securityfs(void)
 		goto err;
 	}
 
+	ap = rcu_access_pointer(ipe_active_policy);
+	if (ap) {
+		rc = ipe_new_policyfs_node(ap);
+		if (rc)
+			goto err;
+	}
+
 	np = securityfs_create_file("new_policy", 0200, root, NULL, &np_fops);
 	if (IS_ERR(np)) {
 		rc = PTR_ERR(np);
security/ipe/ipe.c +12 -0
index e1eeb0646bf1..f13bdda9fa38 100644
@@ -9,6 +9,7 @@
 #include "hooks.h"
 #include "eval.h"
 
+extern const char *const ipe_boot_policy;
 bool ipe_enabled;
 
 static struct lsm_blob_sizes ipe_blobs __ro_after_init = {
@@ -79,9 +80,20 @@ static struct security_hook_list ipe_hooks[] __ro_after_init = {
  */
 static int __init ipe_init(void)
 {
+	struct ipe_policy *p = NULL;
+
 	security_add_hooks(ipe_hooks, ARRAY_SIZE(ipe_hooks), &ipe_lsmid);
 	ipe_enabled = true;
 
+	if (ipe_boot_policy) {
+		p = ipe_new_policy(ipe_boot_policy, strlen(ipe_boot_policy),
+				   NULL, 0);
+		if (IS_ERR(p))
+			return PTR_ERR(p);
+
+		rcu_assign_pointer(ipe_active_policy, p);
+	}
+
 	return 0;
 }
 
Signature · 1 line
2.43.0
author
#36 lore raw

RFC PATCH v12 19/20 ipe: kunit test for parser

In reply to Fan Wu

From: Deven Bowers <[email protected]>

Add various happy/unhappy unit tests for both IPE's policy parser.

Besides, a test suite for IPE functionality is available at
https://github.com/microsoft/ipe/tree/test-suite

---
v1-v6:
+ Not present

v7:
Introduced

v8:
+ Remove the kunit tests with respect to the fsverity digest, as these require significant changes to work with the new method of acquiring the digest at runtime.

v9:
+ Remove the kunit tests related to ipe_context

v10:
+ No changes

v11:
+ No changes

v12:
+ No changes

---
 security/ipe/Kconfig        |  17 +++
 security/ipe/Makefile       |   3 +
 security/ipe/policy_tests.c | 294 ++++++++++++++++++++++++++++++++++++
 3 files changed, 314 insertions(+)
 create mode 100644 security/ipe/policy_tests.c
security/ipe/Kconfig +17 -0
index a6c5d48dd0a3..ac04a9974297 100644
@@ -55,4 +55,21 @@ config IPE_PROP_FS_VERITY
 
 endmenu
 
+config SECURITY_IPE_KUNIT_TEST
+	bool "Build KUnit tests for IPE" if !KUNIT_ALL_TESTS
+	depends on KUNIT=y
+	default KUNIT_ALL_TESTS
+	help
+	  This builds the IPE KUnit tests.
+
+	  KUnit tests run during boot and output the results to the debug log
+	  in TAP format (https://testanything.org/). Only useful for kernel devs
+	  running KUnit test harness and are not for inclusion into a
+	  production build.
+
+	  For more information on KUnit and unit tests in general please refer
+	  to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+	  If unsure, say N.
+
 endif
security/ipe/Makefile +3 -0
index ce23101b66ba..def674e09e84 100644
@@ -26,3 +26,6 @@ obj-$(CONFIG_SECURITY_IPE) += \
 	audit.o \
 
 clean-files := boot-policy.c \
+
+obj-$(CONFIG_SECURITY_IPE_KUNIT_TEST) += \
+	policy_tests.o \
security/ipe/policy_tests.c new file +294 -0

294 lines not on this page · raw message

Signature · 1 line
2.43.0
author
#37 lore raw

RFC PATCH v12 20/20 documentation: add ipe documentation

In reply to Fan Wu

From: Deven Bowers <[email protected]>

Add IPE's admin and developer documentation to the kernel tree.

---
v2:
+ No Changes

v3:
+ Add Acked-by
+ Fixup code block syntax
+ Fix a minor grammatical issue.

v4:
+ Update documentation with the results of other code changes.

v5:
+ No changes

v6:
+ No changes

v7:
+ Add additional developer-level documentation
+ Update admin-guide docs to reflect changes.
+ Drop Acked-by due to significant changes
+ Added section about audit events in admin-guide

v8:
+ Correct terminology from "audit event" to "audit record"
+ Add associated documentation with the correct "audit event" terminology.
+ Add some context to the historical motivation for IPE and design philosophy.
+ Add some content about the securityfs layout in the policies directory.
+ Various spelling and grammatical corrections.

v9:
+ Correct spelling of "pitfalls"
+ Update the docs w.r.t the new parser and new audit formats

v10:
+ Refine user docs per upstream suggestions
+ Update audit events part

v11:
+ No changes

v12:
+ Update audit formats
+ Update initramfs related docs
+ Add test suite link

---
 Documentation/admin-guide/LSM/index.rst       |   1 +
 Documentation/admin-guide/LSM/ipe.rst         | 761 ++++++++++++++++++
 .../admin-guide/kernel-parameters.txt         |  12 +
 Documentation/security/index.rst              |   1 +
 Documentation/security/ipe.rst                | 444 ++++++++++
 MAINTAINERS                                   |   2 +
 6 files changed, 1221 insertions(+)
 create mode 100644 Documentation/admin-guide/LSM/ipe.rst
 create mode 100644 Documentation/security/ipe.rst
Documentation/admin-guide/LSM/index.rst +1 -0
index a6ba95fbaa9f..ce63be6d64ad 100644
@@ -47,3 +47,4 @@ subdirectories.
    tomoyo
    Yama
    SafeSetID
+   ipe
Documentation/admin-guide/LSM/ipe.rst new file +761 -0

761 lines not on this page · raw message

Documentation/admin-guide/kernel-parameters.txt +12 -0
index 31b3a25680d0..3a3e0978e95d 100644
@@ -2282,6 +2282,18 @@
 	ipcmni_extend	[KNL] Extend the maximum number of unique System V
 			IPC identifiers from 32,768 to 16,777,216.
 
+	ipe.enforce=	[IPE]
+			Format: <bool>
+			Determine whether IPE starts in permissive (0) or
+			enforce (1) mode. The default is enforce.
+
+	ipe.success_audit=
+			[IPE]
+			Format: <bool>
+			Start IPE with success auditing enabled, emitting
+			an audit event when a binary is allowed. The default
+			is 0.
+
 	irqaffinity=	[SMP] Set the default irq affinity mask
 			The argument is a cpu list, as described above.
 
Documentation/security/index.rst +1 -0
index 59f8fc106cb0..3e0a7114a862 100644
@@ -19,3 +19,4 @@ Security Documentation
    digsig
    landlock
    secrets/index
+   ipe
Documentation/security/ipe.rst new file +444 -0

444 lines not on this page · raw message

MAINTAINERS +2 -0
index d2f735eb9875..883f16dedcb9 100644
@@ -10649,6 +10649,8 @@ M:	Fan Wu <[email protected]>
 L:	[email protected]
 S:	Supported
 T:	git https://github.com/microsoft/ipe.git
+F:	Documentation/admin-guide/LSM/ipe.rst
+F:	Documentation/security/ipe.rst
 F:	scripts/ipe/
 F:	security/ipe/
 
Signature · 1 line
2.43.0