Skip to contentSkip to conversation

Integrity Policy Enforcement LSM (IPE)

RFC PATCH Superseded [email protected] 6 participants 23 messages Apr 15, 2020 – Jul 15, 2020

Subsystems (9)
Documentation VFS Block layer Kbuild +5 more subsystems

v3 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

v3 cover Integrity Policy Enforcement LSM (IPE)

From: Deven Bowers <[email protected]>

Overview:
------------------------------------

IPE is a Linux Security Module which allows for a configurable policy to enforce integrity requirements on the whole system. It attempts to solve the issue of Code Integrity: that any code being executed (or files being read), are identical to the version that was built by a trusted source.

The type of system for which IPE is designed for use is an embedded device with a specific purpose (e.g. network firewall device in a data center), where all software and configuration is built and provisioned by the owner.

Specifically, a system which leverages IPE is not intended for general purpose computing and does not utilize any software or configuration built by a third party. An ideal system to leverage IPE has both mutable and immutable components, however, all binary executable code is immutable.

The scope of IPE is constrained to the OS. It is assumed that platform firmware verifies the the kernel and optionally the root filesystem (e.g. via U-Boot verified boot). IPE then utilizes LSM hooks to enforce a flexible, kernel-resident integrity verification policy.

IPE differs from other LSMs which provide integrity checking (for instance, IMA), as it has no dependency on the filesystem metadata itself. The attributes that IPE checks are deterministic properties that exist solely in the kernel. Additionally, IPE provides no additional mechanisms of verifying these files (e.g. IMA Signatures) - all of the attributes of verifying files are existing features within the kernel, such as dm-verity or fsverity.

IPE provides a policy that allows owners of the system to easily specify integrity requirements and uses dm-verity signatures to simplify the authentication of allowed objects like authorized code and data.

