Patterns for building dependable systems with trusted bases

Eunsuk Kang, Daniel JacksonPLoP 2010 · DOI

TL;DR

This paper introduces the "Trusted Base" pattern, a design strategy for building dependable software systems by isolating critical requirements into small, reliable components. This approach aims to simplify verification and enhance resilience by minimizing the system's attack surface and the scope of components that must be trusted.

What Problem Does This Paper Address?

Building large, complex software systems that are dependable (i.e., reliably meet their requirements) is a significant challenge. Traditional methods like extensive testing and verification are often prohibitively expensive and may not guarantee complete fault freedom, especially when integrating third-party or unreliable components. The authors highlight that it's often infeasible to ensure every component is reliable, and tight coupling in complex systems can lead to cascading failures. They aim to provide a structured approach to manage dependability in the face of these challenges.

Methods

The core contribution is the introduction of the Trusted Base pattern. This pattern advocates for identifying the most critical system requirements and then designing the system such that these requirements depend only on a small, well-defined subset of components – the "trusted base." This subset is designed to be highly reliable, while the rest of the system can be less trustworthy or even unreliable without compromising the critical functions.

The paper then presents two specialized instances of this pattern:

  1. End-to-End Check: This pattern is applied to systems that perform a computation on an input to produce an output. Instead of trusting every intermediate component, the reliability is ensured by checking the final output against the input using a "checker" component at one of the system's endpoints. This moves the burden of reliability from the entire processing chain (the "channel") to the endpoints.
  2. Trusted Kernel: This pattern is used in systems that manage resources and provide services to participants. It involves encapsulating the control of resource access requests into a small, highly reliable component (the "trusted kernel") that acts as an interface between participants and resources. This kernel enforces safety policies, ensuring that even potentially buggy or malicious participants cannot damage the resources.

The authors emphasize that applying these patterns requires careful consideration throughout the development lifecycle, including:

  • Requirements: Prioritizing critical requirements.
  • Design: Architecting for isolation of critical components.
  • Implementation: Using skilled programmers and safe languages for trusted components.
  • Testing: Focusing rigorous verification efforts on the trusted base.

Datasets

Not discussed in the paper.

Key Insights and Ideas

  • Shifting the Trust Boundary: The fundamental idea is to strategically shrink the "trusted base" rather than trying to make the entire system trustworthy. This is a more pragmatic approach to achieving dependability.
  • Prioritization is Key: Dependability is not an all-or-nothing property. Explicitly prioritizing requirements allows designers to focus limited resources on what matters most, accepting failures in less critical areas.
  • Isolation as a Strategy: The patterns promote architectural designs that isolate critical functions. This prevents failures in less reliable parts of the system from propagating and compromising core functionalities.
  • End-to-End Checks for Computation Integrity: The End-to-End Check pattern is a powerful way to verify the correctness of computations performed over potentially unreliable channels by focusing verification on the input-output relationship at the system's boundaries.
  • Trusted Kernels for Resource Protection: The Trusted Kernel pattern is crucial for systems where resource safety and security are paramount, ensuring that even untrusted actors cannot cause harm to critical system resources.
  • Trade-offs are Inevitable: Achieving higher dependability through these patterns often comes with trade-offs, such as reduced performance or increased complexity in implementing the isolation mechanisms.

Key Results

The paper doesn't present quantitative results from experiments or benchmarks. Instead, its contribution is conceptual and architectural. The "key results" are the introduction and detailed description of the Trusted Base pattern and its two specialized instantiations, End-to-End Check and Trusted Kernel, along with their associated contexts, problems, solutions, and consequences. The paper provides examples of how these patterns can be applied in real-world scenarios like file transfer systems, voting systems, constraint solvers, and operating systems.

Limitations and Future Work

Limitations: * The authors acknowledge that implementing these patterns can be difficult and may require more effort than conventional designs. * The End-to-End Check pattern doesn't guarantee that the system will always produce an output, but rather that "bad things never happen" (i.e., failures are detected). * Achieving dependability through these patterns often involves trade-offs, such as reduced performance (e.g., in microkernel-based OSes) or requiring customers to prioritize requirements, which might lead to sacrifices in functionality. * The Trusted Kernel pattern can introduce complexity in managing the kernel's internal state and ensuring its correctness.

Future Work: The authors believe these patterns are a starting point and plan to:

  • Study more successful system designs that employ techniques for reducing trusted bases.
  • Devise a more extensive catalog of patterns related to trusted bases.

Summary updated

BibTeX
@inproceedings{kang2010patterns,
  author = {Eunsuk Kang and Daniel Jackson},
  title = {{Patterns for building dependable systems with trusted bases}},
  booktitle = {PLoP},
  year = {2010},
  doi = {10.1145/2493288.2493307},
}
Figure