安全代码的洞察

Tapjacking, eine Kombination aus „Tap“ und „Hijacking“, bedeutet genau das. Es handelt sich um einen Angriff, bei dem der Angreifer die Taps des Benutzers kapert und ihn dazu bringt, etwas zu tun, was er nicht beabsichtigt hat. Wie funktioniert es also und wie verhindern wir es?

Wir beginnen unsere Geschichte mit Bildschirm-Overlays. Bildschirmüberlagerungen oder, wie Google sie nennt, Fenster mit dem Typ TYPE_APPLICATION_OVERLAY. Dies sind Fenster, die über anderen Apps gezeichnet werden und normalerweise nur einen Teil des Bildschirms verdecken. Diese werden häufig verwendet (wie das Beispielbild unten), wenn eine App neue Berechtigungen anfordert.

Dies ist eigentlich eine coole und unterhaltsame Funktion, und immer mehr Apps beginnen, sie zu verwenden. Denken Sie an die Chat-Blasen von Facebook oder die Google Maps-Navigation in einer Ecke Ihres Bildschirms, wie im Screenshot unten.

Diese Overlays bergen jedoch einige Sicherheitsrisiken. Jedes aktive Bildschirm-Overlay kann auf Tips achten. Woher sollte Facebook sonst wissen, dass wir auf die Blase getippt oder gezogen haben? Dadurch können Apps dich ausspionieren und möglicherweise Passwörter und Kreditkartendaten stehlen.

Noch einen Schritt weiter, und hier kommt der Begriff Tapjacking her. Overlays können Dinge auf andere Apps zeichnen und den Benutzer dazu verleiten, verschiedene Aktionen auszuführen. Der Benutzer glaubt, mit dem Overlay zu interagieren, aber in Wirklichkeit führen seine Taps auch Aktionen in der zugrunde liegenden App aus. Auf diese Weise kann dich das Overlay dazu verleiten, bestimmte Berechtigungen zu aktivieren oder einige gefährliche Einstellungen zu ändern, wie hier gezeigt altes YouTube-Video.

Das obige Demonstrationsvideo wurde 2010 auf YouTube hochgeladen, also auf einer älteren Version von Android. Aber der Angriff ist auch heute noch relevant, wie Schwachstellen kam ans Licht, das Tapjacking in neueren Versionen von Android wie Nougat und Marshmallow ermöglicht.

Also, was kannst du dagegen tun? Als Benutzer ist es wichtig, die Konsequenzen dieser Overlays zu erkennen und sich der Apps bewusst zu sein, die sie verwenden. Ab API-Level 23 (Android 6.0 Marshmallow) ist dies zu einer Erlaubnis geworden muss vom Nutzer ausdrücklich erteilt werden. Das lässt jedoch 50% von AndroidBenutzer sind immer noch anfällig. In den Einstellungen unter „Vor anderen Apps anzeigen“ kannst du immer noch überprüfen, welche Apps von dieser Berechtigung Gebrauch machen.

Als Entwickler liegt es an uns, sicherzustellen, dass Benutzeraktionen mit dem vollen Wissen und der Zustimmung des Benutzers durchgeführt werden. Android bietet eine Einstellung für Ihre Ansichten, die genau das tun, nämlich Filtert Berührungen, wenn sie verdeckt sind. Wenn es aktiviert ist, verwirft das Framework Berührungen, die empfangen werden, wenn das Ansichtsfenster durch ein anderes sichtbares Fenster verdeckt wird. So einfach ist das, set Berührungen filtern, wenn sie verdeckt sind auf true, und Ihre App ist vor Tapjacking sicher.

Viel Glück und wir sehen uns nächste Woche!

Manchmal ist es wichtig, dass eine Anwendung überprüfen kann, ob eine Aktion mit dem vollen Wissen und der Zustimmung des Benutzers ausgeführt wird, z. B. wenn eine Genehmigungsanfrage erteilt, ein Kauf getätigt oder auf eine Anzeige geklickt wird. Leider kann eine böswillige Anwendung versuchen, den Benutzer dazu zu verleiten, diese Aktionen auszuführen, ohne es zu merken, indem sie den beabsichtigten Zweck der Ansicht verheimlicht.

https://developer.android.com/reference/android/view/View.html

Ursprünglich veröffentlicht auf der DevSecCon-Blog.

Da ich auf beiden Seiten des Zauns war, weiß ich nur zu gut, welche Spannungen zwischen dem Entwicklungsteam und den AppSec-Spezialisten entstehen können, wenn es darum geht, bewährte Sicherheitsverfahren aufrechtzuerhalten.

Es ist schwierig; am Ende des Tages ist die Bereitstellung von Softwarefunktionen die Hauptpriorität eines Entwicklers. Sie müssen schön und funktionell sein und dazu beitragen, die Leistungsfähigkeit der Anwendung zur Geltung zu bringen. Da heutzutage in der Regel agile Entwicklungspraktiken im Einsatz sind, müssen diese Funktionen innerhalb strenger Fristen fertiggestellt werden... und Sicherheit steht selten ganz oben auf der Liste der Bedenken, wenn so viel anderes auf dem Spiel steht.

Sicherheit wird als Domäne des AppSec-Teams angesehen, das die wenig beneidenswerte Aufgabe hat, Code zu scannen (oder noch schlimmer: ihn manuell, Zeile für Zeile zu überprüfen) und dem Entwicklungsteam zu melden, dass sein Code unsicher oder sogar völlig unbrauchbar ist. Sie sind die Spielverderber, die ihre gute Arbeit auseinandernehmen, Innovationen zum Erliegen bringen und Entwicklern generell Kopfschmerzen bereiten. Letzten Endes lassen sich viele Sicherheitsprobleme ganz einfach lösen. „Vielleicht könnte nur eine einzige Codezeile eine anfällige Hintertür innerhalb von Minuten verstärken.

Aber hier ist das Problem. Da „Sicherheit“ so ein Synonym für eine negative Erfahrung ist, beschäftigen sich Entwickler einfach nicht so intensiv damit, wie sie sollten. Diese einzeiligen Korrekturen finden nicht statt: Schließlich stoßen die AppSec-Leute ständig auf dieselben Probleme. Es muss ziemlich verrückt für sie sein, immer noch auf SQL-Injection-Fehler hinzuweisen, mehr als zwanzig Jahre, nachdem wir sie zum ersten Mal entdeckt haben (und ihre anschließende Behebung).