IPE supports two modes, permissive (similar to SELinux's permissive mode) and enforce. Permissive mode performs the same checks, and logs policy violations as enforce mode, but will not enforce the policy. This allows users to test policies before enforcing them.

The default mode is enforce, and can be changed via the kernel commandline parameter ipe.enforce=(0|1), or the sysctl ipe.enforce=(0|1). The ability to switch modes can be compiled out of the LSM via setting the config CONFIG_SECURITY_IPE_PERMISSIVE_SWITCH to N.

IPE additionally supports success auditing. When enabled, all events that pass IPE policy and are not blocked will emit an audit event. This is disabled by default, and can be enabled via the kernel commandline ipe.success_audit=(0|1) or the sysctl ipe.success_audit=(0|1).

Policies can be staged at runtime through securityfs and activated through sysfs. Please see the Deploying Policies section of this cover letter for more information.

The IPE LSM is compiled under CONFIG_SECURITY_IPE.

Policy:
------------------------------------

IPE policy is designed to be both forward compatible and backwards compatible. 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 (NOT the policy syntax version). 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 properties: "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 will allow any execution. 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. Available properties for IPE described in the properties section of this cover-letter, the repository available in Appendix A, and the kernel documentation page.

Order does not matter for the rule's properties - they can be listed in any order, however it is encouraged to have the "op" property be first, and the "action" property be last, for readability.

Additionally, 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.

IPE policy is designed to be forward compatible and backwards compatible, thus any failure to parse a rule will result in the line being ignored, and a warning being emitted. If backwards compatibility is not required, the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

For more information about the policy syntax, please see Appendix A or 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 userland 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 initial superblock:

policy_name="Allow All Initial SB" policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE boot_verified=TRUE action=ALLOW

Allow any signed dm-verity volume and the initial superblock:

policy_name="AllowSignedAndInitial" 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:

policy_name="AllowSignedAndInitial" policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE dmverity_roothash=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="AllowSignedAndInitial" policy_version=0.0.0 DEFAULT action=DENY

op=EXECUTE dmverity_roothash=401fcec5944823ae12f62726e8184407a5fa9599783f030dec146938 action=ALLOW

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

Deploying policies is simple. 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" -binary -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 sysctl "ipe.active_policy":

sysctl ipe.active_policy="$MY_POLICY_NAME"

This will now mark the policy as active and the system will be enforcing $MY_POLICY_NAME. At any point the policy can be updated on the provision that the policy version to be deployed is greater than or equal to the running version (to prevent roll-back attacks). This update can be done by redirecting the file into the policy's "raw" node, under the policies subdirectory:

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

Additionally, policies can be deleted via the "del_policy" securityfs node. Simply write the name of the policy to be deleted to that node:

echo -n "$MY_POLICY_NAME" > /sys/kernel/security/ipe/del_policy

There are two requirements to delete policies:

1. The policy being deleted must not be the active policy.
2. The policy being deleted must not be the boot policy.

It's important to know above that the "echo" command will add a newline to the end of the input, and this will be considered as part of the filename. You can remove the newline via the -n parameter.

NOTE: If a MAC LSM is enabled, the securityfs commands will require CAP_MAC_ADMIN. This is due to sysfs supporting fine-grained MAC attributes, while securityfs at the current moment does not.

Properties:
------------------------------------

This initial patchset introducing IPE adds three properties:
'boot_verified', 'dmverity_signature' and 'dmverity_roothash'.

boot_verified (CONFIG_IPE_BOOT_PROP):
This property can be utilized for authorization of the first super-block that is mounted on the system, where IPE attempts to evaluate a file. Typically this is used for systems with an initramfs or other initial disk, where this is unmounted before the system becomes available, and is not covered by any other property. The format of this property is:

boot_verified=(TRUE|FALSE)

WARNING: This property will trust any disk where the first IPE evaluation occurs. If you do not have a startup disk that is unpacked and unmounted (like initramfs), then it will automatically trust the root filesystem and potentially overauthorize the entire disk.

dmverity_roothash (CONFIG_IPE_DM_VERITY_ROOTHASH):
This property can be utilized for authorization or revocation of specific dmverity volumes, identified via root hash. It has a dependency on the DM_VERITY module. The format of this property is:

dmverity_roothash=<HashHexDigest>

dmverity_signature (CONFIG_IPE_DM_VERITY_SIGNATURE):
This property can be utilized for authorization of all dm-verity volumes that have a signed roothash that chains to the system trusted keyring. It has a dependency on the DM_VERITY_VERIFY_ROOTHASH_SIG config. The format of this property is:

dmverity_signature=(TRUE|FALSE)

Testing:
------------------------------------

A test suite is available (Appendix B) for ease of use. For manual instructions:

Enable IPE through the following Kconfigs:

CONFIG_SECURITY_IPE=y CONFIG_SECURITY_IPE_BOOT_POLICY="../AllowAllInitialSB.pol" CONFIG_SECURITY_IPE_AUDIT_SWITCH=y CONFIG_IPE_BOOT_PROP=y CONFIG_IPE_DM_VERITY_ROOTHASH=y CONFIG_IPE_DM_VERITY_SIGNATURE=y CONFIG_DM_VERITY=y CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG=y CONFIG_SYSTEM_TRUSTED_KEYRING=y CONFIG_SYSTEM_TRUSTED_KEYS="/path/to/my/cert/list.pem"

Start a test system, that boots directly from the filesystem, without an initrd. I recommend testing in permissive mode until all tests pass, then switch to enforce to ensure behavior remains identical.

boot_verified:

If booted correctly, the filesystem mounted on / should be marked as boot_verified. Verify by turning on success auditing (sysctl ipe.success_audit=1), and run a binary. In the audit output, prop_boot_verified should be TRUE.

To test denials, mount a temporary filesystem (mount -t tmpfs -o size=4M tmp tmp), and copy a binary (e.g. ls) to this new filesystem. Disable success auditing and attempt to run the file. The file should have an audit event, but be allowed to execute in permissive mode, and prop_boot_verified should be FALSE.

dmverity_roothash:

First, you must create a dm-verity volume. This can be done through squashfs-tools and veritysetup (provided by cryptsetup).

Creating a squashfs volume:

mksquashfs /path/to/directory/with/executable /path/to/output.squashfs

Format the volume for use with dm-verity & save the root hash:

    output_rh=$(veritysetup format output.squashfs output.hashtree | \
      tee verity_out.txt | awk "/Root hash/" | \
      sed -E "s/Root hash:\s+//g")

    echo -n $output_rh > output.roothash

Create a two policies, filling in the appropriate fields below:

Policy 1:

policy_name="roothash-denial" policy_version=0.0.0 DEFAULT action=ALLOW
op=EXECUTE dmverity_roothash=$output_rh action=DENY

Policy 2:

policy_name="roothash-allow" policy_version=0.0.0 DEFAULT action=ALLOW
DEFAULT op=EXECUTE action=DENY

op=EXECUTE boot_verified=TRUE action=ALLOW op=EXECUTE dmverity_roothash=$output_rh action=ALLOW

Deploy each policy, then mark the first, "roothash-denial" as active, per the "Deploying Policies" section of this cover letter. Mount the dm-verity volume:

veritysetup open output.squashfs output.hashtree unverified \
cat output.roothash

mount /dev/mapper/unverified /my/mount/point

Attempt to execute a binary in the mount point, and it should emit an audit event for a match against the rule:

op=EXECUTE dmverity_roothash=$output_rh action=DENY

To test the second policy, perform the same steps, but this time, enable success auditing before running the executable. The success audit event should be a match against this rule:

op=EXECUTE dmverity_roothash=$output_rh action=ALLOW

dmverity_signature:

Follow the setup steps for dmverity_roothash. Sign the roothash via:

    openssl smime -sign -in "output.roothash" -signer "$MY_CERTIFICATE" \
      -inkey "$MY_PRIVATE_KEY" -binary -outform der -noattr \
      -out "output.p7s"

    Create a policy:

      policy_name="verified" policy_version=0.0.0
      DEFAULT action=DENY

      op=EXECUTE boot_verified=TRUE action=ALLOW
      op=EXECUTE dmverity_verified=TRUE action=ALLOW

Deploy the policy, and mark as active, per the "Deploying Policies" section of this cover letter. Mount the dm-verity volume with verification:

    veritysetup open output.squashfs output.hashtree unverified \
      `cat output.roothash` --root-hash-signature=output.p7s

    mount /dev/mapper/unverified /my/mount/point

NOTE: The --root-hash-signature option was introduced in veritysetup 2.3.0

Turn on success auditing and attempt to execute a binary in the mount point, and it should emit an audit event for a match against the rule:

op=EXECUTE dmverity_verified=TRUE action=ALLOW

To test denials, mount the dm-verity volume the same way as the "dmverity_roothash" section, and attempt to execute a binary. Failure should occur.

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

Full documentation is available on github in IPE's master repository (Appendix A). This is intended to be an exhaustive source of documentation around IPE.

Additionally, there is higher level documentation in the admin-guide.

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, or JIT'd code. Unfortunately, as this is dynamically generated code, there is no way for IPE to detect that this code has not been tampered with in transition from where it was built, to where it is running. As a result, IPE is incapable of tackling this problem for dynamically generated code. However, there is a patch series being prepared that addresses this problem for libffi and gcc closures by implemeting a safer kernel trampoline API.

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. This specific gap is planned on being addressed within IPE. For more information on how we plan to address this gap, please see the Future Development section, below.

Future Development:
------------------------------------

Support for filtering signatures by specific certificates. In this case, our "dmverity_signature" (or a separate property) can be set to a specific certificate declared in IPE's policy, allowing for more controlled use-cases determine by a user's PKI structure.

Support for integrity verification for general file reads. This addresses the script interpreter issue indicated in the "Known Gaps" section, as these script files are typically opened with O_RDONLY. We are evaluating whether to do this by comparing the original userland filepath passed into the open syscall, thereby allowing existing callers to take advantage without any code changes; the alternate design is to extend the new openat2(2) syscall, with an new flag, tentatively called "O_VERIFY". While the second option requires a code change for all the interpreters, frameworks and languages that wish to leverage it, it is a wholly cleaner implementation in the kernel.

Onboarding IPE's test suite to KernelCI. Currently we are developing a test suite in the same vein as SELinux's test suite. Once development of the test suite is complete, and provided IPE is accepted, we intend to onboard this test suite onto KernelCI.

Hardened resistance against roll-back attacks. Currently there exists a window of opportunity between user-mode setup and the user-policy being deployed, where a prior user-policy can be loaded, that is potentially insecure. However, with a kernel update, you can revise the boot policy's version to be the same version as the latest policy, closing this window. In the future, I would like to close this window of opportunity without a kernel update, using some persistent storage mechanism.

Open Issues:
------------

For linux-audit/integrity folks:
1. Introduction of new audit definitions in the kernel integrity range - is this preferred, as opposed to reusing definitions with existing IMA definitions?

TODOs:
------

linux-audit changes to support the new audit events.

Appendix:
------------------------------------

A. IPE Github Repository: https://github.com/microsoft/ipe
Hosted Documentation: https://microsoft.github.io/ipe
B. IPE Users' Guide: Documentation/admin-guide/LSM/ipe.rst C. IPE Test Suite: *TBA* (under development)

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

v1: Introduced

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.

Deven Bowers (12):
scripts: add ipe tooling to generate boot policy
security: add ipe lsm evaluation loop and audit system
security: add ipe lsm policy parser and policy loading
ipe: add property for trust of boot volume
fs: add security blob and hooks for block_device
dm-verity: move signature check after tree validation
dm-verity: add bdev_setsecurity hook for dm-verity signature
ipe: add property for signed dmverity volumes
dm-verity: add bdev_setsecurity hook for root-hash
ipe: add property for dmverity roothash
documentation: add IPE documentation
cleanup: uapi/linux/audit.h

 Documentation/admin-guide/LSM/index.rst      |   1 +
 Documentation/admin-guide/LSM/ipe.rst        | 487 ++++++++++
 MAINTAINERS                                  |   8 +
 drivers/md/dm-verity-target.c                |  50 +-
 drivers/md/dm-verity-verify-sig.c            | 147 ++-
 drivers/md/dm-verity-verify-sig.h            |  20 +-
 drivers/md/dm-verity.h                       |   2 +-
 fs/block_dev.c                               |   8 +
 include/linux/device-mapper.h                |   3 +
 include/linux/fs.h                           |   1 +
 include/linux/lsm_hook_defs.h                |   5 +
 include/linux/lsm_hooks.h                    |  11 +
 include/linux/security.h                     |  22 +
 include/uapi/linux/audit.h                   |  36 +-
 scripts/Makefile                             |   1 +
 scripts/ipe/Makefile                         |   2 +
 scripts/ipe/polgen/.gitignore                |   1 +
 scripts/ipe/polgen/Makefile                  |   7 +
 scripts/ipe/polgen/polgen.c                  | 136 +++
 security/Kconfig                             |  12 +-
 security/Makefile                            |   2 +
 security/ipe/.gitignore                      |   2 +
 security/ipe/Kconfig                         |  45 +
 security/ipe/Makefile                        |  34 +
 security/ipe/ipe-audit.c                     | 297 ++++++
 security/ipe/ipe-audit.h                     |  26 +
 security/ipe/ipe-blobs.c                     |  90 ++
 security/ipe/ipe-blobs.h                     |  18 +
 security/ipe/ipe-engine.c                    | 221 +++++
 security/ipe/ipe-engine.h                    |  49 +
 security/ipe/ipe-hooks.c                     | 169 ++++
 security/ipe/ipe-hooks.h                     | 106 +++
 security/ipe/ipe-parse.c                     | 904 +++++++++++++++++++
 security/ipe/ipe-parse.h                     |  17 +
 security/ipe/ipe-pin.c                       |  93 ++
 security/ipe/ipe-pin.h                       |  56 ++
 security/ipe/ipe-policy.c                    | 148 +++
 security/ipe/ipe-policy.h                    |  72 ++
 security/ipe/ipe-prop-internal.h             |  37 +
 security/ipe/ipe-property.c                  | 112 +++
 security/ipe/ipe-property.h                  |  99 ++
 security/ipe/ipe-secfs.c                     | 806 +++++++++++++++++
 security/ipe/ipe-secfs.h                     |  16 +
 security/ipe/ipe-sysfs.c                     | 206 +++++
 security/ipe/ipe-sysfs.h                     |  14 +
 security/ipe/ipe.c                           | 110 +++
 security/ipe/ipe.h                           |  23 +
 security/ipe/properties/Kconfig              |  35 +
 security/ipe/properties/Makefile             |  13 +
 security/ipe/properties/boot-verified.c      |  81 ++
 security/ipe/properties/dmverity-roothash.c  | 152 ++++
 security/ipe/properties/dmverity-signature.c |  81 ++
 security/ipe/properties/prop-entry.h         |  38 +
 security/ipe/utility.h                       |  32 +
 security/security.c                          |  61 ++
 55 files changed, 5131 insertions(+), 94 deletions(-)
 create mode 100644 Documentation/admin-guide/LSM/ipe.rst
 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/ipe-audit.c
 create mode 100644 security/ipe/ipe-audit.h
 create mode 100644 security/ipe/ipe-blobs.c
 create mode 100644 security/ipe/ipe-blobs.h
 create mode 100644 security/ipe/ipe-engine.c
 create mode 100644 security/ipe/ipe-engine.h
 create mode 100644 security/ipe/ipe-hooks.c
 create mode 100644 security/ipe/ipe-hooks.h
 create mode 100644 security/ipe/ipe-parse.c
 create mode 100644 security/ipe/ipe-parse.h
 create mode 100644 security/ipe/ipe-pin.c
 create mode 100644 security/ipe/ipe-pin.h
 create mode 100644 security/ipe/ipe-policy.c
 create mode 100644 security/ipe/ipe-policy.h
 create mode 100644 security/ipe/ipe-prop-internal.h
 create mode 100644 security/ipe/ipe-property.c
 create mode 100644 security/ipe/ipe-property.h
 create mode 100644 security/ipe/ipe-secfs.c
 create mode 100644 security/ipe/ipe-secfs.h
 create mode 100644 security/ipe/ipe-sysfs.c
 create mode 100644 security/ipe/ipe-sysfs.h
 create mode 100644 security/ipe/ipe.c
 create mode 100644 security/ipe/ipe.h
 create mode 100644 security/ipe/properties/Kconfig
 create mode 100644 security/ipe/properties/Makefile
 create mode 100644 security/ipe/properties/boot-verified.c
 create mode 100644 security/ipe/properties/dmverity-roothash.c
 create mode 100644 security/ipe/properties/dmverity-signature.c
 create mode 100644 security/ipe/properties/prop-entry.h
 create mode 100644 security/ipe/utility.h
Signature · 1 line
2.26.0
#1 lore raw

RFC PATCH v3 1/12 scripts: add ipe tooling to generate boot policy

From: Deven Bowers <[email protected]>

Add a tool for the generation of an IPE policy to be compiled into the kernel. This policy will be enforced until userland deploys and activates a new policy.

---
 MAINTAINERS                   |   6 ++
 scripts/Makefile              |   1 +
 scripts/ipe/Makefile          |   2 +
 scripts/ipe/polgen/.gitignore |   1 +
 scripts/ipe/polgen/Makefile   |   7 ++
 scripts/ipe/polgen/polgen.c   | 136 ++++++++++++++++++++++++++++++++++
 6 files changed, 153 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
MAINTAINERS +6 -0
index e64e5db31497..c9c630f539ef 100644
@@ -8474,6 +8474,12 @@ S:	Supported
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git
 F:	security/integrity/ima/
 
+INTEGRITY POLICY ENFORCEMENT (IPE)
+M:	Deven Bowers <[email protected]>
+L:	[email protected]
+S:	Supported
+F:	scripts/ipe/
+
 INTEL 810/815 FRAMEBUFFER DRIVER
 M:	Antonino Daplas <[email protected]>
 L:	[email protected]
scripts/Makefile +1 -0
index 95ecf970c74c..b3c1882fd6dd 100644
@@ -34,6 +34,7 @@ hostprogs += unifdef
 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 +1 -0
new file mode 100644
index 000000000000..80f32f25d200
@@ -0,0 +1 @@
+polgen
scripts/ipe/polgen/Makefile new file +7 -0
new file mode 100644
index 000000000000..a519b594e13c
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: GPL-2.0
+hostprogs-y	:= polgen
+HOST_EXTRACFLAGS += \
+	-I$(srctree)/include \
+	-I$(srctree)/include/uapi \
+
+always		:= $(hostprogs-y)
scripts/ipe/polgen/polgen.c new file +136 -0

136 lines not on this page · raw message

Signature · 1 line
2.26.0
#2 lore raw

RFC PATCH v3 2/12 security: add ipe lsm evaluation loop and audit system

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add the core logic of the IPE LSM, the evaluation loop (engine), a portion of the audit system, and the skeleton of the policy structure.

---
 MAINTAINERS                      |   1 +
 include/uapi/linux/audit.h       |   4 +
 security/Kconfig                 |  12 +-
 security/Makefile                |   2 +
 security/ipe/.gitignore          |   2 +
 security/ipe/Kconfig             |  43 +++++++
 security/ipe/Makefile            |  26 ++++
 security/ipe/ipe-audit.c         | 212 ++++++++++++++++++++++++++++++
 security/ipe/ipe-audit.h         |  18 +++
 security/ipe/ipe-engine.c        | 213 +++++++++++++++++++++++++++++++
 security/ipe/ipe-engine.h        |  37 ++++++
 security/ipe/ipe-hooks.c         | 149 +++++++++++++++++++++
 security/ipe/ipe-hooks.h         |  61 +++++++++
 security/ipe/ipe-policy.h        |  62 +++++++++
 security/ipe/ipe-prop-internal.h |  35 +++++
 security/ipe/ipe-property.c      | 112 ++++++++++++++++
 security/ipe/ipe-property.h      |  99 ++++++++++++++
 security/ipe/ipe-sysfs.c         | 114 +++++++++++++++++
 security/ipe/ipe-sysfs.h         |  14 ++
 security/ipe/ipe.c               |  62 +++++++++
 security/ipe/ipe.h               |  20 +++
 21 files changed, 1292 insertions(+), 6 deletions(-)
 create mode 100644 security/ipe/.gitignore
 create mode 100644 security/ipe/Kconfig
 create mode 100644 security/ipe/Makefile
 create mode 100644 security/ipe/ipe-audit.c
 create mode 100644 security/ipe/ipe-audit.h
 create mode 100644 security/ipe/ipe-engine.c
 create mode 100644 security/ipe/ipe-engine.h
 create mode 100644 security/ipe/ipe-hooks.c
 create mode 100644 security/ipe/ipe-hooks.h
 create mode 100644 security/ipe/ipe-policy.h
 create mode 100644 security/ipe/ipe-prop-internal.h
 create mode 100644 security/ipe/ipe-property.c
 create mode 100644 security/ipe/ipe-property.h
 create mode 100644 security/ipe/ipe-sysfs.c
 create mode 100644 security/ipe/ipe-sysfs.h
 create mode 100644 security/ipe/ipe.c
 create mode 100644 security/ipe/ipe.h
MAINTAINERS +1 -0
index c9c630f539ef..bed9aa201c39 100644
@@ -8479,6 +8479,7 @@ M:	Deven Bowers <[email protected]>
 L:	[email protected]
 S:	Supported
 F:	scripts/ipe/
+F:	security/ipe/
 
 INTEL 810/815 FRAMEBUFFER DRIVER
 M:	Antonino Daplas <[email protected]>
include/uapi/linux/audit.h +4 -0
index a534d71e689a..4e0122a0ed0c 100644
@@ -153,6 +153,10 @@
 #define AUDIT_INTEGRITY_RULE	    1805 /* policy rule */
 #define AUDIT_INTEGRITY_EVM_XATTR   1806 /* New EVM-covered xattr */
 #define AUDIT_INTEGRITY_POLICY_RULE 1807 /* IMA policy rules */
+#define AUDIT_INTEGRITY_POLICY_LOAD	1808 /* IPE Policy Load */
+#define AUDIT_INTEGRITY_POLICY_ACTIVATE	1809 /* IPE Policy Activation */
+#define AUDIT_INTEGRITY_EVENT		1810 /* IPE Evaluation Event */
+#define AUDIT_INTEGRITY_MODE		1811 /* IPE Mode Switch */
 
 #define AUDIT_KERNEL		2000	/* Asynchronous audit record. NOT A REQUEST. */
 
security/Kconfig +6 -6
index cd3cc7da3a55..94924556b637 100644
@@ -238,6 +238,7 @@ source "security/loadpin/Kconfig"
 source "security/yama/Kconfig"
 source "security/safesetid/Kconfig"
 source "security/lockdown/Kconfig"
+source "security/ipe/Kconfig"
 
 source "security/integrity/Kconfig"
 
@@ -277,11 +278,11 @@ endchoice
 
 config LSM
 	string "Ordered list of enabled LSMs"
-	default "lockdown,yama,loadpin,safesetid,integrity,smack,selinux,tomoyo,apparmor,bpf" if DEFAULT_SECURITY_SMACK
-	default "lockdown,yama,loadpin,safesetid,integrity,apparmor,selinux,smack,tomoyo,bpf" if DEFAULT_SECURITY_APPARMOR
-	default "lockdown,yama,loadpin,safesetid,integrity,tomoyo,bpf" if DEFAULT_SECURITY_TOMOYO
-	default "lockdown,yama,loadpin,safesetid,integrity,bpf" if DEFAULT_SECURITY_DAC
-	default "lockdown,yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor,bpf"
+	default "lockdown,yama,loadpin,ipe,safesetid,integrity,smack,selinux,tomoyo,apparmor,bpf" if DEFAULT_SECURITY_SMACK
+	default "lockdown,yama,loadpin,ipe,safesetid,integrity,apparmor,selinux,smack,tomoyo,bpf" if DEFAULT_SECURITY_APPARMOR
+	default "lockdown,yama,loadpin,ipe,safesetid,integrity,tomoyo,bpf" if DEFAULT_SECURITY_TOMOYO
+	default "lockdown,yama,loadpin,ipe,safesetid,integrity,bpf" if DEFAULT_SECURITY_DAC
+	default "lockdown,yama,loadpin,ipe,safesetid,integrity,selinux,smack,tomoyo,apparmor,bpf"
 	help
 	  A comma-separated list of LSMs, in initialization order.
 	  Any LSMs left off this list will be ignored. This can be
@@ -292,4 +293,3 @@ config LSM
 source "security/Kconfig.hardening"
 
 endmenu
-
security/Makefile +2 -0
index 22e73a3482bd..f2e1ae9ff64b 100644
@@ -13,6 +13,7 @@ subdir-$(CONFIG_SECURITY_LOADPIN)	+= loadpin
 subdir-$(CONFIG_SECURITY_SAFESETID)    += safesetid
 subdir-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown
 subdir-$(CONFIG_BPF_LSM)		+= bpf
+subdir-$(CONFIG_SECURITY_IPE)		+= ipe
 
 # always enable default capabilities
 obj-y					+= commoncap.o
@@ -30,6 +31,7 @@ obj-$(CONFIG_SECURITY_YAMA)		+= yama/
 obj-$(CONFIG_SECURITY_LOADPIN)		+= loadpin/
 obj-$(CONFIG_SECURITY_SAFESETID)       += safesetid/
 obj-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown/
+obj-$(CONFIG_SECURITY_IPE)		+= ipe/
 obj-$(CONFIG_CGROUP_DEVICE)		+= device_cgroup.o
 obj-$(CONFIG_BPF_LSM)			+= bpf/
 
security/ipe/.gitignore new file +2 -0
new file mode 100644
index 000000000000..bbf824e665d7
@@ -0,0 +1,2 @@
+# Generated Boot Policy
+ipe-bp.c
security/ipe/Kconfig new file +43 -0

43 lines not on this page · raw message

security/ipe/Makefile new file +26 -0
new file mode 100644
index 000000000000..aaa2e2c0b2f4
@@ -0,0 +1,26 @@
+# 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.
+#
+
+quiet_cmd_polgen  = IPE_POL $(patsubst "%",%,$(2))
+      cmd_polgen  = scripts/ipe/polgen/polgen security/ipe/ipe-bp.c $(2)
+
+$(eval $(call config_filename,SECURITY_IPE_BOOT_POLICY))
+
+targets += ipe-bp.c
+$(obj)/ipe-bp.c: scripts/ipe/polgen/polgen $(SECURITY_IPE_BOOT_POLICY_FILENAME) FORCE
+	$(call if_changed,polgen,$(SECURITY_IPE_BOOT_POLICY_FILENAME))
+
+obj-$(CONFIG_SECURITY_IPE) += \
+	ipe.o \
+	ipe-audit.o \
+	ipe-bp.o \
+	ipe-engine.o \
+	ipe-property.o \
+	ipe-hooks.o \
+	ipe-sysfs.o \
+
+clean-files := ipe-bp.c
security/ipe/ipe-audit.c new file +212 -0

212 lines not on this page · raw message

security/ipe/ipe-audit.h new file +18 -0
new file mode 100644
index 000000000000..c4fca5e2ab73
@@ -0,0 +1,18 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#include "ipe-engine.h"
+#include "ipe-policy.h"
+
+#ifndef IPE_AUDIT_H
+#define IPE_AUDIT_H
+
+void ipe_audit_mode(void);
+
+void ipe_audit_match(const struct ipe_engine_ctx *ctx,
+		     enum ipe_match match_type, enum ipe_action action,
+		     const struct ipe_rule *rule);
+
+#endif /* IPE_AUDIT_H */
security/ipe/ipe-engine.c new file +213 -0

213 lines not on this page · raw message

security/ipe/ipe-engine.h new file +37 -0
new file mode 100644
index 000000000000..d9a95674e70d
@@ -0,0 +1,37 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#include "ipe-hooks.h"
+
+#include <linux/types.h>
+#include <linux/rbtree.h>
+#include <linux/fs.h>
+
+#ifndef IPE_ENGINE_H
+#define IPE_ENGINE_H
+
+struct ipe_engine_ctx {
+	enum ipe_op op;
+	enum ipe_hook hook;
+	const struct file *file;
+	const char *audit_pathname;
+};
+
+struct ipe_prop_cache {
+	struct rb_node node;
+	void *storage;
+	const struct ipe_property *prop;
+};
+
+enum ipe_match {
+	ipe_match_rule = 0,
+	ipe_match_table,
+	ipe_match_global
+};
+
+int ipe_process_event(const struct file *file, enum ipe_op op,
+		      enum ipe_hook hook);
+
+#endif /* IPE_ENGINE_H */
security/ipe/ipe-hooks.c new file +149 -0

149 lines not on this page · raw message

security/ipe/ipe-hooks.h new file +61 -0

61 lines not on this page · raw message

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

62 lines not on this page · raw message

security/ipe/ipe-prop-internal.h new file +35 -0
new file mode 100644
index 000000000000..c26e6375bbba
@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#include "ipe-property.h"
+
+#include <linux/types.h>
+
+#ifndef IPE_PROPERTY_INTERNAL_H
+#define IPE_PROPERTY_INTERNAL_H
+
+#define IPE_PROPERTY_OPERATION	"op"
+#define IPE_PROPERTY_DEFAULT	"DEFAULT"
+#define IPE_PROPERTY_ACTION	"action"
+
+#define IPE_OP_EXECUTE		"EXECUTE"
+#define IPE_OP_FIRMWARE		"FIRMWARE"
+#define IPE_OP_KEXEC_IMAGE	"KEXEC_IMAGE"
+#define IPE_OP_KEXEC_INITRAMFS	"KEXEC_INITRAMFS"
+#define IPE_OP_X509_CERTIFICATE	"X509_CERT"
+#define IPE_OP_POLICY		"POLICY"
+#define IPE_OP_KMODULE		"KMODULE"
+#define IPE_OP_KERNEL_READ	"KERNEL_READ"
+
+struct ipe_prop_reg {
+	struct rb_node node;
+	const struct ipe_property *prop;
+};
+
+extern struct rb_root ipe_registry_root;
+
+const struct ipe_property *ipe_lookup_prop(const char *key);
+
+#endif /* IPE_PROPERTY_INTERNAL_H */
security/ipe/ipe-property.c new file +112 -0

112 lines not on this page · raw message

security/ipe/ipe-property.h new file +99 -0

99 lines not on this page · raw message

security/ipe/ipe-sysfs.c new file +114 -0

114 lines not on this page · raw message

security/ipe/ipe-sysfs.h new file +14 -0
new file mode 100644
index 000000000000..c1c3a8165867
@@ -0,0 +1,14 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+#include <linux/types.h>
+
+#include "ipe.h"
+
+#ifndef IPE_SYSFS_H
+#define IPE_SYSFS_H
+
+int __init ipe_sysctl_init(void);
+
+#endif /* IPE_SYSFS_H */
security/ipe/ipe.c new file +62 -0

62 lines not on this page · raw message

security/ipe/ipe.h new file +20 -0
new file mode 100644
index 000000000000..6a47f55b05d9
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef IPE_H
+#define IPE_H
+
+#define pr_fmt(fmt) "IPE " fmt "\n"
+
+#include <linux/types.h>
+#include <linux/fs.h>
+
+#define IPE_MODE_ENFORCE	"enforce"
+#define IPE_MODE_PERMISSIVE	"permissive"
+
+extern int ipe_enforce;
+extern int ipe_success_audit;
+
+#endif /* IPE_H */
Signature · 1 line
2.26.0
#3 lore raw

RFC PATCH v3 3/12 security: add ipe lsm policy parser and policy loading

In reply to [email protected]

From: Deven Bowers <[email protected]>

Adds the policy parser and the policy loading to IPE, along with the related sysfs, securityfs entries, and audit events.

---
 security/ipe/Kconfig             |   2 +-
 security/ipe/Makefile            |   3 +
 security/ipe/ipe-audit.c         |  87 ++-
 security/ipe/ipe-audit.h         |   8 +
 security/ipe/ipe-parse.c         | 904 +++++++++++++++++++++++++++++++
 security/ipe/ipe-parse.h         |  17 +
 security/ipe/ipe-policy.c        | 148 +++++
 security/ipe/ipe-policy.h        |  10 +
 security/ipe/ipe-prop-internal.h |   2 +
 security/ipe/ipe-secfs.c         | 799 +++++++++++++++++++++++++++
 security/ipe/ipe-secfs.h         |  16 +
 security/ipe/ipe-sysfs.c         |  92 ++++
 security/ipe/ipe.c               |   2 +
 security/ipe/ipe.h               |   1 +
 14 files changed, 2089 insertions(+), 2 deletions(-)
 create mode 100644 security/ipe/ipe-parse.c
 create mode 100644 security/ipe/ipe-parse.h
 create mode 100644 security/ipe/ipe-policy.c
 create mode 100644 security/ipe/ipe-secfs.c
 create mode 100644 security/ipe/ipe-secfs.h
security/ipe/Kconfig +1 -1
index f9b8292a88ed..83fce5dce847 100644
@@ -5,7 +5,7 @@
 
 menuconfig SECURITY_IPE
 	bool "Integrity Policy Enforcement (IPE)"
-	depends on SECURITY && AUDIT
+	depends on SECURITY && AUDIT && SECURITYFS
 	select SYSTEM_DATA_VERIFICATION
 	help
 	  This option enables the Integrity Policy Enforcement subsystem
security/ipe/Makefile +3 -0
index aaa2e2c0b2f4..4dcfc5b26b58 100644
@@ -19,8 +19,11 @@ obj-$(CONFIG_SECURITY_IPE) += \
 	ipe-audit.o \
 	ipe-bp.o \
 	ipe-engine.o \
+	ipe-parse.o \
+	ipe-policy.o \
 	ipe-property.o \
 	ipe-hooks.o \
+	ipe-secfs.o \
 	ipe-sysfs.o \
 
 clean-files := ipe-bp.c
security/ipe/ipe-audit.c +86 -1

96 lines not on this page · raw message

security/ipe/ipe-audit.h +8 -0
index c4fca5e2ab73..ca78a9578bf1 100644
@@ -3,6 +3,7 @@
  * Copyright (C) Microsoft Corporation. All rights reserved.
  */
 
+#include "ipe-prop-internal.h"
 #include "ipe-engine.h"
 #include "ipe-policy.h"
 
@@ -15,4 +16,11 @@ void ipe_audit_match(const struct ipe_engine_ctx *ctx,
 		     enum ipe_match match_type, enum ipe_action action,
 		     const struct ipe_rule *rule);
 
+void ipe_audit_policy_load(const struct ipe_policy *pol, const uint8_t *raw,
+			   size_t raw_size, struct crypto_shash *tfm);
+
+void ipe_audit_policy_activation(const struct ipe_policy *pol);
+
+void ipe_audit_unset_remap(enum ipe_op op);
+
 #endif /* IPE_AUDIT_H */
security/ipe/ipe-parse.c new file +904 -0

904 lines not on this page · raw message

security/ipe/ipe-parse.h new file +17 -0
new file mode 100644
index 000000000000..b1a9bbd97534
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#include "ipe-policy.h"
+
+#include <linux/types.h>
+
+#ifndef IPE_PARSE_H
+#define IPE_PARSE_H
+
+struct ipe_policy *ipe_parse_policy(char *policy);
+
+void ipe_free_policy(struct ipe_policy *pol);
+
+#endif /* IPE_AUDIT_H */
security/ipe/ipe-policy.c new file +148 -0

148 lines not on this page · raw message

security/ipe/ipe-policy.h +10 -0
index c0c9f2962c92..67c3cd82ee95 100644
@@ -59,4 +59,14 @@ struct ipe_policy {
 	struct ipe_rule_table ops[ipe_op_max - 1];
 };
 
+bool ipe_is_valid_policy(const struct ipe_policy *old,
+			 const struct ipe_policy *new);
+
+bool ipe_is_active_policy(const struct ipe_policy *policy);
+
+int ipe_update_active_policy(const struct ipe_policy *old,
+			     const struct ipe_policy *new);
+
+int ipe_activate_policy(const struct ipe_policy *policy);
+
 #endif /* IPE_POLICY_H */
security/ipe/ipe-prop-internal.h +2 -0
index c26e6375bbba..94ea87283172 100644
@@ -23,6 +23,8 @@
 #define IPE_OP_KMODULE		"KMODULE"
 #define IPE_OP_KERNEL_READ	"KERNEL_READ"
 
+#define IPE_UNKNOWN		"UNKNOWN"
+
 struct ipe_prop_reg {
 	struct rb_node node;
 	const struct ipe_property *prop;
security/ipe/ipe-secfs.c new file +799 -0

799 lines not on this page · raw message

security/ipe/ipe-secfs.h new file +16 -0
new file mode 100644
index 000000000000..147f7801b5e6
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+#include <linux/types.h>
+
+#include "ipe-policy.h"
+
+#ifndef IPE_SECFS_H
+#define IPE_SECFS_H
+
+extern struct mutex ipe_policy_lock;
+
+int ipe_set_active_policy(const char *id, size_t id_len);
+
+#endif /* IPE_SECFS_H */
security/ipe/ipe-sysfs.c +92 -0

110 lines not on this page · raw message

security/ipe/ipe.c +2 -0
index b6553e370f98..07f855ffb79a 100644
@@ -6,6 +6,7 @@
 #include "ipe.h"
 #include "ipe-policy.h"
 #include "ipe-hooks.h"
+#include "ipe-secfs.h"
 #include "ipe-sysfs.h"
 
 #include <linux/module.h>
@@ -60,3 +61,4 @@ DEFINE_LSM(ipe) = {
 
 int ipe_enforce = 1;
 int ipe_success_audit;
+int ipe_strict_parse;
security/ipe/ipe.h +1 -0
index 6a47f55b05d9..bf6cf7744b0e 100644
@@ -16,5 +16,6 @@
 
 extern int ipe_enforce;
 extern int ipe_success_audit;
+extern int ipe_strict_parse;
 
 #endif /* IPE_H */
Signature · 1 line
2.26.0
#4 lore raw

Re: [RFC PATCH v3 03/12] security: add ipe lsm policy parser and policy loading

Quoted 7 lines · On 2020-04-15 09:25:41, [email protected] wrote:

From: Deven Bowers <[email protected]>

Adds the policy parser and the policy loading to IPE, along with the related sysfs, securityfs entries, and audit events.

---

...

Quoted 35 lines
security/ipe/ipe-sysfs.c +20 -0
index 1c65185c531d..a250da29c3b5 100644
@@ -5,6 +5,7 @@
 
 #include "ipe.h"
 #include "ipe-audit.h"
+#include "ipe-secfs.h"
 
 #include <linux/sysctl.h>
 #include <linux/fs.h>
@@ -45,6 +46,79 @@ static int ipe_switch_mode(struct ctl_table *table, int write,
 
 #endif /* CONFIG_SECURITY_IPE_PERMISSIVE_SWITCH */
 
+#ifdef CONFIG_SECURITYFS
+
+/**
+ * ipe_switch_active_policy: Handler to switch the policy IPE is enforcing.
+ * @table: Sysctl table entry from the variable, sysctl_table.
+ * @write: Integer indicating whether this is a write or a read.
+ * @buffer: Data passed to sysctl. This is the policy id to activate,
+ *	    for this function.
+ * @lenp: Pointer to the size of @buffer.
+ * @ppos: Offset into @buffer.
+ *
+ * This wraps proc_dointvec_minmax, and if there's a change, emits an
+ * audit event.
+ *
+ * Return:
+ * 0 - OK
+ * -ENOMEM - Out of memory
+ * -ENOENT - Policy identified by @id does not exist
+ * Other - See proc_dostring and retrieve_backed_dentry

security/ipe/ipe-sysfs.c static int ipe_switch_mode(struct ctl_table *table, int write, · line 77

Quoted 10 lines
security/ipe/ipe-sysfs.c +10 -0
+ */
+static int ipe_switch_active_policy(struct ctl_table *table, int write,
+				    void __user *buffer, size_t *lenp,
+				    loff_t *ppos)
+{
+	int rc = 0;
+	char *id = NULL;
+	size_t size = 0;
+
+	if (write) {

I see that the policy files in securityfs, such as new_policy, are checking for CAP_MAC_ADMIN but there's no check here for CAP_MAC_ADMIN when switching the active policy. I think we should enforce that cap here, too.

Thinking about it some more, I find it a little odd that we're spreading the files necessary to update a policy across both procfs (sysctl) and securityfs. It looks like procfs will have different semantics than securityfs after looking at proc_sys_permission(). I suggest moving strict_parse and active_policy under securityfs for a unified experience and common location when updating policy.

Tyler

Quoted 102 lines
security/ipe/ipe-sysfs.c +62 -0
+		id = kzalloc((*lenp) + 1, GFP_KERNEL);
+		if (!id)
+			return -ENOMEM;
+
+		table->data = id;
+		table->maxlen = (*lenp) + 1;
+
+		rc = proc_dostring(table, write, buffer, lenp, ppos);
+		if (rc != 0)
+			goto out;
+
+		rc = ipe_set_active_policy(id, strlen(id));
+	} else {
+		if (!rcu_access_pointer(ipe_active_policy)) {
+			table->data = "";
+			table->maxlen = 1;
+			return proc_dostring(table, write, buffer, lenp, ppos);
+		}
+
+		rcu_read_lock();
+		size = strlen(rcu_dereference(ipe_active_policy)->policy_name);
+		rcu_read_unlock();
+
+		id = kzalloc(size + 1, GFP_KERNEL);
+		if (!id)
+			return -ENOMEM;
+
+		rcu_read_lock();
+		strncpy(id, rcu_dereference(ipe_active_policy)->policy_name,
+			size);
+		rcu_read_unlock();
+
+		table->data = id;
+		table->maxlen = size;
+
+		rc = proc_dostring(table, write, buffer, lenp, ppos);
+	}
+out:
+	kfree(id);
+	return rc;
+}
+
+#endif /* CONFIG_SECURITYFS */
+
 static struct ctl_table_header *sysctl_header;
 
 static const struct ctl_path sysctl_path[] = {
@@ -75,6 +149,24 @@ static struct ctl_table sysctl_table[] = {
 		.extra1 = SYSCTL_ZERO,
 		.extra2 = SYSCTL_ONE,
 	},
+#ifdef CONFIG_SECURITYFS
+	{
+		.procname = "strict_parse",
+		.data = &ipe_strict_parse,
+		.maxlen = sizeof(int),
+		.mode = 0644,
+		.proc_handler = proc_dointvec_minmax,
+		.extra1 = SYSCTL_ZERO,
+		.extra2 = SYSCTL_ONE,
+	},
+	{
+		.procname = "active_policy",
+		.data = NULL,
+		.maxlen = 0,
+		.mode = 0644,
+		.proc_handler = ipe_switch_active_policy,
+	},
+#endif /* CONFIG_SECURITYFS */
 	{}
 };
 
security/ipe/ipe.c +2 -0
index b6553e370f98..07f855ffb79a 100644
@@ -6,6 +6,7 @@
 #include "ipe.h"
 #include "ipe-policy.h"
 #include "ipe-hooks.h"
+#include "ipe-secfs.h"
 #include "ipe-sysfs.h"
 
 #include <linux/module.h>
@@ -60,3 +61,4 @@ DEFINE_LSM(ipe) = {
 
 int ipe_enforce = 1;
 int ipe_success_audit;
+int ipe_strict_parse;
security/ipe/ipe.h +1 -0
index 6a47f55b05d9..bf6cf7744b0e 100644
@@ -16,5 +16,6 @@
 
 extern int ipe_enforce;
 extern int ipe_success_audit;
+extern int ipe_strict_parse;
 
 #endif /* IPE_H */
Signature · 1 line
2.26.0
#5 lore raw

RFC PATCH v3 4/12 ipe: add property for trust of boot volume

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add a property for IPE policy to express trust of the first superblock where a file would be evaluated to determine trust.

---
 security/ipe/Kconfig                    |  2 +
 security/ipe/Makefile                   |  4 ++
 security/ipe/ipe-engine.c               |  4 ++
 security/ipe/ipe-hooks.c                | 19 +++++
 security/ipe/ipe-hooks.h                |  2 +
 security/ipe/ipe-pin.c                  | 93 +++++++++++++++++++++++++
 security/ipe/ipe-pin.h                  | 56 +++++++++++++++
 security/ipe/ipe.c                      | 24 +++++++
 security/ipe/properties/Kconfig         | 14 ++++
 security/ipe/properties/Makefile        | 11 +++
 security/ipe/properties/boot-verified.c | 81 +++++++++++++++++++++
 security/ipe/properties/prop-entry.h    | 20 ++++++
 security/ipe/utility.h                  | 22 ++++++
 13 files changed, 352 insertions(+)
 create mode 100644 security/ipe/ipe-pin.c
 create mode 100644 security/ipe/ipe-pin.h
 create mode 100644 security/ipe/properties/Kconfig
 create mode 100644 security/ipe/properties/Makefile
 create mode 100644 security/ipe/properties/boot-verified.c
 create mode 100644 security/ipe/properties/prop-entry.h
 create mode 100644 security/ipe/utility.h
security/ipe/Kconfig +2 -0
index 83fce5dce847..8f23176bef24 100644
@@ -40,4 +40,6 @@ config SECURITY_IPE_PERMISSIVE_SWITCH
 
 	  If unsure, answer Y.
 
+source "security/ipe/properties/Kconfig"
+
 endif
security/ipe/Makefile +4 -0
index 4dcfc5b26b58..741914ddc338 100644
@@ -27,3 +27,7 @@ obj-$(CONFIG_SECURITY_IPE) += \
 	ipe-sysfs.o \
 
 clean-files := ipe-bp.c
+
+obj-$(CONFIG_IPE_BOOT_PROP) += ipe-pin.o
+
+obj-$(CONFIG_SECURITY_IPE) += properties/
security/ipe/ipe-engine.c +4 -0
index c79f422245c6..2eab680587ce 100644
@@ -9,6 +9,8 @@
 #include "ipe-policy.h"
 #include "ipe-engine.h"
 #include "ipe-audit.h"
+#include "ipe-pin.h"
+#include "utility.h"
 
 #include <linux/types.h>
 #include <linux/fs.h>
@@ -205,6 +207,8 @@ int ipe_process_event(const struct file *file, enum ipe_op op,
 	if (IS_ERR(ctx))
 		goto cleanup;
 
+	ipe_pin_superblock(ctx->file);
+
 	rc = evaluate(ctx);
 
 cleanup:
security/ipe/ipe-hooks.c +19 -0
index 071c4af23a3d..45efe022be04 100644
@@ -6,6 +6,7 @@
 #include "ipe.h"
 #include "ipe-hooks.h"
 #include "ipe-engine.h"
+#include "ipe-pin.h"
 
 #include <linux/types.h>
 #include <linux/fs.h>
@@ -147,3 +148,21 @@ int ipe_on_kernel_load_data(enum kernel_load_data_id id)
 					 ipe_hook_kernel_load);
 	}
 }
+
+/**
+ * ipe_sb_free_security: LSM hook called on sb_free_security.
+ * @mnt_sb: Super block that is being freed.
+ *
+ * IPE does not currently utilize the super block security hook,
+ * it utilizes this hook to invalidate the saved super block for
+ * the boot_verified property.
+ *
+ * For more information, see the LSM hook, sb_free_security.
+ *
+ * Return:
+ * 0 - OK
+ */
+void ipe_sb_free_security(struct super_block *mnt_sb)
+{
+	ipe_invalidate_pinned_sb(mnt_sb);
+}
security/ipe/ipe-hooks.h +2 -0
index 806659b7cdbe..5e46726f2562 100644
@@ -58,4 +58,6 @@ int ipe_on_kernel_read(struct file *file, enum kernel_read_file_id id);
 
 int ipe_on_kernel_load_data(enum kernel_load_data_id id);
 
+void ipe_sb_free_security(struct super_block *mnt_sb);
+
 #endif /* IPE_HOOK_H */
security/ipe/ipe-pin.c new file +93 -0

93 lines not on this page · raw message

security/ipe/ipe-pin.h new file +56 -0

56 lines not on this page · raw message

security/ipe/ipe.c +24 -0
index 07f855ffb79a..c23d90126cc6 100644
@@ -8,6 +8,7 @@
 #include "ipe-hooks.h"
 #include "ipe-secfs.h"
 #include "ipe-sysfs.h"
+#include "properties/prop-entry.h"
 
 #include <linux/module.h>
 #include <linux/lsm_hooks.h>
@@ -23,8 +24,27 @@ static struct security_hook_list ipe_hooks[] __lsm_ro_after_init = {
 	LSM_HOOK_INIT(kernel_read_file, ipe_on_kernel_read),
 	LSM_HOOK_INIT(kernel_load_data, ipe_on_kernel_load_data),
 	LSM_HOOK_INIT(file_mprotect, ipe_on_mprotect),
+	LSM_HOOK_INIT(sb_free_security, ipe_sb_free_security),
 };
 
+/**
+ * ipe_load_properties: Call the property entry points for all the IPE modules
+ *			that were selected at kernel build-time.
+ *
+ * Return:
+ * 0 - OK
+ */
+static int __init ipe_load_properties(void)
+{
+	int rc = 0;
+
+	rc = ipe_init_bootv();
+	if (rc != 0)
+		return rc;
+
+	return rc;
+}
+
 /**
  * ipe_init: Entry point of IPE.
  *
@@ -42,6 +62,10 @@ static int __init ipe_init(void)
 {
 	int rc;
 
+	rc = ipe_load_properties();
+	if (rc != 0)
+		panic("IPE: properties failed to load");
+
 	rc = ipe_sysctl_init();
 	if (rc != 0)
 		pr_err("failed to configure sysctl: %d", -rc);
security/ipe/properties/Kconfig new file +14 -0
new file mode 100644
index 000000000000..9dc0db8817b2
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: GPL-2.0-only
+#
+# Integrity Policy Enforcement (IPE) configuration
+#
+
+config IPE_BOOT_PROP
+	bool "Enable trust for boot volume"
+	help
+	  This option enables the property "boot_verified" in IPE policy.
+	  This property 'pins' the initial superblock when something is
+	  evaluated. This property will evaluate to true when the file
+	  being evaluated originates from the initial superblock.
+
+	  if unsure, answer N.
security/ipe/properties/Makefile new file +11 -0
new file mode 100644
index 000000000000..e3e7fe17cf58
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (C) Microsoft Corporation. All rights reserved.
+#
+# Makefile for building the properties that IPE uses
+# as part of the kernel tree.
+#
+
+obj-$(CONFIG_SECURITY_IPE) += properties.o
+
+properties-$(CONFIG_IPE_BOOT_PROP) += boot-verified.o
security/ipe/properties/boot-verified.c new file +81 -0

81 lines not on this page · raw message

security/ipe/properties/prop-entry.h new file +20 -0
new file mode 100644
index 000000000000..f598dd9608b9
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#include <linux/types.h>
+
+#ifndef IPE_PROP_ENTRY_H
+#define IPE_PROP_ENTRY_H
+
+#ifndef CONFIG_IPE_BOOT_PROP
+static inline int __init ipe_init_bootv(void)
+{
+	return 0;
+}
+#else
+int __init ipe_init_bootv(void);
+#endif /* CONFIG_IPE_BOOT_PROP */
+
+#endif /* IPE_PROP_ENTRY_H */
security/ipe/utility.h new file +22 -0
new file mode 100644
index 000000000000..a13089bb0d8f
@@ -0,0 +1,22 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+
+#ifndef IPE_UTILITY_H
+#define IPE_UTILITY_H
+
+#include <linux/types.h>
+#include <linux/fs.h>
+
+static inline bool has_mount(const struct file *file)
+{
+	return file && file->f_path.mnt;
+}
+
+static inline bool has_sb(const struct file *file)
+{
+	return has_mount(file) && file->f_path.mnt->mnt_sb;
+}
+
+#endif /* IPE_UTILITY_H */
Signature · 1 line
2.26.0
#6 lore raw

RFC PATCH v3 5/12 fs: add security blob and hooks for block_device

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add a security blob and associated allocation, deallocation and set hooks for a block_device structure.

---
 fs/block_dev.c                |  8 +++++
 include/linux/fs.h            |  1 +
 include/linux/lsm_hook_defs.h |  5 +++
 include/linux/lsm_hooks.h     | 11 +++++++
 include/linux/security.h      | 22 +++++++++++++
 security/security.c           | 61 +++++++++++++++++++++++++++++++++++
 6 files changed, 108 insertions(+)
fs/block_dev.c +8 -0
index 52b6f646cdbd..5dfa25f03208 100644
@@ -35,6 +35,7 @@
 #include <linux/falloc.h>
 #include <linux/uaccess.h>
 #include <linux/suspend.h>
+#include <linux/security.h>
 #include "internal.h"
 
 struct bdev_inode {
@@ -773,11 +774,18 @@ static struct inode *bdev_alloc_inode(struct super_block *sb)
 	struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
 	if (!ei)
 		return NULL;
+
+	if (unlikely(security_bdev_alloc(&ei->bdev))) {
+		kmem_cache_free(bdev_cachep, ei);
+		return NULL;
+	}
+
 	return &ei->vfs_inode;
 }
 
 static void bdev_free_inode(struct inode *inode)
 {
+	security_bdev_free(&BDEV_I(inode)->bdev);
 	kmem_cache_free(bdev_cachep, BDEV_I(inode));
 }
 
include/linux/fs.h +1 -0
index 4f6f59b4f22a..9ed0060c5a91 100644
@@ -506,6 +506,7 @@ struct block_device {
 	int			bd_fsfreeze_count;
 	/* Mutex for freeze */
 	struct mutex		bd_fsfreeze_mutex;
+	void			*security;
 } __randomize_layout;
 
 /* XArray tags, for tagging dirty and writeback pages in the pagecache. */
include/linux/lsm_hook_defs.h +5 -0
index 9cd4455528e5..4782fef7eaf9 100644
@@ -379,3 +379,8 @@ LSM_HOOK(void, LSM_RET_VOID, perf_event_free, struct perf_event *event)
 LSM_HOOK(int, 0, perf_event_read, struct perf_event *event)
 LSM_HOOK(int, 0, perf_event_write, struct perf_event *event)
 #endif /* CONFIG_PERF_EVENTS */
+
+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 +11 -0
index 988ca0df7824..7bf0f82bc5d6 100644
@@ -1476,6 +1476,16 @@
  *
  *     @what: kernel feature being accessed
  *
+ * @bdev_alloc_security:
+ *	Initialize the security field inside a block_device structure.
+ *
+ * @bdev_free_security:
+ *	Cleanup the security information stored inside a block_device structure.
+ *
+ * @bdev_setsecurity:
+ *	Set the security property associated with @name for @bdev with
+ *	value @value. @size indicates the size of the @value in bytes.
+ *
  * Security hooks for perf events
  *
  * @perf_event_open:
@@ -1522,6 +1532,7 @@ struct lsm_blob_sizes {
 	int	lbs_ipc;
 	int	lbs_msg_msg;
 	int	lbs_task;
+	int	lbs_bdev;
 };
 
 /*
include/linux/security.h +22 -0
index a8d9310472df..714eecc82e08 100644
@@ -446,6 +446,11 @@ int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen);
 int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
 int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
 int security_locked_down(enum lockdown_reason what);
+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)
@@ -1273,6 +1278,23 @@ static inline int security_locked_down(enum lockdown_reason what)
 {
 	return 0;
 }
+
+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 */
 
 #ifdef CONFIG_SECURITY_NETWORK
security/security.c +61 -0

91 lines not on this page · raw message

Signature · 1 line
2.26.0
maintainer
#7 lore raw

Re: [RFC PATCH v3 05/12] fs: add security blob and hooks for block_device

Quoted 6 lines · On Wed, 15 Apr 2020, [email protected] wrote:

From: Deven Bowers <[email protected]>

Add a security blob and associated allocation, deallocation and set hooks for a block_device structure.

Is there any feedback from block or LSM folk on the addition of a security blob for block_device here?

IPE uses this is to track the status of integrity verification of e.g. DM-Verity devices, per this code from a subsequent patch:

+ ret = security_bdev_setsecurity(dm_table_get_md(v->ti->table)->bdev,
+ DM_VERITY_SIGNATURE_SEC_NAME,
+ v->sig->sig, v->sig->sig_size);

Signature · 2 lines
James Morris
<[email protected]>
#8 lore raw

Re: [RFC PATCH v3 05/12] fs: add security blob and hooks for block_device

Quoted 10 lines · James Morris
Quoted 6 lines · On Wed, 15 Apr 2020, [email protected] wrote:

From: Deven Bowers <[email protected]>

Add a security blob and associated allocation, deallocation and set hooks for a block_device structure.

Is there any feedback from block or LSM folk on the addition of a security blob for block_device here?

The addition of a blob looks to have been done correctly. As for it's use, I haven't had the chance to review the patches that use it. I didn't see a patch that implements the hooks in a LSM, but that could just be me.

Quoted 10 lines

IPE uses this is to track the status of integrity verification of e.g. DM-Verity devices, per this code from a subsequent patch:

(quoted diff) +3 -0
+       ret = security_bdev_setsecurity(dm_table_get_md(v->ti->table)->bdev,
+                                       DM_VERITY_SIGNATURE_SEC_NAME,
+                                       v->sig->sig, v->sig->sig_size);
#9 lore raw

RFC PATCH v3 6/12 dm-verity: move signature check after tree validation

In reply to [email protected]

From: Deven Bowers <[email protected]>

The CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG introduced by Jaskaran was intended to be used to allow an LSM to enforce verifications for all dm-verity volumes.

However, with it's current implementation, this signature verification occurs after the merkel-tree is validated, as a result the signature can pass initial verification by passing a matching root-hash and signature. This results in an unreadable block_device, but that has passed signature validation (and subsequently, would be marked as verified).

This change moves the signature verification to after the merkel-tree has finished validation.

---
 drivers/md/dm-verity-target.c     |  42 ++++-----
 drivers/md/dm-verity-verify-sig.c | 140 ++++++++++++++++++++++--------
 drivers/md/dm-verity-verify-sig.h |  20 ++---
 drivers/md/dm-verity.h            |   2 +-
 4 files changed, 132 insertions(+), 72 deletions(-)
drivers/md/dm-verity-target.c +18 -24
index eec9f252e935..c507f3a4e237 100644
@@ -471,9 +471,9 @@ static int verity_verify_io(struct dm_verity_io *io)
 	struct bvec_iter start;
 	unsigned b;
 	struct crypto_wait wait;
+	int r;
 
 	for (b = 0; b < io->n_blocks; b++) {
-		int r;
 		sector_t cur_block = io->block + b;
 		struct ahash_request *req = verity_io_hash_req(v, io);
 
@@ -530,6 +530,16 @@ static int verity_verify_io(struct dm_verity_io *io)
 			return -EIO;
 	}
 
+	/*
+	 * At this point, the merkel tree has finished validating.
+	 * if signature was specified, validate the signature here.
+	 */
+	r = verity_verify_root_hash(v);
+	if (r < 0) {
+		DMERR_LIMIT("signature mismatch");
+		return r;
+	}
+
 	return 0;
 }
 
@@ -728,7 +738,7 @@ static void verity_status(struct dm_target *ti, status_type_t type,
 			args++;
 		if (v->validated_blocks)
 			args++;
-		if (v->signature_key_desc)
+		if (v->sig)
 			args += DM_VERITY_ROOT_HASH_VERIFICATION_OPTS;
 		if (!args)
 			return;
@@ -751,9 +761,9 @@ static void verity_status(struct dm_target *ti, status_type_t type,
 		if (v->validated_blocks)
 			DMEMIT(" " DM_VERITY_OPT_AT_MOST_ONCE);
 		sz = verity_fec_status_table(v, sz, result, maxlen);
-		if (v->signature_key_desc)
+		if (v->sig)
 			DMEMIT(" " DM_VERITY_ROOT_HASH_VERIFICATION_OPT_SIG_KEY
-				" %s", v->signature_key_desc);
+				" %s", v->sig->signature_key_desc);
 		break;
 	}
 }
@@ -819,7 +829,7 @@ static void verity_dtr(struct dm_target *ti)
 
 	verity_fec_dtr(v);
 
-	kfree(v->signature_key_desc);
+	verity_verify_dtr(v);
 
 	kfree(v);
 }
