TU Darmstadt / ULB / TUbiblio

Full-Stack Static Security Analysis for the Java Platform

Hermann, Ben :
Full-Stack Static Security Analysis for the Java Platform.
[Online-Edition: http://tuprints.ulb.tu-darmstadt.de/5807]
Technische Universität Darmstadt , Darmstadt
[Dissertation], (2016)

Offizielle URL: http://tuprints.ulb.tu-darmstadt.de/5807

Kurzbeschreibung (Abstract)

We have to face a simple, yet, disturbing fact: current computing is inherently insecure. The systems we develop and maintain have outgrown our capacity to prove them secure in every instance. Moreover, we became increasingly dependent on these systems. From small firmware running in cars and household appliances to smart phones and large-scale banking systems, software systems permeate our every day life. We rely on the safety and security of these systems, yet, we encounter threats to these properties every day. Therefore, systems have be secure by construction and not by maintenance. The principles to achieve this are well known. The Principle of Least Privilege has been published in 1975, yet, software systems do not generally apply it. We argue that new, lightweight methods based on sound theory have to be put forward so that developers can efficiently check that their software is secure in their domain context. In this thesis, we present three analysis techniques that help programmers develop more secure software by informing them about the current state of unsafe operation usage, extensive capability use in third-party components, and suspicious dead software paths that point to programming errors that could lead to insecurity. These three analyses inspect the full stack of a Java program from the application code over library and base-library code down to the native code level. If programmers use the information provided by the analyses, they are able to reduce the attack surface of their applications and provide more safe and secure systems to their users. Furthermore, we contribute two concepts for automated isolation. While the first concept reduces the attack surface by slicing third-party components to their necessary parts, the second concept is more fundamental and aims at achieving a fine-grained privilege separation. We believe that the software engineering discipline needs more research on these language-based approaches that tackle the problem of software security at its root cause: defective implementation. Using formal methods to construct these tools is necessary, yet, software developers cannot be overburdened with new requirements to their work process. Automated tools need to derive security properties from program code by them- selves with as little input required from the programmer as possible. By these means software can be developed reliably secure in an efficient fashion.

Typ des Eintrags: Dissertation
Erschienen: 2016
Autor(en): Hermann, Ben
Titel: Full-Stack Static Security Analysis for the Java Platform
Sprache: Englisch
Kurzbeschreibung (Abstract):

We have to face a simple, yet, disturbing fact: current computing is inherently insecure. The systems we develop and maintain have outgrown our capacity to prove them secure in every instance. Moreover, we became increasingly dependent on these systems. From small firmware running in cars and household appliances to smart phones and large-scale banking systems, software systems permeate our every day life. We rely on the safety and security of these systems, yet, we encounter threats to these properties every day. Therefore, systems have be secure by construction and not by maintenance. The principles to achieve this are well known. The Principle of Least Privilege has been published in 1975, yet, software systems do not generally apply it. We argue that new, lightweight methods based on sound theory have to be put forward so that developers can efficiently check that their software is secure in their domain context. In this thesis, we present three analysis techniques that help programmers develop more secure software by informing them about the current state of unsafe operation usage, extensive capability use in third-party components, and suspicious dead software paths that point to programming errors that could lead to insecurity. These three analyses inspect the full stack of a Java program from the application code over library and base-library code down to the native code level. If programmers use the information provided by the analyses, they are able to reduce the attack surface of their applications and provide more safe and secure systems to their users. Furthermore, we contribute two concepts for automated isolation. While the first concept reduces the attack surface by slicing third-party components to their necessary parts, the second concept is more fundamental and aims at achieving a fine-grained privilege separation. We believe that the software engineering discipline needs more research on these language-based approaches that tackle the problem of software security at its root cause: defective implementation. Using formal methods to construct these tools is necessary, yet, software developers cannot be overburdened with new requirements to their work process. Automated tools need to derive security properties from program code by them- selves with as little input required from the programmer as possible. By these means software can be developed reliably secure in an efficient fashion.

Ort: Darmstadt
Freie Schlagworte: Java, Security, Static Analysis
Fachbereich(e)/-gebiet(e): 20 Fachbereich Informatik
20 Fachbereich Informatik > Softwaretechnik
Hinterlegungsdatum: 04 Dez 2016 20:55
Offizielle URL: http://tuprints.ulb.tu-darmstadt.de/5807
URN: urn:nbn:de:tuda-tuprints-58076
Gutachter / Prüfer: Mezini, Prof. Dr. Mira ; Rashid, Prof. Dr. Awais
Datum der Begutachtung bzw. der mündlichen Prüfung / Verteidigung / mdl. Prüfung: 16 November 2016
Alternatives oder übersetztes Abstract:
AbstractSprache
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.Deutsch
Export:

Optionen (nur für Redakteure)

Eintrag anzeigen Eintrag anzeigen