App Security: Den Schulden ins Auge blicken

Dies ist ein Gastbeitrag von Julian Totzek-Hallhuber, Solution Architect bei Veracode

Einmal das Konto oder die Kreditkarte überzogen – alles nicht so schlimm. Doch wenn man nicht aufpasst, findet man sich schnell in der Schuldenfalle wieder. Ähnliches kann auch in der Anwendungssicherheit passieren. Wie aus kleinen Fehlern in Apps ernsthafte Sicherheitslücken werden können zeigt Julian Totzek-Hallhuber, Solution Architect bei Veracode. Außerdem erklärt er neue Methoden wie DevSecOps, die diesem Problem vorbeugen können.

Bei Veracode beschäftigen wir uns schon lange mit der Analyse von Anwendungen und der Prüfung auf kritische Schwachstellen. Dieses Jahr geht der State of Software Security (SoSS) Report in seine zehnte Runde. Darin wurden mehr als 85.000 Anwendungen von über 2.300 Unternehmen ausgewertet, mit dem Ergebnis, dass zwar 56 Prozent aller neuen Schwachstellen behoben werden, dies aber gleichzeitig zu einer Vernachlässigung alter Probleme führt. Es stauen sich also Probleme an und es kommt zu einer Art „Sicherheitsverschuldung“ in Unternehmen. Diese Schulden abzubauen wird immer schwieriger, beziehungsweise irgendwann unmöglich, wenn Unternehmen sich ausschließlich auf das Beheben neuer Fehler fokussieren und ältere Schwachstellen vernachlässigen.

Die Anwendungssicherheit ist gut, mit Luft nach oben

Vor zehn Jahren mussten wir noch oft erklären, was es mit Anwendungssicherheit auf sich hat und warum das wichtig ist. Das Bewusstsein um die Bedeutung von Anwendungssicherheit hat sich weitgehend durchgesetzt und die meisten Unternehmen feilschen aktuell an der besten Strategie ein App-Sec-Programm zu implementieren. Unternehmen verwenden heute mehr Zeit und Ressourcen darauf, ihre Software nicht nur auf Fehler und Schwachstellen zu scannen, sondern diese auch nach Dringlichkeit zu priorisieren und zu beheben.

Es benötigt allerdings immer noch Zeit, um Schwachstellen in Anwendungen zu beheben. Im ersten SoSS-Report stellten wir dafür eine durchschnittliche Dauer von 59 Tagen fest. Nun, zehn Jahre später, ist dieser Zeitraum auf 171 Tage angestiegen. Einerseits ist das natürlich beachtlich. Berücksichtigt man aber das Gesetz des Durchschnitts, liegt die mittlere Zeit der Fehlerbehebung zehn Jahre später in 2019 immer noch bei 60 Tagen. Das bedeutet also nicht, dass Entwickler länger brauchen, um Fehler zu beheben, sondern dass der Schuldenberg alter Schwachstellen immer größer wird.

Das Problem „Sicherheitsverschuldung“

Ähnlich wie bei finanziellen Schulden, bedarf es auch bei der Sicherheitsverschuldung Veränderungen im Verhalten, um sich von den Schulden befreien zu können. Glücklicherweise gibt es hier Modelle, die Abhilfe schaffen. So hat die Zusammenführung von Softwareentwicklung und IT-Operations (DevOps) und zusätzliche Integration von Sicherheit in diese Prozesse (oftmals DevSecOps genannt) das Verhalten vieler IT-Abteilungen in den letzten Jahren maßgeblich verändert.

DevOps-Teams zeichnen sich dadurch aus, dass sie während dem Entwicklungsprozess regelmäßige Sicherheitsscans durchführen. Dieser Vorgang trägt zu einer schnelleren Behebungszeit bei. So liegt die durchschnittliche Zeitspanne zur Fehlerbehebung für Anwendungen, die 12 oder weniger Mal pro Jahr (also weniger als ein Mal im Monat) gescannt werden, bei 68 Tagen. Dahingegen liegt die durchschnittliche Behebungszeit für Anwendungen, die täglich gescannt werden bei 19 Tagen – also eine Reduzierung von 72 Prozent.