@@ -876,8 +886,7 @@ static int verity_alloc_zero_digest(struct dm_verity *v)
 	return r;
 }
 
-static int verity_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v,
-				 struct dm_verity_sig_opts *verify_args)
+static int verity_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v)
 {
 	int r;
 	unsigned argc;
@@ -927,9 +936,7 @@ static int verity_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v,
 				return r;
 			continue;
 		} else if (verity_verify_is_sig_opt_arg(arg_name)) {
-			r = verity_verify_sig_parse_opt_args(as, v,
-							     verify_args,
-							     &argc, arg_name);
+			r = verity_verify_sig_parse_opt_args(as, v, &argc);
 			if (r)
 				return r;
 			continue;
@@ -960,7 +967,6 @@ static int verity_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v,
 static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv)
 {
 	struct dm_verity *v;
-	struct dm_verity_sig_opts verify_args = {0};
 	struct dm_arg_set as;
 	unsigned int num;
 	unsigned long long num_ll;
@@ -1128,20 +1134,11 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv)
 		as.argc = argc;
 		as.argv = argv;
 
-		r = verity_parse_opt_args(&as, v, &verify_args);
+		r = verity_parse_opt_args(&as, v);
 		if (r < 0)
 			goto bad;
 	}
 
-	/* Root hash signature is  a optional parameter*/
-	r = verity_verify_root_hash(root_hash_digest_to_validate,
-				    strlen(root_hash_digest_to_validate),
-				    verify_args.sig,
-				    verify_args.sig_size);
-	if (r < 0) {
-		ti->error = "Root hash verification failed";
-		goto bad;
-	}
 	v->hash_per_block_bits =
 		__fls((1 << v->hash_dev_block_bits) / v->digest_size);
 