Was wir bisher getan haben, funktioniert bei weitem nicht so effektiv, wie wir es uns erhofft hatten. Wir müssen uns darauf konzentrieren, die Brücke zwischen Entwicklern und AppSec-Spezialisten zu reparieren und eine positive Sicherheitskultur anzustreben, in der Entwickler die Tools und Schulungen erhalten, um in diesem Bereich wirklich etwas bewirken zu können.

Wer weiß? Vielleicht verlieben sie sich sogar in sie wie ich!

Positive Sicherheit ist der schnellste und einfachste Weg, die Anwendungssicherheit zu verbessern.

City „und nein, es geht nicht um irgendeinen Haufen um immaterielle Ergebnisse. Es ist ein absolut wichtiger Bestandteil des Erfolgsrezepts für sichere Codierung.

Entwickler haben den Schlüssel zur Verbesserung der Sicherheit von Beginn der Produktion an in der Hand, indem sie in erster Linie sicheren Code schreiben. Durch die Schaffung einer positiven Sicherheitskultur und die Begeisterung der Entwickler für die Anwendungssicherheit können häufig auftretende Sicherheitslücken behoben werden, bevor sie es im AppSec-Land überhaupt zu einem Scan oder einer manuellen Codeüberprüfung schaffen.

Es ist dreißigmal teurer, Sicherheitslücken in bereits festgeschriebenem Code zu behebenDaher ist die Suche nach Schulungen, die den Stärken der Entwickler gerecht werden, Interesse wecken und tatsächlich funktionieren, ein großer Schritt zur zukünftigen Kostensenkung bei der Identifizierung und Behebung dieser wiederkehrenden Sicherheitslücken.

Positive, entwicklerorientierte Initiativen fördern die richtige Sicherheitskultur.

Wenn alle mit den besten Sicherheitsmethoden auf derselben Wellenlänge sind, ist eine positive Sicherheitskultur ein glückliches, wichtiges Nebenprodukt.

Positive, skalierbare, auf Entwickler ausgerichtete Initiativen fördern die richtige Sicherheitskultur. Die Einbindung der problemlösenden, kreativen Köpfe der Entwickler ist unerlässlich, um sie für sich zu gewinnen und sicherzustellen, dass neue Mitarbeiter schnell mit den Sicherheitserwartungen des Teams Schritt halten können. Nehmen Sie Kontakt auf für einen Überblick darüber, wie sich die Beziehung zwischen Entwicklern im Bereich Sicherheit entwickelt hat, und Ideen zur Einführung eines erfolgreichen Sicherheitsbewusstseinsprogramms in Ihrem eigenen Unternehmen.

Das Löschen von Dateien auf einem Computersystem ist schwierig. Jeder, auch deine Mutter, hat schon einmal zu viele Dateien gelöscht und war froh, sie immer noch im Papierkorb zu finden und sie wiederherstellen zu können.

Daten in Computersystemen werden durch eine Folge von Bits dargestellt. Das bedeutet, dass das System eine gewisse Buchführung innerhalb des Dateisystems durchführen muss, um zu wissen, welche Bits welche Datei repräsentieren. Zu diesen Informationen gehören die Größe der Datei, der Zeitpunkt der letzten Änderung, ihr Besitzer, Zugriffsberechtigungen usw. Diese Buchhaltungsdaten werden getrennt vom Inhalt der Datei gespeichert.

Normalerweise passiert beim Entfernen einer Datei nichts mit den Bits, die die Datei repräsentieren, aber die Buchhaltungsdaten werden geändert, sodass das System weiß, dass dieser Teil des Speichers jetzt bedeutungslos ist und wiederverwendet werden kann. Bis eine andere Datei an diesem Ort gespeichert ist und die Bits an diesem Ort überschrieben werden, können Sie die gespeicherten Daten oft trotzdem wiederherstellen. Dies verbessert nicht nur die Geschwindigkeit beim Löschen von Dateien, sondern ist oft eine nützliche Funktion, um den Löschvorgang rückgängig zu machen.

Dieser Ansatz hat jedoch auch Nachteile. Wenn eine Anwendung auf einem Computersystem vertrauliche Informationen verarbeitet, speichert sie diese Daten irgendwo im Dateisystem. Irgendwann, wenn die Informationen nicht mehr benötigt werden, können diese Daten gelöscht werden. Wenn keine besondere Sorgfalt angewendet wird, können diese Daten möglicherweise immer noch wiederhergestellt werden, obwohl die Absicht des Entwicklers darin bestand, dass alle Daten gelöscht wurden.

Der einfachste Weg, diese Daten vollständig zu löschen, besteht darin, den Dateiinhalt mit zufälligen Daten neu zu schreiben (manchmal sogar mehrmals). Es gibt verschiedene Methoden zum sicheren Entfernen von Dateien, die je nach Speichertyp und Dateisystem unterschiedlich sind, wie z. B. die Gutmann-Methode. Für die tägliche Verwendung von Anwendungen sind diese jedoch etwas übertrieben und Sie können die Daten einfach selbst überschreiben.

Sei aber vorsichtig! Verwenden Sie nicht alle Nullen oder andere Daten mit niedriger Entropie. Viele Dateisysteme optimieren möglicherweise das Schreiben solcher Dateien mit geringer Dichte und lassen einen Teil des ursprünglichen Inhalts übrig. Es wird empfohlen, sichere Zufallsdaten zu generieren, um den gesamten Dateiinhalt zu überschreiben, bevor die Datei selbst gelöscht wird.

Datenremanenz ist die verbleibende physische Repräsentation von Daten, die auf irgendeine Weise gelöscht wurden. Nach dem Löschen von Speichermedien können einige physische Merkmale vorliegen, die eine Rekonstruktion der Daten ermöglichen.

https://fas.org/irp/nsa/rainbow/tg025-2.htm

Da die Zahl der Cyberbedrohungen weiter zunimmt, gehen Unternehmen täglich Kompromisse zwischen Sicherheit, Praktikabilität und Geschwindigkeit ein und setzen sich dabei Risiken aus. Neue Ansätze für sichere Codierung sind erforderlich, also Secure Code Warrior arbeitete mit Evans Data Corp. zusammen, um grundlegende Untersuchungen zur Einstellung von Entwicklern zu sicherem Programmieren, sicheren Codepraktiken und Sicherheitsvorgängen durchzuführen (Whitepaper herunterladen) hier).

