Integrity Policy Enforcement(IPE) 커널 설계

개발자용 IPE 문서

GPL-2.0으로 배포되는 Integrity Policy Enforcement(IPE) 커널 개발 문서다. 관리자용 사용법이 아니라 설계와 구현을 설명하며, 실제 운용 방법은 `IPE admin guide </admin-guide/LSM/ipe>`를 참조해야 한다.

.. SPDX-License-Identifier: GPL-2.0

Integrity Policy Enforcement (IPE) - Kernel Documentation
=========================================================

.. NOTE::

   This is documentation targeted at developers, instead of administrators.
   If you're looking for documentation on the usage of IPE, please see
   :doc:`IPE admin guide </admin-guide/LSM/ipe>`.

잠긴 시스템과 DM-Verity 선택

IPE 구현의 출발점은 부팅 순간부터 안전하며 실행 코드와 기능상 중요한 특정 데이터 파일에 강한 무결성 보장을 제공하는 locked-down 시스템이었다. 보호 대상 데이터는 무결성 정책을 통과해야 읽을 수 있어야 했고, 강제 접근 제어가 존재하므로 xattr도 보호해야 했다. 당시 후보는 IMA+EVM 서명과 DM-Verity였다.

원래 IPE 사용 사례에서 DM-Verity를 선택한 첫 이유는 추가 공격 경로의 방어다. IMA+EVM만 사용하고 암호화하지 않으면 보호 데이터 파일을 대상으로 한 오프라인 공격에 노출된다. 실행과 달리 모든 read에 무결성 검사를 강제할 수 없으므로 SELinux 같은 MAC 레이블로 보호 대상을 고를 수 있지만, 공격자가 파일 시스템을 오프라인으로 수정해 xattr와 레이블을 지우면 선택 기준 자체를 제거할 수 있다. DM-Verity는 xattr도 Merkle tree 일부로 저장하므로 오프라인 수정 시 checksum이 맞지 않아 읽기가 실패한다.

DM-Verity는 hostile block device가 최초 IMA hash 검사에는 정상 내용을 주고 실제 page fault에서는 공격 payload를 돌려주는 공격도 줄인다. 사용 공간 바이너리는 paging되지만 DM-Verity는 page fault의 디스크 접근 때 블록을 다시 검증한다. 또한 전체 파일을 메모리에 읽어 검증하는 대신 블록을 읽을 때 필요에 따라 검증하므로 성능상 이점이 있다.

서명 절차도 단순하다. IMA와 EVM의 두 서명 대신 하나의 서명이 전체 블록 장치를 덮고, 서명을 파일 시스템 메타데이터 밖에 둘 수 있으며 X.509 기반 서명 인프라를 지원한다.

Historical Motivation
---------------------

The original issue that prompted IPE's implementation was the creation
of a locked-down system. This system would be born-secure, and have
strong integrity guarantees over both the executable code, and specific
*data files* on the system, that were critical to its function. These
specific data files would not be readable unless they passed integrity
policy. A mandatory access control system would be present, and
as a result, xattrs would have to be protected. This lead to a selection
of what would provide the integrity claims. At the time, there were two
main mechanisms considered that could guarantee integrity for the system
with these requirements:

  1. IMA + EVM Signatures
  2. DM-Verity

Both options were carefully considered, however the choice to use DM-Verity
over IMA+EVM as the *integrity mechanism* in the original use case of IPE
was due to three main reasons:

  1. Protection of additional attack vectors:

    * With IMA+EVM, without an encryption solution, the system is vulnerable
      to offline attack against the aforementioned specific data files.

      Unlike executables, read operations (like those on the protected data
      files), cannot be enforced to be globally integrity verified. This means
      there must be some form of selector to determine whether a read should
      enforce the integrity policy, or it should not.

      At the time, this was done with mandatory access control labels. An IMA
      policy would indicate what labels required integrity verification, which
      presented an issue: EVM would protect the label, but if an attacker could
      modify filesystem offline, the attacker could wipe all the xattrs -
      including the SELinux labels that would be used to determine whether the
      file should be subject to integrity policy.

      With DM-Verity, as the xattrs are saved as part of the Merkel tree, if
      offline mount occurs against the filesystem protected by dm-verity, the
      checksum no longer matches and the file fails to be read.

    * As userspace binaries are paged in Linux, dm-verity also offers the
      additional protection against a hostile block device. In such an attack,
      the block device reports the appropriate content for the IMA hash
      initially, passing the required integrity check. Then, on the page fault
      that accesses the real data, will report the attacker's payload. Since
      dm-verity will check the data when the page fault occurs (and the disk
      access), this attack is mitigated.

  2. Performance:

    * dm-verity provides integrity verification on demand as blocks are
      read versus requiring the entire file being read into memory for
      validation.

  3. Simplicity of signing:

    * No need for two signatures (IMA, then EVM): one signature covers
      an entire block device.
    * Signatures can be stored externally to the filesystem metadata.
    * The signature supports an x.509-based signing infrastructure.