@@ -1207,13 +1204,10 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv)
 	ti->per_io_data_size = roundup(ti->per_io_data_size,
 				       __alignof__(struct dm_verity_io));
 
-	verity_verify_sig_opts_cleanup(&verify_args);
-
 	return 0;
 
 bad:
 
-	verity_verify_sig_opts_cleanup(&verify_args);
 	verity_dtr(ti);
 
 	return r;
drivers/md/dm-verity-verify-sig.c +104 -36

201 lines not on this page · raw message

drivers/md/dm-verity-verify-sig.h +9 -11
index 19b1547aa741..81158d7702a3 100644
@@ -11,31 +11,30 @@
 #define DM_VERITY_ROOT_HASH_VERIFICATION "DM Verity Sig Verification"
 #define DM_VERITY_ROOT_HASH_VERIFICATION_OPT_SIG_KEY "root_hash_sig_key_desc"
 
-struct dm_verity_sig_opts {
+struct dm_verity_sig {
+	char *signature_key_desc;
 	unsigned int sig_size;
 	u8 *sig;
+	bool passed;
 };
 
 #ifdef CONFIG_DM_VERITY_VERIFY_ROOTHASH_SIG
 
 #define DM_VERITY_ROOT_HASH_VERIFICATION_OPTS 2
 
-int verity_verify_root_hash(const void *data, size_t data_len,
-			    const void *sig_data, size_t sig_len);
+int verity_verify_root_hash(const struct dm_verity *v);
 bool verity_verify_is_sig_opt_arg(const char *arg_name);
 
 int verity_verify_sig_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v,
-				    struct dm_verity_sig_opts *sig_opts,
-				    unsigned int *argc, const char *arg_name);
+				    unsigned int *argc);
 
