Statische Typanalyse in JavaScript. Probieren Sie den Flow-Analyzer von Facebook aus. JavaScript-Sicherheit oder wie man sicheren JS-Code schreibt Analyse- und Code-Optimierungstools

Nicht jede Zeile meines Codes ist beim ersten Mal perfekt. Nun, in manchen Fällen... Manchmal... Nun, fast nie. Die Wahrheit ist, dass ich deutlich mehr Zeit damit verbringe, meine eigenen dummen Fehler zu korrigieren, als mir lieb ist. Aus diesem Grund verwende ich statische Analysatoren in fast jeder JavaScript-Datei, die ich schreibe.

Statische Analysatoren sehen sich den Code an und finden darin Fehler, bevor Sie ihn ausführen. Sie treten auf einfache Kontrollen, wie z. B. die Überprüfung der Erzwingungssyntax (z. B. ob Tabulatoren anstelle von Leerzeichen vorhanden sind) und globalere Überprüfungen, z. B. die Sicherstellung, dass Funktionen nicht zu komplex sind. Statische Analysatoren suchen auch nach Fehlern, die beim Testen nicht gefunden werden können, z. B. == anstelle von ===.

In großen Projekten und bei der Arbeit in großen Teams können Sie verwenden eine kleine Hilfe auf der Suche nach solchen "einfachen" Fehlern, die sich tatsächlich als nicht so einfach herausstellen, wie sie scheinen.

JSLint, JSHint und Closure-Compiler

Es gibt drei Hauptoptionen für statische Analysen für JavaScript: JSLint, JSHint und Closure Compiler.

JSLint war der erste statische Parser für JavaScript. Sie können es auf der offiziellen Website ausführen oder eines der Add-Ons verwenden, die ausgeführt werden können lokale Dateien. JSLint findet viele wichtige Fehler, aber es ist sehr schwierig. Hier ist ein Paradebeispiel:

vars = "mystring";
für (var i = 0; i< s.length; i++) {
console.log(s.charAt(i));
}

JSLint zeigt zwei Fehler in diesem Code:

Unerwartetes "++".
Verschieben Sie „var“-Deklarationen an den Anfang der Funktion.

Das erste Problem ist die Definition der Variablen i in den Schleifenbedingungen. JSLint akzeptiert auch nicht den Operator ++ am Ende einer Schleifendefinition. Er möchte, dass der Code so aussieht:

vars = "mystring";
var ich;
für (i = 0; i< s.length; i = i + 1) {
console.log(s.charAt(i));
}

Ich schätze die Schöpfer von JSLint, aber meiner Meinung nach ist das übertrieben. Auch für Anton Kovalev stellte sich heraus, dass es schwierig war, also gründete er JSHint.

Sie können JSHint von starten, aber in den meisten Fällen ist es besser, JSHint als lokales Befehlszeilentool mit Node.js zu installieren. Sobald Sie JSHint installiert haben, können Sie es mit diesem Befehl in Ihren Dateien ausführen:

jshint test.js

JSHint enthält auch Plugins für Popular Texteditoren, sodass es während des Codierens ausgeführt werden kann.

VERSCHLUSS-COMPILER

Googles Closure Compiler ist eine ganz andere Art von Programm. Wie der Name schon sagt, ist es nicht nur ein Checker, sondern auch ein Compiler. Es ist in Java geschrieben und basiert auf dem Rhino-Parser von Mozilla. Der Closure Compiler enthält einen einfachen Modus zum Ausführen grundlegender Codeprüfungen und erweiterte Modi zum Ausführen zusätzliche Prüfung und die Definitionen einzelner Arten durchzusetzen.

Closure Compiler meldet Fehler in JavaScript-Code, erstellt aber auch minimierte Versionen von JavaScript. Der Compiler entfernt Leerzeichen, Kommentare und ungenutzte Variablen und vereinfacht lange Ausdrücke, wodurch das Skript so kompakt wie möglich wird.

Google hat eine sehr einfache Version des Compilers online verfügbar gemacht, aber höchstwahrscheinlich möchten Sie den Closure Compiler herunterladen und lokal ausführen.

Closure Compiler gibt die Liste der Dateien nach Überprüfung des Codes in eine minimierte Datei aus. Sie können es also ausführen, indem Sie die Datei „compiler.jar“ herunterladen.

java -jar compiler.jar --js_output_file compress.js --js test1.js --js test2.js

Wählen das richtige Programm Schecks

In meinen Projekten kombiniere ich Closure Compiler und JSHint. Der Closure Compiler führt die Minimierung und grundlegende Validierung durch, während JSHint eine komplexere Codeanalyse durchführt. Die beiden Programme arbeiten hervorragend zusammen, und jedes deckt Bereiche ab, die das andere nicht kann. Außerdem kann ich die JSHint-Erweiterung verwenden, um benutzerdefinierte Validatoren zu schreiben. Einer von mir geschrieben allgemeines Programm sucht nach bestimmten Funktionen, die ich nicht benötige, wie das Aufrufen von Funktionen, die nicht in meinem Projekt sein sollten.

Nachdem wir nun ein paar Dame behandelt haben, lassen Sie uns etwas schlechten Code aufschlüsseln. Jedes dieser sechs Beispiele stellt Code dar, der nicht geschrieben werden sollte, und Situationen, in denen Codeprüfer Sie retten können.

Dieser Artikel verwendet JSHint für die meisten Beispiele, aber der Closure Compiler gibt normalerweise ähnliche Warnungen aus.

== oder ===?

JavaScript ist eine dynamisch typisierte Sprache. Sie müssen die Typen nicht beim Schreiben des Codes definieren, aber sie sind beim Start vorhanden.

JavaScript bietet zwei Vergleichsoperatoren, um diese dynamischen Typen zu manipulieren: == und ===. Schauen wir uns das an einem Beispiel an.

Var = 123;
var = "123";

wenn (n == s) (
alert("Variablen sind gleich");
}

wenn (n === s) (
alert("Variablen sind identisch");
}

Vergleichsoperator == sind die Überbleibsel der C-Sprache, in der JavaScript verwurzelt ist. Seine Verwendung ist fast immer ein Fehler: Werte getrennt von Typen zu vergleichen, ist selten das, was der Entwickler eigentlich will. Tatsächlich unterscheidet sich die Zahl „einhundertdreiundzwanzig“ von der Zeichenfolge „eins zwei drei“. Diese Operatoren können leicht falsch geschrieben und noch leichter falsch gelesen werden. Testen Sie diesen Code mit JSHint und Sie erhalten Folgendes:

test.js: Zeile 9, Spalte 12, "===" erwartet und stattdessen "==" gesehen.

Undefinierte Variablen und späte Definitionen

Beginnen wir mit einem einfachen Code:

Funktionstest() (
var myVar = "Hallo Welt";
Konsolenprotokoll (myvar);
}

Sehen Sie den Fehler? Ich mache diesen Fehler jedes Mal. Führen Sie diesen Code aus und Sie erhalten eine Fehlermeldung:

ReferenceError: myvar ist nicht definiert

