docs: security: ipe: fix typos and grammar

*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

as a result, xattrs would have to be protected. This led 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:

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.

     to a 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

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

trusted applications, keys roll, etcetera), updating a kernel to 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

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

``execve``, and ``uselib`` must have rules protecting them, they must simply 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