-void verity_verify_sig_opts_cleanup(struct dm_verity_sig_opts *sig_opts);
+void verity_verify_dtr(struct dm_verity *v);
 
 #else
 
 #define DM_VERITY_ROOT_HASH_VERIFICATION_OPTS 0
 
-int verity_verify_root_hash(const void *data, size_t data_len,
-			    const void *sig_data, size_t sig_len)
+int verity_verify_root_hash(const struct dm_verity *v)
 {
 	return 0;
 }
@@ -46,13 +45,12 @@ bool verity_verify_is_sig_opt_arg(const char *arg_name)
 }
 
 int verity_verify_sig_parse_opt_args(struct dm_arg_set *as, struct dm_verity *v,
-				    struct dm_verity_sig_opts *sig_opts,
-				    unsigned int *argc, const char *arg_name)
+				    unsigned int *argc)
 {
 	return -EINVAL;
 }
 
-void verity_verify_sig_opts_cleanup(struct dm_verity_sig_opts *sig_opts)
+void verity_verify_dtr(struct dm_verity *v)
 {
 }
 
drivers/md/dm-verity.h +1 -1
index 641b9e3a399b..995c495decad 100644
@@ -64,7 +64,7 @@ struct dm_verity {
 	struct dm_verity_fec *fec;	/* forward error correction */
 	unsigned long *validated_blocks; /* bitset blocks validated */
 
-	char *signature_key_desc; /* signature keyring reference */
+	struct dm_verity_sig *sig; /* signature verification */
 };
 
 struct dm_verity_io {
Signature · 1 line
2.26.0
#10 lore raw

RFC PATCH v3 7/12 dm-verity: add bdev_setsecurity hook for dm-verity signature

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add a security hook call to set a security property of a block_device in dm-verity with the results of a verified, signed root-hash.

---
 drivers/md/dm-verity-verify-sig.c | 7 +++++++
 include/linux/device-mapper.h     | 2 ++
 2 files changed, 9 insertions(+)
drivers/md/dm-verity-verify-sig.c +7 -0
index 27dac8aa2e5a..242e2421d3c8 100644
@@ -8,7 +8,10 @@
 #include <linux/device-mapper.h>
 #include <linux/verification.h>
 #include <keys/user-type.h>
+#include <linux/security.h>
+#include <linux/list.h>
 #include <linux/module.h>
+#include "dm-core.h"
 #include "dm-verity.h"
 #include "dm-verity-verify-sig.h"
 
@@ -182,6 +185,10 @@ int verity_verify_root_hash(const struct dm_verity *v)
 		goto cleanup;
 
 	sig_target->passed = true;
+
+	ret = security_bdev_setsecurity(dm_table_get_md(v->ti->table)->bdev,
+					DM_VERITY_SIGNATURE_SEC_NAME,
+					v->sig->sig, v->sig->sig_size);
 cleanup:
 	kfree(root_hash);
 	return ret;
include/linux/device-mapper.h +2 -0
index af48d9da3916..61c26443783c 100644
@@ -627,4 +627,6 @@ static inline unsigned long to_bytes(sector_t n)
 	return (n << SECTOR_SHIFT);
 }
 