무결성 정책의 최소 요구사항

무결성 메커니즘을 선택한 다음에는 이를 집행할 정책이 필요했다. 정책 자체의 무결성 검증과 rollback 저항성, permissive 유사 모드, 재부팅 없는 전체 정책 교체, 원자적 update, 기존 구성 요소 철회, 어느 시점에서든 가능한 audit가 최소 요구사항이었다.

당시 유일한 무결성 정책 메커니즘인 IMA는 요구사항을 모두 충족하지 못했다. IMA를 확장하는 방안은 기존 사용자에게 영향을 줄 수 있는 큰 코드 변경의 regression 위험과, 측정·attestation 정책을 로컬 무결성 집행 정책과 분리하는 편이 낫다는 이유로 폐기됐다. 이에 로컬 무결성 정책 집행만 담당하는 새 LSM인 IPE를 만들었다.

The next step was to choose a *policy* to enforce the integrity mechanism.
The minimum requirements for the policy were:

  1. The policy itself must be integrity verified (preventing trivial
     attack against it).
  2. The policy itself must be resistant to rollback attacks.
  3. The policy enforcement must have a permissive-like mode.
  4. The policy must be able to be updated, in its entirety, without
     a reboot.
  5. Policy updates must be atomic.
  6. The policy must support *revocations* of previously authored
     components.
  7. The policy must be auditable, at any point-of-time.

IMA, as the only integrity policy mechanism at the time, was
considered against these list of requirements, and did not fulfill
all of the minimum requirements. Extending IMA to cover these
requirements was considered, but ultimately discarded for a
two reasons:

  1. Regression risk; many of these changes would result in
     dramatic code changes to IMA, which is already present in the
     kernel, and therefore might impact users.

  2. IMA was used in the system for measurement and attestation;
     separation of measurement policy from local integrity policy
     enforcement was considered favorable.

Due to these reasons, it was decided that a new LSM should be created,
whose responsibility would be only the local integrity policy enforcement.

IPE의 역할과 설계 원칙

IPE는 이름 그대로 무결성 정책을 집행하는 해결책이다. 무결성을 어떤 방식으로 제공해야 하는지는 강제하지 않으며, 시스템 관리자가 자신의 요구에 맞는 메커니즘과 보안 수준을 선택한다. 여러 무결성 제공자는 서로 다른 보장을 제공하고 IPE 정책은 이론적으로 모두를 표현할 수 있다.

IPE 자체에는 무결성을 보장하는 내장 메커니즘이 없다. 무결성 claim을 증명하는 메커니즘과 그 claim을 집행하는 정책은 독립적이다. 따라서 IPE는 무결성 제공자와 쉽게 통합되고 플랫폼 관리자와 시스템 관리자가 쉽게 사용할 수 있도록 설계됐다.

다른 운영체제와 환경의 기존 정책 체계를 조사하면서 사람이 읽을 수 없는 바이너리 중간 형식, 사용자 정의할 수 없는 단일 암묵적 기본 action, 위반 rule을 찾기 위한 수동 디버깅, 정책 작성에 필요한 과도한 시스템 지식이 문제로 확인됐다. IPE는 이 네 가지 함정을 피하려 한다.

Role and Scope
--------------

IPE, as its name implies, is fundamentally an integrity policy enforcement
solution; IPE does not mandate how integrity is provided, but instead
leaves that decision to the system administrator to set the security bar,
via the mechanisms that they select that suit their individual needs.
There are several different integrity solutions that provide a different
level of security guarantees; and IPE allows sysadmins to express policy for
theoretically all of them.

IPE does not have an inherent mechanism to ensure integrity on its own.
Instead, there are more effective layers available for building systems that
can guarantee integrity. It's important to note that the mechanism for proving
integrity is independent of the policy for enforcing that integrity claim.

