|
Eine Sicherheitslücke ist im Gebiet der Informationssicherheit ein Fehler in einer Software, durch den ein Programm mit Schadwirkung (Malware) oder ein Angreifer in ein Computersystem eindringen kann.
Inhaltsverzeichnis
1 Entstehung von Sicherheitslücken
2 Ausnutzung von Sicherheitslücken
3 Umgang mit Sicherheitslücken
4 Beispiele
5 Einzelnachweise
6 Weblinks
Entstehung von Sicherheitslücken
Eine Sicherheitslücke stellt eine Bedrohung für die Sicherheit eines Computersystems dar. Es besteht das Risiko dass die Sicherheitslücke ausgenutzt und das betroffene Computersystem kompromittiert werden kann. Sicherheitslücken entstehen unter anderem durch den unzureichenden Schutz eines Computers vor Angriffen aus dem Netzwerk (beispielsweise mangels Firewall oder anderer Sicherheitssoftware) sowie durch Programmierfehler im Betriebssystem, Browser oder anderen Softwareanwendungen, die auf dem System betrieben werden.
Sicherheitslücken können im Entwicklungsprozess entstehen, wenn Sicherheitsaspekte in der Planung, Konzeption und Entwicklung vernachlässigt werden und Sicherheitsvorgaben nicht ausreichend berücksichtigt werden, z.B. als Qualitätsziele. Des Weiteren ergeben sich Sicherheitslücken aus Fehlern, die auf Grund der Komplexität von Softwaresystemen im Entwicklungsprozess entstehen können. Grobe Schätzungen zeigen, dass ein Programmierer pro 1000 Programmzeilen einen Fehler erzeugt, das entspricht einem Promille Fehlerhäufigkeit; bei 1.000.000 Zeilen sind also etwa 1000 Fehler zu erwarten. Falls beim Alpha- und Beta-Prozess nicht alle Fehler gefunden werden, entsteht ein fehlerhaftes Produkt.
Viele Fehler werden nie entdeckt, da der Fehlergehalt gering ist oder die Auswirkung erst bei längerer Laufzeit des Programms Schaden erzeugen würde. In hochkomplexen Programmen werden solche einfachen Fehler bei Entdeckung zunächst nur dokumentiert und erst später behoben. Dies nicht nur aus Kostengründen, sondern auch deshalb, da jede zur Behebung notwendige Änderung am Programmcode wiederum Quelle neuer Fehler sein kann. Manche Fehler erzeugen jedoch schwerwiegende Sicherheitslücken, ohne dass dies sofort zu einem kompletten Absturz führt.
Derartige Sicherheitslücken sind symptomatisch für Programme, welche mit Programmiersprachen geschrieben wurden, die in Hinblick auf zum Beispiel Performance optimiert sind (beispielsweise C oder Assembler) und auf Grund von ihrem Programmiermodell anfällig für Fehler sind (Stichwort: Zeigerarithmetik). Durch die weite Verbreitung von derartigen Programmiersprachen, dem hohen Zeitdruck in der Softwareerzeugung, verbunden mit dem ausgeprägten Kostendruck der Softwareerzeugerfirmen und dem wenig sensiblen Umgang mit dem Thema sichere Software sind Sicherheitslücken eher die Regel als die Ausnahme.
Ein häufig genanntes Problem sind vor allem Softwareangebote von Hardwareherstellern zu ihren Produkten, welche oftmals nur aus Marketinggründen bei bestimmten Produkten beiliegen (vergleiche Videoschnittsoftware bei Camcordern). Durch kostengünstige Entwicklung und dadurch schlechte Programmierung werden eine Vielzahl von Programmfehlern und Sicherheitslücken geschaffen, die vor allem den Heimanwenderbereich betreffen. Erschwerend kommt hinzu, dass Hardwarefirmen oft nicht auf die Entwicklung von Anwendungssoftware spezialisiert sind, daher Entwicklungsaufträge an Fremdfirmen und somit die Produktqualität auch nicht mehr ohne weiteres selbst überprüfen können. Zum andern sind die Fremdfirmen unter Umständen noch nicht einmal auf die Entwicklung der speziellen Software spezialisiert. Diese Faktoren führen dazu, dass immer wieder neue, fehlerbelastete Software auf den Markt kommt anstatt dass alte Software weiterentwickelt und verbessert wird.[1]
Einige massive Probleme und Fehler könnten heute einfach vermieden werden, wenn statt den sehr systemnahen Sprachen, die eine direkte Adressierung von Speicherbereichen zulassen, Programmiersprachen wie zum Beispiel Modula-2, Eiffel, Oberon oder Component Pascal, in den jeweils entsprechenden Versionen, verwendet würden; nachweislich können Betriebssysteme und Treiber damit ebenfalls sehr effizient geschrieben werden.
Ausnutzung von Sicherheitslücken
Diese Programmfehler ermöglichen es unter Umständen einem Angreifer zum Beispiel mit einem Exploit in ein Computersystem einzudringen und dort Programme auszuführen, die schaden können. Einer der häufigsten Fehler, der zum Eindringen in Computersysteme benutzt wird, ist der Pufferüberlauf. Mangelnde oder überhaupt fehlende Überprüfung der kopierten Datenmenge führt zum Überschreiben anderer Programmteile, was von Angreifern gezielt zum Verändern des Programms oder Einbringen fremder Programmteile benutzt wird.
Umgang mit Sicherheitslücken
In so genannten Closed-Source-Anwendungen ist es die Aufgabe des Herstellers des Programms, die Sicherheitslücke durch einen Patch oder die Bereitstellung einer neuen, fehlerbereinigten Version zu beheben. Die Bereinigung ist nicht zwingend und kann unterbleiben, wenn z.B. der Supportzyklus für das Produkt abgelaufen ist oder der Hersteller die Sicherheitslücke nicht als solche anerkennt und keinen Handlungsbedarf sieht.
Bei Open Source und freier Software sind es oftmals mehrere Entwickler (meist diejenigen, die schon länger an dieser Software beteiligt sind), verstreut auf der ganzen Welt, die einen Patch dafür schreiben, sobald der Fehler entdeckt und veröffentlicht wurde. Gerade bei großen Open-Source-Projekten, wie z.B. Linux gibt es meist kurz nach der Entdeckung der Lücke Patches, um diese zu beheben.
Beispiele
Beispiele finden sich in der Kategorie:Sicherheitslücke.
Einzelnachweise
↑ http://www.sigsoft.org/SEN/parnas.html
Weblinks
Sicherheitslücken werden unter anderem publiziert auf:
Bugtraq (Archiv; englisch)
scip AG (Archiv; deutsch)
Heise Security
Computec.ch
Secunia Research (Archiv; englisch)
Vigil@nce vulnerabilities (Archiv; englisch)
PC-WELT - aktuelle Sicherheitslücken
Erklärungen:
Artikel »Risikoformel für Sicherheitslücken gefunden«
|