Machen wir das Problem etwas komplexer:

Funktionstest() (
myVar = "Hallo Welt";
Konsolenprotokoll (myVar);
}

Führen Sie diesen Code aus und Sie erhalten Folgendes:

Hallo Welt

Dieses zweite Beispiel funktioniert, hat aber einige sehr unerwartete Nebeneffekte. Die Regeln zum Definieren von JavaScript-Variablen und -Bereichen sind bestenfalls verwirrend. Im ersten Fall meldet JSHint Folgendes:

test.js: Zeile 3, Spalte 17, "myvar" ist nicht definiert.

Im zweiten Fall wird Folgendes gemeldet:

test.js: Zeile 2, Spalte 5, "myVar" ist nicht definiert.
test.js: Zeile 3, Spalte 17, "myVar" ist nicht definiert.

Das erste Beispiel hilft Ihnen, einen Laufzeitfehler zu vermeiden. Sie müssen Ihre Anwendung nicht testen – JSHint findet den Fehler für Sie. Das zweite Beispiel ist schlimmer, da Sie im Testergebnis keinen Fehler finden werden.

Das Problem im zweiten Beispiel ist heimtückisch subtil und komplex. Die Variable myVar ist nun aus ihrem Geltungsbereich verschwunden und wurde in den globalen Geltungsbereich befördert. Das bedeutet, dass es auch nach Ablauf der Testfunktion noch existiert und den Wert Hello, World hat. Dies wird als „Global-Scope-Verschmutzung“ bezeichnet.

Die Variable myVar existiert für jede andere Funktion, die nach der Testfunktion ausgeführt wird. Führen Sie den folgenden Code aus, nachdem Sie die Testfunktion ausgeführt haben:

console.log("meineVar: " + meineVar);

Sie erhalten weiterhin Hello, World. Die Variable myVar hängt wie eine Vorlage um Ihren Code herum, was zu komplexen Fehlern führt, nach denen Sie die ganze Nacht vor der Veröffentlichung suchen werden, nur weil Sie vergessen haben, var zu setzen.

Dieser Eintrag wurde durch den Volltext-RSS-Dienst geleitet - wenn dies Ihr Inhalt ist und Sie ihn auf der Website eines anderen lesen, lesen Sie bitte die FAQ unter http://ift.tt/jcXqJW.

Die Entwicklung sicherer JavaScript-Anwendungen ist eine ziemlich schwierige Aufgabe. Aber durchaus machbar. Im heutigen Artikel werden wir uns die Funktionen von JavaScript ansehen, die Sicherheitsprobleme verursachen, und darüber sprechen, wie man sie vermeidet.

Warum es schwierig ist, sicheren JS-Code zu schreiben

Also, hier sind 5 Gründe, warum das Schreiben schwer ist. Sicherheitscode in JS

Der Compiler hilft nicht.

JavaScript ist eine interpretierte Sprache. Und das bedeutet, dass sich der Compiler nicht immer über etwas beschweren wird, sich weigert zu arbeiten und Sie dazu drängt, Fehler zu korrigieren und den Code zu optimieren.

Die dynamische Natur von JavaScript

JavaScript ist dynamisch, schwach typisiert und asynchron. Und das sind alles Anzeichen dafür, dass es leicht ist, in Schwierigkeiten zu geraten.

1. Sprachwerkzeuge wie eval und die Einbeziehung von Code von Drittanbietern durch das Skript src ermöglichen es Ihnen, Zeilen direkt zur Laufzeit auszuführen. Folglich ist es schwierig, "statische Garantien" dafür zu geben, dass sich der Code auf eine bestimmte Weise verhält. Auch die dynamische Analyse erschwert dies (siehe wissenschaftliche Arbeiten).

Verwenden von eval

2. Schwaches Tippen führt dazu, dass es nicht einfach ist, die etablierten Methoden der statischen Analyse anzuwenden – zumindest im Vergleich zu statisch typisierten Sprachen (zum Beispiel Java).

3. Asynchrone Rückrufe, Aufrufe, die JavaScript durch Mechanismen wie setTimeout und XMLHttpRequest (das sehr berühmte AJAX) zulässt, verbergen laut Statistik die heimtückischsten Fehler.

Komplizierte JS-Funktionen

Was wurde im Laufe der Jahre nicht in JavaScript gezogen! Insbesondere verfügt es über Prototypen, erstklassige Funktionen und Verschlüsse. Sie machen die Sprache noch dynamischer und erschweren das Schreiben von sicherem Code.

1. Prototypen. Ihre Bedeutung ist, dass Programme im Sinne eines objektorientierten Ansatzes geschrieben werden, jedoch ohne die Verwendung von Klassen. Bei diesem Ansatz erben Objekte die benötigten Eigenschaften direkt von anderen Objekten (Prototypen). Gleichzeitig können in JS Prototypen direkt zur Laufzeit neu definiert werden. Und wenn diese Neudefinition passiert ist, breitet sich der Effekt sofort auf alle Objekte aus, die die Eigenschaften des überschriebenen Prototyps erben.

Wie Prototypen verarbeitet werden

Fairerweise muss gesagt werden, dass Klassen auch in den neuen ECMAScript-Spezifikationen vorhanden sind.

2. Funktionen der ersten Klasse. JS hat ein sehr flexibles Objekt- und Funktionsmodell. Objekteigenschaften und ihre Werte können direkt zur Laufzeit erstellt, geändert oder gelöscht werden, und auf alle wird über erstklassige Funktionen zugegriffen.

3. Schließungen. Wenn Sie eine Funktion innerhalb einer anderen Funktion deklarieren, erhält die erstere Zugriff auf die Variablen und Argumente der letzteren. Darüber hinaus existieren diese Variablen weiter und bleiben für die innere Funktion verfügbar – selbst nachdem die äußere Funktion, in der diese Variablen definiert sind, abgeschlossen ist.

Aufgrund dieser Flexibilität und Dynamik von JavaScript (siehe Punkte 1 und 3) ist die Bestimmung der Menge aller verfügbaren Eigenschaften eines Objekts während der statischen Analyse eine unlösbare Aufgabe. Webentwickler nutzen jedoch überall die dynamischen Eigenschaften der Sprache und sind dementsprechend bei der Analyse des Codes nicht zu vernachlässigen. Ansonsten, was ist die Sicherheitsgarantie?

Enge Interaktion zwischen JavaScript und DOM

Dies ist notwendig, um eine "nahtlose" Aktualisierung der Webseite direkt zur Laufzeit bereitzustellen. Wie Sie wissen, ist DOM ein Standard Objektmodell, plattform- und sprachneutral, das zum Rendern vorgesehen ist HTML-Dokumente und XML. Das DOM verfügt über eine eigene API für die Arbeit mit dem gerenderten Dokument: um dynamisch auf das gerenderte Dokument (seinen Inhalt, seine Struktur und seinen Stil) zuzugreifen, es zu verschieben und zu aktualisieren. Änderungen am DOM können dynamisch über JavaScript vorgenommen werden. Und diese Änderungen werden sofort im Browser angezeigt.