Dieser Bericht zeigte, dass reaktives Denken der „alten Schule“ zwar immer noch dominiert, aber das Bewusstsein für die Notwendigkeit proaktiverer Lösungen wächst, die die Entwickler selbst zur ersten Verteidigungslinie machen.

Jede Untersuchung der Einführung sicherer Codierungspraktiken muss mit einem Verständnis der an der Implementierung beteiligten Personen, ihrer Wahrnehmung davon und ihrer Fähigkeit, sie umzusetzen, beginnen. Dies führt dann zum wichtigsten Puzzleteil: Wie können sie in die Lage versetzt werden, von Anfang an sicherer zu programmieren und Qualitätscode schneller und mit Zuversicht zu versenden?

Sicheres Programmieren — wo stehen wir jetzt und was muss sich ändern? Herunterladen die Infografik „Das menschliche Element“ jetzt.

Aktuelle Perspektiven — reaktiv oder proaktiv

Als Entwickler und Entwicklungsmanager nach den Aktivitäten gefragt wurden, die sie mit sicherem Programmieren verbinden, lauteten die drei wichtigsten Antworten:

• Verwendung von Scan-Tools für bereitgestellte Anwendungen.
• Manuelles Überprüfen des Codes auf Sicherheitslücken.
• Die aktive und kontinuierliche Praxis, Software zu schreiben, die vor Sicherheitslücken geschützt ist.

Wie wir sehen können, konzentrierten sich zwei der drei häufigsten Antworten immer noch auf reaktive Ansätze — die erste hing von Tools (Scannern) ab, und die zweite davon, dass der Entwickler (d. h. ein Mensch) manuelle Prüfungen durchführt.

Gleichzeitig stützen sich zwei der drei nominierten Aktivitäten auf das menschliche Element. Dies deutet darauf hin, dass Sicherheit zunehmend als menschliches Problem wahrgenommen wird. Von allen nominierten Aktivitäten ist jedoch Nummer 3, die den Faktor Mensch identifiziert, am aussagekräftigsten beim Schreiben von Software, die in erster Linie vor Sicherheitslücken geschützt ist. Dies unterstreicht eine Verlagerung nach links — einen proaktiven und präventiven Ansatz, der Sicherheit von Beginn des SDLC an in die Software integriert.

Wo passt Sicherheit in den SDLC?

Wenn Entwickler und Entwicklungsmanager gefragt werden, welche Sicherheitscode-Praktiken ihrer Meinung nach in den SDLC integriert werden, gehen die Meinungen auseinander. 55% der Manager glauben, dass sicheres Programmieren in den gesamten Entwicklungsprozess integriert ist, verglichen mit nur 43% der Entwickler. Der Unterschied könnte die unterschiedlichen Rollen dieser beiden Gruppen innerhalb des SDLC widerspiegeln. Das Management ist in der Regel weniger in die eigentliche Codierungsarbeit involviert und hat tendenziell eine übergeordnete Sichtweise — wohingegen sich Entwickler möglicherweise mehr mit den Einzelheiten befassen.

Aus Sicht der allgemeinen Sicherheit und Codequalität ist jedoch alarmierend, dass nur 13 Prozent der Entwickler und 10 Prozent der Manager angeben, dass sichere Codepraktiken in die Entwurfsphasen integriert werden sollten — gleich zu Beginn des SDLC. Dies ist eine riesige und noch nicht realisierte Chance. Laut einer IBM-Studie ist es dreißig Mal teurer, Sicherheitslücken im Code nach der Veröffentlichung zu beheben, als wenn sie zu Beginn gefunden und behoben wurden.1 Das ist ein starker Anreiz für eine neue proaktive und von Menschen geleitete Verteidigung der Softwaresicherheit, die Entwickler in die Lage versetzt, von Anfang an sicherer zu programmieren. Softwaresicherheit lässt sich nicht allein durch Tools lösen — sie muss den Faktor Mensch berücksichtigen.

Ist das menschliche Element vorbereitet?

97% der befragten Entwickler sind der Meinung, dass sie ausreichend in sicherer Codierung geschult wurden, und 95% stimmten zu, dass Schulungen in sicherer Codierung für ihre Karriere wertvoll waren. Doch bevor wir diese Behauptungen für bare Münze nehmen, müssen wir uns fragen: Warum sind Code-Schwachstellen immer noch so häufig? Sind die Behauptungen der Entwickler, sie seien Experte im Bereich des sicheren Codes, nur ein Fall von menschlichem Ego? Die Beweise deuten sicherlich in diese Richtung. In einem bescheideneren Eingeständnis geben mehr als 88% der befragten Entwickler zu, dass sicheres Programmieren schwer zu erlernen ist, und 91% der Entwicklungsmanager räumen ein, dass sichere Programmierpraktiken schwierig zu implementieren sind. Auf die Frage nach ihren wichtigsten persönlichen Bedenken im Zusammenhang mit der Implementierung von sicherem Code empfanden 28% der Entwickler den Lernprozess als schwierig, während 24% den Lernprozess als langweilig empfinden. Dies deutet darauf hin, dass die Schulung der Entwickler verbessert werden muss.

Was braucht das menschliche Element?

Um den „herausfordernden“ Faktor zu überwinden, eine lohnende sichere Schulung erfordert einen „Gerüstbau“ -Prozess, der den Entwickler dabei unterstützt, Schritt für Schritt sichere Programmierkenntnisse aufzubauen. Um ein Höchstmaß an Relevanz und unmittelbarer Anwendbarkeit zu erreichen, sollte diese Schulung in dem spezifischen Sprache:Framework stattfinden, das sie täglich verwenden.

Um den Faktor „Langeweile“ zu überwinden, Sicherheitscode-Schulungen müssen praxisnah vermittelt werden — sie haben sich für Entwickler als weitaus ansprechender erwiesen als veraltete Modelle im Klassenzimmer oder „Schau dir dieses Video an“. Dazu sollten Live-Simulationen gehören, die es Entwicklern ermöglichen, manchmal riskante Sicherheitsherausforderungen in einer sicheren Umgebung zu bewältigen. Ziel sollte es sein, Entwicklern beizubringen, Sicherheitslücken im Code während der Arbeit zu finden und zu beheben und sicheres Programmieren zu einem Teil ihres täglichen Ablaufs zu machen. Ein weiterer wichtiger Faktor ist das Linting und Coaching innerhalb der IDE, das Entwicklern hilft, während des Programmierens ständig zu lernen und ihre Fähigkeiten zu verbessern und Sicherheitslücken zu verhindern und zu beseitigen.

