[Paper Review] Enclave-Aware Compartmentalization and Secure Sharing with Sirius

Zahra Tarkhani, Anil Madhavapeddy|arXiv (Cornell University)|Sep 3, 2020

Security and Verification in Computing70 references4 citations

TL;DR

Sirius is a novel compartmentalization framework that enforces strong isolation and secure sharing in TEE-assisted applications by controlling dataflows across kernel objects (e.g., threads, files, sockets) in both secure and normal worlds. It eliminates semantic gaps in TEEs by enforcing fine-grained access control, reducing attack surface, and improving security with only 10.8% overhead on average and performance gains of 0.05%–5.6% in existing TEE applications.

ABSTRACT

Hardware-assisted trusted execution environments (TEEs) are critical building blocks of many modern applications. However, they have a one-way isolation model that introduces a semantic gap between a TEE and its outside world. This lack of information causes an ever-increasing set of attacks on TEE-enabled applications that exploit various insecure interactions with the host OSs, applications, or other enclaves. We introduce Sirius, the first compartmentalization framework that achieves strong isolation and secure sharing in TEE-assisted applications by controlling the dataflows within primary kernel objects (e.g. threads, processes, address spaces, files, sockets, pipes) in both the secure and normal worlds. Sirius replaces ad-hoc interactions in current TEE systems with a principled approach that adds strong inter- and intra-address space isolation and effectively eliminates a wide range of attacks. We evaluate Sirius on ARM platforms and find that it is lightweight ($\approx 15K$ LoC) and only adds $\approx 10.8\%$ overhead to enable TEE support on applications such as httpd, and improves the performance of existing TEE-enabled applications such as the Darknet ML framework and ARM's LibDDSSec by $0.05\%-5.6\%$.

Motivation & Objective

• To address the semantic gap between trusted execution environments (TEEs) and their untrusted host environments, which enables a wide range of attacks.
• To eliminate common vulnerabilities in TEE-enabled applications, such as insecure threading, memory corruption, and privilege escalation via OS facilities.
• To provide a principled, composable mechanism for secure sharing and strong isolation across both secure and normal worlds.
• To reduce reliance on ad-hoc, error-prone security hardening of TEE interfaces by enforcing access control at the kernel object level.
• To enable secure, multi-threaded TEE applications with minimal performance impact and broad compatibility across TEE platforms.

Proposed method

• Sirius introduces an Inter-Module Control (IMC) mechanism that enforces access control policies on kernel objects such as threads, memory regions, files, and sockets in both the normal and secure worlds.
• It extends the kernel's mm_struct and task_struct with IMC metadata, including operation bitmaps (read, write, execute, allocate) and state tracking for each object.
• The framework enforces dataflow control by checking IMC permissions at every system call or privilege transition, ensuring only authorized operations are allowed.
• It leverages existing TEE hardware isolation (e.g., ARM TrustZone, Intel SGX) while adding a layer of mandatory access control over system resources.
• Sirius supports secure inter-enclave and inter-process communication by enforcing policy-based sharing of shared memory, RPCs, and IPCs.
• The system is designed to be lightweight, with only ~15K lines of code, and is portable across TEE platforms like ARM and x86-64.

Experimental results

Research questions

• RQ1 How can we close the semantic gap between TEEs and their host environments to prevent attacks via insecure interactions?
• RQ2 What mechanisms can enforce strong, fine-grained isolation and secure sharing across kernel objects in both secure and normal worlds?
• RQ3 Can a principled, composable access control framework reduce the attack surface of TEE applications without incurring prohibitive performance costs?
• RQ4 How effective is the proposed IMC-based access control model in mitigating real-world TEE vulnerabilities such as TOCTTOU, ROP, and BOOMERANG attacks?
• RQ5 To what extent can Sirius be integrated into existing TEE stacks with minimal modifications?

Key findings

• Sirius reduces the attack surface of TEE applications by enforcing mandatory access control on kernel objects such as threads, files, and shared memory.
• The framework adds only ~10.8% performance overhead on average when enabling TEE support in applications like httpd, with minimal impact on system-level performance.
• Existing TEE-enabled applications such as Darknet and LibDDSSec see performance improvements of 0.05% to 5.6% due to reduced attack surface and optimized dataflow control.
• The system is lightweight, with only ~15K lines of code, and is easily extensible to other TEE platforms like Intel SGX and RISC-V Keystone.
• Sirius effectively mitigates known attack classes including TOCTTOU, ROP, BOOMERANG, and HPE by enforcing strict isolation and access control at the kernel object level.
• The framework is compatible with modern CPU features such as memory tagging and hardware capabilities (e.g., CHERI), enabling future hardening extensions.