3 research outputs found
Small TCBs of policy-controlled operating systems
IT Systeme mit qualitativ hohen Sicherheitsanforderungen verwenden zur
Beschreibung, Analyse und Implementierung ihrer Sicherheitseigenschaften
zunehmend problemspezifische Sicherheitspolitiken, welche ein
wesentlicher Bestandteil der Trusted Computing Base (TCB) eines IT
Systems sind. Aus diesem Grund sind die Korrektheit und Unumgehbarkeit
der Implementierung einer TCB entscheidend, um die geforderten
Sicherheitseigenschaften eines Systems herzustellen, zu wahren und zu
garantieren.
Viele der heutigen Betriebssysteme zeigen, welche Herausforderung die
Realisierung von Sicherheitspolitiken darstellt; seit mehr als 40 Jahren
unterstützen sie wahlfreie identitätsbasierte Zugriffssteuerungspolitiken
nur rudimentär. Dies führt dazu, dass große Teile der
Sicherheitspolitiken von Anwendersoftware durch die Anwendungen selbst
implementiert werden. Infolge dessen sind die TCBs heutiger
Betriebssysteme groß, heterogen und verteilt, so dass die exakte
Bestimmung ihres Funktionsumfangs sehr aufwendig ist. Im Ergebnis sind
die wesentlichen Eigenschaften von TCBs - Korrektheit, Robustheit und
Unumgehbarkeit - nur schwer erreichbar.
Dies hat zur Entwicklung von Politik gesteuerten Betriebssystemen
geführt, die alle Sicherheitspolitiken eines Betriebssystems und seiner
Anwendungen zentral zusammenfassen, indem sie Kernabstraktionen für
Sicherheitspolitiken und Politiklaufzeitumgebungen anbieten. Aktuelle
Politik gesteuerte Betriebssysteme basieren auf monolithischen
Architekturen, was dazu führt, dass ihre Komponenten zur Durchsetzung
ihrer Politiken im Betriebssystemkern verteilt sind. Weiterhin verfolgen
sie das Ziel, ein möglichst breites Spektrum an Sicherheitspolitiken zu
unterstützen. Dies hat zur Folge, dass ihre Laufzeitkomponenten für
Politikentscheidung und -durchsetzung universal sind. Im Ergebnis sind
ihre TCB-Implementierungen groß und komplex, so dass der TCB-
Funktionsumfang nur schwer identifiziert werden kann und wesentliche
Eigenschaften von TCBs nur mit erhöhtem Aufwand erreichbar sind.
Diese Dissertation verfolgt einen Ansatz, der die TCBs Politik
gesteuerter Betriebssysteme systematisch entwickelt. Die Idee ist, das
Laufzeitsystem für Sicherheitspolitiken so maßzuschneidern, dass nur die
Politiken unterstützt werden, die tatsächlich in einer TCB vorhanden
sind. Dabei wird der Funktionsumfang einer TCB durch kausale
Abhängigkeiten zwischen Sicherheitspolitiken und TCB-Funktionen bestimmt.
Das Ergebnis sind kausale TCBs, die nur diejenigen Funktionen enthalten,
die zum Durchsetzen und zum Schutz der vorhandenen Sicherheitspolitiken
notwendig sind. Die präzise Identifikation von TCB-Funktionen erlaubt,
die Implementierung der TCB-Funktionen von nicht-vertrauenswürdigen
Systemkomponenten zu isolieren. Dadurch legen kausale TCBs die Grundlage
für TCB-Implementierungen, deren Größe und Komplexität eine Analyse und
Verifikation bezüglich ihrer Korrektheit und Unumgehbarkeit ermöglichen.
Kausale TCBs haben ein breites Anwendungsspektrum - von eingebetteten
Systemen über Politik gesteuerte Betriebssysteme bis hin zu
Datenbankmanagementsystemen in großen Informationssystemen.Policy-controlled operating systems provide a policy decision and enforcement environment to protect and enforce their security policies. The trusted computing base (TCB) of these systems are large and complex, and their functional perimeter can hardly be precisely identified. As a result, a TCB's correctness and tamper-proofness are hard to ensure in its implementation.
This dissertation develops a TCB engineering method for policy-controlled operating systems that tailors the policy decision and enforcement environment to support only those policies that are actually present in a TCB. A TCB's functional perimeter is identified by exploiting causal dependencies between policies and TCB functions, which results in causal TCBs that contain exactly those functions that are necessary to establish, enforce, and protect their policies. The precise identification of a TCB's functional perimeter allows for implementing a TCB in a safe environment that indeed can be isolated from untrusted system components. Thereby, causal TCB engineering sets the course for implementations whose size and complexity pave the way for analyzing and verifying a TCB's correctness and tamper-proofness.Auch im Buchhandel erhältlich:
Small TCBs of policy-controlled operating systems / Anja Pölck
Ilmenau : Univ.-Verl. Ilmenau, 2014. - xiii, 249 S.
ISBN 978-3-86360-090-7
Preis: 24,40
A Datalog Semantics for Paralocks
Broberg and Sands (POPL’10) introduced a logic-based policy language, Paralocks, suitable for static information-flow control in programs. Although Paralocks comes with a precise information-flow semantics for programs, the logic-based semantics of policies, describing how policies are combined and compared, is less well developed. This makes the algorithms for policy comparison and computation ad-hoc, and their security guarantees less intuitive. In this paper we provide a new semantics for Paralocks policies based on Datalog. By doing so we are able to show that the ad-hoc semantics from earlier work coincides with the natural Datalog interpretation. Furthermore we show that by having a Datalog-inspired semantics, we can borrow language extensions and algorithms from Datalog for the benefit of Paralocks. We explore how these extensions and algorithms interact with the design and implementation of Paragon, a language combining Paralocks with Java
A Policy Semantics and a Programming Language for Securing Software
The work presented in this thesis contributes to the information flowpolicy specification language Paralocks and the enforcement of Paralockspolicies in the programming language Paragon.The thesis starts with a programming tutorial on Paragon. The tutorialaims to make Paragon accessible for programmers without any familiaritywith information flow theory. We gradually introduce the Java programmerto various information flow concepts using the Paragon programming lan-guage. The tutorial also provides information and design patterns needed toset up realistic software applications in Paragon.Next we focus our attention on the design and implementation of Paragon.We discuss how the Paralocks language is generalised to integrate moretightly with Java’s object-oriented programming style, on which Paragonis built. Combined with the dynamic nature of Paralocks policies, Paragonpromises to be a flexible and expressive programming language.Finally we present an alternative semantics for Paralocks, based on thedeclarative language Datalog. Compared to Paralocks’ original semantics,the Datalog-inspired semantics provides a more natural and intuitive inter-pretation for Paralocks policies. We show that the new semantics coincideswith the original semantics. It also allows us to adopt Datalog extensionsand algorithms into Paralocks and Paragon