Wenn Sie herausfinden möchten, wie Sie Ihren Entwicklern dieses neue Niveau an entwicklerzentrierten Tools und Schulungen zur Verfügung stellen können, eine Demo buchen jetzt.

Du kannst auch lade dein Exemplar herunter des Whitepapers Übergang von der Reaktion zur Prävention: Das sich wandelnde Gesicht der Anwendungssicherheit.

‍

Cyberangriffe nehmen zweifellos zu. Laut dem Verizon Data Breach Investigations Report 2021 ist die Bedrohungslandschaft heute gefährlicher als je zuvor. Unternehmen aller Größen sind mit einem höheren Angriffsvolumen und einem höheren Grad an Raffinesse seitens der Bedrohungsakteure konfrontiert, die sie ins Visier nehmen. Und auch die Erfolgsraten der Angreifer steigen sprunghaft an.

Die Analyse der jüngsten Angriffe hilft dabei, einige der häufigsten Sicherheitslücken und Techniken aufzudecken, die von Hackern bei diesem beispiellosen Angriff gegen Cyberabwehr eingesetzt wurden. Einige der beliebtesten Angriffe, wie zum Beispiel diejenigen, die es ins Open Web Application Security Project (OWASP) geschafft haben Die 10 wichtigsten Sicherheitsrisiken und Sicherheitslücken für 2021, beinhaltete den Diebstahl oder die anderweitige Kompromittierung von Zugangsdaten. Und laut Sicherheitsforschung Die überwältigende Mehrheit, fast 75%, wurde von Akamai durchgeführt und zielte direkt auf die Anmeldeinformationen der APIs ab.

Der Aufstieg und der mögliche Ruin von APIs

Kein Wunder, dass Anwendungsprogrammierschnittstellen, meist nur APIs genannt, in den Netzwerken fast aller Unternehmen auf dem Vormarsch sind. Sie sind ein wichtiger Bestandteil der meisten Cloud-basierten Dienste, die in den meisten Unternehmen, Organisationen und Regierungsbehörden zunehmend die Funktionen der lokalen Ressourcen übernehmen. Ohne die Cloud können Sie heutzutage fast keine Geschäfte oder Aufgaben mehr ausführen, insbesondere solche, die öffentlich zugänglich sind. Und das bedeutet, dass APIs sicherlich der Klebstoff sein werden, der eine ganze Reihe von Diensten in jedem Netzwerk zusammenhält.

Das Erstaunliche an APIs ist, dass sie in Bezug auf die Zuweisung von Netzwerkressourcen meist klein und unauffällig sind. Und sie sind völlig flexibel, sodass sie mit fast allen Aufgaben beauftragt werden können. Im Kern sind APIs einzelne Softwareteile, die auf die Steuerung oder Verwaltung eines bestimmten Programms zugeschnitten sind. Sie können verwendet werden, um ganz bestimmte Funktionen auszuführen, z. B. den Zugriff auf Daten von einem Host-Betriebssystem, einer Anwendung oder einem Dienst aus.

Leider sind es genau diese Flexibilität und die Tatsache, dass sie oft klein sind und von Sicherheitsteams übersehen werden, die APIs zu attraktiven Zielen machen. Die meisten APIs wurden von Entwicklern so konzipiert, dass sie absolut flexibel sind, sodass sie beispielsweise auch dann weiter funktionieren können, wenn das von ihnen verwaltete Kernprogramm geändert oder geändert wird. Und es gibt nur wenige Standards. Fast wie Schneeflocken sind viele APIs insofern einzigartig, als sie so konzipiert sind, dass sie eine bestimmte Funktion mit einem einzigen Programm in einem bestimmten Netzwerk erfüllen. Wenn sie von Entwicklern programmiert werden, die nicht sehr sicherheitsbewusst sind oder sich nicht speziell auf Sicherheit konzentrieren, dann können und werden sie wahrscheinlich eine beliebige Anzahl von Schwachstellen die Angreifer finden und ausnutzen können.

Leider läuft das Problem schnell aus dem Ruder. Laut Gartner wird bis 2022 Sicherheitslücken im Zusammenhang mit APIs wird der häufigste Angriffsvektor in allen Cybersicherheitskategorien werden.

Der Hauptgrund, warum Angreifer APIs kompromittieren wollen, ist nicht, dass sie irgendeine spezifische Funktion übernehmen können, die die API ausführt, sondern darin, die damit verbundenen Anmeldeinformationen zu stehlen. Eines der größten Probleme mit APIs ist nicht nur reich an Sicherheitslücken, sondern auch, dass sie häufig viel zu viel erlaubt in Bezug auf ihre Kernfunktionalität. Der Einfachheit halber haben die meisten APIs nahezu Administratorzugriff auf ein Netzwerk. Wenn ein Angreifer die Kontrolle über ein Netzwerk erlangt, kann er dessen Berechtigungen häufig nutzen, um tiefere und substanziellere Eingriffe in ein Netzwerk zu starten. Und da die API die Erlaubnis hat, alle Aufgaben auszuführen, zu denen der Angreifer ihn umleitet, können seine Aktionen häufig die traditionelle Cybersicherheitsüberwachung umgehen, da die API dank ihres VIP-Backstage-Passes für alle Bereiche keine Regeln verstößt.

Wenn Unternehmen nicht vorsichtig sind, kann die Zunahme von APIs in ihrem Netzwerk und ihren Clouds auch große Probleme bereiten, wenn sie von Angreifern ins Visier genommen werden.

Verteidigung der APIs

So gefährlich die Situation mit APIs auch wird, sie ist alles andere als hoffnungslos. Durch Bewegungen entsteht ein großer Kraftaufwand wie DevSecOps um Entwicklern dabei zu helfen, das Sicherheitsbewusstsein zu stärken und Sicherheit und bewährte Verfahren in alle Aspekte der Softwareentwicklung einzubeziehen, von der Entwicklung über das Testen bis hin zur Bereitstellung. Die Einbeziehung der API-Sicherheit in diese Schulung wird für jedes Unternehmen, das sich bis 2022 und darüber hinaus dem Trend der API-Ausnutzung widersetzen will, von entscheidender Bedeutung sein.

Allerdings gibt es einige wirklich gute Best Practices, die derzeit in Bezug auf die API-Sicherheit implementiert werden können.