Dank des DOM können in den Browser geladene Webseiten schrittweise aktualisiert werden, während Daten vom Server geladen werden. Dieser Komfort hat jedoch eine Kehrseite: Besonders fehleranfällig sind die Codeschnipsel, die für das dynamische Zusammenspiel zwischen JS und dem DOM zuständig sind.

Die häufigsten Fehler in Webanwendungen

Komplexe Ereignisinteraktionen

JavaScript ist eine ereignisgesteuerte Sprache. Es ermöglicht Entwicklern, sogenannte "Event Listener" auf DOM-Knoten zu registrieren - Event Listener. Und während die meisten Ereignisse durch Benutzeraktionen ausgelöst werden, gibt es einige, die ohne Benutzeraktionen ausgelöst werden können, z. B. zeitgesteuerte Ereignisse und asynchrone Aufrufe. Darüber hinaus kann jedes Ereignis im gesamten DOM-Baum wiederholt werden und mehrere "Zuhörer" gleichzeitig aktivieren. All dies im Auge zu behalten, ist manchmal eine ziemlich nicht triviale Aufgabe.

Wie Ereignisse gehandhabt werden

Aus diesen Gründen kann es schwierig sein, JS-Code zu verstehen, zu analysieren und zu testen. Spezielle Dienstprogramme erleichtern Webentwicklern das Leben und helfen beim Schreiben von sicherem Code.

Dienstprogramme zum Testen von JS-Code

Es gibt Tools zum Parsen (z. B. Esprima, Rhino), zur Optimierung (z. B. Google Closure Compiler) und zur statischen Codeanalyse für häufige Syntaxfehler (z. B. JSHint).

Darüber hinaus gibt es mehrere erprobte Frameworks, die Webentwicklern helfen, JS-Code mit Tests abzudecken. Unter ihnen:

QUnit ist ein beliebtes Unit-Testing-Framework;
Jasmine - BDD-Framework (Behavior-driven Development) für Code-Tests;
Mocha ist ein Codetest-Framework, das sowohl in Node.js als auch im Browser ausgeführt wird;
jsTestDriver ist ein Framework, das unter anderem eine Reihe von Tests in mehreren Browsern gleichzeitig ausführen kann.

Darüber hinaus gibt es Testframeworks, die das Browserverhalten emulieren und es Ihnen ermöglichen, Testfälle automatisch auszuführen. Sie sind besonders relevant beim Debuggen von Codeabschnitten, die für die Interaktion zwischen JS und dem DOM verantwortlich sind, und bieten eine bequeme Infrastruktur zum Manipulieren des DOM.

Beispielsweise bieten Selenium, PhantomJS und SlimerJS eine API, über die Sie Browserinstanzen starten und mit ihnen arbeiten können. Über die API können Sie Events aktivieren und direkt zur Laufzeit auf DOM-Elemente zugreifen, also den Code unter möglichst realitätsnahen Bedingungen testen. Natürlich wird ein Großteil der Arbeit manuell erledigt werden müssen, aber auch das ist schon eine gute Hilfe beim Testen.

Dienstprogramme für die statische Analyse

Früher waren Dienstprogramme zum Identifizieren problematischer Codeabschnitte statische Analysatoren. Das heißt, angesichts all der dynamischen Macken von JS konnte es nur begrenzt helfen. Sie sind aber auch in der Analyse nützlich. Hier sind einige grundlegende Beispiele.

WARI ist ein statischer Analysator, der Abhängigkeiten zwischen JS-Funktionen untersucht, CSS-Stile, HTML-Tags und Bilder. Der Zweck dieses Dienstprogramms besteht darin, ungenutzte Ressourcen während der statischen Analyse zu finden. Allerdings wird WARI der Dynamik natürlich nicht gewachsen sein.

JSLint ist ein Dienstprogramm zur statischen Codeanalyse, das selbst in JavaScript geschrieben ist. Es prüft den Code auf bewährte Praktiken.

Google Closure Compiler ist ein JS-Optimierer, der Code automatisch umschreibt, um ihn schneller und kompakter zu machen. Gleichzeitig fliegen alle Kommentare und alle ungenutzten Codeabschnitte in die Pipeline.

WebScent (siehe Forschungsbericht) ist ein fortschrittlicher statischer Analysator. Bei der Arbeit geht er davon aus, dass der Client-JS-Code (der in den Browser geladen wird) serverseitig nicht komplett gespeichert wird, sondern stückweise über den Server-Code verstreut ist. Der „Schluck“ in diesen Stücken kann nicht leicht entdeckt werden, bis aus ihnen solider Client-Code generiert wird. WebScent analysiert den Clientcode, um Problembereiche im Servercode zu finden. Gleichzeitig reduziert sich die Arbeit des statischen WebScent-Analyzers hauptsächlich auf das Enträtseln von HTML-, CSS- und JS-Batches – um doppelten Code und Fehler in der HTML-Syntax zu erkennen.

Dienstprogramme für die dynamische Analyse

JSNose ist ein Dienstprogramm, das statische und dynamische Analyse kombiniert. Es analysiert den Code auf dreizehn Antimuster. Sieben davon (einschließlich Lazy Object und Long Function) sind allen Programmiersprachen gemeinsam, und die anderen sechs (Closure Smells, übermäßig viele globale Variablen, verschachtelte Callbacks und andere) sind spezifisch für JavaScript.

DOMpletion ist ein automatisiertes Dienstprogramm, das einem Webentwickler hilft, den Code beim Anzeigen zu verstehen: erklärt den Grund für das Vorhandensein von DOM-Strukturen, führt dynamische Analysen durch und bietet auch eine intelligente automatische Vervollständigung für Code, der mit dem DOM interagiert.

Clematis ist ein Framework, das dabei hilft, komplexe Ereignisinteraktionen aufzuschlüsseln. Clematis erfasst detailliert alle Ereignisse, die bei der Ausführung ausgelöst werden, und visualisiert sie als abstraktes Verhaltensmodell, das die zeitlichen und Ursache-Wirkungs-Beziehungen zwischen Komponenten und Ereignissen widerspiegelt.

Schlussfolgerungen

Daher kann es schwierig sein, den Überblick darüber zu behalten, was passiert, wenn JS-Skripte ausgeführt werden, aber mit den richtigen Tools können Sie Problembereiche selbst im verwirrendsten Code finden und umschreiben. JavaScript steht jedoch nicht still: Neue und neue Funktionen erscheinen darin, jetzt wird es häufig zum Schreiben von Anwendungen (sowohl mobil als auch für Desktop) verwendet und ist dank Node.js auch zunehmend auf Servern (und nicht nur) zu finden. Und das bedeutet, dass die Kunst des Insektenfangens auf eine neue Ebene gehoben werden muss.

Statische Analysatoren sehen sich den Code an und finden darin Fehler, bevor Sie ihn ausführen. Sie führen einfache Überprüfungen durch, z. B. die Überprüfung der Erzwingungssyntax (z. B. ob Tabulatoren anstelle von Leerzeichen vorhanden sind) und allgemeinere Überprüfungen, z. B. die Überprüfung, ob Funktionen nicht zu komplex sind. Statische Analysatoren suchen auch nach Fehlern, die beim Testen nicht gefunden werden können, z. B. == anstelle von ===.

