Dynamic Analysis of Usage Control Policies

Yehia Elrakaiby, Jun PangSECRYPT 2014 · DOI

TL;DR

This paper introduces a novel approach for dynamically analyzing usage control policies, which extend traditional access control by specifying requirements before, during, and after access. By formalizing target domains and their policies using the action language C+ and employing model checking, the authors enable automated verification of these complex policies, ensuring security goals are met before deployment.

What Problem Does This Paper Address?

Traditional access control systems focus on who can access what. However, modern systems require more nuanced control, specifying how, when, and under what conditions access is granted and maintained. This is where "usage control" comes in, allowing for fine-grained policies that cover pre-access (e.g., accepting terms), ongoing-access (e.g., maintaining an ad window), and post-access requirements. The challenge is that these complex policies, when implemented, can lead to unintended vulnerabilities if not correctly specified or enforced. Mis-specified policies can compromise overall system security. While static analysis of policies exists, the dynamic behavior and state evolution of usage control policies have remained largely unexplored. This paper addresses this gap by providing a method to formally analyze and verify these dynamic aspects of usage control policies.

Methods

The core of the paper's approach involves two main steps:

  1. Formal Description: The target domain and its usage control policy are formally described using the action language C+. C+ is a powerful language for specifying dynamic systems with explicit transition system semantics, allowing for the representation of inertia, non-determinism, and complex state changes.
  2. Model Checking: The formalized domain and policy are then fed into a model checker. This allows for the automated verification of desired properties of the usage control policy. The authors also formalize usage control management aspects like activation, cancellation, and session management, enabling the use of standard model-checking techniques.

Key to their method is the construction of a "usage-controlled action description" ($D_{PU}$). This extended description models the target domain after the usage policy has been enforced. It achieves this by:

  • Replacing original domain actions with tryaccess(A) and permitaccess(A) actions.
  • Introducing new policy fluents and actions to track the state of usage sessions and controls.
  • Defining "policy management rules" (causal laws) that specify how these policy fluents and actions interact.

The paper also leverages Action-based Computational Tree Logic (ACTL) to define and verify specific usage control properties, such as authorization policies, obligation fulfillment, and action executability.

Datasets

Not discussed in the paper. The paper uses a running example of a movie player application ("iX") to illustrate its approach, but this is a conceptual example, not a dataset for training or evaluation.

Key Insights and Ideas

  • Bridging the Gap: The paper successfully bridges the gap between abstract usage control policy specifications and their concrete, dynamic enforcement within a target domain.
  • Formalizing Dynamic Behavior: By using C+ and model checking, the authors provide a rigorous way to analyze the state evolution and temporal aspects of usage control policies, which is crucial for understanding their real-world impact.
  • Comprehensive Policy Modeling: The approach accounts for the interplay between authorizations, obligations, and usage sessions, offering a more holistic view of security policy enforcement.
  • Enabling Automated Verification: The formalization allows for automated verification of critical properties, moving beyond manual inspection and reducing the risk of security vulnerabilities.
  • System Accountability: The paper highlights the importance of "system accountability," ensuring that assigned obligations are fulfilled if users are diligent, and that actions are both allowed and executable throughout their lifecycle.

Key Results

The paper presents a formal framework and methodology for the dynamic analysis of usage control policies. While specific quantitative results from running the model checker on a large-scale system are not detailed, the paper demonstrates:

  • The formalization of a movie player application's usage control policy using C+.
  • The definition of ACTL formulas to verify key properties like action allowance, executability, and state obligation satisfaction/violation.
  • A clear methodology for constructing a usage-controlled action description that integrates policy enforcement into the domain model.
  • The potential for automated verification of complex security policies before deployment, thereby improving system security and reliability.

Limitations and Future Work

The authors acknowledge several limitations and suggest future directions:

  • Scalability: The complexity of model checking can be a challenge for very large systems. Future work aims to design heuristics to improve scalability.
  • Timed Systems: The current framework does not explicitly handle timed aspects of deadlines. Future work intends to investigate the use of C+ timed extensions to provide a more elegant representation of delays and deadlines.
  • Structured Policies: The approach can be extended to support structured policies with pre-defined sets of basic entities.
  • Post-Obligations: The paper focuses on pre- and ongoing-obligations. The support for post-obligations (requirements to be satisfied after access ends or is revoked) is not discussed in detail but is a potential area for future work.
  • Real-World Scenarios: While the movie player example is illustrative, applying the framework to more complex, real-world scenarios would be valuable.

Summary updated

BibTeX
@inproceedings{elrakaiby2014dynamic,
  author = {Yehia Elrakaiby and Jun Pang},
  title = {{Dynamic Analysis of Usage Control Policies}},
  booktitle = {SECRYPT},
  year = {2014},
  doi = {10.5220/0005046600880100},
}
Figure