Die erste Sache ist, strenge Identitätskontrollen für alle APIs einzuführen. Sie sollten sie bei der Vergabe von Berechtigungen fast als menschliche Benutzer betrachten. Nur weil eine API nur für eine bestimmte Funktion konzipiert ist, müssen Sie darüber nachdenken, was passieren könnte, wenn ein Angreifer sie kompromittieren kann. Erwägen Sie die Verwendung einer rollenbasierten Zugriffskontrolle. Im Idealfall sollten Sie letztendlich die Zero-Trust-Prinzipien auf Ihre APIs und Benutzer anwenden, aber das ist oft ein langer Weg. Ein gutes Identitätsmanagement ist ein guter Anfang. Achten Sie nur darauf, APIs als Teil dieses Programms einzubeziehen.

Sie sollten auch die verschiedenen Aufrufe, die von Ihren APIs getätigt werden, so genau wie möglich kontrollieren. Wenn Sie diese Aufrufe auf sehr kontextzentrierte Anfragen beschränken, wird es für einen Angreifer viel schwieriger sein, sie für schändliche Zwecke zu ändern. Sie können Ihre APIs sogar überlagern, wobei eine anfängliche API einen stark kontextbezogenen Aufruf an eine andere API tätigt, die genau weiß, wonach sie suchen und was zu ignorieren ist. Das kann eine effektive Methode sein, um die Funktionen einzuschränken, die einem Bedrohungsakteur zur Verfügung stehen, selbst wenn er in der Lage ist, eine API innerhalb dieser Kette auszunutzen und zu kompromittieren.

Die Bedrohungen gegen APIs können sicherlich überwältigend erscheinen. Aber durch die Implementierung von Best Practices und die Unterstützung und Belohnung von Entwicklern, die zu Sicherheitsexperten werden, kann die Situation viel weniger hoffnungslos erscheinen. Mit guter Schulung und Praxis können Sie ein robustes Sicherheitsprogramm aufstellen, das Angreifern wenig Spielraum lässt, selbst wenn sie eines Ihrer winzigen, aber wichtigen API-Arbeitspferde irgendwie gefährden sollten.

Als Experte für Anwendungssicherheit ist es Ihre Aufgabe, die Cybersicherheit der Anwendungen Ihres Unternehmens zu gewährleisten. Sie sind jedoch nicht dafür verantwortlich, den Code zu schreiben, auf dem die Anwendung ausgeführt wird. Ingenieure innerhalb des Entwicklungsteams sind es. Wie stellen Sie also sicher, dass sie diese Systeme unter Berücksichtigung der Sicherheit entwickeln?

Höchstwahrscheinlich machst du einige oder sogar alle der folgenden Dinge:

• Überprüfung des gesamten Codes auf Sicherheitslücken und Meldung dieser an das Entwicklungsteam zur Behebung.
• Durchsetzung eines strengen Peer-Review-Prozesses während Ihres gesamten sicheren Entwicklungslebenszyklus.
• Durchführung regelmäßiger Anwendungsbewertungen/Penetrationstests durch interne oder externe Sicherheitsteams.
• Implementierung von Scan-Tools zur Erkennung von Sicherheitslücken.
  

Dies sind großartige bewährte Methoden, aber sie sind auch teuer und ähneln der Einnahme einer Antibiotikarunde jedes Mal, wenn Sie krank werden. Das ist nicht nur mit hohen Kosten verbunden, es verliert auch an Wirksamkeit und kann Ihr Immunsystem im Laufe der Zeit schwächen.

Wie stellen Sie tatsächlich sicher, dass der Code, den Entwickler ausliefern, überhaupt sicher geschrieben ist?

Abgesehen von der sicheren Codierung sollten Sie zunächst darüber nachdenken, wie Menschen lernen. Die meisten von uns sind visuelle Lerner und lernen durch Handeln. Dennoch werden Schulungen zum Thema „Sicherheitscode“ oft als „Häkchen“ -Aktivität angeboten und sind für die tägliche Arbeit eines Entwicklers nicht relevant. Es soll nachweisen, dass Entwickler häufig Sicherheitsschulungen absolviert haben, um den Industriestandards zu entsprechen, und nicht, dass Entwickler dieses Wissen tatsächlich behalten, geschweige denn Spaß am Lernprozess haben.

Menschen neigen auch dazu, durch unsere Fehler zu lernen, auf die gleiche Weise wie unser Immunsystem. T-Zellen erinnern sich, auf welche Art von Krankheitserregern sie in der Vergangenheit gestoßen sind und die sie erfolgreich ausgerottet haben, sodass sie sich in Zukunft vor ihnen schützen können. Das ist genau die Rolle, die Entwickler in Ihrem sichern SDLC.

Es ist unrealistisch zu erwarten, dass sie keine Fehler machen, aber Sie können sie so vorbereiten, dass Sie Codierungsmuster erkennen können, die in Zukunft zu Sicherheitslücken führen werden.

Dies ist auch der Grund, warum ein robustes Peer-Review-Verfahren so mächtig wird. Nur weil ein Entwickler eine Sicherheitslücke nicht bemerkt, heißt das nicht, dass ein anderer nicht bemerkt. Und je besser das gesamte Entwicklungsteam geschult ist, desto wahrscheinlicher ist es, dass Sicherheitslücken im Nu erkannt werden und es nie in die Produktion schaffen.

Software-Sicherheitslücken sind wie Krankheitserreger

Software-Sicherheitslücken sind in dem Sinne wie Krankheitserreger, man muss sich an sie erinnern, um sie bekämpfen zu können. Bei Krankheitserregern muss unser Immunsystem oft mehrfach exponiert werden, bevor es sich daran erinnert, wie es sie bekämpfen kann, um schwere Krankheiten oder Schlimmeres zu vermeiden.

Ein erfolgreicher Cyberangriff von anfälliger Software kann ein Unternehmen ernsthaft lahmlegen oder zum Erliegen bringen. Wenn Entwickler jedoch zuerst in einer kontrollierten Umgebung mit Software-Sicherheitslücken vertraut gemacht werden, können sie daran arbeiten, eine Immunität gegen diese Bedrohungen aufzubauen, indem sie ihre Kenntnisse und Fähigkeiten im Bereich der sicheren Codierung erweitern und regelmäßig üben.

Setzen Sie Entwickler Sicherheitslücken in einer kontrollierten Umgebung aus

