Integrity Policy Enforcement LSM (IPE)
Subsystems (9)
v2 cover Integrity Policy Enforcement LSM (IPE)
From: Deven Bowers <[email protected]>
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.
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.roothashCreate 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=ALLOWDeploy 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/pointNOTE: 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)
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 ++++++++++ .../admin-guide/kernel-parameters.txt | 20 + 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 | 43 + security/ipe/Makefile | 34 + security/ipe/ipe-audit.c | 313 ++++++ security/ipe/ipe-audit.h | 76 ++ security/ipe/ipe-blobs.c | 90 ++ security/ipe/ipe-blobs.h | 18 + security/ipe/ipe-engine.c | 354 +++++++ security/ipe/ipe-engine.h | 61 ++ security/ipe/ipe-hooks.c | 171 ++++ security/ipe/ipe-hooks.h | 159 ++++ security/ipe/ipe-parse.c | 898 ++++++++++++++++++ security/ipe/ipe-parse.h | 35 + security/ipe/ipe-pin.c | 93 ++ security/ipe/ipe-pin.h | 56 ++ security/ipe/ipe-policy.c | 180 ++++ security/ipe/ipe-policy.h | 116 +++ security/ipe/ipe-prop-internal.h | 43 + security/ipe/ipe-property.c | 112 +++ security/ipe/ipe-property.h | 159 ++++ security/ipe/ipe-secfs.c | 814 ++++++++++++++++ security/ipe/ipe-secfs.h | 25 + security/ipe/ipe-sysfs.c | 203 ++++ security/ipe/ipe-sysfs.h | 21 + security/ipe/ipe.c | 146 +++ security/ipe/ipe.h | 23 + security/ipe/properties/Kconfig | 35 + security/ipe/properties/Makefile | 13 + security/ipe/properties/boot-verified.c | 84 ++ security/ipe/properties/dmverity-roothash.c | 155 +++ security/ipe/properties/dmverity-signature.c | 84 ++ security/ipe/properties/prop-entry.h | 38 + security/ipe/utility.h | 32 + security/security.c | 61 ++ 56 files changed, 5635 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
RFC PATCH v2 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
@@ -8437,6 +8437,12 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git S: Supported 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
@@ -38,6 +38,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
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +subdir-y := polgen
scripts/ipe/polgen/.gitignore new file +1 -0
@@ -0,0 +1 @@ +polgen
scripts/ipe/polgen/Makefile new file +7 -0
@@ -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
RFC PATCH v2 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), 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 | 41 ++++ security/ipe/Makefile | 26 +++ security/ipe/ipe-audit.c | 313 ++++++++++++++++++++++++++++ security/ipe/ipe-audit.h | 76 +++++++ security/ipe/ipe-engine.c | 346 +++++++++++++++++++++++++++++++ security/ipe/ipe-engine.h | 49 +++++ security/ipe/ipe-hooks.c | 151 ++++++++++++++ security/ipe/ipe-hooks.h | 114 ++++++++++ security/ipe/ipe-policy.h | 62 ++++++ security/ipe/ipe-prop-internal.h | 43 ++++ security/ipe/ipe-property.c | 112 ++++++++++ security/ipe/ipe-property.h | 159 ++++++++++++++ security/ipe/ipe-sysfs.c | 115 ++++++++++ security/ipe/ipe-sysfs.h | 21 ++ security/ipe/ipe.c | 99 +++++++++ security/ipe/ipe.h | 20 ++ 21 files changed, 1762 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
@@ -8442,6 +8442,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
@@ -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
@@ -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
@@ -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
@@ -0,0 +1,2 @@ +# Generated Boot Policy +ipe-bp.c
security/ipe/Kconfig new file +41 -0
41 lines not on this page · raw message
security/ipe/Makefile new file +26 -0
@@ -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 +313 -0
313 lines not on this page · raw message
security/ipe/ipe-audit.h new file +76 -0
76 lines not on this page · raw message
security/ipe/ipe-engine.c new file +346 -0
346 lines not on this page · raw message
security/ipe/ipe-engine.h new file +49 -0
49 lines not on this page · raw message
security/ipe/ipe-hooks.c new file +151 -0
151 lines not on this page · raw message
security/ipe/ipe-hooks.h new file +114 -0
114 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 +43 -0
43 lines not on this page · raw message
security/ipe/ipe-property.c new file +112 -0
112 lines not on this page · raw message
security/ipe/ipe-property.h new file +159 -0
159 lines not on this page · raw message
security/ipe/ipe-sysfs.c new file +115 -0
115 lines not on this page · raw message
security/ipe/ipe-sysfs.h new file +21 -0
@@ -0,0 +1,21 @@ +/* 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 + +/** +* ipe_sysctl_init: Initialize IPE's sysfs entries. +* +* Return: +* 0 - OK +* -ENOMEM - Sysctl registration failed +*/ +int __init ipe_sysctl_init (void ); + +#endif /* IPE_SYSFS_H */
security/ipe/ipe.c new file +99 -0
99 lines not on this page · raw message
security/ipe/ipe.h new file +20 -0
@@ -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 + +#include <linux/types.h> +#include <linux/fs.h> + +#define IPE_MODE_ENFORCE "enforce" +#define IPE_MODE_PERMISSIVE "permissive" + +extern int enforce; +extern int success_audit; + +#endif /* IPE_H */
Signature · 1 line
2.26.0
Re: [RFC PATCH v2 02/12] security: add ipe lsm evaluation loop and audit system
Quoted 2 lines · On Tue, Apr 7, 2020 at 12:14 AM <[email protected]> wrote:
Add the core logic of the IPE LSM, the evaluation loop (engine), the audit system, and the skeleton of the policy structure.
Here's a first review pass for this patch without really understanding your data structures yet:
[...]
Quoted 10 lines
security/ipe/Kconfig new file +4
-0@@ -0,0 +1,41 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# Integrity Policy Enforcement (IPE) configuration +#
security/ipe/Kconfig line 14
Quoted 10 lines
security/ipe/Kconfig new file +10
-0+ +menuconfig SECURITY_IPE + bool "Integrity Policy Enforcement (IPE)" + depends on SECURITY && AUDIT + select SYSTEM_DATA_VERIFICATION + help + This option enables the Integrity Policy Enforcement subsystem, + allowing systems to enforce integrity requirements on various + aspects of user-mode applications. These requirements are + controlled by a policy.
This text is very generic and doesn't really make it clear how IPE is different from other LSMs; could you perhaps add some more text here on the parts of IPE that distinguish it from other LSMs?
In the cover letter, you have this stuff at the top:
"""
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. """
Perhaps you could add a summary of that here?
[...]
Quoted 1 line
security/ipe/ipe-audit.c +0
-0
[...]
security/ipe/ipe-audit.c line 59
Quoted 6 lines
security/ipe/ipe-audit.c +6
-0+void ipe_audit_mode (void ) +{ +struct audit_buffer *ab; + + ab =audit_log_start (audit_context (),GFP_ATOMIC | __GFP_NOWARN, +AUDIT_INTEGRITY_MODE );
Why is this GFP_ATOMIC? ipe_audit_mode() is used from ipe_switch_mode(), which is allowed to sleep, right?
Quoted 8 lines
security/ipe/ipe-audit.c +8
-0+if (!ab) +return ; + +audit_log_format (ab,"IPE mode=%s" , (enforce) ?IPE_MODE_ENFORCE : +IPE_MODE_PERMISSIVE ); + +audit_log_end (ab); +}
[...]
security/ipe/ipe-audit.c line 291
Quoted 10 lines
security/ipe/ipe-audit.c +10
-0+/** +* ipe_audit_ignore_line: Emit a warning that the line was not understood by +* IPE's parser and the line will be ignored and not +* parsed. +* @line_num: line number that is being ignored. +*/ +void ipe_audit_ignore_line (size_t i) +{ +pr_warn ("failed to parse line number %zu, ignoring" , i); +}
It seems a bit silly to have an extra method just for this?
security/ipe/ipe-audit.c line 303
Quoted 11 lines
security/ipe/ipe-audit.c +11
-0+/** +* ipe_audit_policy_activation: Emit an audit event that a specific policy +* was activated as the active policy. +* @pol: policy that is being activated +*/ +void ipe_audit_policy_activation (const struct ipe_policy *pol) +{ +struct audit_buffer *ab; + + ab =audit_log_start (audit_context (),GFP_ATOMIC | __GFP_NOWARN, +AUDIT_INTEGRITY_POLICY_ACTIVATE );
Again, this runs in sleepable context and GFP_ATOMIC is unnecessary, right?
Quoted 9 lines
security/ipe/ipe-audit.c +9
-0+if (!ab) +return ; + +audit_log_format (ab,POLICY_ACTIVATE_STR , pol->policy_name, + pol->policy_version.major, pol->policy_version.minor, + pol->policy_version.rev); + +audit_log_end (ab); +}
[...]
Quoted 1 line
security/ipe/ipe-engine.c +0
-0
[...]
Quoted 5 lines
+/**
+ *get_audit_pathname: Return the absolute path of the file struct passed in
+ * @file: file to derive an absolute path from.
+ *
+ * This function walks past chroots and mount points.
[...]
Quoted 3 lines
+ */
security/ipe/ipe-engine.c +2
-0+static char *get_audit_pathname (const struct file *file) +{
[...]
security/ipe/ipe-engine.c line 56
Quoted 9 lines
security/ipe/ipe-engine.c +9
-0+ sb = file->f_path.dentry->d_sb; + + pathbuf =__getname (); +if (!pathbuf) { + rc = -ENOMEM ; + goto err; + } + + pos =d_absolute_path (&file->f_path, pathbuf,PATH_MAX );
Just as an FYI, no change required: d_absolute_path() will also succeed for files that are not contained within the filesystem root of the current process; in that case, you'll get stuff like paths rooted in a different mount namespace.
Quoted 4 lines
security/ipe/ipe-engine.c +4
-0+if (IS_ERR (pos)) { + rc =PTR_ERR (pos); + goto err; + }
security/ipe/ipe-engine.c line 70
Quoted 10 lines
security/ipe/ipe-engine.c +10
-0+ + temp_path =__getname (); +if (!temp_path) { + rc = -ENOMEM ; + goto err; + } + +strlcpy (temp_path, pos,PATH_MAX ); + +if (pathbuf)
This check seems superfluous.
Quoted 11 lines
security/ipe/ipe-engine.c +11
-0+__putname (pathbuf); + +return temp_path; +err: +if (pathbuf) +__putname (pathbuf); +if (temp_path) +__putname (temp_path); + +return ERR_PTR (rc); +}
[...]
Quoted 3 lines
+/**
+ *prealloc_cache: preallocate the cache tree for all ipe properties, so
+ * that this data maybe used later in the read side critical
s/maybe/may be/
Quoted 49 lines
+ * section.
+ * @ctx: Ipe engine context structure passed to the property prealloc function.
+ * @cache: Root of the cache tree to insert nodes under.
+ *
+ * Return:
+ * 0 - OK
+ *-ENOMEM- Out of memory
+ * Other - See individual property preallocator functions.
+ */security/ipe/ipe-engine.c +40
-0+static int prealloc_cache (struct ipe_engine_ctx *ctx, +struct rb_root *cache) +{ +int rc =0 ; +struct rb_node *node; +struct ipe_prop_reg *reg; +struct ipe_prop_cache *storage; + +for (node =rb_first (&ipe_registry_root); node; node =rb_next (node)) { + reg = container_of(node, struct ipe_prop_reg, node); + + storage =insert_or_find_cache (cache, reg->prop); +if (IS_ERR (storage)) +return PTR_ERR (storage); + +if (reg->prop->prealloc) { + rc = reg->prop->prealloc (ctx, &storage->storage); +if (rc !=0 ) +return rc; + } + } + +return rc; +} + +/** +* evaluate: Process an @ctx against IPE's current active policy. +* @ctx: the engine ctx to perform an evaluation on. +* @cache: the red-black tree root that is used for cache storage. +* +* This uses a preallocated @cache as storage for the properties to avoid +* re-evaulation. +* +* Return: +* -EACCES - A match occurred against a "action=DENY" rule +* -ENOMEM - Out of memory +*/ +static int evaluate (struct ipe_engine_ctx *ctx,struct rb_root *cache) +{ +int rc =0 ;
security/ipe/ipe-engine.c line 258
Quoted 10 lines
security/ipe/ipe-engine.c +10
-0+bool match = false; +enum ipe_action action; +struct ipe_prop_cache *c; +enum ipe_match match_type; +const struct ipe_rule *rule; +const struct ipe_policy *pol; +const struct ipe_rule_table *rules; +const struct ipe_prop_container *prop; + +if (!ipe_active_policy)
Please use rcu_access_pointer() here.
Quoted 6 lines
security/ipe/ipe-engine.c +6
-0+return rc; + +rcu_read_lock (); + + pol =rcu_dereference (ipe_active_policy); +
security/ipe/ipe-engine.c line 274
Quoted 10 lines
security/ipe/ipe-engine.c +10
-0+ rules = &pol->ops[ctx->op]; + +list_for_each_entry (rule, &rules->rules, next) { + match = true; + +list_for_each_entry (prop, &rule->props, next) { +void *cache =NULL ; + +if (prop->prop->prealloc) { + c =insert_or_find_cache (cache, prop->prop);
What's going on with the cache pointer here? We give insert_or_find_cache() a NULL cache, and then in insert_or_find_cache() new will be a near-NULL pointer, and it'll crash immediately at while (*new)? Am I missing something?
Also, I think the intent here is that the preceding call to prealloc_cache() should have allocated memory for us. If so, can you please add a short comment here, something like "/* won't sleep because of preceding prealloc_cache() */"?
Quoted 72 lines
security/ipe/ipe-engine.c +72
-0+if (IS_ERR (c)) +return PTR_ERR (c); + + cache = c->storage; + } + + match = match && prop->prop->eval (ctx, prop->value, + &cache); + } + +if (match) +break ; + } + +if (match) { + match_type = ipe_match_rule; + action = rule->action; + }else if (rules->def != ipe_action_unset) { + match_type = ipe_match_table; + action = rules->def; + rule =NULL ; + }else { + match_type = ipe_match_global; + action = pol->def; + rule =NULL ; + } + +ipe_audit_match (ctx, cache, match_type, action, rule); + +if (action == ipe_action_deny) + rc = -EACCES ; + +if (enforce ==0 ) + rc =0 ; + +rcu_read_unlock (); +return rc; +} + +/** +* ipe_process_event: Perform an evaluation of @file, @op, and @hook against +* IPE's current active policy. +* @file: File that is being evaluated against IPE policy. +* @op: Operation that the file is being evaluated against. +* @hook: Specific hook that the file is being evaluated through. +* +* Return: +* -ENOMEM: (No Memory) +* -EACCES: (A match occurred against a "action=DENY" rule) +*/ +int ipe_process_event (const struct file *file,enum ipe_op op, +enum ipe_hook hook) +{ +int rc =0 ; +struct ipe_engine_ctx *ctx; +struct rb_root cache =RB_ROOT ; + + ctx =build_ctx (file, op, hook); +if (IS_ERR (ctx)) + goto cleanup; + + rc =prealloc_cache (ctx, &cache); +if (rc !=0 ) + goto cleanup; + + rc =evaluate (ctx, &cache); + +cleanup: +free_ctx (ctx); +destroy_cache (&cache); +return rc; +}
[...]
Quoted 1 line
security/ipe/ipe-hooks.c +0
-0
[..]
Quoted 1 line
+#define
HAS_EXEC(_p, _rp)(((_rp) &PROT_EXEC) || ((_p) &PROT_EXEC))
This should be unnecessary; reqprot are the protections requested by userspace, prot are the possibly expanded protections the kernel is applying. I think you just want to use prot and ignore reqprot.
[...]
Quoted 1 line
security/ipe/ipe-policy.h +0
-0
[...]
Quoted 1 line
+extern const char *const
ipe_boot_policy;
I don't see anything in the entire patch series that actually sets this variable. Am I missing something?
Quoted 1 line
+extern const struct
ipe_policy*ipe_active_policy;
[...]
Quoted 1 line
security/ipe/ipe-property.c +0
-0
[...]
Quoted 2 lines
security/ipe/ipe-property.c +2
-0+/* global root containing all registered properties */ +struct rb_root ipe_registry_root =RB_ROOT ;
[...]
Quoted 10 lines
security/ipe/ipe-property.c +10
-0+static struct ipe_prop_reg *reg_lookup (const char *key) +{ +struct rb_node *n = ipe_registry_root.rb_node; + +while (n) { +int r; +struct ipe_prop_reg *reg = + container_of(n, struct ipe_prop_reg, node); + + r =strcmp (reg->prop->property_name, key);
security/ipe/ipe-property.c line 44
Quoted 10 lines
security/ipe/ipe-property.c +10
-0+if (r ==0 ) +return reg; +else if (r >0 ) + n = n->rb_right; +else + n = n->rb_left; + } + +return NULL ; +}
Where is the locking for ipe_registry_root? I've looked through the callers and can't find it. Also, please add a lockdep assertion (lockdep_assert_held(...)) here if possible to ensure that when the kernel is buildt with appropriate debugging options turned on (CONFIG_LOCKDEP), it will warn about calling this method with inappropriate locking.
[...]
Quoted 7 lines
security/ipe/ipe-property.c +7
-0+/** +* ipe_register_property: Insert a property into the registration system. +* @prop: Read-only property structure containing the property_name, as well +* as the necessary function pointers for a property. +* +* The caller needs to maintain the lifetime of @prop throughout the life of +* the system, after calling ipe_register_property.
security/ipe/ipe-property.c
Quoted 10 lines
security/ipe/ipe-property.c +10
-0+* +* All necessary properties need to be loaded via this method before +* loading a policy, otherwise the properties will be ignored as unknown. +* +* Return: +* 0 - OK +* -EEXIST - A key exists with the name @prop->property_name +* -ENOMEM - Out of memory +*/ +int ipe_register_property (const struct ipe_property *prop);
Normal Linux kernel style is to have comments on the definitions of methods (in the .c files), not in the headers. It looks like you duplicated the same comment between the header and the .c file - please don't do that. Same thing in a bunch of other places.
Quoted 2 lines
security/ipe/ipe-property.c +1
-0+#endif /* IPE_PROPERTY_H */ security/ipe/ipe-sysfs.c +0
-0
[...]
security/ipe/ipe-sysfs.c line 110
Quoted 10 lines
security/ipe/ipe-sysfs.c +10
-0+#else /* !CONFIG_SYSCTL */ + +/** +* ipe_sysctl_init: Initialize IPE's sysfs entries. +* +* Return: +* 0 - OK +* -ENOMEM - Sysctl registration failed +*/ +inline int __init ipe_sysctl_init (void )
"inline" doesn't make sense to me if the caller is in a different compilation unit
[...]
Quoted 1 line
security/ipe/ipe.c +0
-0
[...]
security/ipe/ipe.c line 37
Quoted 11 lines
security/ipe/ipe.c +11
-0+/** +* 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 ) +{ +return 0 ; +}
this belongs in patch 4 ("ipe: add property for trust of boot volume")
[...]
security/ipe/ipe.c line 54
Quoted 3 lines
security/ipe/ipe.c +3
-0+static int __init ipe_init (void ) +{ +int rc =0 ;
useless initialization
security/ipe/ipe.c line 58
Quoted 3 lines
security/ipe/ipe.c +3
-0+ rc =ipe_sysctl_init (); +if (rc !=0 ) +pr_err ("failed to configure sysctl: %d" , -rc);
pr_err() needs to have an explicit \n at the end of the message unless you're planning to continue printing more text on the same line via pr_cont(). Same issue in many other places.
security/ipe/ipe.c line 63
Quoted 5 lines
security/ipe/ipe.c +5
-0+ +pr_info ("mode=%s" , (enforce ==1 ) ?IPE_MODE_ENFORCE : +IPE_MODE_PERMISSIVE ); + +RCU_INIT_POINTER (ipe_active_policy,NULL );
Why? Statically allocated variables are zero-initialized by default in C.
Quoted 4 lines
security/ipe/ipe.c +4
-0+security_add_hooks (ipe_hooks,ARRAY_SIZE (ipe_hooks),"IPE" ); + +return rc; +}
[...]
Quoted 8 lines
security/ipe/ipe.c +8
-0+/** +* enforce: Kernel command line parameter to set the permissive mode for IPE +* at system startup. By default, this will always be in enforce mode. +* +* This is also controlled by the sysctl, "ipe.enforce". +*/ +module_param (enforce, int,0644 ); +MODULE_PARM_DESC (enforce,"enforce/permissive mode switch" );
[...]
security/ipe/ipe.c line 99
Quoted 10 lines
security/ipe/ipe.c +10
-0+/** +* success_audit: Kernel command line parameter to enable success auditing +* (emit an audit event when a file is allowed) at system +* startup. By default, this will be off. +* +* This is also controlled by the sysctl, "ipe.success_audit". +*/ +int success_audit; +module_param (success_audit, int,0644 ); +MODULE_PARM_DESC (success_audit,"audit message on allow" );
There is a pending patch series that will allow setting arbitrary sysctls from the kernel command line
(https://lore.kernel.org/lkml/[email protected]/);
if that also works for your usecase, you should probably avoid explicitly adding module parameters here, unless that is necessary because the pending series sets the sysctls too late.
Quoted 1 line
security/ipe/ipe.h +0
-0
[...]
security/ipe/ipe.h line 18
Quoted 2 lines
security/ipe/ipe.h +2
-0+extern int enforce; +extern int success_audit;
You probably shouldn't be defining global symbols with such broad names to avoid colliding with global symbols defined elsewhere in the kernel. Consider adding "ipe_" prefixes to the variable names, or something like that.
Re: [RFC PATCH v2 02/12] security: add ipe lsm evaluation loop and audit system
Quoted 56 lines · Jann Horn
Quoted 2 lines · On Tue, Apr 7, 2020 at 12:14 AM<[email protected]> wrote:
Add the core logic of the IPE LSM, the evaluation loop (engine), the audit system, and the skeleton of the policy structure.
Here's a first review pass for this patch without really understanding your data structures yet:
[...]
Quoted 10 lines
security/ipe/Kconfig new file +4
-0@@ -0,0 +1,41 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# Integrity Policy Enforcement (IPE) configuration +#security/ipe/Kconfig line 14
Quoted 10 lines
security/ipe/Kconfig new file +10
-0+ +menuconfig SECURITY_IPE + bool "Integrity Policy Enforcement (IPE)" + depends on SECURITY && AUDIT + select SYSTEM_DATA_VERIFICATION + help + This option enables the Integrity Policy Enforcement subsystem, + allowing systems to enforce integrity requirements on various + aspects of user-mode applications. These requirements are + controlled by a policy.This text is very generic and doesn't really make it clear how IPE is different from other LSMs; could you perhaps add some more text here on the parts of IPE that distinguish it from other LSMs?
In the cover letter, you have this stuff at the top:
"""
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.
Quoted 6 lines
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. """
Perhaps you could add a summary of that here?
Sure, no problem. I'll add a bit more detail to the Kconfig in v3, something like:
"""
This option enables the Integrity Policy Enforcement subsystem allowing systems to enforce integrity requirements on user land binaries. IPE differs from other LSMs by removing dependencies on filesystem metadata, making its decisions based off of kernel- resident features and data structures. A key feature of IPE is a customizable policy to allow admins to reconfigure integrity requirements on the fly.
"""
Quoted 11 lines
[...]
Quoted 1 line
security/ipe/ipe-audit.c +0
-0[...]
security/ipe/ipe-audit.c line 59
Quoted 6 lines
security/ipe/ipe-audit.c +6
-0+void ipe_audit_mode (void ) +{ +struct audit_buffer *ab; + + ab =audit_log_start (audit_context (),GFP_ATOMIC | __GFP_NOWARN, +AUDIT_INTEGRITY_MODE );Why is this
GFP_ATOMIC?ipe_audit_mode()is used fromipe_switch_mode(), which is allowed to sleep, right?
Yeah, that's a fair point. I had originally based _all_ of these audit functions off of common_lsm_audit which utilizes these two flags. We chose not to use that specific function for several reasons, but there's no reason to keep these allocator flags. I'll move it to GFP_KERNEL.
Quoted 9 lines
Quoted 8 lines
security/ipe/ipe-audit.c +8
-0+if (!ab) +return ; + +audit_log_format (ab,"IPE mode=%s" , (enforce) ?IPE_MODE_ENFORCE : +IPE_MODE_PERMISSIVE ); + +audit_log_end (ab); +}[...]
Quoted 11 lines
security/ipe/ipe-audit.c line 291
Quoted 10 lines
security/ipe/ipe-audit.c +10
-0+/** +* ipe_audit_ignore_line: Emit a warning that the line was not understood by +* IPE's parser and the line will be ignored and not +* parsed. +* @line_num: line number that is being ignored. +*/ +void ipe_audit_ignore_line (size_t i) +{ +pr_warn ("failed to parse line number %zu, ignoring" , i); +}It seems a bit silly to have an extra method just for this?
Fair point. I wanted to collapse as much of the *common* user-facing strings into one file, and I was trying to adhere to the 80-character limit.
I'll remove the function and inline it.
Quoted 4 lines
Quoted 4 lines
+/**
+ *ipe_audit_policy_activation: Emit an audit event that a specific policy
+ * was activated as the active policy.
+ * @pol: policy that is being activated
Quoted 8 lines
security/ipe/ipe-audit.c line 303
Quoted 7 lines
+ */
security/ipe/ipe-audit.c +6
-0+void ipe_audit_policy_activation (const struct ipe_policy *pol) +{ +struct audit_buffer *ab; + + ab =audit_log_start (audit_context (),GFP_ATOMIC | __GFP_NOWARN, +AUDIT_INTEGRITY_POLICY_ACTIVATE );Again, this runs in sleepable context and
GFP_ATOMICis unnecessary, right?
Yep. I'll fix it in v3. Same with ipe_audit_policy_activation, below. The only one that runs in non-sleepable context is ipe_audit_match.
Quoted 36 lines
Quoted 9 lines
security/ipe/ipe-audit.c +9
-0+if (!ab) +return ; + +audit_log_format (ab,POLICY_ACTIVATE_STR , pol->policy_name, + pol->policy_version.major, pol->policy_version.minor, + pol->policy_version.rev); + +audit_log_end (ab); +}[...]
Quoted 1 line
security/ipe/ipe-engine.c +0
-0[...]
Quoted 5 lines
+/**
+ *get_audit_pathname: Return the absolute path of the file struct passed in
+ * @file: file to derive an absolute path from.
+ *
+ * This function walks past chroots and mount points.[...]
Quoted 3 lines
+ */
security/ipe/ipe-engine.c +2
-0+static char *get_audit_pathname (const struct file *file) +{[...]
security/ipe/ipe-engine.c line 56
Quoted 9 lines
security/ipe/ipe-engine.c +9
-0+ sb = file->f_path.dentry->d_sb; + + pathbuf =__getname (); +if (!pathbuf) { + rc = -ENOMEM ; + goto err; + } + + pos =d_absolute_path (&file->f_path, pathbuf,PATH_MAX );Just as an FYI, no change required:
d_absolute_path()will also succeed for files that are not contained within the filesystem root of the current process; in that case, you'll get stuff like paths rooted in a different mount namespace.
Quoted 15 lines
Quoted 4 lines
security/ipe/ipe-engine.c +4
-0+if (IS_ERR (pos)) { + rc =PTR_ERR (pos); + goto err; + }security/ipe/ipe-engine.c line 70
Quoted 10 lines
security/ipe/ipe-engine.c +10
-0+ + temp_path =__getname (); +if (!temp_path) { + rc = -ENOMEM ; + goto err; + } + +strlcpy (temp_path, pos,PATH_MAX ); + +if (pathbuf)This check seems superfluous.
I'll remove it.
Quoted 12 lines
Quoted 11 lines
security/ipe/ipe-engine.c +11
-0+__putname (pathbuf); + +return temp_path; +err: +if (pathbuf) +__putname (pathbuf); +if (temp_path) +__putname (temp_path); + +return ERR_PTR (rc); +}[...]
Quoted 4 lines
Quoted 3 lines
+/**
+ *prealloc_cache: preallocate the cache tree for all ipe properties, so
+ * that this data maybe used later in the read side criticals/maybe/may be/
Thanks!
Quoted 52 lines
Quoted 52 lines
+ * section.
+ * @ctx: Ipe engine context structure passed to the property prealloc function.
+ * @cache: Root of the cache tree to insert nodes under.
+ *
+ * Return:
+ * 0 - OK
+ *-ENOMEM- Out of memory
+ * Other - See individual property preallocator functions.
+ */security/ipe/ipe-engine.c +43
-0+static int prealloc_cache (struct ipe_engine_ctx *ctx, +struct rb_root *cache) +{ +int rc =0 ; +struct rb_node *node; +struct ipe_prop_reg *reg; +struct ipe_prop_cache *storage; + +for (node =rb_first (&ipe_registry_root); node; node =rb_next (node)) { + reg = container_of(node, struct ipe_prop_reg, node); + + storage =insert_or_find_cache (cache, reg->prop); +if (IS_ERR (storage)) +return PTR_ERR (storage); + +if (reg->prop->prealloc) { + rc = reg->prop->prealloc (ctx, &storage->storage); +if (rc !=0 ) +return rc; + } + } + +return rc; +} + +/** +* evaluate: Process an @ctx against IPE's current active policy. +* @ctx: the engine ctx to perform an evaluation on. +* @cache: the red-black tree root that is used for cache storage. +* +* This uses a preallocated @cache as storage for the properties to avoid +* re-evaulation. +* +* Return: +* -EACCES - A match occurred against a "action=DENY" rule +* -ENOMEM - Out of memory +*/ +static int evaluate (struct ipe_engine_ctx *ctx,struct rb_root *cache) +{ +int rc =0 ; +bool match = false; +enum ipe_action action; +struct ipe_prop_cache *c;
Quoted 8 lines
security/ipe/ipe-engine.c line 258
Quoted 7 lines
security/ipe/ipe-engine.c +7
-0+enum ipe_match match_type; +const struct ipe_rule *rule; +const struct ipe_policy *pol; +const struct ipe_rule_table *rules; +const struct ipe_prop_container *prop; + +if (!ipe_active_policy)Please use
rcu_access_pointer()here.
Thanks. I'm still new to rcu - any comments or corrections regarding it are greatly appreciated.
Quoted 21 lines
Quoted 6 lines
security/ipe/ipe-engine.c +6
-0+return rc; + +rcu_read_lock (); + + pol =rcu_dereference (ipe_active_policy); +security/ipe/ipe-engine.c line 274
Quoted 10 lines
security/ipe/ipe-engine.c +10
-0+ rules = &pol->ops[ctx->op]; + +list_for_each_entry (rule, &rules->rules, next) { + match = true; + +list_for_each_entry (prop, &rule->props, next) { +void *cache =NULL ; + +if (prop->prop->prealloc) { + c =insert_or_find_cache (cache, prop->prop);What's going on with the
cachepointer here? We giveinsert_or_find_cache()a NULL cache, and then ininsert_or_find_cache()newwill be a near-NULL pointer, and it'll crash immediately atwhile (*new)? Am I missing something?
Quoted 4 lines
Also, I think the intent here is that the preceding call to
prealloc_cache()should have allocated memory for us. If so, can you please add a short comment here, something like "/* won't sleep because of precedingprealloc_cache()*/"?
Well, this is embarrassing. This is supposed to be the argument, cache, not the variable, cache. The variable shadowing does indeed do what you describe.
This didn't come up in any of my testing because none of the properties introduced in this patch series utilize the cache. It's kept in to facilitate the storage of potentially expensive operations.
I'm just going to cut out all of this code. It'll be re-added if something actually needs it.
Quoted 73 lines
Quoted 72 lines
security/ipe/ipe-engine.c +72
-0+if (IS_ERR (c)) +return PTR_ERR (c); + + cache = c->storage; + } + + match = match && prop->prop->eval (ctx, prop->value, + &cache); + } + +if (match) +break ; + } + +if (match) { + match_type = ipe_match_rule; + action = rule->action; + }else if (rules->def != ipe_action_unset) { + match_type = ipe_match_table; + action = rules->def; + rule =NULL ; + }else { + match_type = ipe_match_global; + action = pol->def; + rule =NULL ; + } + +ipe_audit_match (ctx, cache, match_type, action, rule); + +if (action == ipe_action_deny) + rc = -EACCES ; + +if (enforce ==0 ) + rc =0 ; + +rcu_read_unlock (); +return rc; +} + +/** +* ipe_process_event: Perform an evaluation of @file, @op, and @hook against +* IPE's current active policy. +* @file: File that is being evaluated against IPE policy. +* @op: Operation that the file is being evaluated against. +* @hook: Specific hook that the file is being evaluated through. +* +* Return: +* -ENOMEM: (No Memory) +* -EACCES: (A match occurred against a "action=DENY" rule) +*/ +int ipe_process_event (const struct file *file,enum ipe_op op, +enum ipe_hook hook) +{ +int rc =0 ; +struct ipe_engine_ctx *ctx; +struct rb_root cache =RB_ROOT ; + + ctx =build_ctx (file, op, hook); +if (IS_ERR (ctx)) + goto cleanup; + + rc =prealloc_cache (ctx, &cache); +if (rc !=0 ) + goto cleanup; + + rc =evaluate (ctx, &cache); + +cleanup: +free_ctx (ctx); +destroy_cache (&cache); +return rc; +}[...]
Quoted 6 lines
Quoted 1 line
security/ipe/ipe-hooks.c +0
-0[..]
Quoted 1 line
+#define
HAS_EXEC(_p, _rp)(((_rp) &PROT_EXEC) || ((_p) &PROT_EXEC))This should be unnecessary; reqprot are the protections requested by userspace, prot are the possibly expanded protections the kernel is applying. I think you just want to use prot and ignore reqprot.
Thanks, I'll correct it.
Quoted 6 lines
[...]
Quoted 1 line
security/ipe/ipe-policy.h +0
-0[...]
Quoted 1 line
+extern const char *const
ipe_boot_policy;I don't see anything in the entire patch series that actually sets this variable. Am I missing something?
This variable is set by an auto-generated file, invoked by the tool created in the first patch of this series. It creates a file called "ipe-bp.c" whose only purpose is to set this variable.
Quoted 25 lines
Quoted 1 line
+extern const struct
ipe_policy*ipe_active_policy;[...]
Quoted 1 line
security/ipe/ipe-property.c +0
-0[...]
Quoted 2 lines
security/ipe/ipe-property.c +2
-0+/* global root containing all registered properties */ +struct rb_root ipe_registry_root =RB_ROOT ;[...]
Quoted 18 lines
security/ipe/ipe-property.c +18
-0+static struct ipe_prop_reg *reg_lookup (const char *key) +{ +struct rb_node *n = ipe_registry_root.rb_node; + +while (n) { +int r; +struct ipe_prop_reg *reg = + container_of(n, struct ipe_prop_reg, node); + + r =strcmp (reg->prop->property_name, key); +if (r ==0 ) +return reg; +else if (r >0 ) + n = n->rb_right; +else + n = n->rb_left; + } +
Quoted 8 lines
security/ipe/ipe-property.c
Quoted 2 lines
security/ipe/ipe-property.c +2
-0+return NULL ; +}Where is the locking for
ipe_registry_root? I've looked through the callers and can't find it. Also, please add a lockdep assertion (lockdep_assert_held(...)) here if possible to ensure that when the kernel is buildt with appropriate debugging options turned on (CONFIG_LOCKDEP), it will warn about calling this method with inappropriate locking.
I'm not sure why locking is necessary on this structure? This structure is only added to, synchronously, at lsm_init. The first time it's queried after that is core_init with ipe_securityfs_init. Every subsequent time is when user mode is setup and 1.) IPE is evaluating a binary, or 2.) IPE is loading a policy. We don't support the run time loading of properties, nor do we support the removal of policies, so the tree should be stable without locks?
Quoted 14 lines
[...]
Quoted 13 lines
+/**
+ *ipe_register_property: Insert a property into the registration system.
+ * @prop: Read-only property structure containing theproperty_name, as well
+ * as the necessary function pointers for a property.
+ *
+ * The caller needs to maintain the lifetime of @prop throughout the life of
+ * the system, after callingipe_register_property.
+ *
+ * All necessary properties need to be loaded via this method before
+ * loading a policy, otherwise the properties will be ignored as unknown.
+ *
+ * Return:
+ * 0 - OK
Quoted 8 lines
Quoted 4 lines
+ *
-EEXIST- A key exists with the name @prop->property_name
+ *-ENOMEM- Out of memory
+ */
+intipe_register_property(const struct ipe_property *prop);Normal Linux kernel style is to have comments on the definitions of methods (in the .c files), not in the headers. It looks like you duplicated the same comment between the header and the .c file - please don't do that. Same thing in a bunch of other places.
Thanks, I'll strip the header comments.
Quoted 15 lines
Quoted 2 lines
security/ipe/ipe-property.c +1
-0+#endif /* IPE_PROPERTY_H */ security/ipe/ipe-sysfs.c +0
-0[...]
security/ipe/ipe-sysfs.c line 110
Quoted 10 lines
security/ipe/ipe-sysfs.c +10
-0+#else /* !CONFIG_SYSCTL */ + +/** +* ipe_sysctl_init: Initialize IPE's sysfs entries. +* +* Return: +* 0 - OK +* -ENOMEM - Sysctl registration failed +*/ +inline int __init ipe_sysctl_init (void )"inline" doesn't make sense to me if the caller is in a different compilation unit
I'll remove it.
Quoted 15 lines
[...]
Quoted 1 line
security/ipe/ipe.c +0
-0[...]
security/ipe/ipe.c line 37
Quoted 11 lines
security/ipe/ipe.c +11
-0+/** +* 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 ) +{ +return 0 ; +}this belongs in patch 4 ("ipe: add property for trust of boot volume")
I'll move it forward.
Quoted 5 lines
[...]
security/ipe/ipe.c line 54
Quoted 3 lines
security/ipe/ipe.c +3
-0+static int __init ipe_init (void ) +{ +int rc =0 ;useless initialization
I'll fix it.
Quoted 6 lines
security/ipe/ipe.c line 58
Quoted 3 lines
security/ipe/ipe.c +3
-0+ rc =ipe_sysctl_init (); +if (rc !=0 ) +pr_err ("failed to configure sysctl: %d" , -rc);
pr_err()needs to have an explicit \n at the end of the message unless you're planning to continue printing more text on the same line viapr_cont(). Same issue in many other places.
Easily fixed by adding a \n to pr_fmt. Will be fixed in next iteration.
Quoted 6 lines
security/ipe/ipe.c line 63
Quoted 5 lines
security/ipe/ipe.c +5
-0+ +pr_info ("mode=%s" , (enforce ==1 ) ?IPE_MODE_ENFORCE : +IPE_MODE_PERMISSIVE ); + +RCU_INIT_POINTER (ipe_active_policy,NULL );Why? Statically allocated variables are zero-initialized by default in C.
This is my inexperience with rcu. I recognize statically allocated variables are zero-initialized, however, I thought that the rcu system needed to set things up with the pointer through this method before it can be used. I'll remove it.
Quoted 14 lines
Quoted 4 lines
security/ipe/ipe.c +4
-0+security_add_hooks (ipe_hooks,ARRAY_SIZE (ipe_hooks),"IPE" ); + +return rc; +}[...]
Quoted 8 lines
security/ipe/ipe.c +8
-0+/** +* enforce: Kernel command line parameter to set the permissive mode for IPE +* at system startup. By default, this will always be in enforce mode. +* +* This is also controlled by the sysctl, "ipe.enforce". +*/ +module_param (enforce, int,0644 ); +MODULE_PARM_DESC (enforce,"enforce/permissive mode switch" );[...]
Quoted 16 lines
security/ipe/ipe.c line 99
Quoted 10 lines
security/ipe/ipe.c +10
-0+/** +* success_audit: Kernel command line parameter to enable success auditing +* (emit an audit event when a file is allowed) at system +* startup. By default, this will be off. +* +* This is also controlled by the sysctl, "ipe.success_audit". +*/ +int success_audit; +module_param (success_audit, int,0644 ); +MODULE_PARM_DESC (success_audit,"audit message on allow" );There is a pending patch series that will allow setting arbitrary sysctls from the kernel command line
(https://lore.kernel.org/lkml/[email protected]/);
if that also works for your usecase, you should probably avoid explicitly adding module parameters here, unless that is necessary because the pending series sets the sysctls too late.
Ah, this is great! It's not a problem with the sysctls being set too late - the enforce and success_audit sysctls only come into play once user land is setup after kernel boot,
Quoted 8 lines
Quoted 1 line
security/ipe/ipe.h +0
-0[...]
security/ipe/ipe.h line 18
Quoted 2 lines
security/ipe/ipe.h +2
-0+extern int enforce; +extern int success_audit;You probably shouldn't be defining global symbols with such broad names to avoid colliding with global symbols defined elsewhere in the kernel. Consider adding "
ipe_" prefixes to the variable names, or something like that.
I'll add the prefixes. Thanks.
RFC PATCH v2 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 and securityfs entries.
--- security/ipe/Kconfig | 2 +- security/ipe/Makefile | 3 + security/ipe/ipe-parse.c | 898 ++++++++++++++++++++++++++++++++++++++ security/ipe/ipe-parse.h | 35 ++ security/ipe/ipe-policy.c | 180 ++++++++ security/ipe/ipe-policy.h | 54 +++ security/ipe/ipe-secfs.c | 814 ++++++++++++++++++++++++++++++++++ security/ipe/ipe-secfs.h | 25 ++ security/ipe/ipe-sysfs.c | 86 ++++ security/ipe/ipe.c | 13 + security/ipe/ipe.h | 1 + 11 files changed, 2110 insertions(+), 1 deletion(-) 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
@@ -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
@@ -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-parse.c new file +898 -0
898 lines not on this page · raw message
security/ipe/ipe-parse.h new file +35 -0
@@ -0,0 +1,35 @@ +/* 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 + +/** +* ipe_parse_policy: Given a string, parse the string into an IPE policy +* structure. +* @policy: NULL terminated string to parse. +* +* This function's behavior changes when strict_parse is set. When the strict +* parser is enabled, this function will break backwards policy compatibility, +* erroring on unknown syntax. This function will modify @policy. +* +* Return: +* Valid ipe_policy structure - OK +* ERR_PTR(-EBADMSG) - Invalid Policy Syntax (Unrecoverable) +* ERR_PTR(-ENOMEM) - Out of Memory +*/ +struct ipe_policy *ipe_parse_policy (char *policy); + +/** +* ipe_free_policy: Deallocate an ipe_policy structure. +* @pol: Policy to free. +*/ +void ipe_free_policy (struct ipe_policy *pol); + +#endif /* IPE_AUDIT_H */
security/ipe/ipe-policy.c new file +180 -0
180 lines not on this page · raw message
security/ipe/ipe-policy.h +54 -0
58 lines not on this page · raw message
security/ipe/ipe-secfs.c new file +814 -0
814 lines not on this page · raw message
security/ipe/ipe-secfs.h new file +25 -0
@@ -0,0 +1,25 @@ +/* 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 + +/** +* ipe_set_active_policy: Set the policy identified by @id as the active +* policy. +* @id: Policy id represnting the policy to activate. +* @id_len: Length of @id. +* +* Return: +* 0 - OK +* -ENOENT - Policy identified by @id does not exist +* Other - See retrieve_backed_dentry +*/ +int ipe_set_active_policy (const char *id,size_t id_len); + +#endif /* IPE_SECFS_H */
security/ipe/ipe-sysfs.c +86 -0
104 lines not on this page · raw message
security/ipe/ipe.c +13 -0
@@ -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>
@@ -97,3 +98,15 @@ MODULE_PARM_DESC(enforce, "enforce/permissive mode switch");int success_audit;module_param (success_audit, int,0644 );MODULE_PARM_DESC (success_audit,"audit message on allow" ); + +/** +* strict_parse: Kernel command line parameter to enable strict parsing of +* IPE policies - causing unrecognized properties to fail +* parsing. This breaks backwards compatibility of IPE policies, +* when enabled. +* +* This is also controlled by the sysctl, "ipe.strict_parse". +*/ +int strict_parse; +module_param (strict_parse, int,0644 ); +MODULE_PARM_DESC (strict_parse,"parse using strict semantics" );
security/ipe/ipe.h +1 -0
@@ -16,5 +16,6 @@extern int enforce;extern int success_audit; +extern int strict_parse;#endif /* IPE_H */
Signature · 1 line
2.26.0
Re: [RFC PATCH v2 03/12] security: add ipe lsm policy parser and policy loading
On Tue, Apr 7, 2020 at 12:14 AM <[email protected]> wrote:
[...]
Quoted 2 lines
Adds the policy parser and the policy loading to IPE, along with the related sysfs and securityfs entries.
[...]
Quoted 1 line
security/ipe/ipe-parse.c +0
-0
[...]
Quoted 17 lines
security/ipe/ipe-parse.c +17
-0+/* Internal Type Definitions */ +enum property_priority { + other =0 , + action =1 , + op =2 , + default_action =3 , + policy_ver =4 , + policy_name =5 , +}; + +struct token { +struct list_head next_tok; +const char *key; +enum property_priority key_priority; +const char *val; +}; +
[...]
Quoted 17 lines
security/ipe/ipe-parse.c +17
-0+/** +* ipe_free_policy: Deallocate an ipe_policy structure. +* @pol: Policy to free. +*/ +void ipe_free_policy (struct ipe_policy *pol) +{ +size_t i; +struct ipe_rule *ptr; +struct ipe_rule_table *op; +struct list_head *l_ptr, *l_next; + +if (IS_ERR_OR_NULL (pol)) +return ; + +for (i =0 ; i <ARRAY_SIZE (pol->ops); ++i) { + op = &pol->ops[i]; +
security/ipe/ipe-parse.c line 645
Quoted 10 lines
security/ipe/ipe-parse.c +10
-0+list_for_each_safe (l_ptr, l_next, &op->rules) { + ptr = list_entry(l_ptr, struct ipe_rule, next); +list_del (l_ptr); +ipe_free_rule (ptr); + } + } + +kfree (pol->policy_name); +kfree (pol); + pol =NULL ;
What is this assignment supposed to do?
Quoted 1 line
+}
[...]
Quoted 1 line
security/ipe/ipe-policy.c +0
-0
[...]
Quoted 11 lines
security/ipe/ipe-policy.c +11
-0+/** +* ipe_is_active_policy: Determine if @policy is the currently active policy. +* @policy: Policy to check if it's the active policy. +* +* NOTE: If this attribute is needed to be consistent over a critical section, +* do not use this function, as it does not hold the read lock over the +* entirety of the critical section. +* +* Return: +* true - @policy is the active policy +* false - @policy is not the active policy
security/ipe/ipe-policy.c line 85
Quoted 10 lines
security/ipe/ipe-policy.c +10
-0+*/ +bool ipe_is_active_policy (const struct ipe_policy *policy) +{ +bool result; + +rcu_read_lock (); + + result =rcu_dereference (ipe_active_policy) == policy; + +rcu_read_unlock ();
You're not actually accessing the pointer, so you can use rcu_access_pointer() and get rid of the rcu_read_lock()/rcu_read_unlock(). Then this helper turns into a one-liner.
Quoted 13 lines
security/ipe/ipe-policy.c +13
-0+return result; +} + +/** +* ipe_update_active_policy: Determine if @old is the active policy, and update +* the active policy if necessary. +* @old: The previous policy that the update is trying to replace. +* @new: The new policy attempting to replace @old. +* +* If @old is not the active policy, nothing will be done. +* +* Return: +* 0 - OK
security/ipe/ipe-policy.c line 109
Quoted 10 lines
security/ipe/ipe-policy.c +10
-0+* -EBADMSG - Invalid Policy +*/ +int ipe_update_active_policy (const struct ipe_policy *old, +const struct ipe_policy *new) +{ +int rc =0 ; +const struct ipe_policy *curr_policy =NULL ; + +/* no active policy, safe to update */ +if (!ipe_active_policy)
This should be rcu_access_pointer().
Quoted 1 line
+ return 0;
[...]
Quoted 1 line
+}
[...]
Quoted 1 line
security/ipe/ipe-secfs.c +0
-0
[...]
Quoted 21 lines
security/ipe/ipe-secfs.c +21
-0+/** +* alloc_callback: Callback given to verify_pkcs7_signature function to set +* the inner content reference and parse the policy. +* @ctx: "ipe_policy_node" to set inner content, size and parsed policy of. +* @data: Start of PKCS#7 inner content. +* @len: Length of @data. +* @asn1hdrlen: Unused. +* +* Return: +* 0 - OK +* ERR_PTR(-EBADMSG) - Invalid policy syntax +* ERR_PTR(-ENOMEM) - Out of memory +*/ +static int alloc_callback (void *ctx,const void *data,size_t len, +size_t asn1hdrlen) +{ +char *cpy =NULL ; +struct ipe_policy *pol =NULL ; +struct ipe_policy_node *n = (struct ipe_policy_node *)ctx; + + n->content = (const u8 *)data;
security/ipe/ipe-secfs.c line 130
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ n->content_size = len; + +if (len ==0 ) +return -EBADMSG ; + + cpy =kzalloc (len +1 ,GFP_KERNEL ); +if (!cpy) +return -ENOMEM ; + + (void )strncpy (cpy, data, len);
Shouldn't this just be memcpy()?
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ pol =ipe_parse_policy (cpy); +if (IS_ERR (pol)) { +kfree (cpy); +return PTR_ERR (pol); + } + + n->parsed = pol; +kfree (cpy); +return 0 ; +}
[...]
security/ipe/ipe-secfs.c line 281
Quoted 9 lines
security/ipe/ipe-secfs.c +9
-0+static ssize_t ipe_secfs_new_policy (struct file *f,const char __user *data, +size_t len,loff_t *offset) +{ +ssize_t rc =0 ; +u8 *cpy =NULL ; +ssize_t written =0 ; + +if (!ns_capable (current_user_ns (),CAP_MAC_ADMIN )) +return -EPERM ;
Use file_ns_capable(f, &init_user_ns, CAP_MAC_ADMIN) instead, both here and elsewhere.
security/ipe/ipe-secfs.c line 293
Quoted 11 lines
security/ipe/ipe-secfs.c +11
-0+ cpy =kzalloc (len,GFP_KERNEL ); +if (!cpy) { + rc = -ENOMEM ; + goto err; + } + + written =simple_write_to_buffer (cpy, len, offset, data, len); +if (written <0 ) { + rc = written; + goto err; + }
This should probably be memdup_user() instead of
kzalloc()+simple_write_to_buffer()?
Quoted 23 lines
security/ipe/ipe-secfs.c +23
-0+ rc =ipe_build_policy_secfs_node (cpy, written); +err: +kfree (cpy); +return rc <0 ? rc : written; +} + +/** +* retrieve_backed_dentry: Retrieve a dentry with a backing inode, identified +* by @name, under @parent. +* @name: Name of the dentry under @parent. +* @parent: The parent dentry to search under for @name. +* @size: Length of @name. +* +* This takes a reference to the returned dentry. Caller needs to call dput +* to drop the reference. +* +* Return: +* valid dentry - OK +* ERR_PTR - Error, see lookup_one_len_unlocked +* NULL - No backing inode was found +*/ +static struct dentry *retrieve_backed_dentry(const char *name, + struct dentry *parent,
security/ipe/ipe-secfs.c line 327
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ size_t size) +{ +int rc =0 ; +struct dentry *tmp =NULL ; + + tmp =lookup_one_len_unlocked (name, parent, size); +if (IS_ERR (tmp)) { + rc =PTR_ERR (tmp); + goto out; + }
You could just "return tmp;" here.
security/ipe/ipe-secfs.c line 330
Quoted 3 lines
security/ipe/ipe-secfs.c +3
-0+ +if (!d_really_is_positive (tmp)) + goto out1;
And here "return NULL;".
security/ipe/ipe-secfs.c line 334
Quoted 3 lines
security/ipe/ipe-secfs.c +3
-0+return tmp; +out1: + tmp =NULL ;
This just sets a variable that is never read again to NULL?
Quoted 64 lines
security/ipe/ipe-secfs.c +64
-0+out: +return rc ==0 ?NULL :ERR_PTR (rc); +} + +/** +* ipe_secfs_del_policy: Delete a policy indicated by the name provided by +* @data +* @f: Unused. +* @data: Buffer containing the policy id to delete. +* @len: Length of @data. +* @offset: Offset into @data. +* +* NOTE: Newlines are treated as part of the name, if using echo to test, +* use -n to prohibit the silent addition of a newline. +* +* Return: +* > 0 - OK +* -ENOMEM - Out of memory +* -EPERM - Policy is active +* -ENOENT - Policy does not exist +* -EPERM - if a MAC subsystem is enabled, missing CAP_MAC_ADMIN +* Other - See retrieve_backed_dentry +*/ +static ssize_t ipe_secfs_del_policy (struct file *f,const char __user *data, +size_t len,loff_t *offset) +{ +ssize_t rc =0 ; +char *id =NULL ; +ssize_t written =0 ; +struct dentry *raw =NULL ; +struct dentry *content =NULL ; +struct inode *policy_i =NULL ; +struct dentry *policy_root =NULL ; +struct inode *policies_root =NULL ; +const struct ipe_policy *target =NULL ; + +if (!ns_capable (current_user_ns (),CAP_MAC_ADMIN )) +return -EPERM ; + + id =kzalloc (len,GFP_KERNEL ); +if (!id) { + rc = -ENOMEM ; + goto out; + } + + written =simple_write_to_buffer (id, len, offset, data, len); +if (written <0 ) { + rc = written; + goto out; + } + + policies_root =d_inode (ipe_policies_root); + + policy_root =retrieve_backed_dentry (id, ipe_policies_root, written); +if (IS_ERR_OR_NULL (policy_root)) { + rc =IS_ERR (policy_root) ?PTR_ERR (policy_root) : -ENOENT ; + goto out; + } + + policy_i =d_inode (policy_root); + +/* if the found dentry matches boot policy, fail */ +if (boot_policy_node == policy_root) { + rc = -EACCES ;
security/ipe/ipe-secfs.c line 408
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ goto out1; + } + + target = ((struct ipe_policy_node *)policy_i->i_private)->parsed; + +/* fail if it's the active policy */ +if (ipe_is_active_policy (target)) { + rc = -EPERM ; + goto out1; + }
Why can it not become the active policy after this check?
Quoted 63 lines
security/ipe/ipe-secfs.c +63
-0+ raw =retrieve_backed_dentry (IPE_FULL_CONTENT , policy_root, +strlen (IPE_FULL_CONTENT )); +if (IS_ERR_OR_NULL (raw)) { + rc =IS_ERR (raw) ?PTR_ERR (raw) : -ENOENT ; + goto out1; + } + + content =retrieve_backed_dentry (IPE_INNER_CONTENT , policy_root, +strlen (IPE_INNER_CONTENT )); +if (IS_ERR_OR_NULL (content)) { + rc =IS_ERR (content) ?PTR_ERR (content) : -ENOENT ; + goto out2; + } + +inode_lock (policies_root); +ipe_free_policy_node (policy_i->i_private); + policy_i->i_private =NULL ; +inode_unlock (policies_root); + +dput (raw); +dput (content); +dput (policy_root); +securityfs_remove (raw); +securityfs_remove (content); +securityfs_remove (policy_root); + +kfree (id); +return written; +out2: +dput (raw); +out1: +dput (policy_root); +out: +kfree (id); +return rc; +} + +/** +* ipe_secfs_rd_policy: Read the raw content (full enveloped PKCS7) data of +* the policy stored within the file's parent inode. +* @f: File representing the securityfs entry. +* @data: User mode buffer to place the raw pkcs7. +* @len: Length of @data. +* @offset: Offset into @data. +* +* Return: +* > 0 - OK +* -ENOMEM - Out of memory +*/ +static ssize_t ipe_secfs_rd_policy (struct file *f,char __user *data, +size_t size,loff_t *offset) +{ +ssize_t rc =0 ; +size_t avail =0 ; +u8 *buffer =NULL ; +struct inode *root =NULL ; +const struct ipe_policy_node *node =NULL ; + + root =d_inode (f->f_path.dentry->d_parent); + +inode_lock_shared (root); + node = (const struct ipe_policy_node *)root->i_private; +
security/ipe/ipe-secfs.c line 482
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ avail = node->data_len; + buffer =kmemdup (node->data, avail,GFP_KERNEL ); +if (!buffer) { + rc = -ENOMEM ; + goto cleanup; + } + + rc =simple_read_from_buffer (data, size, offset, buffer, avail); +cleanup: +inode_unlock_shared (root);
Same thing as in ipe_secfs_rd_content(): simple_read_from_buffer() needlessly within locked section, buffer not freed.
Quoted 33 lines
security/ipe/ipe-secfs.c +33
-0+ +return rc; +} + +/** +* ipe_secfs_ud_policy: Update a policy in place with a new PKCS7 policy. +* @f: File representing the securityfs entry. +* @data: Buffer user mode to place the raw pkcs7. +* @len: Length of @data. +* @offset: Offset into @data. +* +* Return: +* 0 - OK +* -EBADMSG - Invalid policy format +* -ENOMEM - Out of memory +* -EPERM - if a MAC subsystem is enabled, missing CAP_MAC_ADMIN +* -EINVAL - Incorrect policy name for this node, or version is < current +*/ +static ssize_t ipe_secfs_ud_policy (struct file *f,const char __user *data, +size_t len,loff_t *offset) +{ +ssize_t rc =0 ; +u8 *cpy =NULL ; +ssize_t written =0 ; +struct inode *root =NULL ; +struct crypto_shash *tfm =NULL ; +struct ipe_policy_node *new =NULL ; +struct ipe_policy_node *old =NULL ; + +if (!ns_capable (current_user_ns (),CAP_MAC_ADMIN )) +return -EPERM ; + + cpy =kzalloc (len,GFP_KERNEL );
security/ipe/ipe-secfs.c line 525
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+if (!cpy) { + rc = -ENOMEM ; + goto out; + } + + written =simple_write_to_buffer (cpy, len, offset, data, len); +if (written <0 ) { + rc = written; + goto out; + }
You'd probably be better off just doing memdup_user() here. simple_write_to_buffer() only makes sense if you have a buffer that can be continuously updated with multiple writes.
Quoted 47 lines
security/ipe/ipe-secfs.c +47
-0+ new =ipe_alloc_policy_node (cpy, len); +if (IS_ERR (new)) { + rc =PTR_ERR (new); + goto out; + } + + tfm =crypto_alloc_shash ("sha1" ,0 ,0 ); +if (IS_ERR (tfm)) + goto out2; + + root =d_inode (f->f_path.dentry->d_parent); +inode_lock (root); + + old = (struct ipe_policy_node *)root->i_private; + +if (strcmp (old->parsed->policy_name, new->parsed->policy_name)) { + rc = -EINVAL ; + goto out3; + } + +if (!ipe_is_valid_policy (old->parsed, new->parsed)) { + rc = -EINVAL ; + goto out3; + } + + rc =ipe_update_active_policy (old->parsed, new->parsed); +if (rc !=0 ) + goto out3; + +ipe_audit_policy_load (new->parsed, new->data, new->data_len, tfm); +swap (root->i_private, new); + +inode_unlock (root); +kfree (cpy); +ipe_free_policy_node (new); +crypto_free_shash (tfm); + +return written; +out3: +inode_unlock (root); +ipe_free_policy_node (new); +out2: +crypto_free_shash (tfm); +out: +kfree (cpy); +return rc; +}
[...]
Quoted 14 lines
security/ipe/ipe-secfs.c +14
-0+static ssize_t ipe_secfs_rd_content (struct file *f,char __user *data, +size_t size,loff_t *offset) +{ +ssize_t rc =0 ; +size_t avail =0 ; +u8 *buffer =NULL ; +struct inode *root =NULL ; +const struct ipe_policy_node *node =NULL ; + + root =d_inode (f->f_path.dentry->d_parent); + +inode_lock (root); + node = (const struct ipe_policy_node *)root->i_private; +
security/ipe/ipe-secfs.c line 610
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ avail = node->content_size; + buffer =kmemdup (node->content, avail,GFP_KERNEL ); +if (!buffer) { + rc = -ENOMEM ; + goto cleanup; + } + + rc =simple_read_from_buffer (data, size, offset, buffer, avail); +cleanup: +inode_unlock (root);
Why are you nod doing the simple_read_from_buffer() after inode_unlock()? The way you're doing it now, there isn't really a point in the kmemdup() at all...
Also, you'll have to free the buffer before returning.
Quoted 2 lines
security/ipe/ipe-secfs.c +2
-0+return rc; +}
[...]
Quoted 1 line
security/ipe/ipe-sysfs.c +0
-0
[...]
Quoted 14 lines
security/ipe/ipe-sysfs.c +14
-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) { + id =kzalloc ((*lenp) +1 ,GFP_KERNEL ); +if (!id) +return -ENOMEM ; + + table->data = id;
security/ipe/ipe-sysfs.c static int ipe_switch_mode(struct ctl_table *table, int write, · line 92
Quoted 10 lines
security/ipe/ipe-sysfs.c +10
-0+ 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 { +rcu_read_lock (); + size =strlen (rcu_dereference (ipe_active_policy)->policy_name);
Can't ipe_active_policy be NULL here?
security/ipe/ipe-sysfs.c static int ipe_switch_mode(struct ctl_table *table, int write, · line 95
Quoted 3 lines
security/ipe/ipe-sysfs.c +3
-0+rcu_read_unlock (); + + id =kzalloc (size +1 ,GFP_KERNEL );
The + 1 seems unnecessary.
Quoted 19 lines
security/ipe/ipe-sysfs.c +19
-0+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 */
[...]
Quoted 1 line
security/ipe/ipe.c +0
-0
[...]
security/ipe/ipe.c MODULE_PARM_DESC(enforce, "enforce/permissive mode switch"); · line 106
Quoted 6 lines
security/ipe/ipe.c +6
-0+ +/** +* strict_parse: Kernel command line parameter to enable strict parsing of +* IPE policies - causing unrecognized properties to fail +* parsing. This breaks backwards compatibility of IPE policies, +* when enabled.
I guess the backwards compatibility stuff is referring to an out-of-tree version of this series that you've already shipped?
Quoted 2 lines
+ * This is also controlled by the sysctl, "ipe.strict_parse".
+ */
(Also, same thing as in the other patch re sysctls and kernel command line parameters for the same feature.)
Re: [RFC PATCH v2 03/12] security: add ipe lsm policy parser and policy loading
Quoted 45 lines · Jann Horn
On Tue, Apr 7, 2020 at 12:14 AM<[email protected]> wrote:
[...]Quoted 2 lines
Adds the policy parser and the policy loading to IPE, along with the related sysfs and securityfs entries.
[...]
Quoted 1 line
security/ipe/ipe-parse.c +0
-0[...]
Quoted 17 lines
security/ipe/ipe-parse.c +17
-0+/* Internal Type Definitions */ +enum property_priority { + other =0 , + action =1 , + op =2 , + default_action =3 , + policy_ver =4 , + policy_name =5 , +}; + +struct token { +struct list_head next_tok; +const char *key; +enum property_priority key_priority; +const char *val; +}; +[...]
Quoted 20 lines
security/ipe/ipe-parse.c +20
-0+/** +* ipe_free_policy: Deallocate an ipe_policy structure. +* @pol: Policy to free. +*/ +void ipe_free_policy (struct ipe_policy *pol) +{ +size_t i; +struct ipe_rule *ptr; +struct ipe_rule_table *op; +struct list_head *l_ptr, *l_next; + +if (IS_ERR_OR_NULL (pol)) +return ; + +for (i =0 ; i <ARRAY_SIZE (pol->ops); ++i) { + op = &pol->ops[i]; + +list_for_each_safe (l_ptr, l_next, &op->rules) { + ptr = list_entry(l_ptr, struct ipe_rule, next); +list_del (l_ptr);
Quoted 8 lines
security/ipe/ipe-parse.c line 645
Quoted 7 lines
security/ipe/ipe-parse.c +7
-0+ipe_free_rule (ptr); + } + } + +kfree (pol->policy_name); +kfree (pol); + pol =NULL ;What is this assignment supposed to do?
Apologies, it's a useless statement. I occasionally forget to strip this pattern throughout my code. It's supposed to help avoid double-free but ultimately it's useless.
Quoted 20 lines
Quoted 1 line
+}
[...]
Quoted 1 line
security/ipe/ipe-policy.c +0
-0[...]
Quoted 16 lines
security/ipe/ipe-policy.c +16
-0+/** +* ipe_is_active_policy: Determine if @policy is the currently active policy. +* @policy: Policy to check if it's the active policy. +* +* NOTE: If this attribute is needed to be consistent over a critical section, +* do not use this function, as it does not hold the read lock over the +* entirety of the critical section. +* +* Return: +* true - @policy is the active policy +* false - @policy is not the active policy +*/ +bool ipe_is_active_policy (const struct ipe_policy *policy) +{ +bool result; +
Quoted 8 lines
security/ipe/ipe-policy.c line 85
Quoted 5 lines
security/ipe/ipe-policy.c +5
-0+rcu_read_lock (); + + result =rcu_dereference (ipe_active_policy) == policy; + +rcu_read_unlock ();You're not actually accessing the pointer, so you can use
rcu_access_pointer()and get rid of the rcu_read_lock()/rcu_read_unlock(). Then this helper turns into a one-liner.
Got it. There's several places it looks like I did this. I'll fix it all.
Quoted 16 lines
Quoted 16 lines
security/ipe/ipe-policy.c +16
-0+return result; +} + +/** +* ipe_update_active_policy: Determine if @old is the active policy, and update +* the active policy if necessary. +* @old: The previous policy that the update is trying to replace. +* @new: The new policy attempting to replace @old. +* +* If @old is not the active policy, nothing will be done. +* +* Return: +* 0 - OK +* -EBADMSG - Invalid Policy +*/ +int ipe_update_active_policy(const struct ipe_policy *old,
Quoted 8 lines
security/ipe/ipe-policy.c line 109
Quoted 7 lines
security/ipe/ipe-policy.c +7
-0+ const struct ipe_policy *new) +{ +int rc =0 ; +const struct ipe_policy *curr_policy =NULL ; + +/* no active policy, safe to update */ +if (!ipe_active_policy)This should be
rcu_access_pointer().
Got it.
Quoted 30 lines
Quoted 1 line
+ return 0;
[...]
Quoted 1 line
+}
[...]
Quoted 1 line
security/ipe/ipe-secfs.c +0
-0[...]
Quoted 24 lines
security/ipe/ipe-secfs.c +24
-0+/** +* alloc_callback: Callback given to verify_pkcs7_signature function to set +* the inner content reference and parse the policy. +* @ctx: "ipe_policy_node" to set inner content, size and parsed policy of. +* @data: Start of PKCS#7 inner content. +* @len: Length of @data. +* @asn1hdrlen: Unused. +* +* Return: +* 0 - OK +* ERR_PTR(-EBADMSG) - Invalid policy syntax +* ERR_PTR(-ENOMEM) - Out of memory +*/ +static int alloc_callback (void *ctx,const void *data,size_t len, +size_t asn1hdrlen) +{ +char *cpy =NULL ; +struct ipe_policy *pol =NULL ; +struct ipe_policy_node *n = (struct ipe_policy_node *)ctx; + + n->content = (const u8 *)data; + n->content_size = len; + +if (len ==0 )
Quoted 8 lines
security/ipe/ipe-secfs.c line 130
Quoted 7 lines
security/ipe/ipe-secfs.c +7
-0+return -EBADMSG ; + + cpy =kzalloc (len +1 ,GFP_KERNEL ); +if (!cpy) +return -ENOMEM ; + + (void )strncpy (cpy, data, len);Shouldn't this just be
memcpy()?
Good point. It won't ever be null terminated because of the signature format, so it's effectively memcpy. I'll change it.
Quoted 11 lines
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ pol =ipe_parse_policy (cpy); +if (IS_ERR (pol)) { +kfree (cpy); +return PTR_ERR (pol); + } + + n->parsed = pol; +kfree (cpy); +return 0 ; +}[...]
Quoted 11 lines
security/ipe/ipe-secfs.c line 281
Quoted 9 lines
security/ipe/ipe-secfs.c +9
-0+static ssize_t ipe_secfs_new_policy (struct file *f,const char __user *data, +size_t len,loff_t *offset) +{ +ssize_t rc =0 ; +u8 *cpy =NULL ; +ssize_t written =0 ; + +if (!ns_capable (current_user_ns (),CAP_MAC_ADMIN )) +return -EPERM ;Use
file_ns_capable(f, &init_user_ns, CAP_MAC_ADMIN)instead, both here and elsewhere.
Thanks.
Quoted 11 lines
security/ipe/ipe-secfs.c line 293
Quoted 11 lines
security/ipe/ipe-secfs.c +11
-0+ cpy =kzalloc (len,GFP_KERNEL ); +if (!cpy) { + rc = -ENOMEM ; + goto err; + } + + written =simple_write_to_buffer (cpy, len, offset, data, len); +if (written <0 ) { + rc = written; + goto err; + }
Quoted 2 lines
This should probably be
memdup_user()instead of
kzalloc()+simple_write_to_buffer()?
I wasn't aware of memdup_user. I'll change it next iteration.
Quoted 38 lines
Quoted 23 lines
security/ipe/ipe-secfs.c +23
-0+ rc =ipe_build_policy_secfs_node (cpy, written); +err: +kfree (cpy); +return rc <0 ? rc : written; +} + +/** +* retrieve_backed_dentry: Retrieve a dentry with a backing inode, identified +* by @name, under @parent. +* @name: Name of the dentry under @parent. +* @parent: The parent dentry to search under for @name. +* @size: Length of @name. +* +* This takes a reference to the returned dentry. Caller needs to call dput +* to drop the reference. +* +* Return: +* valid dentry - OK +* ERR_PTR - Error, see lookup_one_len_unlocked +* NULL - No backing inode was found +*/ +static struct dentry *retrieve_backed_dentry(const char *name, + struct dentry *parent,security/ipe/ipe-secfs.c line 327
Quoted 10 lines
security/ipe/ipe-secfs.c +10
-0+ size_t size) +{ +int rc =0 ; +struct dentry *tmp =NULL ; + + tmp =lookup_one_len_unlocked (name, parent, size); +if (IS_ERR (tmp)) { + rc =PTR_ERR (tmp); + goto out; + }You could just "return tmp;" here.
security/ipe/ipe-secfs.c line 330
Quoted 3 lines
security/ipe/ipe-secfs.c +3
-0+ +if (!d_really_is_positive (tmp)) + goto out1;
Quoted 6 lines
And here "return NULL;".
security/ipe/ipe-secfs.c line 334
Quoted 3 lines
security/ipe/ipe-secfs.c +3
-0+return tmp; +out1: + tmp =NULL ;This just sets a variable that is never read again to NULL?
Thanks, I'll fix these up.
Quoted 67 lines
Quoted 67 lines
security/ipe/ipe-secfs.c +67
-0+out: +return rc ==0 ?NULL :ERR_PTR (rc); +} + +/** +* ipe_secfs_del_policy: Delete a policy indicated by the name provided by +* @data +* @f: Unused. +* @data: Buffer containing the policy id to delete. +* @len: Length of @data. +* @offset: Offset into @data. +* +* NOTE: Newlines are treated as part of the name, if using echo to test, +* use -n to prohibit the silent addition of a newline. +* +* Return: +* > 0 - OK +* -ENOMEM - Out of memory +* -EPERM - Policy is active +* -ENOENT - Policy does not exist +* -EPERM - if a MAC subsystem is enabled, missing CAP_MAC_ADMIN +* Other - See retrieve_backed_dentry +*/ +static ssize_t ipe_secfs_del_policy (struct file *f,const char __user *data, +size_t len,loff_t *offset) +{ +ssize_t rc =0 ; +char *id =NULL ; +ssize_t written =0 ; +struct dentry *raw =NULL ; +struct dentry *content =NULL ; +struct inode *policy_i =NULL ; +struct dentry *policy_root =NULL ; +struct inode *policies_root =NULL ; +const struct ipe_policy *target =NULL ; + +if (!ns_capable (current_user_ns (),CAP_MAC_ADMIN )) +return -EPERM ; + + id =kzalloc (len,GFP_KERNEL ); +if (!id) { + rc = -ENOMEM ; + goto out; + } + + written =simple_write_to_buffer (id, len, offset, data, len); +if (written <0 ) { + rc = written; + goto out; + } + + policies_root =d_inode (ipe_policies_root); + + policy_root =retrieve_backed_dentry (id, ipe_policies_root, written); +if (IS_ERR_OR_NULL (policy_root)) { + rc =IS_ERR (policy_root) ?PTR_ERR (policy_root) : -ENOENT ; + goto out; + } + + policy_i =d_inode (policy_root); + +/* if the found dentry matches boot policy, fail */ +if (boot_policy_node == policy_root) { + rc = -EACCES ; + goto out1; + } +
Quoted 8 lines
security/ipe/ipe-secfs.c line 408
Quoted 7 lines
security/ipe/ipe-secfs.c +7
-0+ target = ((struct ipe_policy_node *)policy_i->i_private)->parsed; + +/* fail if it's the active policy */ +if (ipe_is_active_policy (target)) { + rc = -EPERM ; + goto out1; + }Why can it not become the active policy after this check?
Ah, good catch. (The test suite just caught this as well). So this needs to be synchronized with the active policy functions. I'm pretty sure I should just move the policy lock from the activation functions to be locked & unlocked here. That'll enforce that both are checked in blocking sections.
Quoted 67 lines
Quoted 67 lines
security/ipe/ipe-secfs.c +67
-0+ raw =retrieve_backed_dentry (IPE_FULL_CONTENT , policy_root, +strlen (IPE_FULL_CONTENT )); +if (IS_ERR_OR_NULL (raw)) { + rc =IS_ERR (raw) ?PTR_ERR (raw) : -ENOENT ; + goto out1; + } + + content =retrieve_backed_dentry (IPE_INNER_CONTENT , policy_root, +strlen (IPE_INNER_CONTENT )); +if (IS_ERR_OR_NULL (content)) { + rc =IS_ERR (content) ?PTR_ERR (content) : -ENOENT ; + goto out2; + } + +inode_lock (policies_root); +ipe_free_policy_node (policy_i->i_private); + policy_i->i_private =NULL ; +inode_unlock (policies_root); + +dput (raw); +dput (content); +dput (policy_root); +securityfs_remove (raw); +securityfs_remove (content); +securityfs_remove (policy_root); + +kfree (id); +return written; +out2: +dput (raw); +out1: +dput (policy_root); +out: +kfree (id); +return rc; +} + +/** +* ipe_secfs_rd_policy: Read the raw content (full enveloped PKCS7) data of +* the policy stored within the file's parent inode. +* @f: File representing the securityfs entry. +* @data: User mode buffer to place the raw pkcs7. +* @len: Length of @data. +* @offset: Offset into @data. +* +* Return: +* > 0 - OK +* -ENOMEM - Out of memory +*/ +static ssize_t ipe_secfs_rd_policy (struct file *f,char __user *data, +size_t size,loff_t *offset) +{ +ssize_t rc =0 ; +size_t avail =0 ; +u8 *buffer =NULL ; +struct inode *root =NULL ; +const struct ipe_policy_node *node =NULL ; + + root =d_inode (f->f_path.dentry->d_parent); + +inode_lock_shared (root); + node = (const struct ipe_policy_node *)root->i_private; + + avail = node->data_len; + buffer =kmemdup (node->data, avail,GFP_KERNEL ); +if (!buffer) { + rc = -ENOMEM ;
Quoted 8 lines
security/ipe/ipe-secfs.c line 482
Quoted 6 lines
security/ipe/ipe-secfs.c +6
-0+ goto cleanup; + } + + rc =simple_read_from_buffer (data, size, offset, buffer, avail); +cleanup: +inode_unlock_shared (root);Same thing as in
ipe_secfs_rd_content():simple_read_from_buffer()needlessly within locked section, buffer not freed.
I don't know how I missed such an obvious memleak. I'll remove the unnecessary kmemdup.
Quoted 38 lines
Quoted 38 lines
security/ipe/ipe-secfs.c +38
-0+ +return rc; +} + +/** +* ipe_secfs_ud_policy: Update a policy in place with a new PKCS7 policy. +* @f: File representing the securityfs entry. +* @data: Buffer user mode to place the raw pkcs7. +* @len: Length of @data. +* @offset: Offset into @data. +* +* Return: +* 0 - OK +* -EBADMSG - Invalid policy format +* -ENOMEM - Out of memory +* -EPERM - if a MAC subsystem is enabled, missing CAP_MAC_ADMIN +* -EINVAL - Incorrect policy name for this node, or version is < current +*/ +static ssize_t ipe_secfs_ud_policy (struct file *f,const char __user *data, +size_t len,loff_t *offset) +{ +ssize_t rc =0 ; +u8 *cpy =NULL ; +ssize_t written =0 ; +struct inode *root =NULL ; +struct crypto_shash *tfm =NULL ; +struct ipe_policy_node *new =NULL ; +struct ipe_policy_node *old =NULL ; + +if (!ns_capable (current_user_ns (),CAP_MAC_ADMIN )) +return -EPERM ; + + cpy =kzalloc (len,GFP_KERNEL ); +if (!cpy) { + rc = -ENOMEM ; + goto out; + } +
Quoted 8 lines
security/ipe/ipe-secfs.c line 327
Quoted 5 lines
security/ipe/ipe-secfs.c +5
-0+ written =simple_write_to_buffer (cpy, len, offset, data, len); +if (written <0 ) { + rc = written; + goto out; + }You'd probably be better off just doing
memdup_user()here.simple_write_to_buffer()only makes sense if you have a buffer that can be continuously updated with multiple writes.
Thanks, I'll fix it.
Quoted 68 lines
Quoted 47 lines
security/ipe/ipe-secfs.c +47
-0+ new =ipe_alloc_policy_node (cpy, len); +if (IS_ERR (new)) { + rc =PTR_ERR (new); + goto out; + } + + tfm =crypto_alloc_shash ("sha1" ,0 ,0 ); +if (IS_ERR (tfm)) + goto out2; + + root =d_inode (f->f_path.dentry->d_parent); +inode_lock (root); + + old = (struct ipe_policy_node *)root->i_private; + +if (strcmp (old->parsed->policy_name, new->parsed->policy_name)) { + rc = -EINVAL ; + goto out3; + } + +if (!ipe_is_valid_policy (old->parsed, new->parsed)) { + rc = -EINVAL ; + goto out3; + } + + rc =ipe_update_active_policy (old->parsed, new->parsed); +if (rc !=0 ) + goto out3; + +ipe_audit_policy_load (new->parsed, new->data, new->data_len, tfm); +swap (root->i_private, new); + +inode_unlock (root); +kfree (cpy); +ipe_free_policy_node (new); +crypto_free_shash (tfm); + +return written; +out3: +inode_unlock (root); +ipe_free_policy_node (new); +out2: +crypto_free_shash (tfm); +out: +kfree (cpy); +return rc; +}[...]
Quoted 20 lines
security/ipe/ipe-secfs.c +20
-0+static ssize_t ipe_secfs_rd_content (struct file *f,char __user *data, +size_t size,loff_t *offset) +{ +ssize_t rc =0 ; +size_t avail =0 ; +u8 *buffer =NULL ; +struct inode *root =NULL ; +const struct ipe_policy_node *node =NULL ; + + root =d_inode (f->f_path.dentry->d_parent); + +inode_lock (root); + node = (const struct ipe_policy_node *)root->i_private; + + avail = node->content_size; + buffer =kmemdup (node->content, avail,GFP_KERNEL ); +if (!buffer) { + rc = -ENOMEM ; + goto cleanup; + }
Quoted 8 lines
security/ipe/ipe-secfs.c line 610
Quoted 4 lines
security/ipe/ipe-secfs.c +4
-0+ + rc =simple_read_from_buffer (data, size, offset, buffer, avail); +cleanup: +inode_unlock (root);Why are you nod doing the
simple_read_from_buffer()afterinode_unlock()? The way you're doing it now, there isn't really a point in thekmemdup()at all...
Also, you'll have to free the buffer before returning.
I don't know how I missed such an obvious memleak. I'll remove the unnecessary kmemdup.
Quoted 32 lines
Quoted 3 lines
security/ipe/ipe-secfs.c +2
-0+return rc; +}[...]
Quoted 1 line
security/ipe/ipe-sysfs.c +0
-0[...]
Quoted 14 lines
security/ipe/ipe-sysfs.c +14
-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) { + id =kzalloc ((*lenp) +1 ,GFP_KERNEL ); +if (!id) +return -ENOMEM ; + + table->data = id;security/ipe/ipe-sysfs.c static int ipe_switch_mode(struct ctl_table *table, int write, · line 92
Quoted 10 lines
security/ipe/ipe-sysfs.c +10
-0+ 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 { +rcu_read_lock (); + size =strlen (rcu_dereference (ipe_active_policy)->policy_name);Can't
ipe_active_policybe NULL here?
Quoted 4 lines
security/ipe/ipe-sysfs.c static int ipe_switch_mode(struct ctl_table *table, int write, · line 95
Quoted 3 lines
security/ipe/ipe-sysfs.c +3
-0+rcu_read_unlock (); + + id =kzalloc (size +1 ,GFP_KERNEL );The
+ 1seems unnecessary.
This is actually necessary. size would point to the string without nullterm. strncpy below is due to if the active policy changes: if it's bigger, then we truncate, if it's smaller, we'll exit early. Either way, it's guaranteed to be null terminated.
Later, in proc_dostring, strlen is called, and as a result KASAN catches an OOB read without the +1.
Quoted 23 lines
Quoted 20 lines
security/ipe/ipe-sysfs.c +19
-0+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 */ [...]
Quoted 1 line
security/ipe/ipe.c +0
-0[...]
Quoted 8 lines
security/ipe/ipe.c MODULE_PARM_DESC(enforce, "enforce/permissive mode switch"); · line 106
Quoted 6 lines
security/ipe/ipe.c +6
-0+ +/** +* strict_parse: Kernel command line parameter to enable strict parsing of +* IPE policies - causing unrecognized properties to fail +* parsing. This breaks backwards compatibility of IPE policies, +* when enabled. I guess the backwards compatibility stuff is referring to an out-of-tree version of this series that you've already shipped?
Actually no. The backwards compatibility stuff is intended to help divorcing kernel updates from policy updates. At the moment, the default behavior of IPE is to ignore any lines that do not parse successfully. This allows policies written for newer versions of IPE to parse and apply successfully. Thus, policy can be updated without a dependency on the kernel being updated.
If that behavior isn't desirable, then you can enable this sysctl / kernel command line parameter to cause the unrecognized lines to error fatally. Operationally, I see merits to both methods, at the cost of what boils down to an if statement, so I kept this as a configurable option.
Quoted 5 lines
Quoted 3 lines
+ * This is also controlled by the sysctl, "ipe.strict_parse".
+ */(Also, same thing as in the other patch re sysctls and kernel command line parameters for the same feature.)
Yes, I am going to strip out all this.
RFC PATCH v2 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 | 14 +++- security/ipe/properties/Kconfig | 14 ++++ security/ipe/properties/Makefile | 11 +++ security/ipe/properties/boot-verified.c | 84 ++++++++++++++++++++++ security/ipe/properties/prop-entry.h | 20 ++++++ security/ipe/utility.h | 22 ++++++ 13 files changed, 344 insertions(+), 1 deletion(-) 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
@@ -38,4 +38,6 @@ config SECURITY_IPE_PERMISSIVE_SWITCH If unsure, answer Y. +source "security/ipe/properties/Kconfig" + endif
security/ipe/Makefile +4 -0
@@ -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
@@ -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>
@@ -333,6 +335,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 =prealloc_cache (ctx, &cache);if (rc !=0 ) goto cleanup;
security/ipe/ipe-hooks.c +19 -0
@@ -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>
@@ -149,3 +150,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
@@ -111,4 +111,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 +13 -1
@@ -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,6 +24,7 @@ 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), };/**
@@ -34,7 +36,13 @@ static struct security_hook_list ipe_hooks[] __lsm_ro_after_init = {*/ static int __init ipe_load_properties (void ) { -return 0 ; +int rc =0 ; + + rc =ipe_init_bootv (); +if (rc !=0 ) +return rc; + +return rc; }/**
@@ -54,6 +62,10 @@ static int __init ipe_init(void) {int rc =0 ; + 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
@@ -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
@@ -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 +84 -0
84 lines not on this page · raw message
security/ipe/properties/prop-entry.h new file +20 -0
@@ -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
@@ -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
RFC PATCH v2 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
RFC PATCH v2 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
@@ -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
@@ -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
@@ -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
kbuild test robot
build botRe: [RFC PATCH v2 06/12] dm-verity: move signature check after tree validation
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please…
Hi,
[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on kbuild/for-next]
[also build test ERROR on linus/master next-20200406]
[cannot apply to security/next-testing dm/for-next v5.6]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/deven-desai-linux-microsoft-com/Integrity-Policy-Enforcement-LSM-IPE/20200407-061828 base: https://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git for-next config: sparc64-randconfig-a001-20200407 (attached as .config) compiler: sparc64-linux-gcc (GCC) 9.3.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
GCC_VERSION=9.3.0 make.cross ARCH=sparc64
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
In file included from drivers/md/dm-verity-target.c:18:
>> drivers/md/dm-verity-verify-sig.h:38:1: error: expected identifier or '(' before '{' token
38 | {
| ^vim +38 drivers/md/dm-verity-verify-sig.h
88cd3e6cfac915 Jaskaran Khurana 2019-07-17 36
6a8bbd6bb3b982 Deven Bowers 2020-04-06 37 int verity_verify_root_hash(const struct dm_verity *v);
88cd3e6cfac915 Jaskaran Khurana 2019-07-17 @38 {
88cd3e6cfac915 Jaskaran Khurana 2019-07-17 39 return 0;
88cd3e6cfac915 Jaskaran Khurana 2019-07-17 40 }88cd3e6cfac915 Jaskaran Khurana 2019-07-17 41
:::::: The code at line 38 was first introduced by commit
:::::: 88cd3e6cfac915f50f7aa7b699bdf053afec866e dm verity: add root hash pkcs#7 signature verification
:::::: TO: Jaskaran Khurana <[email protected]> :::::: CC: Mike Snitzer <[email protected]>
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
RFC PATCH v2 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
@@ -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
@@ -624,4 +624,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
RFC PATCH v2 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 | 84 ++++++++++++++++++++ security/ipe/properties/prop-entry.h | 9 +++ security/ipe/utility.h | 10 +++ 15 files changed, 291 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
@@ -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
@@ -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
@@ -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
@@ -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>
@@ -124,6 +125,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
@@ -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
@@ -15,6 +15,7 @@#include <linux/mman.h> #include <linux/mm.h> #include <linux/security.h> +#include <linux/device-mapper.h> #define HAS_EXEC (_p, _rp) (((_rp) & PROT_EXEC) || ((_p) & PROT_EXEC))
security/ipe/ipe-hooks.h +43 -0
47 lines not on this page · raw message
security/ipe/ipe.c +18 -0
@@ -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; }
@@ -80,9 +87,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 enforce =1 ;
security/ipe/ipe.h +2 -0
@@ -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 enforce;extern int success_audit;extern int strict_parse;
security/ipe/properties/Kconfig +10 -0
@@ -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
@@ -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 +84 -0
84 lines not on this page · raw message
security/ipe/properties/prop-entry.h +9 -0
@@ -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
@@ -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
RFC PATCH v2 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
@@ -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
@@ -625,5 +625,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
RFC PATCH v2 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 | 155 ++++++++++++++++++++ security/ipe/properties/prop-entry.h | 9 ++ 7 files changed, 194 insertions(+), 1 deletion(-) create mode 100644 security/ipe/properties/dmverity-roothash.c
security/ipe/ipe-blobs.c +10 -0
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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 +155 -0
155 lines not on this page · raw message
security/ipe/properties/prop-entry.h +9 -0
@@ -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
RFC PATCH v2 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 | 487 ++++++++++++++++++ .../admin-guide/kernel-parameters.txt | 20 + MAINTAINERS | 1 + 4 files changed, 509 insertions(+) create mode 100644 Documentation/admin-guide/LSM/ipe.rst
Documentation/admin-guide/LSM/index.rst +1 -0
@@ -47,3 +47,4 @@ subdirectories. tomoyo Yama SafeSetID + ipe
Documentation/admin-guide/LSM/ipe.rst new file +487 -0
487 lines not on this page · raw message
Documentation/admin-guide/kernel-parameters.txt +20 -0
@@ -1913,6 +1913,26 @@ ip= [IP_PNP] See Documentation/admin-guide/nfs/nfsroot.rst. + ipe.enforce= [IPE] + Format: { "0" | "1" } + 0 - Start IPE in audit mode + 1 - Start IPE in enforce mode (default). + See Documentation/security/ipe.rst + + ipe.success_audit= + [IPE] Start IPE with success auditing + Format: { "0" | "1" } + 0 - Disable success auditing (default) + 1 - Enable success auditing + See Documentation/security/ipe.rst + + ipe.strict_parse= + [IPE] Start IPE with strict policy parsing enabled + Format: { "0" | "1" } + 0 - Disable strict parsing (default) + 1 - Enable strict parsing + See Documentation/security/ipe.rst + ipcmni_extend [KNL] Extend the maximum number of unique System V IPC identifiers from 32,768 to 16,777,216.
MAINTAINERS +1 -0
@@ -8441,6 +8441,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
Re: [RFC PATCH v2 11/12] documentation: Add IPE Documentation
Quoted 5 lines · On Mon, 6 Apr 2020 15:14:38 -0700 [email protected] wrote:
From: Deven Bowers <[email protected]>
Add IPE's documentation to the kernel tree.
Signed-off-by Deven Bowers <[email protected]>
Thanks for including this nice documentation from the outset! I have a couple of tiny nits to pick, but nothing really substantive to complain about, so:
[...]
Quoted 1 line
+IPE is a Linux Security Module, which allows for a configurable policy
I'd drop the comma (I told you these were nits!)
[...]
Documentation/admin-guide/LSM/ipe.rst line 111
Quoted 10 lines
Documentation/admin-guide/LSM/ipe.rst new file +10
-0+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
This pattern can be compressed a bit by just putting the "::" at the end of the last line of text:
indicating the policy name, and the policy version, for instance::
policy_name="Ex Policy" policy_version=0.0.0
The result is a bit more readable in the plain-text format, IMO, and renders exactly the same in Sphinx.
Thanks,
jon
Re: [RFC PATCH v2 11/12] documentation: Add IPE Documentation
Quoted 5 lines · Jonathan Corbet
Quoted 2 lines · On Mon, 6 Apr 2020 15:14:38 -0700 [email protected] wrote:
From: Deven Bowers <[email protected]>
Quoted 8 lines
Quoted 3 lines
Add IPE's documentation to the kernel tree.
Signed-off-by Deven Bowers <[email protected]>Thanks for including this nice documentation from the outset! I have a couple of tiny nits to pick, but nothing really substantive to complain about, so:
Acked-by Jonathan Corbet <[email protected]>
Thanks!
Quoted 4 lines
[...]
Quoted 1 line
+IPE is a Linux Security Module, which allows for a configurable policy
I'd drop the comma (I told you these were nits!)
Got it, thanks!
Quoted 16 lines
[...]
Documentation/admin-guide/LSM/ipe.rst line 111
Quoted 10 lines
Documentation/admin-guide/LSM/ipe.rst new file +10
-0+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.0This pattern can be compressed a bit by just putting the "::" at the end of the last line of text:
Quoted 6 lines
indicating the policy name, and the policy version, for instance::
policy_name="Ex Policy" policy_version=0.0.0
The result is a bit more readable in the plain-text format, IMO, and renders exactly the same in Sphinx.
Awesome. I'll address this feedback in v3.
RFC PATCH v2 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
@@ -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
Quoted 12 lines · On 4/6/20 6:14 PM, [email protected] wrote:
From: Deven Bowers <[email protected]>
Changelog:
------------------------------------v1: Introduced
v2:
Split the second patch of the previous series into two. Minor corrections in the cover-letter and documentation comments regardingCAP_MAC_ADMINchecks in IPE.
Quoted 7 lines
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.
Can you please clarify the "motivation" for this patch set more clearly? It seems to define a policy layer on top of dm-verity, which may be compiled into the kernel. In the motivation, can you please also make it explicit why existing mechanisms cannot be extended to achieve your purpose?
Also, AFIK, the changelog should be moved to the end of the patch description.
Thanks & Regards,
- Nayna
Quoted 22 lines · Nayna
Quoted 12 lines · On 4/6/20 6:14 PM, [email protected] wrote:
From: Deven Bowers <[email protected]>
Changelog:
------------------------------------v1: Introduced
v2:
Split the second patch of the previous series into two. Minor corrections in the cover-letter and documentation comments regardingCAP_MAC_ADMINchecks in IPE.Quoted 7 lines
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.
Quoted 2 lines
Can you please clarify the "motivation" for this patch set more clearly? It seems to define a policy layer on top of dm-verity, which may be compiled into the kernel. In the motivation, can you please also make it explicit why existing mechanisms cannot be extended to achieve your purpose?
This LSM was born out of a motivation to provide strong integrity guarantees without a dependency on file-metadata, allow the integrity claims to be configurable on a hot system, and allow for the mechanisms for ensuring integrity to be extendable.
This naturally had to be an LSM, as controlling execution at the block or filesystem layer does not make sense. Existing LSM implementations use filesystem metadata, and since one of IPE's goals is to secure file metadata, it is circular to depend on the file metadata itself to make decisions about whether the file has been modified.
Additionally, IPE while IPE currently provides dm-verity support and the trust root support, it can be easily extended to other implementations such as fs-verity. At it's core, IPE is attempting to separate mechanism (dm-verity, fs-verity, etc.) from policy (IPE).
Quoted 2 lines
Also, AFIK, the changelog should be moved to the end of the patch description.
Thanks! I'll move the changelog.