+#define DM_VERITY_SIGNATURE_SEC_NAME DM_NAME	".verity-sig"
+
 #endif	/* _LINUX_DEVICE_MAPPER_H */
Signature · 1 line
2.26.0
#11 lore raw

RFC PATCH v3 8/12 ipe: add property for signed dmverity volumes

In reply to [email protected]

From: Deven Bowers <[email protected]>

Allow IPE to leverage the stacked security blob infrastructure, and enlighten IPE to the block_device security blob.

This allows IPE to have a property to express rules around a device-mapper verity volume whose root-hash has been signed, and the signature has been verified against the system keyring. This is property is also added in this patch.

---
 security/ipe/Kconfig                         |  2 +-
 security/ipe/Makefile                        |  1 +
 security/ipe/ipe-blobs.c                     | 80 +++++++++++++++++++
 security/ipe/ipe-blobs.h                     | 18 +++++
 security/ipe/ipe-engine.c                    |  4 +
 security/ipe/ipe-engine.h                    |  9 +++
 security/ipe/ipe-hooks.c                     |  1 +
 security/ipe/ipe-hooks.h                     | 43 +++++++++++
 security/ipe/ipe.c                           | 18 +++++
 security/ipe/ipe.h                           |  2 +
 security/ipe/properties/Kconfig              | 10 +++
 security/ipe/properties/Makefile             |  1 +
 security/ipe/properties/dmverity-signature.c | 81 ++++++++++++++++++++
 security/ipe/properties/prop-entry.h         |  9 +++
 security/ipe/utility.h                       | 10 +++
 15 files changed, 288 insertions(+), 1 deletion(-)
 create mode 100644 security/ipe/ipe-blobs.c
 create mode 100644 security/ipe/ipe-blobs.h
 create mode 100644 security/ipe/properties/dmverity-signature.c
security/ipe/Kconfig +1 -1
index 8f23176bef24..8b8685381439 100644
@@ -5,7 +5,7 @@
 
 menuconfig SECURITY_IPE
 	bool "Integrity Policy Enforcement (IPE)"
-	depends on SECURITY && AUDIT && SECURITYFS
+	depends on SECURITY && AUDIT && SECURITYFS && BLOCK
 	select SYSTEM_DATA_VERIFICATION
 	help
 	  This option enables the Integrity Policy Enforcement subsystem
security/ipe/Makefile +1 -0
index 741914ddc338..615797f4cd38 100644
@@ -25,6 +25,7 @@ obj-$(CONFIG_SECURITY_IPE) += \
 	ipe-hooks.o \
 	ipe-secfs.o \
 	ipe-sysfs.o \
+	ipe-blobs.o \
 
 clean-files := ipe-bp.c
 
security/ipe/ipe-blobs.c new file +80 -0

80 lines not on this page · raw message

security/ipe/ipe-blobs.h new file +18 -0
new file mode 100644
index 000000000000..7561f4cef558
@@ -0,0 +1,18 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+#include <linux/types.h>
+#include <linux/fs.h>
+
+#include "ipe.h"
+
+#ifndef IPE_BLOB_H
+#define IPE_BLOB_H
+
+static inline struct ipe_bdev_blob *ipe_bdev(struct block_device *bdev)
+{
+	return bdev->security + ipe_blobs.lbs_bdev;
+}
+
+#endif /* IPE_BLOB_H */
security/ipe/ipe-engine.c +4 -0
index 2eab680587ce..5785e51e8630 100644
@@ -10,6 +10,7 @@
 #include "ipe-engine.h"
 #include "ipe-audit.h"
 #include "ipe-pin.h"
+#include "ipe-blobs.h"
 #include "utility.h"
 
 #include <linux/types.h>
@@ -116,6 +117,9 @@ static struct ipe_engine_ctx *build_ctx(const struct file *file,
 	local->op = op;
 	local->hook = hook;
 
+	if (has_bdev(file))
+		local->sec_bdev = ipe_bdev(bdev(file));
+
 	return local;
 }
 
security/ipe/ipe-engine.h +9 -0
index d9a95674e70d..038c39a8973e 100644
@@ -3,20 +3,29 @@
  * Copyright (C) Microsoft Corporation. All rights reserved.
  */
 
+#include "ipe.h"
 #include "ipe-hooks.h"
 
 #include <linux/types.h>
 #include <linux/rbtree.h>
 #include <linux/fs.h>
 
+#include <crypto/pkcs7.h>
+
 #ifndef IPE_ENGINE_H
 #define IPE_ENGINE_H
 
+struct ipe_bdev_blob {
+	u8	*dmverity_rh_sig;
+	size_t	dmv_rh_sig_len;
+};
+
 struct ipe_engine_ctx {
 	enum ipe_op op;
 	enum ipe_hook hook;
 	const struct file *file;
 	const char *audit_pathname;
+	const struct ipe_bdev_blob *sec_bdev;
 };
 
 struct ipe_prop_cache {
security/ipe/ipe-hooks.c +1 -0
index 45efe022be04..18ab2dcd74d1 100644
@@ -15,6 +15,7 @@
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/security.h>
+#include <linux/device-mapper.h>
 
 /**
  * ipe_on_exec: LSM hook called on the exec family of system calls.
security/ipe/ipe-hooks.h +43 -0

47 lines not on this page · raw message

security/ipe/ipe.c +18 -0
index c23d90126cc6..eceecb9423bd 100644
@@ -25,6 +25,9 @@ static struct security_hook_list ipe_hooks[] __lsm_ro_after_init = {
 	LSM_HOOK_INIT(kernel_load_data, ipe_on_kernel_load_data),
 	LSM_HOOK_INIT(file_mprotect, ipe_on_mprotect),
 	LSM_HOOK_INIT(sb_free_security, ipe_sb_free_security),
+	LSM_HOOK_INIT(bdev_alloc_security, ipe_bdev_alloc_security),
+	LSM_HOOK_INIT(bdev_free_security, ipe_bdev_free_security),
+	LSM_HOOK_INIT(bdev_setsecurity, ipe_bdev_setsecurity),
 };
 
 /**
@@ -42,6 +45,10 @@ static int __init ipe_load_properties(void)
 	if (rc != 0)
 		return rc;
 
+	rc = ipe_init_dm_verity_signature();
+	if (rc != 0)
+		return rc;
+
 	return rc;
 }
 
@@ -78,9 +85,20 @@ static int __init ipe_init(void)
 	return rc;
 }
 
+struct lsm_blob_sizes ipe_blobs = {
+	.lbs_cred = 0,
+	.lbs_file = 0,
+	.lbs_inode = 0,
+	.lbs_ipc = 0,
+	.lbs_msg_msg = 0,
+	.lbs_task = 0,
+	.lbs_bdev = sizeof(struct ipe_bdev_blob),
+};
+
 DEFINE_LSM(ipe) = {
 	.name = "ipe",
 	.init = ipe_init,
+	.blobs = &ipe_blobs,
 };
 
 int ipe_enforce = 1;
security/ipe/ipe.h +2 -0
index bf6cf7744b0e..0fbd079e6804 100644
@@ -10,10 +10,12 @@
 
 #include <linux/types.h>
 #include <linux/fs.h>
+#include <linux/lsm_hooks.h>
 
 #define IPE_MODE_ENFORCE	"enforce"
 #define IPE_MODE_PERMISSIVE	"permissive"
 
+extern struct lsm_blob_sizes ipe_blobs;
 extern int ipe_enforce;
 extern int ipe_success_audit;
 extern int ipe_strict_parse;
security/ipe/properties/Kconfig +10 -0
index 9dc0db8817b2..2d8866ee456e 100644
@@ -12,3 +12,13 @@ config IPE_BOOT_PROP
 	  being evaluated originates from the initial superblock.
 
 	  if unsure, answer N.
+
+config IPE_DM_VERITY_SIGNATURE
+	bool "Enable property for signature verified dm-verity volumes"
+	depends on DM_VERITY_VERIFY_ROOTHASH_SIG
+	help
+	  This option enables IPE's integration with Device-Mapper Verity's
+	  signed root-hashes. This enables the usage of the property,
+	  "dmverity_signature" in IPE's policy.
+
+	  if unsure, answer Y.
security/ipe/properties/Makefile +1 -0
index e3e7fe17cf58..6b67cbe36e31 100644
@@ -9,3 +9,4 @@
 obj-$(CONFIG_SECURITY_IPE) += properties.o
 
 properties-$(CONFIG_IPE_BOOT_PROP) += boot-verified.o
+properties-$(CONFIG_IPE_DM_VERITY_SIGNATURE) += dmverity-signature.o
security/ipe/properties/dmverity-signature.c new file +81 -0

81 lines not on this page · raw message

security/ipe/properties/prop-entry.h +9 -0
index f598dd9608b9..85366366ff0d 100644
@@ -17,4 +17,13 @@ static inline int __init ipe_init_bootv(void)
 int __init ipe_init_bootv(void);
 #endif /* CONFIG_IPE_BOOT_PROP */
 
+#ifndef CONFIG_IPE_DM_VERITY_SIGNATURE
+static inline int __init ipe_init_dm_verity_signature(void)
+{
+	return 0;
+}
+#else
+int __init ipe_init_dm_verity_signature(void);
+#endif /* CONFIG_IPE_DM_VERITY_SIGNATURE */
+
 #endif /* IPE_PROP_ENTRY_H */
security/ipe/utility.h +10 -0
index a13089bb0d8f..7580f17274a3 100644
@@ -19,4 +19,14 @@ static inline bool has_sb(const struct file *file)
 	return has_mount(file) && file->f_path.mnt->mnt_sb;
 }
 
+static inline bool has_bdev(const struct file *file)
+{
+	return has_sb(file) && file->f_path.mnt->mnt_sb->s_bdev;
+}
+
+static inline struct block_device *bdev(const struct file *file)
+{
+	return file->f_path.mnt->mnt_sb->s_bdev;
+}
+
 #endif /* IPE_UTILITY_H */
Signature · 1 line
2.26.0
#12 lore raw

RFC PATCH v3 9/12 dm-verity: add bdev_setsecurity hook for root-hash

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add a security hook call to set a security property of a block_device in dm-verity with the root-hash that was verified to match the merkel-tree.

---
 drivers/md/dm-verity-target.c | 8 ++++++++
 include/linux/device-mapper.h | 1 +
 2 files changed, 9 insertions(+)
drivers/md/dm-verity-target.c +8 -0
index c507f3a4e237..225f67ab378d 100644
@@ -16,8 +16,10 @@
 #include "dm-verity.h"
 #include "dm-verity-fec.h"
 #include "dm-verity-verify-sig.h"
+#include "dm-core.h"
 #include <linux/module.h>
 #include <linux/reboot.h>
+#include <linux/security.h>
 
 #define DM_MSG_PREFIX			"verity"
 
@@ -530,6 +532,12 @@ static int verity_verify_io(struct dm_verity_io *io)
 			return -EIO;
 	}
 
+	r = security_bdev_setsecurity(dm_table_get_md(v->ti->table)->bdev,
+				      DM_VERITY_ROOTHASH_SEC_NAME,
+				      v->root_digest, v->digest_size);
+	if (unlikely(r < 0))
+		return r;
+
 	/*
 	 * At this point, the merkel tree has finished validating.
 	 * if signature was specified, validate the signature here.
include/linux/device-mapper.h +1 -0
index 61c26443783c..0c274546c515 100644
@@ -628,5 +628,6 @@ static inline unsigned long to_bytes(sector_t n)
 }
 
 #define DM_VERITY_SIGNATURE_SEC_NAME DM_NAME	".verity-sig"
+#define DM_VERITY_ROOTHASH_SEC_NAME DM_NAME	".verity-rh"
 
 #endif	/* _LINUX_DEVICE_MAPPER_H */
Signature · 1 line
2.26.0
#13 lore raw

RFC PATCH v3 10/12 ipe: add property for dmverity roothash

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add a property to allow IPE policy to express rules around a specific root-hash of a dm-verity volume.

This can be used for revocation, (when combined with the previous dm-verity property) or the authorization of a single dm-verity volume.

---
 security/ipe/ipe-blobs.c                    |  10 ++
 security/ipe/ipe-engine.h                   |   3 +
 security/ipe/ipe.c                          |   4 +
 security/ipe/properties/Kconfig             |  13 +-
 security/ipe/properties/Makefile            |   1 +
 security/ipe/properties/dmverity-roothash.c | 152 ++++++++++++++++++++
 security/ipe/properties/prop-entry.h        |   9 ++
 7 files changed, 191 insertions(+), 1 deletion(-)
 create mode 100644 security/ipe/properties/dmverity-roothash.c
security/ipe/ipe-blobs.c +10 -0
index a4ee8df02855..1e054eb13857 100644
@@ -45,6 +45,8 @@ void ipe_bdev_free_security(struct block_device *bdev)
 {
 	struct ipe_bdev_blob *bdev_sec = ipe_bdev(bdev);
 
+	kfree(bdev_sec->dmverity_rh);
+
 	memset(bdev_sec, 0x0, sizeof(*bdev_sec));
 }
 
@@ -76,5 +78,13 @@ int ipe_bdev_setsecurity(struct block_device *bdev, const char *key,
 		bdev_sec->dmv_rh_sig_len = len;
 	}
 
+	if (!strcmp(key, DM_VERITY_ROOTHASH_SEC_NAME)) {
+		bdev_sec->dmverity_rh = kmemdup(value, len, GFP_KERNEL);
+		if (!bdev_sec->dmverity_rh)
+			return -ENOMEM;
+
+		bdev_sec->rh_size = len;
+	}
+
 	return 0;
 }
