TL;DR
This paper introduces a novel framework for "Representation-Independent Data Usage Control" that allows security policies to be defined and enforced across all representations of a data item, regardless of its layer of abstraction. This is crucial for modern systems where data exists in diverse forms (files, memory, network packets, etc.) and ensuring consistent security across these forms is a significant challenge.
What Problem Does This Paper Address?
In today's complex computing environments, data rarely exists in a single form. A document can be a file on disk, a block of memory, a network packet, or a visual representation in a GUI. Traditional usage control models often struggle with this, as policies are typically defined for specific representations (e.g., "don't copy this file"). This leads to a fragmented security approach where a policy applied to a file might not automatically extend to its cached copy or its representation in a running application. The challenge is to create a unified security model that understands and controls data usage across all its manifestations, from the operating system level to the application and windowing system levels.
Methods
The authors propose a framework that combines two key technologies:
- Usage Control (UC) Policies: They extend existing UC models to incorporate "data usages," allowing policies to refer to data items directly rather than specific representations. This is achieved by augmenting the policy language with state-based operators that query the system's data state.
- Data Flow Tracking: To understand how data moves between representations, they integrate a data flow tracking model. This model tracks the flow of data between different "containers" (representations) and across various abstraction layers.
The core of their approach is to link these two. When a usage control policy is triggered, the system consults the data flow tracking component to identify all representations of the data item in question. The policy is then evaluated against all these representations simultaneously. They also introduce a layered architecture consisting of:
- Policy Enforcement Point (PEP): Observes, intercepts, and potentially modifies events.
- Policy Decision Point (PDP): Evaluates policies based on events and system state.
- Policy Information Point (PIP): Provides the current data flow state to the PDP.
Datasets
Not discussed in the paper. The paper focuses on a conceptual model and its implementation, with examples and proofs of concept rather than formal dataset evaluations.
Key Insights and Ideas
- Data vs. Representation: The fundamental insight is the explicit distinction between "data" and its "representation." This allows for a more holistic approach to security.
- Unified Policy Enforcement: By combining data flow tracking with usage control, policies can be enforced consistently across all representations of a data item, regardless of where they reside in the system.
- Layered Abstraction: The framework is designed to be instantiated at different layers of abstraction (OS, windowing system, browser), enabling cross-layer enforcement.
- "Data Usage" Events: Introducing a new class of events that refer to data items directly, rather than specific containers, is key to achieving representation-independent control.
Key Results
The paper presents a formal model and a proof-of-concept implementation demonstrating the feasibility of their approach. They showcase instantiations for:
- Operating System (OpenBSD): Enforcing policies on file access, including temporal and cardinality constraints.
- Windowing System (X11): Preventing unauthorized screenshots by modifying parameters.
- Web Browser (Firefox): Controlling printing and copy-paste operations, and preventing data leakage.
They also demonstrate a cross-layer enforcement scenario where policies are coordinated across these layers, such as preventing a user from saving a picture downloaded from a web page to disk, while allowing it to be viewed within the browser.
Limitations and Future Work
The authors acknowledge several limitations:
- Security and Performance Analysis: The paper focuses on the model and implementation, not on rigorous security or performance analyses. They note that their current implementation has an overhead of one to two orders of magnitude.
- Policy Deployment and Lifecycle Management: The paper does not address how policies are deployed, managed, or updated dynamically.
- Media Breaks: The problem of media breaks (e.g., taking a photograph of the screen) is not addressed.
- Data Flow Model Simplicity: The current data flow model is considered simple and may lead to "label creep" in practice. They plan to investigate more sophisticated models, like quantitative information flow.
- Cross-Layer Implementation: The current cross-layer enforcement is an "ad-hoc" implementation, and a generic solution is still a subject of future work.
- Virtualization: They note that running in a virtual machine could bypass some security measures, suggesting the need for hypervisor-level enforcement.
Future work includes developing generic cross-layer enforcement, formalizing dependent events, and protecting the enforcement infrastructure itself.
Summary updated