Bei großen Projekten und beim Arbeiten in großen Teams können Sie ein wenig Hilfe gebrauchen, um solche "einfachen" Fehler zu finden, die eigentlich nicht so einfach sind, wie sie scheinen.

JSLint, JSHint und Closure-Compiler

Es gibt drei Hauptoptionen für statische Analysen für JavaScript: JSLint, JSHint und Closure Compiler.

JSLint war der erste statische Parser für JavaScript. Sie können es auf der offiziellen Website ausführen oder eines der Add-Ons verwenden, die für lokale Dateien ausgeführt werden können. JSLint findet viele wichtige Fehler, aber es ist sehr schwierig. Hier ist ein Paradebeispiel:

vars = "mystring"; für (var i = 0; i< s.length; i++) { console.log(s.charAt(i)); }

JSLint zeigt zwei Fehler in diesem Code:

Unerwartetes "++". Verschieben Sie „var“-Deklarationen an den Anfang der Funktion.

vars = "mystring"; var ich; für (i = 0; i< s.length; i = i + 1) { console.log(s.charAt(i)); }

Ich schätze die Schöpfer von JSLint, aber meiner Meinung nach ist das übertrieben. Auch für Anton Kovalev stellte sich heraus, dass es schwierig war, also gründete er JSHint.

JSHint funktioniert genauso wie JSLint, ist aber zusätzlich zu Node.js geschrieben und daher flexibler. JSHint enthält eine große Anzahl von Optionen, mit denen Sie benutzerdefinierte Prüfungen durchführen können, indem Sie Ihren eigenen Berichtsgenerator schreiben.
Sie können JSHint von starten, aber in den meisten Fällen ist es besser, JSHint als lokales Befehlszeilentool mit Node.js zu installieren. Sobald Sie JSHint installiert haben, können Sie es mit diesem Befehl in Ihren Dateien ausführen:

jshint test.js

JSHint enthält auch Plugins für gängige Texteditoren, sodass Sie es ausführen können, während Sie Code schreiben.

VERSCHLUSS-COMPILER

Googles Closure Compiler ist eine ganz andere Art von Programm. Wie der Name schon sagt, ist es nicht nur ein Checker, sondern auch ein Compiler. Es ist in Java geschrieben und basiert auf dem Rhino-Parser von Mozilla. Der Closure Compiler enthält einen einfachen Modus zum Durchführen einer grundlegenden Codevalidierung und erweiterte Modi zum Durchführen einer zusätzlichen Validierung und zum Erzwingen bestimmter Ansichtsdefinitionen.

Der Closure Compiler meldet Fehler im JavaScript-Code, erzeugt aber auch minimierte Versionen von JavaScript. Der Compiler entfernt Leerzeichen, Kommentare und ungenutzte Variablen und vereinfacht lange Ausdrücke, wodurch das Skript so kompakt wie möglich wird.

Google hat eine sehr einfache Version des Compilers online verfügbar gemacht, aber höchstwahrscheinlich möchten Sie den Closure Compiler herunterladen und lokal ausführen.

Closure Compiler gibt die Liste der Dateien nach Überprüfung des Codes in eine minimierte Datei aus. Sie können es also ausführen, indem Sie die Datei „compiler.jar“ herunterladen.

Java -jar compiler.jar --js_output_file compress.js --js test1.js --js test2.js

Auswahl des richtigen Testprogramms

In meinen Projekten kombiniere ich Closure Compiler und JSHint. Der Closure Compiler führt die Minimierung und grundlegende Validierung durch, während JSHint eine komplexere Codeanalyse durchführt. Die beiden Programme arbeiten hervorragend zusammen, und jedes deckt Bereiche ab, die das andere nicht kann. Außerdem kann ich die JSHint-Erweiterung verwenden, um benutzerdefinierte Validatoren zu schreiben. Ein generisches Programm, das ich geschrieben habe, überprüft bestimmte Funktionen, die ich nicht benötige, z. B. das Aufrufen von Funktionen, die nicht in meinem Projekt enthalten sein sollten.

Dieser Artikel verwendet JSHint für die meisten Beispiele, aber der Closure Compiler gibt normalerweise ähnliche Warnungen aus.

== oder ===?

JavaScript ist eine dynamisch typisierte Sprache. Sie müssen die Typen nicht beim Schreiben des Codes definieren, aber sie sind beim Start vorhanden.

JavaScript bietet zwei Vergleichsoperatoren, um diese dynamischen Typen zu manipulieren: == und ===. Schauen wir uns das an einem Beispiel an.

Warn = 123; var = "123"; if (n == s) ( alert("Die Variablen sind gleich"); ) if (n === s) ( alert("Die Variablen sind identisch"); )

Test.js: Zeile 9, Spalte 12, "===" erwartet und stattdessen "==" gesehen.

Undefinierte Variablen und späte Definitionen

Beginnen wir mit einem einfachen Code:

Funktionstest() ( var myVar = "Hallo Welt"; console.log(myvar); )

Sehen Sie den Fehler? Ich mache diesen Fehler jedes Mal. Führen Sie diesen Code aus und Sie erhalten eine Fehlermeldung:

ReferenceError: myvar ist nicht definiert

Machen wir das Problem etwas komplexer:

Funktionstest() ( myVar = "Hallo Welt"; console.log(myVar); )

Führen Sie diesen Code aus und Sie erhalten Folgendes:

Hallo Welt

Test.js: Zeile 3, Spalte 17, "myvar" ist nicht definiert.

Im zweiten Fall wird Folgendes gemeldet:

Test.js: Zeile 2, Spalte 5, "myVar" ist nicht definiert. test.js: Zeile 3, Spalte 17, "myVar" ist nicht definiert.

Die Variable myVar existiert für jede andere Funktion, die nach der Testfunktion ausgeführt wird. Führen Sie den folgenden Code aus, nachdem Sie die Testfunktion ausgeführt haben:

Console.log("myVar: " + myVar);

ALEXANDER MAYOROW, Programmierer, 11 Jahre Erfahrung in der Programmierung, davon sieben in der Entwicklung für mobile Geräte

Statische Typanalyse in JavaScript
Probieren Sie den Flow-Analyzer von Facebook aus

Facebook hat ein neues Open-Source-Projekt Flow vorgestellt – einen statischen Code-Analysator für die JavaScript-Sprache. Der Hauptzweck der Entwicklung des Analysators besteht darin, die Suche nach Fehlern zu vereinfachen

Darüber hinaus bietet Flow in Form einer syntaktischen Erweiterung der JavaScript-Sprache im TypeScript-Stil eine Möglichkeit, Typen explizit anzugeben. Viele der neuen Features, die in der ECMAScript 6-Spezifikation eingeführt wurden, werden unterstützt.