Therefore, IPE was designed around:

  1. Easy integrations with integrity providers.
  2. Ease of use for platform administrators/sysadmins.

Design Rationale:
-----------------

IPE was designed after evaluating existing integrity policy solutions
in other operating systems and environments. In this survey of other
implementations, there were a few pitfalls identified:

  1. Policies were not readable by humans, usually requiring a binary
     intermediary format.
  2. A single, non-customizable action was implicitly taken as a default.
  3. Debugging the policy required manual steps to determine what rule was violated.
  4. Authoring a policy required an in-depth knowledge of the larger system,
     or operating system.

IPE attempts to avoid all of these pitfalls.

사람이 읽는 일반 텍스트 정책

IPE 정책은 일반 텍스트다. 다른 LSM보다 파일이 조금 커질 수 있지만 바이너리 정책에서 생기는 유지보수 중복과 투명성 문제를 해결한다. 정책 작성자는 XML·JSON·YAML 등 어떤 형태든 사람이 이해하는 문자열 표현으로 시작한다. 바이너리 설계라면 이를 바이너리로 만드는 serializer와 커널 구조체로 바꾸는 deserializer가 필요하다.

배포된 정책을 나중에 이해하려면 바이너리를 가능한 많은 정보와 함께 사람이 읽는 형식으로 되돌리는 또 다른 deserializer도 필요하다. 대규모 fleet에서는 여러 운영체제와 운용 요구에 따라 수년 전 stale policy가 남을 수 있으므로 checksum과 원본 파일을 별도 추적하거나 정책 복구 인프라를 운영해야 한다. 일반 텍스트를 직접 parse하면 사람이 읽는 형식에서 커널 구조체로 가는 serializer 하나만 유지하면 된다.

정책은 시스템 자원의 신뢰를 기준으로 접근을 통제하므로 정책 변경 자체도 신뢰할 수 있어야 하고 서명 과정이 필요하다. 서명 대상은 무결성 집행 체계를 공격하는 데 쓰일 수 있어 높은 보안 기준을 적용해야 한다. 바이너리 blob은 서명자가 내용을 보기 어렵지만 일반 텍스트 정책은 실제 규칙을 확인한 뒤 서명할 수 있어 투명하다.

Policy
~~~~~~

Plain Text
^^^^^^^^^^

IPE's policy is plain-text. This introduces slightly larger policy files than
other LSMs, but solves two major problems that occurs with some integrity policy
solutions on other platforms.

The first issue is one of code maintenance and duplication. To author policies,
the policy has to be some form of string representation (be it structured,
through XML, JSON, YAML, etcetera), to allow the policy author to understand
what is being written. In a hypothetical binary policy design, a serializer
is necessary to write the policy from the human readable form, to the binary
form, and a deserializer is needed to interpret the binary form into a data
structure in the kernel.

Eventually, another deserializer will be needed to transform the binary from
back into the human-readable form with as much information preserved. This is because a
user of this access control system will have to keep a lookup table of a checksum
and the original file itself to try to understand what policies have been deployed
on this system and what policies have not. For a single user, this may be alright,
as old policies can be discarded almost immediately after the update takes hold.
For users that manage computer fleets in the thousands, if not hundreds of thousands,
with multiple different operating systems, and multiple different operational needs,
this quickly becomes an issue, as stale policies from years ago may be present,
quickly resulting in the need to recover the policy or fund extensive infrastructure
to track what each policy contains.

With now three separate serializer/deserializers, maintenance becomes costly. If the
policy avoids the binary format, there is only one required serializer: from the
human-readable form to the data structure in kernel, saving on code maintenance,
and retaining operability.

The second issue with a binary format is one of transparency. As IPE controls
access based on the trust of the system's resources, it's policy must also be
trusted to be changed. This is done through signatures, resulting in needing
signing as a process. Signing, as a process, is typically done with a
high security bar, as anything signed can be used to attack integrity
enforcement systems. It is also important that, when signing something, that
the signer is aware of what they are signing. A binary policy can cause
obfuscation of that fact; what signers see is an opaque binary blob. A
plain-text policy, on the other hand, the signers see the actual policy
submitted for signing.

부팅 정책과 initramfs 전환

