We continue discussing the paper "Shielding applications from an untrusted cloud with Haven,” written by Andrew Baumann, Marcus Peinado, and Galen Hunt. We were discussing how Haven mitigates lago attacks from a malicious host by narrowing down the OS calls, implementing a user mode runtime and by checking the parameters and return values of calls. In the event of an attack, the shield handles incorrect host behavior by panicking. It emits a short debug message, requests the host to terminate its process, and rejects subsequent attempts to enter the enclave. The interface at the enclave boundary that checks the correctness of all operations also enables a policy/mechanism separation. The guest controls policy for virtual resources ( virtual address allocation, threads, etc.), while the host manages policy only for physical resources (e.g. memory and CPU time). This is a classic design pattern that lets the host govern the state and restricts it to resource allocation and release. Since the host is responsible only for the physical resources, attacks and surface area is significantly reduced. Besides it takes the volatility out of the host, while enabling those changes with easy to modify policies by the guest. The policies can all be dropped and reloaded  at will while the server keeps track of only its state. The server doesn't even need to keep track of the changes to the allocations because policies can be dynamically mapped to resources. The combination of policy with the mechanism complement each other for the resource management.In this case, the implementation and verification becomes even more efficient with a minimalistic interface that is expressed as Drawbridge ABI. Specifically, this interface provides the following operations:
it calls to commit, free and protect specific page,
it manages threads and signals
it performs I/O streams to access untrusted storage and network and
it is a source of system time.
Haven augments the Drawbridge  ABI with this untrusted interface and an untrusted runtime outside the enclave. This runtime creates the enclave, loads the shield and forwards calls between the enclave and the host OS.