Das Thema Tippen in Programmiersprachen wird oft angesprochen. Dies ist das Thema von Holivars und der Bestimmung der positiven oder negativen Merkmale einer bestimmten Sprache. In letzter Zeit wurde viel über das Eingeben von JavaScript gesprochen. Manche mögen es so wie es ist. Leute, die mit anderen Programmiersprachen vertraut sind, insbesondere solche mit starker expliziter Typisierung, betrachten diesen Ansatz als „eine Granate in den Händen eines Affen“. Wir alle wissen, dass JavaScript eine lose dynamisch typisierte Sprache ist. Front-End-Entwicklungsgurus haben gelernt, dies für immer zu nutzen, aber der Code ist manchmal schwer zu verstehen. Diejenigen, die gerade in die Welt der JavaScript-Programmierung einsteigen, sind verblüfft über die Magie, die der Interpreter vollbringt, und fangen Fehler oft aus heiterem Himmel. Aber lassen Sie uns zuerst ein wenig über das Tippen im Allgemeinen verstehen. Wie ist es?

Eintippen in Programmiersprachen

Typisierte Programmiersprachen fallen in zwei große Lager – typisierte und nicht typisierte. Typisierte Sprachen umfassen beispielsweise Sprachen wie C, Python, PHP, Lua, JavaScript. Beispiele für untypisierte Sprachen: Assembler, Forth, Brainfuck. Ja Ja genau. JavaScript ist wie viele andere interpretierte Sprachen typisiert. Sagen Sie daher auf keinen Fall, dass es nicht typisiert ist. Vor allem in Vorstellungsgesprächen.

Getippte Sprachen wiederum werden in mehrere sich überschneidende Kategorien unterteilt:

Mit statischer oder dynamischer Typisierung.
Bei starkem oder lockerem Tippen.
Mit expliziter oder impliziter Typisierung.

Sprachen mit statischer Typisierung

Bei statische Typisierung Die endgültigen Typen von Variablen und Funktionen werden zur Kompilierzeit festgelegt. Der Compiler korrigiert Ihre Typkonfliktfehler, bevor er das Programm ausführt. Beispielsprachen: C, Java, C#.

Sprachen mit dynamischer Typisierung

Bei der dynamischen Typisierung werden alle Typen zur Laufzeit bestimmt. Und wenn Sie einen Fehler machen, erfahren Sie davon erst, wenn Sie das Programm ausführen. Daher ist es sehr wichtig, bei der dynamischen Typisierung besonderes Augenmerk auf Prüfungen und Fehlerbehandlung zu legen. Beispielsprachen: JavaScript, PHP, Python, Ruby.

Starkes Tippen (stark)

Stark typisierte Sprachen erlauben kein Mischen verschiedener Typen in Ausdrücken und führen keine automatischen impliziten Typkonvertierungen durch. Beispielsweise können Sie keine Zahl oder einen anderen Typ als Zeichenfolge von einer Zeichenfolge subtrahieren. Beispielsprachen: Java, Python, Haskell, Lisp.

Lockeres Tippen (schwach)

Locker typisierte Sprachen führen viele implizite Typkonvertierungen automatisch durch. Sie tun dies, obwohl ein Verlust an Genauigkeit oder Konvertierung auftreten kann, mehrdeutig. Beispielsprachen: PHP, JavaScript, Visual Basic.

Explizite Eingabe

In explizit typisierten Sprachen muss der Typ neuer Variablen/Funktionen und Argumente explizit gesetzt werden. Beispielsprachen: C++, D, C#.

Implizite Eingabe

In Sprachen mit impliziter Typisierung wird die Aufgabe der Typisierung auf den Compiler/Interpreter verlagert. Beispielsprachen: JavaScript, PHP, Lua. In solchen Sprachen haben Objekte in der Regel spezielle Methoden, die aufgerufen werden, wenn sie in einen Typ umgewandelt werden. Beispielsweise hat PHP die Methode _toString() und JavaScript hat eine Methode mit demselben Namen, aber ohne Unterstrich, toString(). Diese Methoden werden aufgerufen, wenn ein Objekt in einen Zeichenfolgentyp umgewandelt wird. Manchmal werden solche Methoden magisch genannt (alle impliziten Prozesse sind immer magisch).

Es ist wichtig zu beachten, dass sich alle diese Kategorien überschneiden. Basierend auf diesen Kategorien schließen wir, dass JavaScript über dynamische implizite Typisierung verfügt. Und überspitzt gesagt lässt sich das Wesen der Sprache wie folgt beschreiben: Bringe in jeder unverständlichen Situation alles zu Primitiven, hauptsächlich zu einer Schnur. Obwohl in Wirklichkeit alles etwas komplizierter ist, gehen wir jetzt nicht ins Detail.

Warum müssen wir tippen? Sie könnten fragen. Ohne sie hat JavaScript 20 Jahre lang gut funktioniert. Die Antwort ist einfach: Früher wurden komplexe Aufgaben auf Unternehmensebene nicht in JavaScript gelöst. Jetzt ist diese Sprache über den Browser hinausgegangen und hat das Territorium des Backends betreten. Beim Schreiben einer großen Anwendung wird es schwierig, Fehler zu erkennen, die häufig mit der Typumwandlung verbunden sind.

JavaScript-Add-Ons

Da wird JavaScript weiter ausgeführt Kundenseite(in Browsern), dann besteht eine der Möglichkeiten zur Lösung des Problems darin, eine Sprache zu erstellen - einen Dialekt, der in JS kompiliert wird. Es fungiert als Assembler.

Es sind Sprachen wie TypeScript, Dart, AtScript entstanden, die eine statische starke Typisierung und sogar eine Typüberprüfung zur Laufzeit hinzufügen (obwohl dies den Overhead erhöht). Alle diese Sprachen fügen nicht nur Typen hinzu, sie fügen auch entweder syntaktischen Zucker oder sogar ihre eigene VM-Implementierung hinzu, die in JS geschrieben ist.

Lesen Sie den vollständigen Artikel im Magazin Systemadministrator“, Nr. 1-2 für 2015 auf den Seiten 86-88.

PDF-Version angegebene Nummer können in unserem Shop erworben werden.

Die Flow-Website ist http://flowtype.org.

In Kontakt mit