Wir können uns nie vollständig davor schützen, krank zu werden, aber es gibt Dinge, die wir tun können, um unser Immunsystem zu stärken und so gesund wie möglich zu bleiben. Dinge wie regelmäßige Bewegung, gesunde Ernährung und viel Schlaf gehören zu den Lebensgewohnheiten, die häufig mit einem starken Immunsystem in Verbindung gebracht werden. Aber all diese Dinge erfordern ein wenig Aufwand und müssen kontinuierlich sein. Eine Woche lang jeden Tag joggen oder einen Monat lang auf das Trinken verzichten, wird Ihre allgemeine Gesundheit kaum beeinträchtigen. Es ist auch nicht ratsam, am ersten Tag, an dem wir mit dem Laufen beginnen, rauszugehen und 10 km zu laufen. Wir müssen zuerst unser Herz und unsere Muskeln der Übung aussetzen. Wir wissen auch, dass es ein bisschen Experimentieren erfordert, bis wir ein gutes Gleichgewicht zwischen unserem Körper und gesunden Lebensmitteln und Übungen, die wir lieben, gefunden haben.

Es ist nicht so anders, wenn es um sichere Softwareentwicklung geht. Das Lernen erfolgt im Laufe der Zeit und mit der Praxis, und Entwickler benötigen dieselbe fortlaufende Schulung, um ihre Fähigkeiten im Bereich der sicheren Codierung regelmäßig zu verbessern. Ganz zu schweigen davon, dass sich die Softwareentwicklung ständig weiterentwickelt und sich anpasst, was auch die Sicherheitslücken bedeutet. Deshalb reicht eine einfache Schulung nicht aus. Entwickler müssen regelmäßig geschult werden, um mit potenziellen Bedrohungen vertraut genug zu sein, um angemessen gegen sie gewappnet zu sein.

Ziel ist es, innerhalb des Entwicklungsteams eine Herdenimmunität zu erreichen

Eine einzelne Person kann nicht alle Sicherheitsprobleme verhindern. Es ist toll, Sicherheitsexperten im Team zu haben, aber um den besten Schutz zu erhalten, gilt: Je mehr Mitarbeiter über Sicherheitslücken und deren Vermeidung erfahren haben, desto bessere Chancen hat Ihr Unternehmen, sie zu verhindern. Auch hier ist es nicht viel anders als die Tatsache, dass das Immunsystem verschiedene Typen von T-Zellen für unterschiedliche Zwecke verwendet. Jeder einzelne Entwickler ist Teil eines Teams, das für Sicherheit sorgt. Wenn sie befähigt sind, Verantwortung zu übernehmen, es gut zu machen und sogar Spaß daran haben, dann können Sie innerhalb des Entwicklungsteams eine Herdenimmunität gegen Cyberbedrohungen schaffen.

Behalten Sie die Sicherheit bei wiederholter Exposition im Auge

Unser Gehirn lernt auf ähnliche Weise, wie unser Immunsystem funktioniert. Deutscher Psychologe Herman Ebbinghaus war ein Pionier auf dem Gebiet des Gedächtnisses und Lernens. Er folgerte daraus, dass Lernen im Laufe der Zeit und mit mehreren Lernsitzungen erfolgen muss. Wenn wir in der Schule sind, wird von uns nie erwartet, dass wir nach der ersten Einführung neues Wissen beibehalten. Zuerst werden uns die Informationen präsentiert, dann üben wir sie unter Anleitung und dann üben wir sie selbst. Und selbst wenn wir es gut genug gelernt haben, um eine Prüfung zu bestehen, neigen die Informationen dazu, kurz darauf vergessen zu werden, wenn wir das Wissen, für das wir Zeit und Mühe aufgewendet haben, nicht regelmäßig anwenden. Wie viele von uns können von sich behaupten, dass sie sich an ihr Highschool-Französisch erinnern?

Wie können wir also glauben, dass ein einziger Tag, an dem wir uns Folien ansehen und jemandem zuhören, der über Sicherheit spricht, tatsächlich dazu führen würde, dass die anwesenden Entwickler sicherer programmieren?

Muster wiederkehrender Sicherheitslücken zeigen uns, dass dies einfach nicht funktioniert.

Wie erreicht man eine sichere Entwicklungsimmunität?

Die Antwort liegt in unserer Natur. Unser Körper und unser Geist funktionieren auf die gleiche Weise und sie bieten wunderbare Lösungen für Probleme, solange wir mit ihnen und nicht gegen sie arbeiten.

Um sicherzustellen, dass Ihre Anwendungen sicher sind, müssen Sie zunächst Entwickler darin schulen, sicheren Code zu schreiben. Andernfalls wird AppSec weiterhin ihre gesamte Zeit damit verbringen, den gesamten Code auf Sicherheitslücken zu überprüfen und dieselben wiederkehrenden Sicherheitslücken an die Entwicklung zurückzumelden, nur um schnell behoben zu werden, ohne dass etwas gelernt wurde. Und dann machen Sie alles noch einmal für die nächste Version.

Lassen Sie uns das noch einmal wiederholen.

Wenn Sie dabei mit Ihren Entwicklungsmanagern zusammenarbeiten, implementieren Sie nicht nur ein sicheres SDLC und kreuzen das Kästchen für die Einhaltung der Sicherheitsschulungen an, sondern Sie werden auch einen realen Einfluss auf den Entwicklungsprozess haben. Um dem Ganzen noch einen drauf zu setzen: AppSec wird nicht mehr auf Sicherheitslücken stoßen und diese den Entwicklungsteams melden und Entwickler werden weniger Zeit damit verbringen, sie zu beheben. Das bedeutet, dass sie mehr Zeit damit verbringen können, die fantastische Software zu entwickeln und zu verbessern, die unsere Welt besser macht.

Sind Sie bereit, Ihr Entwicklungsteam weiterzubilden? Mach weiter und eine Demo buchen bei uns.

Obwohl es für jeden, der außerhalb der Softwareentwicklung arbeitet, kontraintuitiv erscheinen mag, haben viele der im Laufe der Jahre im Bereich Anwendungssicherheit beschäftigten Experten in diesen wichtigen Rollen mit wenig oder keiner Programmiererfahrung gearbeitet. Diese AppSec-Experten sind Teil des Teams, das dafür verantwortlich ist, sicherzustellen, dass sich keine Sicherheitslücken in die Anwendungen einschleichen, die zum Lebenselixier vieler Branchen und Organisationen geworden sind, und dennoch können nur wenige von ihnen den Code tatsächlich direkt selbst evaluieren oder reparieren.

