Der stetige Strom an Exploit-Meldungen scheint es zu bestätigen: Aktuelle Software-Systeme sind unsicher. Die Größe der Systeme, die wir entwickeln und warten hat unsere Möglichkeiten überstiegen ihre Sicherheit nachzuweisen. Dazu sind wir sehr viel abhängiger von diesen Systemen geworden, als noch vor zehn Jahren. Software-Systeme durchziehen unser tägliches Leben angefangen von Firmware in Automobilen und Haushaltsgeräten über Smartphones bis zu großen Banktransaktions-Systemen. Wir verlassen uns auf die Sicherheit dieser Systeme, jedoch erfahren wir tagtäglich die Gefahr, die von diesen Systemen ausgeht.

Daher meinen wir, dass Software-Systeme durch Konstruktion sicher sein müssen und nicht durch Wartung. Die dafür notwendigen Prinzipien sind bekannt. Das "Principle of Least Privilege" wurde 1975 publiziert, jedoch wird es in aktuellen Systemen immer noch nicht konsequent umgesetzt. Wir vertreten die Ansicht, dass neue, leichtgewichtige Methoden, welche auf tragfähigen theoretischen Ansätzen beruhen, eingesetzt werden müssen, damit Entwickler die Sicherheit der von ihnen entwickelten Software in ihrem Kontext effizient überprüfen können.

In dieser Arbeit präsentieren wir drei Analyse-Techniken, die es Programmierern ermöglichen sichere Software zu entwickeln, in dem sie über den aktuellen Zustand der für das System relevanten Sicherheitskriterien informiert werden. Dies sind im Einzelnen die Nutzung unsicherer Programmiermethoden, die übermäßige Nutzung von Betriebsystem-Ressourcen in Drittanbieter-Komponenten und verdächtige tote Softwarepfade, die auf Programmierfehler hindeuten, welche auch Sicherheitslücken beinhalten können. Diese drei Analysen decken alle Schichten einer Java-Applikation vom Applikationscode über Bibliotheks- und Basis-Bibliothekscode bis zur nativen Codeebene ab. Programmierer sind in der Lage die Angriffsfläche ihrer Applikationen signifikant zu reduzieren, in dem sie die Informationen aus diesen Analysen nutzen, und somit sicherere Software für ihre Endanwender bereit zu stellen.

Weiterhin zeigen wir zwei neuartige Konzepte für automatisierte Isolation vor. Während das erste Konzept die Angriffsfläche einer Anwendung dadurch reduziert, in dem es Drittanbieter-Komponenten auf den tatsächlich genutzten Programmcode reduziert, stellt das zweite Konzept einen fundamentaleren Eingriff dar und hilft dabei eine fein-granulare Berechtigungskontrolle herzustellen.

Wir sind der Meinung, dass Softwareentwicklung weitere Forschung in diesem Bereich programmiersprachlich-basierter Ansätze für Sicherheit benötigt, um die Probleme an ihrem Kern anzugehen: fehlerhafte Implementierung. Während der Einsatz formaler Methoden für die Entwicklung von Werkzeugen hierfür notwendig ist, dürfen Softwareentwickler nicht mit weiteren Anforderungen für die tägliche Arbeit überfordert werden. Automatisierte Werkzeuge müssen Sicherheitsattribute selbstständig aus dem Programmcode ableiten können und sollten dabei auf möglichst wenig zusätzliche Eingaben des Softwareentwicklers bauen. Durch diese Techniken wird es möglich sein nachweisbar sichere Software in effizienter Weise zu entwickeln.