Jedes Mitglied des ][-Teams hat seine eigenen Vorlieben in Bezug auf Software und Dienstprogramme für Pentesting. Nach der Beratung haben wir festgestellt: Die Auswahl ist so unterschiedlich, dass Sie aus bewährten Programmen ein echtes Gentleman-Set machen können. Das haben sie entschieden. Um kein Sammelsurium zu bilden, ist die gesamte Liste in Themen unterteilt. Heute werden wir analysieren Statische Codeanalysatoren nach Schwachstellen in Anwendungen zu suchen, wenn deren Quellcodes vorliegen.

Die Verfügbarkeit von Programmquellcodes vereinfacht die Suche nach Schwachstellen erheblich. Anstatt die verschiedenen Parameter, die an die Anwendung übergeben werden, blind zu manipulieren, ist es viel einfacher, in den Sorten zu sehen, wie sie sie verarbeiten. Nehmen wir an, wenn die Daten vom Benutzer ohne Überprüfungen und Transformationen übertragen werden, erreichen sie die SQL-Abfrage - wir haben eine Schwachstelle SQL-Typ Injektion. Wenn sie zur Ausgabe im HTML-Code gelangen, erhalten wir klassisches XSS. Um solche Situationen eindeutig zu erkennen, ist ein statischer Scanner erforderlich, aber leider ist dies nicht immer so einfach, wie es scheint.

Moderne Compiler

Es mag lustig erscheinen, aber eines der effektivsten Code-Analysatoren sind die Compiler selbst. Natürlich sind sie für etwas ganz anderes gedacht, aber als Bonus bietet jeder von ihnen einen guten Quellcode-Verifizierer, der eine große Anzahl von Fehlern erkennen kann. Warum speichert er nicht? Anfangs sind die Einstellungen für eine solche Codeüberprüfung ziemlich loyal eingestellt: Um den Programmierer nicht in Verlegenheit zu bringen, beginnt der Compiler nur bei den schwerwiegendsten Pfosten zu fluchen. Aber vergebens – stellt man die Warnstufe höher ein, kann man durchaus viele dubiose Stellen im Code ausgraben. Es sieht aus wie das. Nehmen wir an, im Code wird die Länge der Zeichenfolge nicht überprüft, bevor sie in den Puffer kopiert wird. Der Scanner findet eine Funktion, die einen String (oder ein Fragment davon) in einen Puffer fester Größe kopiert, ohne vorher seine Länge zu prüfen. Es verfolgt den Weg der Übergabe von Argumenten: von den Eingabedaten zur anfälligen Funktion und prüft, ob es möglich ist, eine Zeichenfolgenlänge zu wählen, die einen Überlauf in der anfälligen Funktion verursachen würde und nicht durch die vorangegangenen Prüfungen abgeschnitten würde. Wenn es keine solche Überprüfung gibt, finden wir fast 100% Pufferüberlauf. Die Hauptschwierigkeit bei der Verwendung eines Compilers zur Überprüfung besteht darin, ihn den Code eines anderen "schlucken" zu lassen. Wenn Sie jemals versucht haben, eine Anwendung aus dem Quellcode zu kompilieren, wissen Sie, wie schwierig es ist, alle Abhängigkeiten zu erfüllen, insbesondere in großen Projekten. Aber das Ergebnis ist es wert! Darüber hinaus verfügen leistungsstarke IDEs neben dem Compiler auch über einige andere Tools für Codeanalyse. Beispielsweise gibt der folgende Codeabschnitt in Visual Studio eine Warnung über die Verwendung der _alloca-Funktion in der Schleife aus, die den Stapel schnell überlaufen lassen kann:

Zeichen*b;
tun(
b = (char*)_alloca(9)
) während (1)

Dies ist das Verdienst des statischen Analysators PREfast. Wie FxCop für die Analyse von verwaltetem Code wurde PREfast ursprünglich als verteilt separates Dienstprogramm und wurde erst später Teil von Visual Studio.

RATS - Rough Auditing Tool für Sicherheit

Website: www.securesoftware.com
Lizenz: GNU GPL
Plattform: Unix, Windows
Sprachen: C++, PHP, Python, Ruby

Fehler Fehler - Streit. Einige der Fehler, die Programmierer machen, sind nicht kritisch und drohen nur mit der Instabilität des Programms. Andere wiederum ermöglichen es Ihnen, Shellcode einzuschleusen und beliebige Befehle auf einem entfernten Server auszuführen. Ein besonderes Risiko im Code sind Befehle, die einen Pufferüberlauf und andere ähnliche Arten von Angriffen ermöglichen. Es gibt viele solcher Befehle, im Fall von C/C++ sind das Funktionen zum Arbeiten mit Strings (xstrcpy(), strcat(), gets(), sprintf(), printf(), snprintf(), syslog() ), Systembefehle ( access(), chown(), chgrp(), chmod(), tmpfile(), tmpnam(), tempnam(), mktemp()) sowie Systemaufrufbefehle (exec(), system (), poppen() ). Das manuelle Untersuchen des gesamten Codes (insbesondere wenn er aus mehreren tausend Zeilen besteht) ist ziemlich mühsam. Dies bedeutet, dass Sie die Übertragung einiger Funktionen von ungeprüften Parametern leicht übersehen können. Spezielle Tools für die Prüfung, einschließlich des bekannten Dienstprogramms RATTEN (Grobes Überwachungstool für Sicherheit) der bekannten Firma Fortify. Es wird nicht nur in C / C ++ geschriebenen Code erfolgreich verarbeiten, sondern auch Perl-, PHP- und Python-Skripte verarbeiten können. Die Utility-Datenbank enthält eine beeindruckende Auswahl mit einer detaillierten Beschreibung von Problembereichen im Code. Mit Hilfe des Analysators verarbeitet sie die ihr zugeführte Quelle und versucht, Fehler zu identifizieren, und gibt dann Auskunft über die gefundenen Mängel. RATTEN wirkt durch Befehlszeile, sowohl unter Windows als auch unter *nix-Systemen.

Yasca

Website: www.yasca.org
Lizenz: Open Source
Plattform: Unix, Windows
Sprachen: C++, Java, .NET, ASP, Perl, PHP, Python und andere.

Yasca genau wie RATS muss nicht installiert werden, während es nicht nur eine Konsolenschnittstelle, sondern auch eine einfache GUI hat. Die Entwickler empfehlen, das Dienstprogramm über die Konsole auszuführen - sie sagen, es gibt mehr Möglichkeiten. Komischerweise ist die Yasca-Engine in PHP 5.2.5 geschrieben, und der Interpreter (in der am stärksten verkürzten Version) befindet sich in einem der Unterordner des Archivs mit dem Programm. Das ganze Programm besteht logischerweise aus einem Frontend, einer Reihe von Scan-Plugins, einem Report-Generator und der Engine selbst, die alle Zahnräder zusammen rotieren lässt. Plugins werden in das Plugins-Verzeichnis abgelegt - dort sollten auch zusätzliche Addons installiert werden. Wichtiger Punkt! Drei der mitgelieferten Standard-Plugins Yasca, böse Abhängigkeiten haben. JLint, das die .class-Dateien von Java scannt, erfordert jlint.exe im Verzeichnis resource/utility.Das zweite Plugin, antiC, das verwendet wird, um Java- und C/C++-Sortierungen zu parsen, erfordert antic.exe im selben Verzeichnis.PMD, das verarbeitet Java-Code, erfordert Java JRE 1.4 oder höher auf dem System installiert. Sie können überprüfen, ob die Installation korrekt ist, indem Sie den Befehl "yasca ./resources/test/" eingeben. Wie sieht der Scan aus? Yasca erstellt das Ergebnis in Form eines Sonderberichts. Beispielsweise ermöglicht eines der Standard-GREP-Plugins die Verwendung der in .grep-Dateien beschriebenen Muster, um anfällige Konstrukte zu spezifizieren und eine Reihe von Schwachstellen einfach zu identifizieren. Eine Reihe solcher Muster ist bereits im Programm enthalten: Suche nach schwacher Verschlüsselung, "Passwort gleich Login"-Autorisierung, mögliche SQL-Injections und vieles mehr. Wenn Sie detailliertere Informationen im Bericht sehen möchten, seien Sie nicht zu faul, zusätzliche Plugins zu installieren. Was eines wert ist, ist, dass Sie mit ihrer Hilfe zusätzlich Code in .NET (VB.NET, C#, ASP.NET), PHP, ColdFusion, COBOL, HTML, JavaScript, CSS, Visual Basic, ASP, Python, Perl scannen können .

Cppcheck

Webseite:
Lizenz: Open Source
Plattform: Unix, Windows
Sprachen: C++

Entwickler Cppcheck beschlossen, nicht über Kleinigkeiten zu streuen und daher nur streng definierte Kategorien von Fehlern und nur in C ++ - Code zu fangen. Erwarten Sie nicht, dass das Programm Compiler-Warnungen dupliziert - es kommt ohne Eingabeaufforderung aus. Seien Sie daher nicht zu faul, um die maximale Warnstufe für den Compiler festzulegen, und verwenden Sie Cppcheck, um nach Speicherlecks, Verstößen gegen Zuweisungs-Aufhebungs-Operationen, verschiedenen Pufferüberläufen, Verwendung veralteter Funktionen und vielem mehr zu suchen. Ein wichtiges Detail: Die Entwickler von Cppcheck haben versucht, die Anzahl der Fehlalarme auf ein Minimum zu beschränken. Wenn das Programm einen Fehler behebt, können Sie daher höchstwahrscheinlich sagen: "Das ist es wirklich!" Sie können die Analyse sowohl von der Konsole als auch mit Hilfe einer netten GUI-Schnittstelle starten, die in Qt geschrieben ist und unter jeder Plattform funktioniert.

Graudit

Website: www.justanotherhacker.com/projects/graudit.html
Lizenz: Open Source
Plattform: Unix, Windows
Sprachen: C++, PHP, Python, Perl

Dieses einfache Skript, kombiniert mit einer Reihe von Signaturen, ermöglicht es Ihnen, eine Reihe kritischer Schwachstellen im Code zu finden, und die Suche wird mit dem bekannten grep-Dienstprogramm durchgeführt. Es ist unangemessen, die GUI-Oberfläche hier auch nur zu erwähnen: Alles wird über die Konsole erledigt. Es gibt mehrere Schlüssel zum Starten, aber im einfachsten Fall reicht es, den Pfad zu den Quellen als Parameter anzugeben:

graudit /path/to/scan

Der Lohn für den Fleiß wird ein bunter Bericht über potenziell ausnutzbare Stellen im Code sein. Ich muss sagen, dass neben dem Skript selbst (das nur 100 Zeilen Bash-Code umfasst) Signaturdatenbanken von Wert sind, die reguläre Ausdrücke und Namen potenziell anfälliger Funktionen in verschiedenen Sprachen enthalten. Standardmäßig sind Grundlagen für Python, Perl, PHP, C++ enthalten - Sie können Dateien aus dem Signaturordner nehmen und in Ihren eigenen Entwicklungen verwenden.

SWAT

Website: www.owasp.org
Lizenz: Open Source
Plattform: Unix, Windows
Sprachen: Java, JSP, ASP.Net, PHP

Wenn graudit Textdateien verwendet, um die Schwachstellensignatur zu setzen, dann in SWAT- ein fortgeschrittenerer Ansatz mit XML-Dateien. So sieht eine typische Signatur aus:

vuln spiel- regulären Ausdruck Für die Suche;
type - gibt die Art der Schwachstelle an:
Schweregrad – gibt die Risikostufe an (hoch, mittel oder niedrig)
alt- Alternative Möglichkeit Code um das Problem zu lösen

SWAT liest die Signaturdatenbank und verwendet sie, um Problembereiche in Java-, JSP-, ASP .Net- und PHP-Quellen zu finden. Die Datenbank wird ständig aktualisiert und enthält neben der Liste der "gefährlichen" Funktionen auch typische Fehler bei der Verwendung von Zeichenfolgenformatierungen und beim Erstellen von SQL-Abfragen. Bemerkenswert ist, dass das Programm in C# geschrieben ist, aber dank des Mono-Projekts - einer offenen Implementierung der .Net-Plattform - auch unter nix funktioniert.

PHP-Bug-Scanner

Website: raz0r.name/releases/php-bug-scanner
Lizenz: Freeware
Plattform: Windows
Sprachen: PHP

Wenn Sie eine PHP-Anwendung statisch analysieren müssen, empfehle ich Ihnen, es zu versuchen PHP-Bug-Scanner, die von unserem Autor geschrieben wurde - raz0r. Die Arbeit des Programms basiert auf dem Scannen verschiedene Funktionen und Variablen in PHP-Skripten, die bei Webangriffen verwendet werden können. Die Beschreibung solcher Situationen erfolgt in Form sogenannter Presets, und das Programm enthält bereits 7 spezielle Presets, die in Kategorien eingeteilt sind:

Codeausführung;
Befehlsausführung;
Verzeichnisdurchlauf;
Globals überschreiben;
enthalten;
SQL-Injektion;
Sonstiges.

Es ist lustig, dass das Programm in PHP/WinBinder geschrieben und mit bamcompile kompiliert wurde, sodass es wie eine normale Windows-Anwendung aussieht. Über eine benutzerfreundliche Oberfläche kann ein Pentester die Codeanalyse für bestimmte Schwachstellen aktivieren oder deaktivieren.

Elf

Website: pixybox.seclab.tuwien.ac.at
Lizenz: Freeware
Plattform: Unix, Windows
Sprachen: PHP

Das Herzstück des Tools ist das Scannen Quellcode und Erstellen von Datenflussdiagrammen. Dieses Diagramm zeichnet den Weg von Daten nach, die von außerhalb des Programms kommen – vom Benutzer, von der Datenbank, von einem externen Plugin usw. Auf diese Weise wird eine Liste von Schwachstellen (oder Eingängen) in Anwendungen erstellt. Mit Hilfe von Mustern, die Schwachstellen beschreiben, überprüft Pixy solche Punkte und ermöglicht es Ihnen, XSS- und SQL-Schwachstellen zu ermitteln. Darüber hinaus können die Graphen selbst, die während der Analyse erstellt werden, im Graphs-Ordner eingesehen werden (z. B. xss_file.php_1_dep.dot) - dies ist sehr nützlich, um zu verstehen, warum dieser oder jener Abschnitt des Codes als Pixy betrachtet wird -verletzlich. Im Allgemeinen ist die Entwicklung selbst äußerst informativ und zeigt, wie fortschrittliche Dienstprogramme für die statische Codeanalyse funktionieren. Auf der Dokumentationsseite spricht der Entwickler deutlich über die verschiedenen Phasen des Programms, erklärt die Logik und den Algorithmus, wie dieses oder jenes Stück Code vom Programm analysiert werden soll. Das Programm selbst ist in Java geschrieben und wird in Open Source vertrieben, und auf der Homepage gibt es sogar einen einfachen Online-Dienst, um Code auf XSS-Schwachstellen zu prüfen.

Unze 6

Website: www.ouncelabs.com/products
Lizenz: Shareware
Plattform: Windows

Leider sind die bestehenden kostenlosen Lösungen immer noch einen Schnitt niedriger als ihre kommerziellen Pendants. Es reicht aus, die Qualität und die Einzelheiten des Berichts zu studieren Unze 6– und verstehen warum. Das Programm basiert auf einer speziellen Analyse-Engine Ounce Core, die den Code auf die Einhaltung der Regeln und Richtlinien überprüft, die von einem Team professioneller Pentester erstellt wurden, die die Erfahrung namhafter Sicherheitsunternehmen, der Hacker-Community und Sicherheitsstandards gesammelt haben . Das Programm erkennt eine Vielzahl von Schwachstellen im Code: von Pufferüberläufen bis hin zu SQL-Injections. Auf Wunsch lässt sich Ounce problemlos in gängige IDEs integrieren, um eine automatische Codeprüfung während des Builds jedes neuen Builds der zu entwickelnden Anwendung zu implementieren. Die Entwicklerfirma – Ounce Labs – wurde übrigens diesen Sommer von IBM selbst aufgekauft. Daher wird das Produkt höchstwahrscheinlich als Teil einer der kommerziellen Anwendungen von IBM weiter entwickelt.

Klocwork-Einblick

Website: www.klocwork.com
Lizenz: Shareware
Plattform: Windows
Sprachen: C++, Java, C#

Lange Zeit war dies wiederum ein kommerzielles Produkt, das statisches Code-Scannen nur für C, C+ und Java implementierte. Doch sobald Visual Studio 2008 und das .NET Framework 3.5 herauskamen, kündigten die Entwickler die Unterstützung für C# an. Ich habe das Programm auf zwei meiner Hilfsprojekte ausgeführt, die ich hastig auf "scharf" geschrieben habe, und das Programm hat 7 kritische Schwachstellen aufgedeckt. Gut, dass sie ausschließlich für den internen Gebrauch geschrieben sind :). Klocwork-Einblick anfänglich vorkonfiguriert, um in Verbindung mit integrierten Entwicklungsumgebungen zu arbeiten. Die Integration mit demselben Visual Studio oder Eclipse ist äußerst erfolgreich - Sie beginnen ernsthaft zu glauben, dass solche Funktionen standardmäßig in ihnen implementiert werden sollten :). Wenn wir Probleme mit der Logik der Anwendung und Probleme mit der Geschwindigkeit nicht berücksichtigen, dann Klocwork-Einblick leistet hervorragende Arbeit beim Auffinden von Pufferüberläufen, fehlender Benutzercodefilterung, SQL/Path/Cross-Site-Injection, schwacher Verschlüsselung usw. Eine weitere interessante Option besteht darin, einen Anwendungsausführungsbaum zu erstellen, mit dem Sie sich schnell einarbeiten können allgemeines Prinzip Anwendungsbetrieb und protokollieren beispielsweise die Verarbeitung von Benutzereingaben separat. Und für den schnellen Aufbau von Regeln zur Überprüfung des Codes wird sogar ein spezielles Tool angeboten - Klowork Checker Studio.

Coverity Prevent Statische Analyse

Website: www.coverity.com/products
Lizenz: Shareware
Plattform: Windows
Sprachen: C++, Java, C#

Einer der bekanntesten statischen Codeanalysatoren für C/C++, Java und C#. Nach Angaben der Entwickler wird die Lösung von mehr als 100.000 Entwicklern auf der ganzen Welt verwendet. Durchdachte Mechanismen ermöglichen es Ihnen, die Suche nach Speicherlecks, nicht erfassten Ausnahmen, Leistungsproblemen und natürlich Sicherheitslücken zu automatisieren. Das Produkt unterstützt verschiedene Plattformen, Compiler (gcc, Microsoft Visual C++ und viele andere) und lässt sich auch in verschiedene Entwicklungsumgebungen integrieren, hauptsächlich Eclipse und Visual Studio. Code Traversal basiert nicht auf dummen Traversal-Algorithmen von Anfang bis Ende, sondern so etwas wie ein Debugger, der analysiert, wie sich das Programm in verschiedenen Situationen nach einer Verzweigungsbegegnung verhalten wird. Somit wird eine 100%ige Codeabdeckung erreicht. Ein solch komplexer Ansatz war unter anderem erforderlich, um speziell für den Betrieb auf Mehrkernprozessoren optimierte Multithread-Anwendungen vollständig zu analysieren. Coverity-Integritätszentrum ermöglicht es Ihnen, Fehler wie Race Conditions (ein Fehler im Design eines Multitasking-Systems, bei dem der Betrieb des Systems von der Reihenfolge abhängt, in der Teile des Codes ausgeführt werden), Deadlocks und vieles mehr zu finden. Warum ist es für Umkehrer notwendig? Fragen Sie die Entwickler von 0day sploits für Firefox und IE danach :).

OWASP-Code-Crawler

Website: www.owasp.org
Lizenz: GNU GPL
Plattform: Windows
Sprachen: Java, C#, VB

Der Schöpfer dieses Tools, Alessio Marziali, ist Autor von zwei Büchern über ASP.NET, ein maßgeblicher Programmierer von Hochlastanwendungen für den Finanzsektor und ein Pentester. 2007 veröffentlichte er kritische Sicherheitslücken auf 27 Websites der italienischen Regierung. Sein Nachwuchs - OWASP-Code-Crawler- konzipiert für die statische Analyse von .NET- und J2EE/JAVA-Code, offen im Internet verfügbar, und der Autor verspricht, Ende des Jahres zu veröffentlichen neue Version Programme mit viel mehr Funktionalität. Aber das Wichtigste ist bereits umgesetzt – die Analyse von Quellcodes in C#, Visual Basic und Java. Die zu scannenden Dateien werden über die GUI ausgewählt und der Scanvorgang startet automatisch. Für jeden problematischen Codeabschnitt wird eine Beschreibung der Schwachstelle im Abschnitt Bedrohungsbeschreibung angezeigt. Richtig, Feld OWASP-Richtlinien, die wahrscheinlich Möglichkeiten zur Lösung des Problems aufzeigt, ist leider noch nicht verfügbar. Sie können jedoch die experimentelle Funktion zum Scannen von Code auf einem Remote-Computer verwenden, die auf der Registerkarte Remote-Scan verfügbar ist. Der Autor verspricht, diese Funktion ernsthaft zu verbessern und unter anderem den Quellcode der Anwendung zur Analyse direkt aus dem Versionskontrollsystem zu aggregieren.

WARNUNG

Die Informationen dienen zu Informationszwecken und zeigen in erster Linie auf, wie Entwickler kritische Fehler bei der Anwendungsentwicklung vermeiden können. Weder der Autor noch die Herausgeber haften für die Verwendung des erworbenen Wissens zu rechtswidrigen Zwecken.