security/ipe/ipe-engine.h +3 -0
index 038c39a8973e..696baaa423ff 100644
@@ -18,6 +18,9 @@
 struct ipe_bdev_blob {
 	u8	*dmverity_rh_sig;
 	size_t	dmv_rh_sig_len;
+
+	u8 *dmverity_rh;
+	size_t rh_size;
 };
 
 struct ipe_engine_ctx {
security/ipe/ipe.c +4 -0
index eceecb9423bd..b85e6a3ffff5 100644
@@ -49,6 +49,10 @@ static int __init ipe_load_properties(void)
 	if (rc != 0)
 		return rc;
 
+	rc = ipe_init_dm_verity_rh();
+	if (rc != 0)
+		return rc;
+
 	return rc;
 }
 
security/ipe/properties/Kconfig +12 -1
index 2d8866ee456e..57b97b2b3877 100644
@@ -13,8 +13,19 @@ config IPE_BOOT_PROP
 
 	  if unsure, answer N.
 
+config IPE_DM_VERITY_ROOTHASH
+	bool "Enable property for authorizing dm-verity volumes via root-hash"
+	depends on DM_VERITY
+	help
+	  This option enables IPE's integration with Device-Mapper Verity.
+	  This enables the usage of the property "dmverity_roothash" in IPE's
+	  policy. This property allows authorization or revocation via a
+	  a hex-string representing the roothash of a dmverity volume.
+
+	  if unsure, answer Y.
+
 config IPE_DM_VERITY_SIGNATURE
-	bool "Enable property for signature verified dm-verity volumes"
+	bool "Enable property for verified dm-verity volumes"
 	depends on DM_VERITY_VERIFY_ROOTHASH_SIG
 	help
 	  This option enables IPE's integration with Device-Mapper Verity's
security/ipe/properties/Makefile +1 -0
index 6b67cbe36e31..d9a3807797f4 100644
@@ -10,3 +10,4 @@ obj-$(CONFIG_SECURITY_IPE) += properties.o
 
 properties-$(CONFIG_IPE_BOOT_PROP) += boot-verified.o
 properties-$(CONFIG_IPE_DM_VERITY_SIGNATURE) += dmverity-signature.o
+properties-$(CONFIG_IPE_DM_VERITY_ROOTHASH) += dmverity-roothash.o
security/ipe/properties/dmverity-roothash.c new file +152 -0

152 lines not on this page · raw message

security/ipe/properties/prop-entry.h +9 -0
index 85366366ff0d..86a360570f3b 100644
@@ -26,4 +26,13 @@ static inline int __init ipe_init_dm_verity_signature(void)
 int __init ipe_init_dm_verity_signature(void);
 #endif /* CONFIG_IPE_DM_VERITY_SIGNATURE */
 
+#ifndef CONFIG_IPE_DM_VERITY_ROOTHASH
+static inline int __init ipe_init_dm_verity_rh(void)
+{
+	return 0;
+}
+#else
+int __init ipe_init_dm_verity_rh(void);
+#endif /* CONFIG_IPE_DM_VERITY_ROOTHASH */
+
 #endif /* IPE_PROP_ENTRY_H */
Signature · 1 line
2.26.0
#14 lore raw

RFC PATCH v3 11/12 documentation: add ipe documentation

In reply to [email protected]

From: Deven Bowers <[email protected]>

Add IPE's documentation to the kernel tree.

---
 Documentation/admin-guide/LSM/index.rst |   1 +
 Documentation/admin-guide/LSM/ipe.rst   | 467 ++++++++++++++++++++++++
 MAINTAINERS                             |   1 +
 3 files changed, 469 insertions(+)
 create mode 100644 Documentation/admin-guide/LSM/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 +467 -0

467 lines not on this page · raw message

MAINTAINERS +1 -0
index bed9aa201c39..cf46928faffb 100644
@@ -8478,6 +8478,7 @@ INTEGRITY POLICY ENFORCEMENT (IPE)
 M:	Deven Bowers <[email protected]>
 L:	[email protected]
 S:	Supported
+F:	Documentation/admin-guide/LSM/ipe.rst
 F:	scripts/ipe/
 F:	security/ipe/
 
Signature · 1 line
2.26.0
#15 lore raw

RFC PATCH v3 12/12 cleanup: uapi/linux/audit.h

In reply to [email protected]

From: Deven Bowers <[email protected]>

Remove trailing whitespaces and align the integrity #defines in linux/uapi/audit.h

---
 include/uapi/linux/audit.h | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)
include/uapi/linux/audit.h +16 -16
index 4e0122a0ed0c..d642ade068b5 100644
@@ -48,7 +48,7 @@
  * 2500 - 2999 future user space (maybe integrity labels and related events)
  *
  * Messages from 1000-1199 are bi-directional. 1200-1299 & 2100 - 2999 are
- * exclusively user space. 1300-2099 is kernel --> user space 
+ * exclusively user space. 1300-2099 is kernel --> user space
  * communication.
  */
 #define AUDIT_GET		1000	/* Get status */
@@ -78,7 +78,7 @@
 #define AUDIT_LAST_USER_MSG	1199
 #define AUDIT_FIRST_USER_MSG2	2100	/* More user space messages */
 #define AUDIT_LAST_USER_MSG2	2999
- 
+
 #define AUDIT_DAEMON_START      1200    /* Daemon startup record */
 #define AUDIT_DAEMON_END        1201    /* Daemon normal stop record */
 #define AUDIT_DAEMON_ABORT      1202    /* Daemon error stop record */
@@ -139,20 +139,20 @@
 #define AUDIT_MAC_CALIPSO_ADD	1418	/* NetLabel: add CALIPSO DOI entry */
 #define AUDIT_MAC_CALIPSO_DEL	1419	/* NetLabel: del CALIPSO DOI entry */
 
-#define AUDIT_FIRST_KERN_ANOM_MSG   1700
-#define AUDIT_LAST_KERN_ANOM_MSG    1799
-#define AUDIT_ANOM_PROMISCUOUS      1700 /* Device changed promiscuous mode */
-#define AUDIT_ANOM_ABEND            1701 /* Process ended abnormally */
-#define AUDIT_ANOM_LINK		    1702 /* Suspicious use of file links */
-#define AUDIT_ANOM_CREAT	    1703 /* Suspicious file creation */
-#define AUDIT_INTEGRITY_DATA	    1800 /* Data integrity verification */
-#define AUDIT_INTEGRITY_METADATA    1801 /* Metadata integrity verification */
-#define AUDIT_INTEGRITY_STATUS	    1802 /* Integrity enable status */
-#define AUDIT_INTEGRITY_HASH	    1803 /* Integrity HASH type */
-#define AUDIT_INTEGRITY_PCR	    1804 /* PCR invalidation msgs */
-#define AUDIT_INTEGRITY_RULE	    1805 /* policy rule */
-#define AUDIT_INTEGRITY_EVM_XATTR   1806 /* New EVM-covered xattr */
-#define AUDIT_INTEGRITY_POLICY_RULE 1807 /* IMA policy rules */
+#define AUDIT_FIRST_KERN_ANOM_MSG	1700
+#define AUDIT_LAST_KERN_ANOM_MSG	1799
+#define AUDIT_ANOM_PROMISCUOUS		1700 /* Device changed promiscuous mode */
+#define AUDIT_ANOM_ABEND		1701 /* Process ended abnormally */
+#define AUDIT_ANOM_LINK			1702 /* Suspicious use of file links */
+#define AUDIT_ANOM_CREAT		1703 /* Suspicious file creation */
+#define AUDIT_INTEGRITY_DATA		1800 /* Data integrity verification */
+#define AUDIT_INTEGRITY_METADATA	1801 /* Metadata integrity verification */
+#define AUDIT_INTEGRITY_STATUS		1802 /* Integrity enable status */
+#define AUDIT_INTEGRITY_HASH		1803 /* Integrity HASH type */
+#define AUDIT_INTEGRITY_PCR		1804 /* PCR invalidation msgs */
+#define AUDIT_INTEGRITY_RULE		1805 /* policy rule */
+#define AUDIT_INTEGRITY_EVM_XATTR	1806 /* New EVM-covered xattr */
+#define AUDIT_INTEGRITY_POLICY_RULE	1807 /* IMA policy rules */
 #define AUDIT_INTEGRITY_POLICY_LOAD	1808 /* IPE Policy Load */
 #define AUDIT_INTEGRITY_POLICY_ACTIVATE	1809 /* IPE Policy Activation */
 #define AUDIT_INTEGRITY_EVENT		1810 /* IPE Evaluation Event */
Signature · 1 line
2.26.0
#16 lore raw
In reply to [email protected]
Quoted 94 lines · On 15/04/2020 18:25, [email protected] wrote:

From: Deven Bowers <[email protected]>

Overview:
------------------------------------

IPE is a Linux Security Module which allows for a configurable policy to enforce integrity requirements on the whole system. It attempts to solve the issue of Code Integrity: that any code being executed (or files being read), are identical to the version that was built by a trusted source.

The type of system for which IPE is designed for use is an embedded device with a specific purpose (e.g. network firewall device in a data center), where all software and configuration is built and provisioned by the owner.

Specifically, a system which leverages IPE is not intended for general purpose computing and does not utilize any software or configuration built by a third party. An ideal system to leverage IPE has both mutable and immutable components, however, all binary executable code is immutable.

The scope of IPE is constrained to the OS. It is assumed that platform firmware verifies the the kernel and optionally the root filesystem (e.g. via U-Boot verified boot). IPE then utilizes LSM hooks to enforce a flexible, kernel-resident integrity verification policy.

IPE differs from other LSMs which provide integrity checking (for instance, IMA), as it has no dependency on the filesystem metadata itself. The attributes that IPE checks are deterministic properties that exist solely in the kernel. Additionally, IPE provides no additional mechanisms of verifying these files (e.g. IMA Signatures) - all of the attributes of verifying files are existing features within the kernel, such as dm-verity or fsverity.

IPE provides a policy that allows owners of the system to easily specify integrity requirements and uses dm-verity signatures to simplify the authentication of allowed objects like authorized code and data.