Viele Sicherheitsexperten kommen nicht aus dem Bereich Programmieren, sondern betrachten ihre Rollen aus der Perspektive von Schlüsselkenntnissen über Angriffsvektoren, Bedrohungen, Exploits und Geschäftsrisiken. Sie haben einen begrenzten Überblick über Code. Zwar verfügt nicht jeder AppSec-Experte über die gleichen Fähigkeiten, aber ein typischer Arbeitsalltag für viele beinhaltet die Zusammenarbeit mit Code-Reviewern und Scan-Tools, um sicherzustellen, dass Programme und Systeme gemäß den Unternehmensstandards oder den relevanten Branchen- und Regierungsvorschriften geschützt sind. Anschließend verfassen sie Berichte über ihre Ergebnisse und senden Informationen über den Angriffsvektor zurück, der den Code knacken könnte. Es liegt dann an den Entwicklern, die notwendigen Korrekturen vorzunehmen, unabhängig davon, wie störend das für die aktuelle Arbeit sein mag.

Der Grund, warum sich die Situation so entwickelt hat, ist, dass die vorherrschende Logik im Laufe der Jahre war, dass die Aufgabe, Netzwerke und Anwendungen zu schützen, so umfangreich war, dass es keinen Sinn machte, zu erwarten, dass jeder, der im Bereich Cybersicherheit arbeitet, jede Rolle wahrnimmt. Tiefgehende Programmierkenntnisse blieben den Entwicklern überlassen, und es wurde wenig Wert auf die Fähigkeit gelegt, Code weiter unten in der Entwicklungspipeline zu schreiben oder zu bearbeiten.

Diese Denkweise ändert sich schnell, und das ist eine einzigartige Gelegenheit für Entwickler, den lukrativen Sprung und den Karrierewechsel zu AppSec zu wagen. Nicht jeder Entwickler wird sich der sogenannten dunklen Seite zuwenden wollen, und viele Entwickler stehen AppSec-Teams nicht besonders positiv gegenüber. Aber für diejenigen, die das tun, gab es nie einen besseren Zeitpunkt, um sich diesen immer verlockender werdenden Messingring zu schnappen.

DevSecOps treibt fast jede Branche an

Einer der wichtigsten Faktoren bei der Steigerung des Nutzens sicherheitsbewusster Programmierer und Entwickler in jeder Organisation ist der fast allumfassende Schritt hin zu agileren Entwicklungspraktiken. wie DevSecOps. Wenn Entwicklung, Sicherheit und Betrieb kombiniert werden, wird Cybersicherheit zu einer gemeinsamen Verantwortung, die von Anfang bis Ende in die Entwicklung neuer Software integriert wird. In dieser Umgebung wird die Fähigkeit zum Programmieren zunehmend auf der ganzen Linie als wertvolles Gut angesehen, und dies gilt insbesondere für Ingenieure, die sich auch von Natur aus mit Sicherheit auskennen.

Ein AppSec-Experte, der nicht nur Cybersicherheit auf hohem Niveau versteht, sondern auch den Code, der dafür sorgt, dass alles funktioniert, ist für jedes Unternehmen von Natur aus wertvoller als jemand, dessen Wissen sich auf die Theorie konzentriert. Die Fähigkeit, im Code gefundene Sicherheitslücken schnell zu entdecken und zu bewerten und diese Probleme dann zu mindern, ist der Hauptgrund, warum DevSecOps so beliebt ist.

Entwickler, die in AppSec arbeiten, bieten jedem Unternehmen, das sie beschäftigt, einen weiteren großen Vorteil. Da sie aus der Entwicklungsabteilung des Hauses kommen, ist es für sie einfach, mit Entwicklern über Sicherheit und Sicherheitslücken zu sprechen. Es macht es auch viel einfacher, Coaches für die Entwicklungsteams zu werden, was ihnen hilft, bessere Programmierer zu werden. Im Laufe der Zeit werden sie möglicherweise sogar in der Lage sein, das Stigma der „dunklen Seite“ von AppSec zu entfernen und dabei zu helfen, Teams innerhalb der Softwareentwicklung im gesamten Unternehmen zu vereinheitlichen.

Der Fachkräftemangel im Bereich Cybersicherheit wird immer schlimmer

Shakespeare überlegte, dass es ein böser Wind ist, der niemanden gut weht. Er meinte damit, dass selbst die dunkelste Situation wahrscheinlich jemandem nützt. Der Fachkräftemangel im Bereich Cybersicherheit ist ein gutes Beispiel dafür.

Der Personalmangel ist fast überall akut zu spüren. In einem aktuelle Umfrage In einer vom Center for Strategic and International Studies durchgeführten Studie gaben 82 Prozent der IT-Entscheidungsträger an, dass ihre Unternehmen unter einem Mangel an Cybersicherheitskompetenzen litten, und 71 Prozent gaben an, dass der Mangel zu direkten und messbaren Schäden für ihre Unternehmen geführt hat. Um diese Krise in ein noch besseres Licht zu rücken, wies der Bericht darauf hin, dass allein in den Vereinigten Staaten im Jahr 2020 allein in den Vereinigten Staaten mehr als 520.000 unbesetzte Stellen im Bereich Cybersicherheit in einem Bereich, in dem nur etwa 940.000 beschäftigt sind, unbesetzt waren.

Der Personalmangel im Bereich Cybersicherheit ist eine schlechte Nachricht für Unternehmen, die versuchen, ihre Infrastruktur, ihr Geschäft und ihre Daten vor einer zunehmend gefährlichen Bedrohungslandschaft zu schützen. Es ist jedoch eine gute Gelegenheit für Entwickler, die sich mit AppSec und Sicherheit befassen möchten. Die Chancen stehen gut, dass Stellen in den Bereichen Cybersicherheit und AppSec fast überall verfügbar sind. Und die Zahl der Stellen im Bereich Cybersicherheit beträgt im Durchschnitt 21% mehr Zeit Um diese Tage zu füllen, steigen die Gehälter auf breiter Front.

Der Sprung zu AppSec

Es gibt vielleicht nie einen besseren Zeitpunkt für Entwickler, um den lukrativen Sprung auf die sonnige Sicherheitsseite des Lebens zu wagen. Sicherheitsbewusste Entwickler werden nicht mehr nur als Teil einer provisorischen Sicherheitsmethode angesehen, sondern nehmen stattdessen eine umfassende und respektierte Rolle als Verteidiger der Cybersicherheit ein. Dies gilt insbesondere für Unternehmen, die DevSecOps und andere agilere Entwicklungsmethoden eingeführt haben. Und der Mangel an Talenten im Bereich Cybersicherheit bedeutet, dass Stellen in fast jedem Unternehmen, jeder Regierungsbehörde oder Organisation verfügbar sind. Wer über die richtigen Fähigkeiten verfügt, kann sich aussuchen, wo er arbeiten möchte.