적절히 설정된 IPE는 커널 부팅 뒤 usermode가 시작되자마자 정책을 집행할 수 있다. 시작 정책의 저장 방식은 디스크 파일을 커널이 집행 결정 전에 읽기, bootloader가 정책을 커널에 전달하기, 정책 파일을 커널에 빌드해 초기화 때 parse하기의 세 가지다.

커널이 사용자 공간의 파일을 직접 읽는 첫 방식은 권장되지 않고 드물다. 두 번째는 Linux가 지원하는 모든 bootloader가 새 전달 방식을 구현해야 하거나 별도 소스가 필요하며 커널 시작 절차를 필요 이상으로 크게 바꿀 수 있다. 세 번째가 가장 적합하지만 정책이 커널 이미지 공간을 차지한다. 또한 사용자 공간이 더 복잡한 새 정책을 올릴 수 있을 만큼 일반적이면서 과도한 권한을 주지 않을 만큼 제한적이어야 한다.

initramfs를 사용하면 이 전환을 구성할 수 있다. 커널은 initramfs만 신뢰하는 최소 정책으로 시작한다. initramfs 안에서 실제 rootfs를 mount하되 아직 전환하기 전에 새 rootfs를 신뢰하는 정책을 배포하고 활성화한다. 이 방식은 어느 단계에서도 과도한 권한을 주지 않고 빌드 내장 정책도 작게 유지한다.

모든 시스템이 initramfs로 시작하지는 않으므로 커널에 빌드된 시작 정책은 다음 부팅 단계의 신뢰 수립 방식을 표현할 유연성이 필요하다. 빌드 내장 정책을 완전한 IPE 정책으로 만들면 시스템 제작자가 첫 단계의 부팅 요구사항을 정확히 기술할 수 있다.

Boot Policy
~~~~~~~~~~~

IPE, if configured appropriately, is able to enforce a policy as soon as a
kernel is booted and usermode starts. That implies some level of storage
of the policy to apply the minute usermode starts. Generally, that storage
can be handled in one of three ways:

  1. The policy file(s) live on disk and the kernel loads the policy prior
     to an code path that would result in an enforcement decision.
  2. The policy file(s) are passed by the bootloader to the kernel, who
     parses the policy.
  3. There is a policy file that is compiled into the kernel that is
     parsed and enforced on initialization.

The first option has problems: the kernel reading files from userspace
is typically discouraged and very uncommon in the kernel.

The second option also has problems: Linux supports a variety of bootloaders
across its entire ecosystem - every bootloader would have to support this
new methodology or there must be an independent source. It would likely
result in more drastic changes to the kernel startup than necessary.

The third option is the best but it's important to be aware that the policy
will take disk space against the kernel it's compiled in. It's important to
keep this policy generalized enough that userspace can load a new, more
complicated policy, but restrictive enough that it will not overauthorize
and cause security issues.

The initramfs provides a way that this bootup path can be established. The
kernel starts with a minimal policy, that trusts the initramfs only. Inside
the initramfs, when the real rootfs is mounted, but not yet transferred to,
it deploys and activates a policy that trusts the new root filesystem.
This prevents overauthorization at any step, and keeps the kernel policy
to a minimal size.

Startup
^^^^^^^

Not every system, however starts with an initramfs, so the startup policy
compiled into the kernel will need some flexibility to express how trust
is established for the next phase of the bootup. To this end, if we just
make the compiled-in policy a full IPE policy, it allows system builders
to express the first stage bootup requirements appropriately.

재부팅 없는 전체 정책 교체와 서명

기존 신뢰 애플리케이션의 취약점 발견이나 키 교체처럼 요구사항은 변한다. 보안 목표만을 위해 커널을 갱신하는 것은 항상 적절하거나 무위험하지 않고, 보안 update를 막으면 시스템이 취약해진다. 따라서 IPE 정책은 기존 정책을 철회할 수 있도록 전체를 교체할 수 있어야 하고, 커널 외부에서 공급해 커널 update 없이 갱신할 수 있어야 한다.

커널은 부팅 간 상태를 보존하지 않고 커널 공간에서 디스크 정책 파일을 읽는 것도 바람직하지 않으므로 update는 재부팅 없이 이뤄져야 한다. 외부 소스는 악의적일 수 있어 정책이 신뢰됨을 식별해야 한다. IPE는 커널의 신뢰 원천으로 이어지는 서명을 사용하며, 기본 신뢰 원천은 빌드 시 채워지는 `SYSTEM_TRUSTED_KEYRING`이다. 이는 빌드 내장 정책 작성자와 update 배포 주체가 같다는 기대에 맞는다.