IPE supports two modes, permissive (similar to SELinux's permissive mode) and enforce. Permissive mode performs the same checks, and logs policy violations as enforce mode, but will not enforce the policy. This allows users to test policies before enforcing them.

The default mode is enforce, and can be changed via the kernel commandline parameter ipe.enforce=(0|1), or the sysctl ipe.enforce=(0|1). The ability to switch modes can be compiled out of the LSM via setting the config CONFIG_SECURITY_IPE_PERMISSIVE_SWITCH to N.

IPE additionally supports success auditing. When enabled, all events that pass IPE policy and are not blocked will emit an audit event. This is disabled by default, and can be enabled via the kernel commandline ipe.success_audit=(0|1) or the sysctl ipe.success_audit=(0|1).

Policies can be staged at runtime through securityfs and activated through sysfs. Please see the Deploying Policies section of this cover letter for more information.

The IPE LSM is compiled under CONFIG_SECURITY_IPE.

Policy:
------------------------------------

IPE policy is designed to be both forward compatible and backwards compatible. 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 (NOT the policy syntax version). 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 properties: "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 will allow any execution. 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. Available properties for IPE described in the properties section of this cover-letter, the repository available in Appendix A, and the kernel documentation page.

Order does not matter for the rule's properties - they can be listed in any order, however it is encouraged to have the "op" property be first, and the "action" property be last, for readability.

Additionally, 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.

Quoted 5 lines

IPE policy is designed to be forward compatible and backwards compatible, thus any failure to parse a rule will result in the line being ignored, and a warning being emitted. If backwards compatibility is not required, the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current kernel ABI. This could be done with a securityfs file listing the current policy grammar.

#17 lore raw

On 5/10/2020 2:28 AM, Mickaël Salaün wrote:

[...snip]

Quoted 11 lines
Quoted 10 lines

Additionally, 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.

IPE policy is designed to be forward compatible and backwards compatible, thus any failure to parse a rule will result in the line being ignored, and a warning being emitted. If backwards compatibility is not required, the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Quoted 6 lines

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current kernel ABI. This could be done with a securityfs file listing the current policy grammar.

That's a fair point. From a manual perspective, I think this is fine. A human-user can interpret a grammar successfully on their own when new syntax is introduced.

From a producing API perspective, I'd have to think about it a bit more. Ideally, the grammar would be structured in such a way that the userland interpreter of this grammar would not have to be updated once new syntax
is introduced, avoiding the need to update the userland binary. To do so
generically ("op=%s") is easy, but doesn't necessarily convey sufficient
information (what happens when a new "op" token is introduced?). I think
this may come down to regular expression representations of valid values
for these tokens, which worries me as regular expressions are incredibly
error-prone[1].

I'll see what I can come up with regarding this.

[1] https://blog.cloudflare.com/details-of-the-cloudflare-outage-on-july-2-2019/

#18 lore raw
Quoted 38 lines · Deven Bowers

On 5/10/2020 2:28 AM, Mickaël Salaün wrote:

[...snip]

Quoted 11 lines
Quoted 10 lines

Additionally, 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.

IPE policy is designed to be forward compatible and backwards compatible, thus any failure to parse a rule will result in the line being ignored, and a warning being emitted. If backwards compatibility is not required, the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Quoted 6 lines

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current kernel ABI. This could be done with a securityfs file listing the current policy grammar.

That's a fair point. From a manual perspective, I think this is fine. A human-user can interpret a grammar successfully on their own when new syntax is introduced.

From a producing API perspective, I'd have to think about it a bit
more. Ideally, the grammar would be structured in such a way that the userland interpreter of this grammar would not have to be updated once new syntax is introduced, avoiding the need to update the userland binary. To do so generically ("op=%s") is easy, but doesn't necessarily convey sufficient information (what happens when a new "op" token is introduced?). I think this may come down to regular expression representations of valid values for these tokens, which worries me as regular expressions are incredibly error-prone[1].

Quoted 1 line

I'll see what I can come up with regarding this.

I have not found a way that I like to expose some kind of grammar through securityfs that can be understood by usermode to parse the policy. Here's what I propose as a compromise:

1. I remove the unknown command behavior. This address your
first point about inconsistent behaviors, and effectively removes the strict_parse sysctl (as it is always enabled).

2. I introduce a versioning system for the properties
themselves. The valid set of properties and their versions can be found in securityfs, under say, ipe/config in a key=value format where key indicates the understood token, and value indicates their current version. For example:

	$ cat $SECURITYFS/ipe/config
	op=1
	action=1
	policy_name=1
	policy_version=1
	dmverity_signature=1
	dmverity_roothash=1
	boot_verified=1

if new syntax is introduced, the version number is increased.

3. The format of those versions are documented as part of
the admin-guide around IPE. If user-mode at that point wants to rip the documentation formats and correlate with the versioning, then it fulfills the same functionality as above, with out the complexity around exposing a parsing grammar and interpreting it on-the-fly. Many of these are unlikely to move past version 1, however.

Thoughts?

#19 lore raw
Quoted 62 lines · Deven Bowers
Quoted 43 lines · Deven Bowers

On 5/10/2020 2:28 AM, Mickaël Salaün wrote:

[...snip]

Quoted 15 lines
Quoted 7 lines

Additionally, 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.

Quoted 7 lines

IPE policy is designed to be forward compatible and backwards compatible,
thus any failure to parse a rule will result in the line being ignored, and a warning being emitted. If backwards compatibility is not required,
the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Quoted 6 lines

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current kernel ABI. This could be done with a securityfs file listing the current policy grammar.

That's a fair point. From a manual perspective, I think this is fine. A human-user can interpret a grammar successfully on their own when new syntax is introduced.

 From a producing API perspective, I'd have to think about it a bit more. Ideally, the grammar would be structured in such a way that the userland
interpreter of this grammar would not have to be updated once new syntax is introduced, avoiding the need to update the userland binary. To do so generically ("op=%s") is easy, but doesn't necessarily convey sufficient information (what happens when a new "op" token is introduced?). I think this may come down to regular expression representations of valid values for these tokens, which worries me as regular expressions are incredibly error-prone[1].

Quoted 1 line

I'll see what I can come up with regarding this.

I have not found a way that I like to expose some kind of grammar through securityfs that can be understood by usermode to parse the policy. Here's what I propose as a compromise:

    1. I remove the unknown command behavior. This address your first point about inconsistent behaviors, and effectively removes the strict_parse sysctl (as it is always enabled).

    2. I introduce a versioning system for the properties themselves. The valid set of properties and their versions can be found in securityfs, under say, ipe/config in a key=value format where key indicates the understood token, and value indicates their current version. For example:

Quoted 8 lines
    $ cat $SECURITYFS/ipe/config
    op=1
    action=1
    policy_name=1
    policy_version=1
    dmverity_signature=1
    dmverity_roothash=1
    boot_verified=1

The name ipe/config sounds like a file to configure IPE. Maybe something like ipe/config_abi or ipe/config_grammar?

Quoted 12 lines

if new syntax is introduced, the version number is increased.

    3. The format of those versions are documented as part of the admin-guide around IPE. If user-mode at that point wants to rip the documentation formats and correlate with the versioning, then it fulfills the same functionality as above, with out the complexity around exposing a parsing grammar and interpreting it on-the-fly. Many of these are unlikely to move past version 1, however.

Thoughts?

That seems reasonable.

#20 lore raw

Hello Mickael,

Quoted 86 lines · Mickaël Salaün
Quoted 62 lines · Deven Bowers
Quoted 43 lines · Deven Bowers

On 5/10/2020 2:28 AM, Mickaël Salaün wrote:

[...snip]

Quoted 15 lines
Quoted 7 lines

Additionally, 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.

Quoted 7 lines

IPE policy is designed to be forward compatible and backwards compatible,
thus any failure to parse a rule will result in the line being ignored, and a warning being emitted. If backwards compatibility is not required,
the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Quoted 6 lines

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current kernel ABI. This could be done with a securityfs file listing the current policy grammar.

That's a fair point. From a manual perspective, I think this is fine. A human-user can interpret a grammar successfully on their own when new syntax is introduced.

 From a producing API perspective, I'd have to think about it a bit more. Ideally, the grammar would be structured in such a way that the userland
interpreter of this grammar would not have to be updated once new syntax is introduced, avoiding the need to update the userland binary. To do so generically ("op=%s") is easy, but doesn't necessarily convey sufficient information (what happens when a new "op" token is introduced?). I think this may come down to regular expression representations of valid values for these tokens, which worries me as regular expressions are incredibly error-prone[1].

Quoted 1 line

I'll see what I can come up with regarding this.

I have not found a way that I like to expose some kind of grammar through securityfs that can be understood by usermode to parse the policy. Here's what I propose as a compromise:

    1. I remove the unknown command behavior. This address your first point about inconsistent behaviors, and effectively removes the strict_parse sysctl (as it is always enabled).

    2. I introduce a versioning system for the properties themselves. The valid set of properties and their versions can be found in securityfs, under say, ipe/config in a key=value format where key indicates the understood token, and value indicates their current version. For example:

Quoted 8 lines
    $ cat $SECURITYFS/ipe/config
    op=1
    action=1
    policy_name=1
    policy_version=1
    dmverity_signature=1
    dmverity_roothash=1
    boot_verified=1

The name ipe/config sounds like a file to configure IPE. Maybe something like ipe/config_abi or ipe/config_grammar?

Quoted 10 lines

if new syntax is introduced, the version number is increased.

    3. The format of those versions are documented as part of the admin-guide around IPE. If user-mode at that point wants to rip the documentation formats and correlate with the versioning, then it fulfills the same functionality as above, with out the complexity around exposing a parsing grammar and interpreting it on-the-fly. Many of these are unlikely to move past version 1, however.

Quoted 5 lines
Quoted 2 lines

Thoughts?

That seems reasonable.

There is a use case for not having strict parsing in the cloud world where there are multiple versions of OS deployed across a large number of systems say 100,000 nodes. An OS update can take weeks to complete across all the nodes, and we end up having a heterogeneous mix of OS versions.

Without non-strict parsing, to fix an issue in a policy we will need to update the various versions of the policy (one each for all OS versions
which have different IPE policy schema). We will lose the agility we need to fix and deploy something urgently in the policy, the nodes might be failing some critical workloads meanwhile. All the various versions of the policy will need to be changed and production signed then deployed etc. Further some versions might introduce newer issues and we will need to see what all versions of the policy have that bug.

I propose keeping the non-strict option as well to cater to this use case. Let me know your thoughts on this.

Regards,
JK

#21 lore raw

Hello Mickael,

Could you please share your thoughts for the below proposal.

Regards,
JK

Quoted 109 lines · Jaskaran Singh Khurana

Hello Mickael,

Quoted 88 lines · Mickaël Salaün
Quoted 64 lines · Deven Bowers
Quoted 45 lines · Deven Bowers

On 5/10/2020 2:28 AM, Mickaël Salaün wrote:

[...snip]

Quoted 16 lines
Quoted 7 lines

Additionally, 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.

Quoted 8 lines

IPE policy is designed to be forward compatible and backwards compatible,
thus any failure to parse a rule will result in the line being ignored,
and a warning being emitted. If backwards compatibility is not required,
the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Quoted 7 lines

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current
kernel ABI. This could be done with a securityfs file listing the current policy grammar.

That's a fair point. From a manual perspective, I think this is fine. A human-user can interpret a grammar successfully on their own when new syntax is introduced.

 From a producing API perspective, I'd have to think about it a bit more. Ideally, the grammar would be structured in such a way that the userland
interpreter of this grammar would not have to be updated once new syntax is introduced, avoiding the need to update the userland binary. To do so generically ("op=%s") is easy, but doesn't necessarily convey sufficient information (what happens when a new "op" token is introduced?). I think this may come down to regular expression representations of valid values for these tokens, which worries me as regular expressions are incredibly error-prone[1].

Quoted 1 line

I'll see what I can come up with regarding this.

I have not found a way that I like to expose some kind of grammar through securityfs that can be understood by usermode to parse the policy. Here's what I propose as a compromise:

    1. I remove the unknown command behavior. This address your first point about inconsistent behaviors, and effectively removes the strict_parse sysctl (as it is always enabled).

    2. I introduce a versioning system for the properties themselves. The valid set of properties and their versions can be found in securityfs, under say, ipe/config in a key=value format where key indicates the understood token, and value indicates their current version. For example:

Quoted 8 lines
     $ cat $SECURITYFS/ipe/config
     op=1
     action=1
     policy_name=1
     policy_version=1
     dmverity_signature=1
     dmverity_roothash=1
     boot_verified=1

The name ipe/config sounds like a file to configure IPE. Maybe something like ipe/config_abi or ipe/config_grammar?

Quoted 10 lines

if new syntax is introduced, the version number is increased.

    3. The format of those versions are documented as part of the admin-guide around IPE. If user-mode at that point wants to rip the documentation formats and correlate with the versioning, then it fulfills the same functionality as above, with out the complexity around exposing a parsing grammar and interpreting it on-the-fly. Many of these are unlikely to move past version 1, however.

Quoted 5 lines
Quoted 2 lines

Thoughts?

That seems reasonable.

There is a use case for not having strict parsing in the cloud world where there are multiple versions of OS deployed across a large number of systems say 100,000 nodes. An OS update can take weeks to complete across all the nodes, and we end up having a heterogeneous mix of OS versions.

Without non-strict parsing, to fix an issue in a policy we will need to update the various versions of the policy (one each for all OS versions
which have different IPE policy schema). We will lose the agility we need to fix and deploy something urgently in the policy, the nodes might be failing some critical workloads meanwhile. All the various versions of the policy will need to be changed and production signed then deployed etc. Further some versions might introduce newer issues and we will need to see what all versions of the policy have that bug.

I propose keeping the non-strict option as well to cater to this use case. Let me know your thoughts on this.

Regards,
JK

#22 lore raw
In reply to Jaskaran Singh Khurana

Hi Jaskaran,

Quoted 111 lines · Jaskaran Singh Khurana

Hello Mickael,

Quoted 94 lines · Mickaël Salaün
Quoted 70 lines · Deven Bowers
Quoted 51 lines · Deven Bowers

On 5/10/2020 2:28 AM, Mickaël Salaün wrote:

[...snip]

Quoted 16 lines
Quoted 7 lines

Additionally, 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.

Quoted 8 lines

IPE policy is designed to be forward compatible and backwards compatible,
thus any failure to parse a rule will result in the line being ignored,
and a warning being emitted. If backwards compatibility is not required,
the kernel commandline parameter and sysctl, ipe.strict_parse can be enabled, which will cause these warnings to be fatal.

Quoted 7 lines

Ignoring unknown command may lead to inconsistent beaviors. To achieve forward compatibility, I think it would be better to never ignore unknown rule but to give a way to userspace to known what is the current
kernel ABI. This could be done with a securityfs file listing the current policy grammar.

That's a fair point. From a manual perspective, I think this is fine. A human-user can interpret a grammar successfully on their own when new syntax is introduced.

 From a producing API perspective, I'd have to think about it a bit more. Ideally, the grammar would be structured in such a way that the userland
interpreter of this grammar would not have to be updated once new syntax
is introduced, avoiding the need to update the userland binary. To do so
generically ("op=%s") is easy, but doesn't necessarily convey sufficient
information (what happens when a new "op" token is introduced?). I think
this may come down to regular expression representations of valid values
for these tokens, which worries me as regular expressions are incredibly
error-prone[1].

Quoted 1 line

I'll see what I can come up with regarding this.

I have not found a way that I like to expose some kind of grammar through securityfs that can be understood by usermode to parse the policy. Here's what I propose as a compromise:

    1. I remove the unknown command behavior. This address your first point about inconsistent behaviors, and effectively removes the strict_parse sysctl (as it is always enabled).

    2. I introduce a versioning system for the properties themselves. The valid set of properties and their versions can be found in securityfs, under say, ipe/config in a key=value format where key indicates the understood token, and value indicates their current version. For example:

Quoted 8 lines
    $ cat $SECURITYFS/ipe/config
    op=1
    action=1
    policy_name=1
    policy_version=1
    dmverity_signature=1
    dmverity_roothash=1
    boot_verified=1

The name ipe/config sounds like a file to configure IPE. Maybe something like ipe/config_abi or ipe/config_grammar?

Quoted 10 lines

if new syntax is introduced, the version number is increased.

    3. The format of those versions are documented as part of the admin-guide around IPE. If user-mode at that point wants to rip the documentation formats and correlate with the versioning, then it fulfills the same functionality as above, with out the complexity around exposing a parsing grammar and interpreting it on-the-fly. Many of these are unlikely to move past version 1, however.

Quoted 5 lines
Quoted 2 lines

Thoughts?

That seems reasonable.

There is a use case for not having strict parsing in the cloud world where there are multiple versions of OS deployed across a large number of systems say 100,000 nodes. An OS update can take weeks to complete across all the nodes, and we end up having a heterogeneous mix of OS versions.

Quoted 8 lines

Without non-strict parsing, to fix an issue in a policy we will need to update the various versions of the policy (one each for all OS versions which have different IPE policy schema). We will lose the agility we need to fix and deploy something urgently in the policy, the nodes might be failing some critical workloads meanwhile. All the various versions of the policy will need to be changed and production signed then deployed etc. Further some versions might introduce newer issues and we will need to see what all versions of the policy have that bug.

What can be done in the kernel to ignore some policy rules could also be done in a tool managing different policies. For instance, a simple tool can instantiate a human-written policy into multiple backward compatible policies (according to different versions of supported kernels). The appropriate policy could then be fetched on the fly by the nodes or pushed by an orchestration system.

Quoted 3 lines

I propose keeping the non-strict option as well to cater to this use case. Let me know your thoughts on this.

With your constraints in mind, I still think that flexible policy management can be achieved with strict kernel policy parsing. The complexity should be handled by infrastructure management system.

Quoted 3 lines

Regards,
JK