Schnellere Fixraten sind äußerst wichtig, denn je länger Schwachstellen bestehen, desto schwerer fällt ihre Beseitigung. Nur bei etwa einem Viertel der untersuchten Anwendungen gelingt es über die Zeit, die Schulden abzubauen. Ein weiteres Viertel hält zumindest den Status quo. Die andere Hälfte steigert ihre Verschuldung allerdings über die Zeit. Entwickler müssen demnach darauf achten, solche Probleme von vorneherein zu vermeiden.

Mit DevSecOps gefährlichen Sicherheitsaltlasten vorbeugen

Probleme, wie die oben skizzierten, entstehen, wenn man mit dem Testing von Anwendungen zu spät beginnt. Das lässt sich am Beispiel eines Autos veranschaulichen: Ein Fahrzeughersteller, der ein Auto aus irgendwelchen ungeprüften Teilen zusammenbaut und erst am Ende das komplette Fahrzeug untersucht, wird unweigerlich Probleme bekommen. Entweder kann er wegen fehlender Daten Problemen keine konkreten Ursachen zuordnen, oder schlimmer, Schwachstellen bleiben unentdeckt. Damit dies nicht geschieht, wird jedes zu verbauende Bauteil vorher auf Herz und Nieren getestet. So wird sichergestellt, dass die Materialeigenschaften von Stahlteilen allen Belastungen angemessen sind oder Dichtungen im Motor der Hitze standhalten usw.

Die Lösung heißt DevSecOps. Die enge Verflechtung von Entwicklung und Betrieb ist heute allgemein verbreitet. Jetzt geht es darum, auch die Sicherheit von Anwendungen in den Software-Entwicklungsprozess zu integrieren. Ähnlich wie bei der Umstellung vom Wasserfallprinzip auf agile Methoden in der Entwicklung, ist auch bei der Einführung von DevSecOps einige Arbeit nötig und Geduld gefragt. Doch am Ende des Tages lohnt sich der Aufwand, wie Zahlen aus dem SoSS-Report zeigen: Es gibt einen eindeutigen Zusammenhang zwischen der Häufigkeit von Tests und der Zeitspanne, die zur Fehlerbehebung erforderlich ist. Dies kann die Sicherheitsverschuldung im Laufe der Zeit drastisch reduzieren, da weniger Fehler entstehen, die später behoben werden müssten. Außerdem gibt es den Entwickler-Teams wertvolle Zeit sich auf die Behebung älterer Fehler zu konzentrieren, die schon lange fortbestehen.

Um DevSecOps erfolgreich zu implementieren, müssen Entwickler automatisierte Testwerkzeuge nutzen. Denn die Abhängigkeit von manuellen Prozessen verhindert, mit beschleunigten Entwicklungszyklen schrittzuhalten. Tools, die in einer integrierten Entwicklungsumgebung (IDE) eingesetzt werden können, sind von entscheidender Bedeutung, da sie es Entwicklern ermöglichen, Sicherheit in ihren Workflow zu integrieren, anstatt eine neue Umgebung starten zu müssen, wenn sie Code testen wollen. Lösungen, die schon während des Codens Fehler suchen, sorgen dafür, dass Entwickler Schwachstellen sehr früh und mit weniger Aufwand beheben können.

Fazit

Wer seine Schulden loswerden möchte muss etwas ändern. In Bezug auf die „Sicherheitsverschuldung“ von Anwendungen heißt das, Unternehmen müssen dafür Sorge tragen, dass sie eine Strategie verfolgen, die die Risiken, die sich aus langfristig bestehenden Schwachstellen ergeben adressiert. Das tun sie am besten, indem sie DevSecOps implementieren. Diese Methode des kontinuierlichen Testens erlaubt es, Fehler sehr früh zu erkennen und dementsprechend einfach zu beheben.

Über den Autor

Julian Totzek-Hallhuber ist Solution Architect bei Veracode. Als Spezialist für Anwendungssicherheit mit mehr als 15 Jahren Erfahrung im IT-Sicherheitsumfeld, verfügt er über Expertise in den Bereichen Anwendungsentwicklung, Penetrationstests sowie Sicherheit von Webanwendungen. Zudem ist er Autor zahlreicher Artikel, regelmäßig als Sprecher auf Messen anzutreffen und hat bei Projekten von www.webappsec.org mitgewirkt.

Weitere Informationen unter:
http://www.veracode.com/

0 Kommentare

Hinterlasse ein Kommentar

An der Diskussion beteiligen?
Hinterlasse uns deinen Kommentar!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.