Updatable, Rebootless Policy
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

As requirements change over time (vulnerabilities are found in previously
trusted applications, keys roll, etcetera). Updating a kernel to change the
meet those security goals is not always a suitable option, as updates are not
always risk-free, and blocking a security update leaves systems vulnerable.
This means IPE requires a policy that can be completely updated (allowing
revocations of existing policy) from a source external to the kernel (allowing
policies to be updated without updating the kernel).

Additionally, since the kernel is stateless between invocations, and reading
policy files off the disk from kernel space is a bad idea(tm), then the
policy updates have to be done rebootlessly.

To allow an update from an external source, it could be potentially malicious,
so this policy needs to have a way to be identified as trusted. This is
done via a signature chained to a trust source in the kernel. Arbitrarily,
this is  the ``SYSTEM_TRUSTED_KEYRING``, a keyring that is initially
populated at kernel compile-time, as this matches the expectation that the
author of the compiled-in policy described above is the same entity that can
deploy policy updates.

policy_version과 재부팅 경계

시간이 지나면 취약점이 발견되어 기존 자원을 더 이상 신뢰할 수 없고, 잘못 작성한 안전하지 않은 정책을 배포했다가 수정할 수도 있다. 공격자가 서명된 취약 정책을 확보했다면 안전한 update 이후 그 정책으로 되돌리는 rollback을 막아야 한다.

IPE 정책의 `policy_version`은 시스템에서 활성화할 수 있는 모든 정책의 최소 버전을 나타내며 실행 중 rollback을 막는다. 그러나 커널은 부팅 간 상태를 보존하지 않으므로 다음 부팅에서는 정책 버전이 `0.0.0`으로 초기화된다. 시스템 제작자는 부팅 직후 새 안전 정책을 가능한 빨리 배포해 공격자가 취약 정책을 올릴 수 있는 시간 창을 최소화해야 한다.

Anti-Rollback / Anti-Replay
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Over time, vulnerabilities are found and trusted resources may not be
trusted anymore. IPE's policy has no exception to this. There can be
instances where a mistaken policy author deploys an insecure policy,
before correcting it with a secure policy.

Assuming that as soon as the insecure policy is signed, and an attacker
acquires the insecure policy, IPE needs a way to prevent rollback
from the secure policy update to the insecure policy update.

Initially, IPE's policy can have a policy_version that states the
minimum required version across all policies that can be active on
the system. This will prevent rollback while the system is live.

.. WARNING::

  However, since the kernel is stateless across boots, this policy
  version will be reset to 0.0.0 on the next boot. System builders
  need to be aware of this, and ensure the new secure policies are
  deployed ASAP after a boot to ensure that the window of
  opportunity is minimal for an attacker to deploy the insecure policy.

operation별 명시적 DEFAULT action

암묵적 action의 문제는 시스템 안의 여러 operation에 서로 다른 보안 기준을 적용할 때 드러난다. 실행 코드는 예외 없이 강한 무결성을 요구하지만 중요한 특정 데이터 파일만 보호하고 일반 로그 쓰기·읽기는 허용할 수 있다. rule 불일치 시 항상 DENY, 항상 ALLOW, 정책 작성자가 operation별 기본 action을 지정하는 세 모델이 가능하다.

불일치를 DENY하는 첫 모델에서 `op=EXECUTE integrity_verified=YES action=ALLOW`는 실행 보호에 잘 맞는다. 그러나 데이터 read에는 중요 레이블의 검증 실패를 DENY하고 나머지를 ALLOW하는 마지막 빈 규칙이 필요해 실질적으로 기본값을 바꾼다. 불일치를 ALLOW하는 두 번째 모델은 중요 데이터 read 규칙은 간단하지만 실행에서는 검증 성공을 ALLOW한 뒤 나머지를 DENY하는 빈 규칙이 필요하다.

IPE는 세 번째 모델을 택해 사용자가 각 operation의 기본값을 명시하도록 강제한다. 예제는 `DEFAULT op=EXECUTE action=DENY` 뒤 검증된 실행만 ALLOW하고, `DEFAULT op=READ action=ALLOW` 뒤 `critical_t` 레이블에서 검증되지 않은 read만 DENY한다. 규칙은 작성 순서대로 평가된다.

