A technical architecture for enforcing usage control requirements in service-oriented architectures

Berthold Agreiter, Muhammad Alam, Ruth Breu, Michael Hafner, Alexander Pretschner, Jean-Pierre Seifert, Xinwen ZhangSws 2007 · DOI

TL;DR

This paper presents a technical architecture for enforcing usage control policies on remote clients in Service-Oriented Architectures (SOAs). By leveraging trusted computing technologies and a model-driven approach to policy specification, it allows data providers to maintain control over how their data is used even after it leaves their direct control.

What Problem Does This Paper Address?

In traditional Service-Oriented Architectures (SOAs), once data is shared with a remote client, the data provider loses control over its usage. This is a significant security concern, especially when dealing with sensitive information. Existing security models primarily focus on access control at the server, but they don't address "usage control" – what happens to the data after it's been accessed. The challenge is to enforce policies on remote, potentially untrusted, client platforms, which are often heterogeneous and open. This paper tackles the problem of enforcing granular usage control requirements on remote clients in SOAs, ensuring that data is used according to the owner's specifications.

Methods

The proposed architecture combines several key technologies:

  • Trusted Computing (TC): The foundation of the system relies on hardware-based roots of trust, specifically the Trusted Platform Module (TPM). This allows for secure measurement of the software stack running on the client, enabling remote attestation to verify the client's integrity.
  • Model-Driven Security: To simplify policy creation, the authors introduce a model-driven approach using a predicative language called SECTET-PL. This language allows for the specification of fine-grained, data-dependent access permissions and usage constraints in a platform-independent manner. These specifications are then automatically translated into XACML (eXtensible Access Control Markup Language) policies.
  • OSGi Framework: The architecture utilizes the OSGi framework to create a secure, domain-separated runtime environment on the client. This framework manages independent Java services (Bundles) and ensures that only signed, trusted code is executed.
  • Enforcing Agent (EA) and Attestation Agent (AA): These are key OSGi Bundles. The EA acts as a security proxy, enforcing the usage control policies. The AA verifies the properties of other application bundles to ensure they can enforce the policies.
  • Asymmetric Authorization Transfer Protocol (AATP): This protocol is used to securely transfer authorization data (a "domain secret") to the remote client, which is then protected by the TPM.

Datasets

Not discussed in the paper.

Key Insights and Ideas

  • Bridging the Gap in SOAs: The paper effectively addresses the critical gap in SOA security where data control is lost once it leaves the server. By enabling remote policy enforcement, it brings a new level of security to data sharing.
  • Trusted Computing for Open Systems: Leveraging TC technologies like TPMs is crucial for establishing trust in open and heterogeneous SOA environments, which are typically difficult to secure.
  • Simplifying Policy Management: The model-driven approach with SECTET-PL significantly reduces the complexity of defining and managing usage control policies, making them accessible to policy modelers without deep technical knowledge of the target platform.
  • Granular Enforcement at the Application Level: The architecture enforces usage control at the level of trusted applications, offering a more fine-grained control than traditional operating system calls or API enforcement.
  • Holistic Security Approach: The integration of authentication, remote attestation, policy enforcement, and secure data handling creates a robust and comprehensive security framework.

Key Results

The paper presents a technical architecture and the underlying protocols for enforcing usage control policies. While specific quantitative results are not detailed, the contribution lies in the architectural design and the proposed mechanisms for:

  • Establishing a trusted relationship between service providers and remote clients through authentication and remote attestation.
  • Securely delivering documents along with usage and application policies.
  • Configuring an "Enforcing Agent" on the client to adhere to these policies.
  • Demonstrating how usage control requirements (e.g., time-based restrictions, access limitations) can be specified and enforced.

Limitations and Future Work

The authors acknowledge several limitations and suggest future directions:

  • Trust in Applications: The architecture assumes that the "trusted applications" running on the client will adhere to the policies. It does not enforce usage restrictions at the level of Java API or operating system calls, relying on the integrity of these trusted applications.
  • Implementation and Case Studies: The authors plan to implement the architecture using existing trusted computing technology and conduct case studies to assess its benefits and shortcomings.
  • Granularity of Enforcement: Further research is needed to determine the optimal level of granularity for usage control enforcement (e.g., trusted applications vs. OS/API calls) and the contexts where each is most appropriate.
  • Semantic Attestation: While the paper focuses on property-based attestation, future work could explore more advanced semantic attestation techniques for richer policy enforcement.

Summary updated

BibTeX
@inproceedings{agreiter2007technical,
  author = {Berthold Agreiter and Muhammad Alam and Ruth Breu and Michael Hafner and Alexander Pretschner and Jean-Pierre Seifert and Xinwen Zhang},
  title = {{A technical architecture for enforcing usage control requirements in service-oriented architectures}},
  booktitle = {Sws},
  year = {2007},
  doi = {10.1145/1314418.1314422},
}
Figure