Die Umstellung auf AppSec ist vielleicht nicht jedermanns Sache, und natürlich werden sich die meisten Entwickler weiterhin darauf konzentrieren, tolle Funktionen zu entwickeln. Aber für diejenigen, die erwägen, den Sprung zu wagen, kann die Investition in Sicherheitsschulungen zur Erweiterung ihrer vorhandenen Programmierkenntnisse viele Türen öffnen. Die besten AppSec-Mitarbeiter kommen aus dem Ingenieurwesen, weil sie die Technologie sehr gut verstehen und Empathie für die Notlage ihrer Entwicklerkollegen haben. DevSecOps bedeutet, dass jetzt sowieso jeder für die Sicherheit verantwortlich ist. Warum also nicht den aktuellen Fachkräftemangel nutzen, um Ihre Karriere im Bereich Anwendungssicherheit voranzutreiben? Es gab noch nie einen besseren Zeitpunkt, um einen positiven Schritt für sich, Ihre Familie und Ihre Karriere zu unternehmen.

侧信道攻击是指黑客可以从软件系统的物理实现中收集信息，而不是从算法的理论弱点或软件代码的错误中收集信息。

我喜欢用一个例子来更清楚地说明这一点，就是一个做用户名枚举的方法。如果你想知道什么是用户名枚举，或者为什么它是坏的，请访问我们的网站获取视频解释，或者玩一个挑战，看看你是否能在代码中识别它。

现在，为了理解如何通过侧面渠道攻击进行用户名枚举，你需要对现代网络应用中如何处理密码（或至少应该如此）有一些了解。一个好的网络应用程序不知道你的密码，它不会把你的密码保存或储存在任何地方。那么，它怎么知道你输入的是正确的，而且是你的密码呢？嗯，你的密码是散列的。

散列函数是一种数学运算，它很容易以一种方式进行（尽管计算上有些昂贵），但很难逆转，对于好的散列算法，输出是唯一的，取决于输入。当你在一个网站上注册时，该散列值被安全地存储，而不是你的密码本身。这意味着，每次你登录时，网络应用都会对你的输入进行散列，并将散列结果与存储的散列进行比较。如果你想了解更多关于安全的密码存储，你可以在我们的平台上进行。

哈希输入需要在计算机上花费一些时间，开发人员总是试图优化他们编写的一切，以使用户有一个流畅的体验。有一件事可以加快程序的速度，那就是在不需要的时候跳过散列。例如，当用户名不存在时（因此不需要检查密码），他们可以立即响应用户。这样他们就可以跳过对密码进行哈希运算的缓慢计算。如果用户名是正确的，他们将对输入的密码进行散列，并将其与存储的散列进行比较。

在这一点上，你可能已经猜到了事情可能出错的地方。尽管在现实中哈希运算只需要几毫秒，但黑客可以利用这个额外的延迟来找出他输入的用户名是否正确，因为一个错误的用户名会有一个稍快的反应，因为没有进行哈希运算。这种类型的旁门左道攻击被称为定时攻击，它是一个很好的例子，说明不同的非功能需求是如何相互抵消的。有时代码不能同时做到快速和安全。

因此，尽管密码处理得很完美，而且显示的信息是通用的，没有提示密码或用户名是否错误，但系统仍有漏洞。解决方法很简单，总是对密码进行哈希处理，或者将发送回复的时间推迟到哈希处理所需的时间。

获得的信息可以被攻击者用来获得系统中的用户列表。这些信息可以用来攻击网络应用程序，例如，通过暴力或默认用户名/密码攻击。

https://www.owasp.org/index.php/Testing_for_User_Enumeration_and_Guessable_User_Account_(OWASP-AT-002)

在2022年Gartner软件工程领域Cool Vendors报告中强调了开发人员安全技能的重要性。在此阅读报告全文。

Secure Code Warrior 被Gartner认定为四个 "软件工程领域的优秀供应商"之一。提高开发人员的生产力"，由Gartner颁发。根据Gartner的说法，"Cool Vendor的定义是提供创新、有影响或耐人寻味的技术或服务的小公司"。酷厂商的三个要素包括。

创新- 使用户能够做他们以前不能做的事情。

有影响力 - 已经或将要产生业务影响，而不仅仅是为了技术而技术。

诱人--在过去6个月中引起了Gartner的兴趣。

正如报告中所概述的，"软件工程师在保持生产力的同时，还要努力驾驭复杂的代码环境，提高他们所构建系统的安全性。这些很酷的供应商提供了创新的解决方案，帮助软件工程的领导者提高开发人员的生产力和减少安全风险"。

作为名单上唯一一家专注于开发者驱动安全的公司，这一认可证明了我们的战略，即让开发者拥有正确的安全技能和上下文工具，以便他们能够快速学习、构建和应用他们的技能，快速交付安全代码，从而提高软件安全。

虽然左移的好处已经被颂扬了一段时间，但许多组织仍在努力确保在软件开发生命周期的开始阶段就考虑安全问题。我们最近的 "安全 "调查显示开发者驱动的安全状况调查强调，缺乏时间是采用安全编码实践时需要克服的最大障碍，这也反映在Gartner最近的报告中。由于熟练的工程师严重短缺，再加上庞大而复杂的代码库和超过一半的运行时栈由开源软件组成，开发人员几乎没有足够的时间来维护现有的代码，更不用说确保其安全性了。

在Secure Code Warrior ，我们的解决方案是在确保软件安全的同时提高生产力的需要。尽管在上述调查中提到没有时间采用安全编码实践，但76%的受访者同意，良好的安全编码培训实际上会提高生产力，减少需要管理的安全票和返工。当掌握了正确的安全技能和工具后，开发人员团队可以轻松地降低风险，并持续地以创新的特性和功能，快速交付安全、优质的代码。 

因此，感谢Gartner的认可--不仅是对Secure Code Warrior ，而且还强调了具有安全技能的开发人员在网络安全方面可以发挥的重要作用。

访问 Gartner软件工程领域的最佳供应商。提高开发人员的工作效率报告。 

‍