Implicit Actions:
~~~~~~~~~~~~~~~~~

The issue of implicit actions only becomes visible when you consider
a mixed level of security bars across multiple operations in a system.
For example, consider a system that has strong integrity guarantees
over both the executable code, and specific *data files* on the system,
that were critical to its function. In this system, three types of policies
are possible:

  1. A policy in which failure to match any rules in the policy results
     in the action being denied.
  2. A policy in which failure to match any rules in the policy results
     in the action being allowed.
  3. A policy in which the action taken when no rules are matched is
     specified by the policy author.

The first option could make a policy like this::

  op=EXECUTE integrity_verified=YES action=ALLOW

In the example system, this works well for the executables, as all
executables should have integrity guarantees, without exception. The
issue becomes with the second requirement about specific data files.
This would result in a policy like this (assuming each line is
evaluated in order)::

  op=EXECUTE integrity_verified=YES action=ALLOW

  op=READ integrity_verified=NO label=critical_t action=DENY
  op=READ action=ALLOW

This is somewhat clear if you read the docs, understand the policy
is executed in order and that the default is a denial; however, the
last line effectively changes that default to an ALLOW. This is
required, because in a realistic system, there are some unverified
reads (imagine appending to a log file).

The second option, matching no rules results in an allow, is clearer
for the specific data files::

  op=READ integrity_verified=NO label=critical_t action=DENY

And, like the first option, falls short with the execution scenario,
effectively needing to override the default::

  op=EXECUTE integrity_verified=YES action=ALLOW
  op=EXECUTE action=DENY

  op=READ integrity_verified=NO label=critical_t action=DENY

This leaves the third option. Instead of making users be clever
and override the default with an empty rule, force the end-user
to consider what the appropriate default should be for their
scenario and explicitly state it::

  DEFAULT op=EXECUTE action=DENY
  op=EXECUTE integrity_verified=YES action=ALLOW

  DEFAULT op=READ action=ALLOW
  op=READ integrity_verified=NO label=critical_t action=DENY

일치한 규칙을 직접 audit

정책 개발에서는 어떤 줄이 위반됐는지 알아야 조사 범위를 줄일 수 있다. 일부 체계는 평가 입력만 기록해 사용자가 정책과 다시 대조해야 하지만, IPE는 실제로 일치한 rule을 내보낸다. 구체 rule이면 정확한 정책 줄, `DEFAULT`면 해당 section까지 범위를 좁혀 반복 수정과 조사 시간을 줄인다.

정책 엔진은 사람이 실패 과정을 재현하기 쉽게 설계됐다. 각 줄을 작성 순서대로 평가하므로 알고리즘이 단순하다. load 때 rule을 정렬하는 등 최적화하는 체계는 디버깅 단계가 늘고 코드를 읽기 전에는 실제 순서가 분명하지 않을 수 있지만 IPE는 원문 순서를 유지한다.

Policy Debugging:
~~~~~~~~~~~~~~~~~

When developing a policy, it is useful to know what line of the policy
is being violated to reduce debugging costs; narrowing the scope of the
investigation to the exact line that resulted in the action. Some integrity
policy systems do not provide this information, instead providing the
information that was used in the evaluation. This then requires a correlation
with the policy to evaluate what went wrong.

Instead, IPE just emits the rule that was matched. This limits the scope
of the investigation to the exact policy line (in the case of a specific
rule), or the section (in the case of a DEFAULT). This decreases iteration
and investigation times when policy failures are observed while evaluating
policies.

IPE's policy engine is also designed in a way that it makes it obvious to
a human of how to investigate a policy failure. Each line is evaluated in
the sequence that is written, so the algorithm is very simple to follow
for humans to recreate the steps and could have caused the failure. In other
surveyed systems, optimizations occur (sorting rules, for instance) when loading
the policy. In those systems, it requires multiple steps to debug, and the
algorithm may not always be clear to the end-user without reading the code first.

syscall 대신 operation 중심 정책

IPE 정책의 대상은 커널 개발자가 아니라 시스템 관리자다. 개별 LSM hook이나 syscall 대신 상위 수준 operation을 다룬다. 관리자는 `mmap`, `mprotect`, `execve`, `uselib` 각각을 알아야 하는 대신 code execution을 제한한다는 요구만 표현하면 된다. 이로써 내부 지식 부족으로 생기는 우회를 줄이고, 어떤 hook이 어떤 조건에서 operation으로 매핑되는지는 IPE 유지관리자가 책임진다.

Simplified Policy:
~~~~~~~~~~~~~~~~~~

Finally, IPE's policy is designed for sysadmins, not kernel developers. Instead
of covering individual LSM hooks (or syscalls), IPE covers operations. This means
instead of sysadmins needing to know that the syscalls ``mmap``, ``mprotect``,
``execve``, and ``uselib`` must have rules protecting them, they must simple know
that they want to restrict code execution. This limits the amount of bypasses that
could occur due to a lack of knowledge of the underlying system; whereas the
maintainers of IPE, being kernel developers can make the correct choice to determine
whether something maps to these operations, and under what conditions.

익명 메모리와 파일 없는 입력

IPE는 익명 메모리를 다른 접근과 별도로 취급하지 않는다. 익명 메모리에 `+X`를 부여하면 `file_mmap` 또는 `file_mprotect` hook으로 들어오지만 파일 객체는 `NULL`이다. 이 요청도 다른 파일처럼 평가되지만 현재 trust property는 모두 파일 기반이므로 파일과 연결되지 않은 operation에서는 모두 false가 된다.

`kernel_load_data` hook에서 커널이 파일로 뒷받침되지 않는 사용자 공간 버퍼의 데이터를 load할 때도 같은 일이 발생한다. 이 경우에도 현재 trust property는 모두 false로 평가된다.

Implementation Notes
--------------------

Anonymous Memory
~~~~~~~~~~~~~~~~

Anonymous memory isn't treated any differently from any other access in IPE.
When anonymous memory is mapped with ``+X``, it still comes into the ``file_mmap``
or ``file_mprotect`` hook, but with a ``NULL`` file object. This is submitted to
the evaluation, like any other file. However, all current trust properties will
evaluate to false, as they are all file-based and the operation is not
associated with a file.

.. WARNING::

  This also occurs with the ``kernel_load_data`` hook, when the kernel is
  loading data from a userspace buffer that is not backed by a file. In this
  scenario all current trust properties will also evaluate to false.

정책별 securityfs 트리

IPE의 정책별 `securityfs` 트리는 일반적인 정책 트리와 조금 다르다. `MyPolicy` 디렉터리 아래에는 `active`, `delete`, `name`, `pkcs7`, `policy`, `update`, `version` 항목이 있다. 정책 객체는 `MyPolicy` inode의 `->i_private` 데이터에 저장된다.

Securityfs Interface
~~~~~~~~~~~~~~~~~~~~

The per-policy securityfs tree is somewhat unique. For example, for
a standard securityfs policy tree::

  MyPolicy
    |- active
    |- delete
    |- name
    |- pkcs7
    |- policy
    |- update
    |- version

The policy is stored in the ``->i_private`` data of the MyPolicy inode.

KUnit과 통합 테스트

IPE에는 정책 parser용 KUnit 테스트가 있다. 권장 `kunitconfig`는 KUnit, Security, securityfs, PKCS#7 parser, system data verification, fs-verity와 내장 서명, block·device mapper·dm-verity와 root hash 서명 검증, networking, audit와 audit syscall, initrd를 활성화한다.

IPE 자체 설정으로 `CONFIG_SECURITY_IPE`, DM-Verity·DM-Verity 서명·fs-verity·fs-verity 내장 서명 trust property와 `CONFIG_SECURITY_IPE_KUNIT_TEST`를 활성화한다. 원문의 전체 `CONFIG_*` 목록과 값은 그대로 보존된다.

추가로 IPE에는 Python 기반 통합 테스트 모음 `https://github.com/microsoft/ipe/tree/test-suite`가 있으며 사용자 인터페이스와 실제 정책 집행 기능을 함께 검사할 수 있다.

Tests
-----

IPE has KUnit Tests for the policy parser. Recommended kunitconfig::

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

  CONFIG_SECURITY_IPE=y
  CONFIG_IPE_PROP_DM_VERITY=y
  CONFIG_IPE_PROP_DM_VERITY_SIGNATURE=y
  CONFIG_IPE_PROP_FS_VERITY=y
  CONFIG_IPE_PROP_FS_VERITY_BUILTIN_SIG=y
  CONFIG_SECURITY_IPE_KUNIT_TEST=y

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