Essayer l'analyseur de flux de Facebook. Analyse de type statique en JavaScript. Essayer l'analyseur de flux de Facebook Choisir le bon vérificateur

Toutes les lignes de mon code ne sont pas parfaites la première fois. Eh bien, dans certains cas... Parfois... Eh bien, presque jamais. La vérité est que je passe beaucoup plus de temps à corriger mes propres erreurs stupides que je ne le voudrais. C'est pourquoi j'utilise des analyseurs statiques dans presque tous les fichiers JavaScript que j'écris.

Les analyseurs statiques examinent le code et y trouvent des erreurs avant de l'exécuter. Ils effectuent des vérifications simples, telles que la vérification de la syntaxe d'application (par exemple, s'il y a des tabulations au lieu d'espaces) et des vérifications plus globales, telles que la vérification que les fonctions ne sont pas trop complexes. Les analyseurs statiques recherchent également les erreurs qui ne peuvent pas être trouvées lors des tests, par exemple, == au lieu de ===.

Sur de grands projets et lorsque vous travaillez dans de grandes équipes, vous pouvez utiliser un peu d'aide pour trouver ces bogues "simples" qui ne sont en fait pas aussi simples qu'ils le paraissent.

Compilateur JSLint, JSHint et Closure

Il existe trois principales options d'analyseur statique pour JavaScript : JSLint, JSHint et Closure Compiler.

JSLint a été le premier analyseur statique pour JavaScript. Vous pouvez l'exécuter sur le site officiel ou utiliser l'un des modules complémentaires pouvant être exécutés sur des fichiers locaux. JSLint trouve beaucoup de bogues importants, mais c'est très difficile. Voici un excellent exemple :

vars = "machaîne" ; pour (var i = 0; je< s.length; i++) { console.log(s.charAt(i)); }

JSLint affiche deux erreurs dans ce code :

"++" inattendu. Déplacez les déclarations "var" en haut de la fonction.

Le premier problème est la définition de la variable i dans les conditions de boucle. JSLint n'accepte pas non plus l'opérateur ++ à la fin d'une définition de boucle. Il veut que le code ressemble à ceci :

vars = "machaîne" ; var je ; pour (i = 0; je< s.length; i = i + 1) { console.log(s.charAt(i)); }

J'apprécie les créateurs de JSLint, mais à mon avis, c'est exagéré. Cela s'est également avéré difficile pour Anton Kovalev, alors il a créé JSHint.

JSHint fonctionne de la même manière que JSLint, mais il est écrit en plus de Node.js et donc plus flexible. JSHint comprend un grand nombre d'options qui vous permettent d'effectuer des vérifications personnalisées en écrivant votre propre générateur de rapports.
Vous pouvez démarrer JSHint à partir de , mais dans la plupart des cas, il est préférable d'installer JSHint en tant qu'outil de ligne de commande local à l'aide de Node.js. Une fois JSHint installé, vous pouvez l'exécuter dans vos fichiers avec cette commande :

jshint test.js

JSHint comprend également des plugins pour les éditeurs de texte populaires, vous pouvez donc l'exécuter pendant que vous écrivez du code.

COMPILATEUR DE FERMETURE

Le compilateur de fermeture de Google est un type de programme complètement différent. Comme son nom l'indique, ce n'est pas seulement un vérificateur mais aussi un compilateur. Il est écrit en Java et basé sur l'analyseur Rhino de Mozilla. Le compilateur de fermeture comprend un mode simple pour effectuer une validation de code de base et des modes plus avancés pour effectuer une validation supplémentaire et appliquer des définitions de vue spécifiques.

Le Closure Compiler signale les erreurs dans le code JavaScript, mais produit également des versions réduites de JavaScript. Le compilateur supprime les espaces blancs, les commentaires et les variables inutilisées et simplifie les expressions longues, rendant le script aussi compact que possible.

Google a mis à disposition en ligne une version très simple du compilateur, mais vous voudrez probablement télécharger le Closure Compiler et l'exécuter localement.

Closure Compiler génère la liste des fichiers dans un fichier minifié après avoir vérifié le code. Vous pouvez donc l'exécuter en téléchargeant le fichier compiler.jar.

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

Choisir le bon programme de test

Dans mes projets, je combine Closure Compiler et JSHint. Closure Compiler effectue la minification et la validation de base, tandis que JSHint effectue une analyse de code plus complexe. Les deux programmes fonctionnent très bien ensemble et chacun couvre des domaines que l'autre ne peut pas. De plus, je peux utiliser l'extension JSHint pour écrire des validateurs personnalisés. Un programme générique que j'ai écrit vérifie certaines fonctions dont je n'ai pas besoin, telles que l'appel de fonctions qui ne devraient pas figurer dans mon projet.

Maintenant que nous avons couvert quelques vérificateurs, décomposons un mauvais code. Chacun de ces six exemples représente du code qui ne vaut pas la peine d'être écrit et des situations dans lesquelles les vérificateurs de code peuvent vous sauver.

Cet article utilise JSHint pour la plupart des exemples, mais le compilateur de fermeture émet généralement des avertissements similaires.

== ou === ?

JavaScript est un langage typé dynamiquement. Vous n'avez pas besoin de définir les types lors de l'écriture du code, mais ils existent au démarrage.

JavaScript propose deux opérateurs de comparaison pour manipuler ces types dynamiques : == et ===. Regardons cela avec un exemple.

Var = 123 ; vars = "123" ; if (n == s) ( alert("Les variables sont égales"); ) if (n === s) ( alert("Les variables sont identiques"); )

Opérateur de comparaison == sont les vestiges du langage C dans lequel JavaScript est enraciné. Son utilisation est presque toujours une erreur : comparer les valeurs séparément des types est rarement ce que le développeur souhaite réellement faire. En fait, le nombre "cent vingt-trois" est différent de la chaîne "un deux trois". Ces opérateurs sont faciles à mal orthographier et encore plus faciles à mal lire. Testez ce code avec JSHint et vous obtiendrez ceci :

Test.js : ligne 9, col 12, Attendu "===" et à la place vu "==".

Variables indéfinies et définitions tardives

Commençons par un code simple :

Fonction test() ( var myVar = "Hello, World"; console.log(myvar); )

Vous voyez le bogue ? Je fais cette erreur à chaque fois. Exécutez ce code et vous obtiendrez une erreur :

ReferenceError : myvar n'est pas défini

Complexifions un peu le problème :

Fonction test() ( myVar = "Hello, World"; console.log(myVar); )

Exécutez ce code et vous obtiendrez ceci :

Bonjour le monde

Ce deuxième exemple fonctionne, mais il a des effets secondaires très inattendus. Les règles de définition des variables JavaScript et de la portée sont au mieux déroutantes. Dans le premier cas, JSHint rapportera ce qui suit :

Test.js : ligne 3, col 17, "myvar" n'est pas défini.

Dans le second cas, il signalera ceci :

Test.js : ligne 2, col 5, "myVar" n'est pas défini. test.js : ligne 3, col 17, "myVar" n'est pas défini.

Le premier exemple vous aidera à éviter une erreur d'exécution. Vous n'avez pas besoin de tester votre application - JSHint trouvera l'erreur pour vous. Le deuxième exemple est pire, car vous ne trouverez pas de bogue dans le résultat du test.

Le problème du deuxième exemple est insidieusement subtil et complexe. La variable myVar a maintenant disparu de sa portée et a été promue à la portée globale. Cela signifie qu'il existera et aura la valeur Hello, World même après l'exécution de la fonction de test. C'est ce qu'on appelle la "pollution d'envergure mondiale".

La variable myVar existera pour toutes les autres fonctions qui seront exécutées après la fonction de test. Exécutez le code suivant après avoir exécuté la fonction de test :

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

Vous obtiendrez toujours Hello, World. La variable myVar traînera dans votre code comme un modèle, ce qui entraînera des bogues complexes que vous chercherez toute la nuit avant la publication, tout cela parce que vous avez oublié de mettre var.

ALEXANDRE MAYOROV, programmeur, 11 années d'expérience en programmation, dont sept consacrées au développement pour appareils mobiles

Analyse de type statique en JavaScript
Essayer l'analyseur de flux de Facebook

Facebook a introduit un nouveau projet open source Flow - un analyseur de code statique pour le langage JavaScript. L'objectif principal du développement de l'analyseur est de simplifier la recherche d'erreurs

De plus, Flow fournit un moyen, sous la forme d'une extension syntaxique de style TypeScript du langage JavaScript, de spécifier explicitement les types. La plupart des nouvelles fonctionnalités introduites dans la spécification ECMAScript 6 sont prises en charge.

Le sujet de la saisie dans les langages de programmation est souvent abordé. C'est le sujet des holivars et de la détermination des caractéristiques positives ou négatives d'une langue particulière. On a beaucoup parlé ces derniers temps de la saisie en JavaScript. Certaines personnes l'aiment tel qu'il est. Les personnes familiarisées avec d'autres langages de programmation, en particulier ceux avec un typage explicite fort, considèrent cette approche comme "une grenade entre les mains d'un singe". Nous savons tous que JavaScript est un langage faiblement typé dynamiquement. Les gourous du développement front-end ont appris à l'utiliser pour de bon, mais le code est parfois difficile à comprendre. Ceux qui viennent d'entrer dans le monde de la programmation JavaScript sont perplexes devant la magie que fait l'interpréteur et attrapent souvent des erreurs à l'improviste. Mais d'abord, comprenons un peu la dactylographie en général. Comment est-ce?

Saisie dans les langages de programmation

Les langages de programmation typés se divisent en deux grands camps - typés et non typés. Les langages typés, par exemple, incluent des langages tels que C, Python, PHP, Lua, JavaScript. Exemples de langages non typés : assembleur, Forth, Brainfuck. Oui Oui exactement. JavaScript, comme beaucoup d'autres langages interprétés, est typé. Par conséquent, en aucun cas, ne dites pas qu'il est non typé. Surtout dans les entretiens.

À leur tour, les langues typées sont divisées en plusieurs catégories qui se chevauchent :

Avec typage statique ou dynamique.
Avec une frappe forte ou lâche.
Avec typage explicite ou implicite.

Langues avec typage statique

Avec le typage statique, les types finaux de variables et de fonctions sont définis au moment de la compilation. Le compilateur corrige vos erreurs d'incompatibilité de type avant d'exécuter le programme. Exemples de langages : C, Java, C#.

Langues avec typage dynamique

Dans le typage dynamique, tous les types sont déterminés au moment de l'exécution. Et si vous faites une erreur, vous ne le saurez que lorsque vous exécuterez le programme. Par conséquent, il est très important d'accorder une attention particulière aux vérifications et à la détection d'erreurs dans le typage dynamique. Exemples de langages : JavaScript, PHP, Python, Ruby.

Dactylographie forte (forte)

Les langages fortement typés ne permettent pas de mélanger différents types dans les expressions et n'effectueront pas de conversions automatiques de types implicites. Par exemple, vous ne pouvez pas soustraire un nombre ou un autre type autre qu'une chaîne d'une chaîne. Exemples de langages : Java, Python, Haskell, Lisp.

Dactylographie lâche (faible)

Les langages faiblement typés effectuent automatiquement de nombreuses conversions de type implicites. Ils le font même si une perte de précision ou de conversion peut se produire, de manière ambiguë. Exemples de langages : PHP, JavaScript, Visual Basic.

Typage explicite

Dans les langages explicitement typés, le type des nouvelles variables/fonctions et arguments doit être défini explicitement. Exemples de langages : C++, D, C#.

Typage implicite

Dans les langages à typage implicite, la tâche de spécifier les types est transférée au compilateur/interpréteur. Exemples de langages : JavaScript, PHP, Lua. Dans ces langages, en règle générale, les objets ont des méthodes spéciales qui sont appelées lors d'une conversion en type. Par exemple, PHP a la méthode _toString() et JavaScript a une méthode du même nom, mais sans le trait de soulignement, toString(). Ces méthodes sont appelées lorsqu'un objet est converti en un type chaîne. Parfois, ces méthodes sont appelées magiques (tout processus implicite est toujours magique).

Il est important de noter que toutes ces catégories se chevauchent. Sur la base de ces catégories, nous concluons que JavaScript a un typage implicite dynamique. Et en parlant exagérément, la nature du langage peut être décrite comme suit: dans toute situation incompréhensible, apportez tout aux primitifs, principalement à une chaîne. Bien qu'en réalité tout soit un peu plus compliqué, mais nous n'entrerons pas dans les détails maintenant.

Pourquoi avons-nous besoin de taper? vous pourriez demander. Sans lui, JavaScript a bien vécu pendant 20 ans. La réponse est simple : auparavant, les tâches complexes au niveau de l'entreprise n'étaient pas résolues en JavaScript. Maintenant, ce langage a dépassé le navigateur et est entré sur le territoire du backend. Lors de l'écriture d'une application volumineuse, il devient difficile de détecter les erreurs souvent associées à la conversion de type.

Modules JavaScript

Étant donné que JavaScript est exécuté côté client (dans les navigateurs), l'une des solutions au problème consiste à créer un langage - un dialecte qui sera compilé en JS. Il agit comme un assembleur.

Des langages tels que TypeScript, Dart, AtScript ont émergé qui ajoutent un typage fort statique et même une vérification de type à l'exécution (bien que cela ajoute une surcharge). Tous ces langages ne se contentent pas d'ajouter des types, ils ajoutent également soit du sucre syntaxique, soit même leur propre implémentation de VM, qui est écrite en JS.

Lire l'article complet dans la revue "System Administrator", n°1-2 pour 2015 aux pages 86-88.

Une version PDF de ce numéro peut être achetée dans notre magasin.

Le site Web de Flow est http://flowtype.org.

En contact avec

Chacune de l'équipe ][ a ses propres préférences concernant les logiciels et les utilitaires pour le pentesting. Après consultation, nous avons découvert: le choix est si différent que vous pouvez créer un ensemble de programmes éprouvés pour un vrai gentleman. Là-dessus, ils ont décidé. Afin de ne pas faire un méli-mélo combiné, la liste entière est divisée en sujets. Aujourd'hui, nous allons analyser analyseurs de code statiques pour rechercher des vulnérabilités dans les applications lorsque leurs codes sources sont à portée de main.

La disponibilité des codes sources des programmes simplifie grandement la recherche de vulnérabilités. Au lieu de manipuler aveuglément divers paramètres qui sont passés à l'application, il est beaucoup plus facile de voir dans les sortes comment elle les traite. Disons que si les données de l'utilisateur sont transmises sans contrôles ni transformations, elles atteignent la requête SQL, nous avons une vulnérabilité d'injection SQL. S'ils arrivent à la sortie en code HTML, nous obtenons le XSS classique. Un scanner statique est nécessaire pour détecter clairement de telles situations, mais, malheureusement, ce n'est pas toujours aussi facile qu'il n'y paraît.

Compilateurs modernes

Cela peut sembler drôle, mais l'un des plus efficaces analyseurs de code sont les compilateurs eux-mêmes. Bien sûr, ils sont destinés à quelque chose de complètement différent, mais en prime, chacun d'eux propose un bon vérificateur de code source capable de détecter un grand nombre d'erreurs. Pourquoi n'économise-t-il pas ? Initialement, les paramètres d'une telle vérification de code sont définis de manière assez loyale: par conséquent, afin de ne pas embarrasser le programmeur, le compilateur ne commence à jurer que dans le cas des jambages les plus graves. Mais en vain - si vous définissez un niveau d'avertissement plus élevé, il est tout à fait possible de déterrer de nombreux endroits douteux dans le code. Cela ressemble à ceci. Disons que dans le code, il n'y a pas de vérification de la longueur de la chaîne avant de la copier dans le tampon. L'analyseur trouve une fonction qui copie une chaîne (ou un fragment de celle-ci) dans un tampon de taille fixe sans d'abord vérifier sa longueur. Il trace la trajectoire de passage des arguments : des données d'entrée à la fonction vulnérable et voit s'il est possible de choisir une longueur de chaîne qui provoquerait un débordement dans la fonction vulnérable et ne serait pas coupée par les vérifications qui l'ont précédée. S'il n'y a pas une telle vérification, nous trouvons presque 100% de débordement de tampon. La principale difficulté dans l'utilisation d'un compilateur pour vérifier est de lui faire "avaler" le code de quelqu'un d'autre. Si vous avez déjà essayé de compiler une application à partir des sources, vous savez à quel point il est difficile de satisfaire toutes les dépendances, surtout dans les grands projets. Mais le résultat en vaut la peine ! De plus, en plus du compilateur, les IDE puissants disposent également d'autres outils pour analyse de code. Par exemple, le morceau de code suivant dans Visual Studio émettra un avertissement concernant l'utilisation de la fonction _alloca dans la boucle, qui peut rapidement déborder la pile :

caractère*b ;
fais(
b = (char*)_alloca(9)
) tandis que(1)

C'est le mérite de l'analyseur statique PREfast. Comme FxCop pour l'analyse de code managé, PREfast était à l'origine distribué en tant qu'utilitaire distinct et n'a été intégré que plus tard à Visual Studio.

RATS - Outil d'audit approximatif pour la sécurité

Site Web : www.securesoftware.com
Licence : GNU GPL
Plate-forme : Unix, Windows
Langages : C++, PHP, Python, Ruby

Erreur d'erreur - conflit. Certaines des failles commises par les programmeurs ne sont pas critiques et ne menacent que l'instabilité du programme. D'autres, au contraire, permettent d'injecter du shellcode et d'exécuter des commandes arbitraires sur un serveur distant. Les commandes qui autorisent le débordement de la mémoire tampon et d'autres types d'attaques similaires présentent un risque particulier dans le code. Il existe de nombreuses commandes de ce type, dans le cas de C/C++, ce sont des fonctions permettant de travailler avec des chaînes (xstrcpy(), strcat(), gets(), sprintf(), printf(), snprintf(), syslog() ), les commandes système ( access(), chown(), chgrp(), chmod(), tmpfile(), tmpnam(), tempnam(), mktemp()), ainsi que les commandes d'appel système (exec(), system (), popen() ). Examiner manuellement tout le code (surtout s'il est composé de plusieurs milliers de lignes) est assez fastidieux. Cela signifie que vous pouvez facilement ignorer le transfert de certaines fonctions de paramètres non contrôlés. Outils spéciaux pour l'audit, y compris l'utilitaire bien connu LES RATS (Outil d'audit approximatif pour la sécurité) de la célèbre société Fortify. Non seulement il gérera avec succès du code écrit en C/C++, mais il sera également capable de traiter des scripts Perl, PHP et Python. La base de données des utilitaires contient une sélection impressionnante avec une description détaillée des problèmes dans le code. Avec l'aide de l'analyseur, elle traitera la source qui lui sera fournie et tentera d'identifier les bogues, après quoi elle donnera des informations sur les lacunes trouvées. LES RATS fonctionne via la ligne de commande, à la fois sous les systèmes Windows et *nix.

Yasca

Site Web : www.yasca.org
Licence : Open Source
Plate-forme : Unix, Windows
Langages : C++, Java, .NET, ASP, Perl, PHP, Python et autres.

Yasca tout comme RATS n'a pas besoin d'être installé, alors qu'il a non seulement une interface de console, mais aussi une interface graphique simple. Les développeurs recommandent d'exécuter l'utilitaire via la console - ils disent qu'il y a plus d'opportunités. C'est drôle que le moteur Yasca soit écrit en PHP 5.2.5, et l'interpréteur (dans la version la plus tronquée) se trouve dans l'un des sous-dossiers de l'archive avec le programme. L'ensemble du programme se compose logiquement d'un front-end, d'un ensemble de plugins de numérisation, d'un générateur de rapports et du moteur lui-même, qui fait tourner tous les engrenages ensemble. Les plugins sont déversés dans le répertoire des plugins - des addons supplémentaires doivent également y être installés. Point important! Trois des plugins standard fournis avec Yasca, ont de mauvaises dépendances. JLint, qui analyse les fichiers .class de Java, nécessite jlint.exe dans le répertoire des ressources/utilitaires. Le deuxième plug-in, antiC, qui est utilisé pour analyser les tris Java et C/C++, nécessite antic.exe dans le même répertoire. PMD, qui traite le code Java, nécessite Java JRE 1.4 ou supérieur installé sur le système. Vous pouvez vérifier si l'installation est correcte en tapant la commande "yasca ./resources/test/". À quoi ressemble l'analyse ? Après avoir traité les tris envoyés à le programme, Yasca produit le résultat sous la forme d'un rapport spécial. Par exemple, l'un des plugins GREP standard permet d'utiliser les modèles décrits dans les fichiers .grep pour spécifier des constructions vulnérables et identifier facilement un certain nombre de vulnérabilités. Un ensemble de ces modèles est déjà inclus dans le programme : pour rechercher un cryptage faible, une autorisation "mot de passe égal à la connexion", d'éventuelles injections SQL, et bien plus encore. Lorsque vous souhaitez voir des informations plus détaillées dans le rapport, ne soyez pas trop paresseux pour installer des plugins supplémentaires. Ce qui vaut une chose, c'est qu'avec leur aide, vous pouvez également scanner du code dans .NET (VB.NET, C#, ASP.NET), PHP, ColdFusion, COBOL, HTML, JavaScript, CSS, Visual Basic, ASP, Python, Perl .

Cppcheck

Site Internet:
Licence : Open Source
Plate-forme : Unix, Windows
Langages : C++

Développeurs Cppcheck a décidé de ne pas se disperser sur des bagatelles, et donc de n'attraper que des catégories de bogues strictement définies et uniquement dans le code C ++. Ne vous attendez pas à ce que le programme duplique les avertissements du compilateur - il le fera sans prompteur. Par conséquent, ne soyez pas trop paresseux pour définir le niveau maximum d'avertissements pour le compilateur et utilisez Cppcheck pour vérifier les fuites de mémoire, les violations des opérations d'allocation-désallocation, divers dépassements de mémoire tampon, l'utilisation de fonctions obsolètes, et bien plus encore. Un détail important : les développeurs de Cppcheck ont essayé de limiter au maximum le nombre de faux positifs. Par conséquent, si le programme corrige une erreur, vous pouvez très probablement dire : "C'est vraiment le cas !" Vous pouvez démarrer l'analyse à la fois depuis la console et à l'aide d'une belle interface graphique écrite en Qt et fonctionnant sous n'importe quelle plate-forme.

graudit

Site Web : www.justanotherhacker.com/projects/graudit.html
Licence : Open Source
Plate-forme : Unix, Windows
Langages : C++, PHP, Python, Perl

Ce script simple, combiné à un ensemble de signatures, vous permet de trouver un certain nombre de vulnérabilités critiques dans le code, et la recherche est effectuée à l'aide du célèbre utilitaire grep. Il est même inapproprié de mentionner ici l'interface graphique : tout se fait via la console. Il existe plusieurs clés pour démarrer, mais dans le cas le plus simple, il suffit de préciser le chemin vers les sources en paramètre :

Graaudit /chemin/vers/scan

La récompense de la diligence sera un rapport coloré sur les endroits potentiellement exploitables dans le code. Je dois dire qu'en plus du script lui-même (qui ne contient que 100 lignes de code Bash), les bases de données de signatures contenant des expressions rationnelles et des noms de fonctions potentiellement vulnérables dans différentes langues sont utiles. Par défaut, les bases de Python, Perl, PHP, C++ sont incluses - vous pouvez prendre des fichiers du dossier des signatures et les utiliser dans vos propres développements.

SWAT

Site Web : www.owasp.org
Licence : Open Source
Plate-forme : Unix, Windows
Langages : Java, JSP, ASP.Net, PHP

Si graudit utilise des fichiers texte pour définir la signature de vulnérabilité, alors dans SWAT- une approche plus poussée avec des fichiers XML. Voici à quoi ressemble une signature typique :

vuln match - expression régulière pour la recherche ;
type - indique le type de vulnérabilité :
gravité - indique le niveau de risque (élevé, moyen ou faible)
alt - code alternatif pour résoudre le problème

SWAT lit la base de données des signatures et l'utilise pour trouver les problèmes dans les sources Java, JSP, ASP .Net et PHP. La base de données est constamment mise à jour et en plus de la liste des fonctions "dangereuses", elle inclut les erreurs typiques d'utilisation du formatage des chaînes et de compilation des requêtes SQL. Il est à noter que le programme est écrit en C #, mais il fonctionne également très bien sous niks, grâce au projet Mono - une implémentation ouverte de la plate-forme .Net.

Analyseur de bogues PHP

Site : raz0r.name/releases/php-bug-scanner
Licence : Logiciel gratuit
Plate-forme : Windows
Langages : PHP

Si vous avez besoin d'analyser statiquement une application PHP, je vous recommande d'essayer Analyseur de bogues PHP, qui a été écrit par notre auteur - raz0r. Le travail du programme est basé sur l'analyse de diverses fonctions et variables dans les scripts PHP qui peuvent être impliquées dans des attaques Web. La description de telles situations est faite sous la forme de soi-disant préréglages, et le programme comprend déjà 7 préréglages spéciaux, regroupés en catégories :

exécution de code ;
exécution de la commande ;
parcours de répertoire ;
les globales écrasent ;
comprendre;
injection SQL ;
divers.

C'est drôle que le programme soit écrit en PHP/WinBinder et compilé avec bamcompile , il ressemble donc à une application Windows normale. Grâce à une interface conviviale, un pentester peut activer ou désactiver l'analyse de code pour certaines vulnérabilités.

lutin

Site Web : pixybox.seclab.tuwien.ac.at
Licence : Logiciel gratuit
Plate-forme : Unix, Windows
Langages : PHP

L'outil est basé sur la numérisation du code source et la construction de graphiques de flux de données. Ce graphique trace le chemin des données provenant de l'extérieur du programme - de l'utilisateur, de la base de données, d'un plugin externe, etc. De cette façon, une liste de points (ou d'entrées) vulnérables dans les applications est construite. À l'aide de modèles décrivant les vulnérabilités, Pixy vérifie ces points et vous permet de déterminer les vulnérabilités XSS et SQL. De plus, les graphiques eux-mêmes, qui sont construits lors de l'analyse, peuvent être visualisés dans le dossier des graphiques (par exemple, xss_file.php_1_dep.dot) - c'est très utile pour comprendre pourquoi telle ou telle section du code est considérée comme Pixy -vulnérable. En général, le développement lui-même est extrêmement informatif et montre comment fonctionnent les utilitaires avancés d'analyse de code statique. Sur la page de documentation, le développeur parle clairement des différentes étapes du programme, explique la logique et l'algorithme de la façon dont tel ou tel morceau de code doit être analysé par le programme. Le programme lui-même est écrit en Java et distribué en open source, et sur la page d'accueil il y a même un simple service en ligne pour vérifier le code pour les vulnérabilités XSS.

Once 6

Site Web : www.ouncelabs.com/products
Licence : shareware
Plate-forme : Windows

Hélas, les solutions gratuites existantes sont encore un cran inférieures à leurs homologues commerciales. Il suffit d'étudier la qualité et le détail du rapport, qui est Once 6– et comprendre pourquoi. Le programme est basé sur un moteur d'analyse spécial Ounce Core, qui vérifie la conformité du code aux règles et politiques élaborées par une équipe de pentesters professionnels qui ont accumulé l'expérience d'entreprises de sécurité bien connues, de la communauté des hackers et des normes de sécurité. . Le programme détecte une variété de vulnérabilités dans le code : des débordements de tampon aux injections SQL. Si vous le souhaitez, Ounce s'intègre facilement aux IDE populaires pour implémenter la vérification automatique du code lors de la construction de chaque nouvelle version de l'application en cours de développement. Soit dit en passant, la société de développement - Ounce Labs - a été achetée par IBM elle-même cet été. Ainsi, le produit continuera très probablement à être développé dans le cadre d'une des applications commerciales d'IBM.

Aperçu de Klocwork

Site Web : www.klocwork.com
Licence : shareware
Plate-forme : Windows
Langages : C++, Java, C#

Pendant longtemps, encore une fois, un produit commercial a implémenté l'analyse de code statique uniquement pour C, C + et Java. Mais, dès la sortie de Visual Studio 2008 et du .NET Framework 3.5, les développeurs ont annoncé la prise en charge de C#. J'ai exécuté le programme sur deux de mes projets auxiliaires, que j'ai écrits à la hâte sur "sharp" et le programme a révélé 7 vulnérabilités critiques. C'est bien qu'ils soient écrits exclusivement pour un usage interne :). Aperçu de Klocwork initialement configuré, tout d'abord, pour fonctionner en conjonction avec des environnements de développement intégrés. L'intégration avec le même Visual Studio ou Eclipse est extrêmement réussie - vous commencez à penser sérieusement qu'une telle fonctionnalité devrait y être implémentée par défaut :). Si nous ne prenons pas en compte les problèmes de logique de l'application et les problèmes de vitesse, alors Aperçu de Klocwork fait un excellent travail pour trouver les débordements de tampon, le manque de filtrage du code utilisateur, l'injection SQL/Path/Cross-site, le cryptage faible, etc. Une autre option intéressante consiste à créer une arborescence d'exécution d'application, qui vous permet de comprendre rapidement le principe général de l'application et de suivre séparément, par exemple, le traitement de toute entrée utilisateur. Et pour la construction rapide de règles de vérification du code, même un outil spécial est proposé - Klocwork Checker Studio.

La couverture empêche l'analyse statique

Site Web : www.coverity.com/products
Licence : shareware
Plate-forme : Windows
Langages : C++, Java, C#

L'un des analyseurs de code statique les plus connus pour C/C++, Java et C#. Selon ses créateurs, la solution est utilisée par plus de 100 000 développeurs à travers le monde. Des mécanismes réfléchis vous permettent d'automatiser la recherche de fuites de mémoire, d'exceptions non détectées, de problèmes de performances et, bien sûr, de vulnérabilités de sécurité. Le produit prend en charge différentes plates-formes, compilateurs (gcc, Microsoft Visual C++ et bien d'autres) et s'intègre également à divers environnements de développement, principalement Eclipse et Visual Studio. La traversée du code n'est pas basée sur des algorithmes de traversée stupides du début à la fin, mais quelque chose comme un débogueur qui analyse le comportement du programme dans diverses situations après une rencontre de branche. Ainsi, une couverture de code de 100 % est atteinte. Une approche aussi complexe était nécessaire, entre autres, pour analyser complètement les applications multithread spécialement optimisées pour fonctionner sur des processeurs multicœurs. Centre d'intégrité Coverity vous permet de trouver des erreurs telles que des conditions de concurrence (une erreur dans la conception d'un système multitâche, dans lequel le fonctionnement du système dépend de l'ordre dans lequel les parties du code sont exécutées), des blocages, et bien plus encore. Pourquoi est-ce nécessaire pour les inverseurs ? Demandez aux développeurs de 0day sploits pour Firefox et IE à ce sujet :).

Robot d'exploration de code OWASP

Site Web : www.owasp.org
Licence : GNU GPL
Plate-forme : Windows
Langages : Java, C#, VB

Le créateur de cet outil, Alessio Marziali, est l'auteur de deux livres sur ASP.NET, un codeur faisant autorité d'applications à forte charge pour le secteur financier, et un pentester. En 2007, il a publié des vulnérabilités critiques sur 27 sites Web du gouvernement italien. Sa progéniture - Robot d'exploration de code OWASP- conçu pour l'analyse statique du code .NET et J2EE / JAVA, librement disponible sur Internet, et à la fin de l'année, l'auteur promet de publier une nouvelle version du programme avec beaucoup plus de fonctionnalités. Mais la chose la plus importante a déjà été mise en œuvre - l'analyse des codes sources en C #, Visual Basic et Java. Les fichiers à analyser sont sélectionnés via l'interface graphique et l'analyse démarre automatiquement. Pour chaque section de code problématique, une description de la vulnérabilité est affichée dans la section Description de la menace. Vrai, champ Lignes directrices de l'OWASP, indiquant probablement des moyens de résoudre le problème, hélas, n'est pas encore disponible. Mais vous pouvez utiliser la fonction expérimentale d'analyse de code sur une machine distante, disponible dans l'onglet Analyse à distance. L'auteur promet de sérieusement mettre à jour cette fonctionnalité et, entre autres, d'agréger le code source de l'application pour analyse directement depuis le système de contrôle de version.

ATTENTION

Les informations sont fournies à titre informatif et montrent principalement comment les développeurs peuvent éviter les erreurs critiques lors du développement d'applications. Ni l'auteur ni les éditeurs ne sont responsables de l'utilisation des connaissances acquises à des fins illégales.

Compilateur JSLint, JSHint et Closure

Il existe trois principales options d'analyseur statique pour JavaScript : JSLint, JSHint et Closure Compiler.

vars = "machaîne" ;
pour (var i = 0; je< s.length; i++) {
console.log(s.charAt(i));
}

JSLint affiche deux erreurs dans ce code :

"++" inattendu.
Déplacez les déclarations "var" en haut de la fonction.

vars = "machaîne" ;
var je ;
pour (i = 0; je< s.length; i = i + 1) {
console.log(s.charAt(i));
}

J'apprécie les créateurs de JSLint, mais à mon avis, c'est exagéré. Cela s'est également avéré difficile pour Anton Kovalev, alors il a créé JSHint.

Vous pouvez démarrer JSHint à partir de , mais dans la plupart des cas, il est préférable d'installer JSHint en tant qu'outil de ligne de commande local à l'aide de Node.js. Une fois JSHint installé, vous pouvez l'exécuter dans vos fichiers avec cette commande :

jshint test.js

JSHint comprend également des plugins pour les éditeurs de texte populaires, vous pouvez donc l'exécuter pendant que vous écrivez du code.

COMPILATEUR DE FERMETURE

Google a mis à disposition en ligne une version très simple du compilateur, mais vous voudrez probablement télécharger le Closure Compiler et l'exécuter localement.

Closure Compiler génère la liste des fichiers dans un fichier minifié après avoir vérifié le code. Vous pouvez donc l'exécuter en téléchargeant le fichier compiler.jar.

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

Choisir le bon programme de test

Cet article utilise JSHint pour la plupart des exemples, mais le compilateur de fermeture émet généralement des avertissements similaires.

== ou === ?

JavaScript est un langage typé dynamiquement. Vous n'avez pas besoin de définir les types lors de l'écriture du code, mais ils existent au démarrage.

JavaScript propose deux opérateurs de comparaison pour manipuler ces types dynamiques : == et ===. Regardons cela avec un exemple.

varn = 123 ;
vars = "123" ;

si (n == s) (
alert("Les variables sont égales");
}

si (n === s) (
alert("Les variables sont identiques");
}

Opérateur de comparaison == sont les vestiges du langage C, dans lequel JavaScript est enraciné. Son utilisation est presque toujours une erreur : comparer les valeurs séparément des types est rarement ce que le développeur souhaite réellement faire. En fait, le nombre "cent vingt-trois" est différent de la chaîne "un deux trois". Ces opérateurs sont faciles à mal orthographier et encore plus faciles à mal lire. Testez ce code avec JSHint et vous obtiendrez ceci :

test.js : ligne 9, col 12, Attendu "===" et à la place vu "==".

Variables indéfinies et définitions tardives

Commençons par un code simple :

test de fonctionnalité() (
var maVar = "Bonjour le monde" ;
journal de la console (mavar);
}

Vous voyez le bogue ? Je fais cette erreur à chaque fois. Exécutez ce code et vous obtiendrez une erreur :

ReferenceError : myvar n'est pas défini

Complexifions un peu le problème :

test de fonctionnalité() (
maVar = "Bonjour le monde" ;
journal de la console (myVar);
}

Exécutez ce code et vous obtiendrez ceci :

Bonjour le monde

Dans le second cas, il signalera ceci :

test.js : ligne 2, col 5, "myVar" n'est pas défini.
test.js : ligne 3, col 17, "myVar" n'est pas défini.

La variable myVar existera pour toutes les autres fonctions qui seront exécutées après la fonction de test. Exécutez le code suivant après avoir exécuté la fonction de test :

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

Cette entrée est passée par le service Full-Text RSS - s'il s'agit de votre contenu et que vous le lisez sur le site de quelqu'un d'autre, veuillez lire la FAQ à l'adresse http://ift.tt/jcXqJW.

Développer des applications JavaScript sécurisées est une tâche assez difficile. Mais tout à fait faisable. Dans l'article d'aujourd'hui, nous examinerons les fonctionnalités de JavaScript qui causent des problèmes de sécurité et expliquerons comment les éviter.

Pourquoi il est difficile d'écrire du code JS sécurisé

Voici donc 5 raisons pour lesquelles il est difficile d'écrire du code JS sécurisé.

Le compilateur n'aidera pas.

JavaScript est un langage interprété. Et cela signifie que le compilateur ne se plaindra pas toujours de quelque chose, refusant de travailler et vous poussant à corriger les erreurs et à optimiser le code.

La nature dynamique de JavaScript

JavaScript est dynamique, faiblement typé et asynchrone. Et ce sont tous des signes qu'il est facile d'avoir des ennuis.

1. Outils linguistiques comme eval et l'inclusion de code tiers via le script src vous permet d'exécuter des lignes directement au moment de l'exécution. Par conséquent, il est difficile de donner des "garanties statiques" que le code se comportera d'une certaine manière. L'analyse dynamique complique également cela (voir travaux scientifiques).

Utiliser eval

2. Dactylographie faible conduit au fait qu'il n'est pas facile d'appliquer les méthodes établies d'analyse statique - du moins en comparaison avec les langages typés statiquement (par exemple, Java).

3. Rappels asynchrones, les appels que JavaScript permet via des mécanismes comme setTimeout et XMLHttpRequest (le très célèbre AJAX), selon les statistiques, cachent les erreurs les plus insidieuses.

Fonctionnalités JS complexes

Qu'est-ce qui n'a pas été glissé dans JavaScript au fil des ans ! En particulier, il a des prototypes, des fonctions de première classe et des fermetures. Ils rendent le langage encore plus dynamique et compliquent l'écriture de code sécurisé.

1. Prototypes. Leur signification est que les programmes sont écrits dans l'esprit d'une approche orientée objet, mais sans l'utilisation de classes. Avec cette approche, les objets héritent des propriétés dont ils ont besoin directement d'autres objets (prototypes). Dans le même temps, dans JS, les prototypes peuvent être redéfinis directement au moment de l'exécution. Et si cette redéfinition se produit, l'effet se propage immédiatement à tous les objets qui héritent des propriétés du prototype remplacé.

Comment les prototypes sont traités

En toute honnêteté, il faut dire que les classes sont également présentes dans les nouvelles spécifications ECMAScript.

2. Fonctions de la première classe. JS a un modèle d'objet et de fonction très flexible. Les propriétés des objets et leurs valeurs peuvent être créées, modifiées ou supprimées directement au moment de l'exécution, et toutes sont accessibles via des fonctions de première classe.

3. Fermetures. Si vous déclarez une fonction à l'intérieur d'une autre fonction, la première a accès aux variables et aux arguments de la seconde. De plus, ces variables continuent d'exister et restent disponibles pour la fonction interne - même après la fin de la fonction externe dans laquelle ces variables sont définies.

En raison de la flexibilité et du dynamisme de JavaScript (voir points 1 et 3), déterminer l'ensemble de toutes les propriétés disponibles d'un objet lors de l'analyse statique est une tâche insoluble. Cependant, les développeurs Web utilisent partout les fonctionnalités dynamiques du langage et, par conséquent, ils ne peuvent pas être négligés lors de l'analyse du code. Sinon, quelle est la garantie de sécurité ?

Interaction étroite entre JavaScript et DOM

Ceci est nécessaire pour fournir une mise à jour "transparente" de la page Web, juste au moment de l'exécution. Le DOM, comme vous le savez, est un modèle d'objet standard indépendant de la plate-forme et du langage, conçu pour restituer des documents HTML et XML. Le DOM a sa propre API pour travailler avec le document rendu : pour accéder, déplacer et mettre à jour dynamiquement le document rendu (son contenu, sa structure et son style). Les modifications apportées au DOM peuvent être apportées dynamiquement via JavaScript. Et ces changements sont immédiatement affichés dans le navigateur.

Grâce au DOM, les pages Web chargées dans le navigateur peuvent être mises à jour par étapes au fur et à mesure que les données sont chargées à partir du serveur. Cependant, cette commodité a un inconvénient : les extraits de code qui sont responsables de l'interaction dynamique entre JS et le DOM sont particulièrement sujets aux erreurs.

Les erreurs les plus courantes dans les applications Web

Interactions d'événements complexes

JavaScript est un langage événementiel. Il permet aux développeurs d'enregistrer des soi-disant "écouteurs d'événements" sur les nœuds DOM - des écouteurs d'événements. Et bien que la plupart des événements soient déclenchés par des actions de l'utilisateur, certains peuvent être déclenchés sans cela, comme les événements chronométrés et les appels asynchrones. De plus, chaque événement peut être répercuté dans l'arborescence DOM et activer plusieurs "auditeurs" à la fois. Parfois, garder une trace de tout cela est une tâche plutôt non triviale.

Comment sont gérés les événements

Pour ces raisons, le code JS peut être difficile à comprendre, analyser et tester. Des utilitaires spéciaux faciliteront la vie d'un développeur Web et aideront à écrire un code sûr.

Utilitaires pour tester le code JS

Il existe des outils d'analyse (par exemple Esprima, Rhino), d'optimisation (par exemple Google Closure Compiler) et d'analyse de code statique pour les erreurs de syntaxe courantes (par exemple JSHint).

De plus, il existe plusieurs frameworks éprouvés qui aident les développeurs Web à couvrir le code JS avec des tests. Parmi eux:

QUnit est un framework de test unitaire populaire ;
Jasmine - Framework BDD (Behavior-Driven Development) pour les tests de code ;
Mocha est un framework de test de code qui s'exécute à la fois dans Node.js et dans le navigateur.
jsTestDriver est un framework qui, entre autres, peut exécuter un ensemble de tests sur plusieurs navigateurs à la fois.

De plus, il existe des frameworks de test qui émulent le comportement du navigateur et vous permettent d'exécuter automatiquement des cas de test. Ils sont particulièrement pertinents lors du débogage de sections de code responsables de l'interaction entre JS et le DOM, et fournissent une infrastructure pratique pour manipuler le DOM.

Par exemple, Selenium, PhantomJS et SlimerJS fournissent une API à travers laquelle vous pouvez lancer et travailler avec des instances de navigateur. Grâce à l'API, vous pouvez activer des événements et accéder aux éléments DOM directement au moment de l'exécution, c'est-à-dire tester le code dans des conditions aussi proches que possible de la réalité. Bien sûr, une grande partie du travail devra être effectuée manuellement, mais même cela est déjà une bonne aide pour les tests.

Utilitaires pour l'analyse statique

Auparavant, les utilitaires d'identification des sections de code problématiques étaient des analyseurs statiques. C'est-à-dire, compte tenu de toutes les bizarreries dynamiques de JS, ne pouvait fournir qu'une aide limitée. Cependant, ils sont également utiles dans l'analyse. Voici quelques exemples de base.

WARI est un analyseur statique qui explore les dépendances entre les fonctionnalités JS, les styles CSS, les balises HTML et les images. Le but de cet utilitaire est de trouver les ressources inutilisées lors de l'analyse statique. Cependant, WARI, bien sûr, ne fera pas face à la dynamique.

JSLint est un utilitaire d'analyse de code statique lui-même écrit en JavaScript. Il vérifie le code par rapport aux bonnes pratiques.

Google Closure Compiler est un optimiseur JS qui réécrit automatiquement le code pour le rendre plus rapide et plus compact. En même temps, tous les commentaires et toutes les sections de code inutilisées volent dans le tuyau.

WebScent (voir document de recherche) est un analyseur statique avancé. Dans le travail, il part du fait que le code JS client (celui qui est chargé dans le navigateur) n'est pas stocké côté serveur dans son intégralité, mais est éparpillé par morceaux dans le code serveur. Le "suck" dans ces pièces ne peut pas être facilement découvert jusqu'à ce qu'un code client solide soit généré à partir d'eux. WebScent analyse le code client afin de trouver les zones problématiques dans le code serveur. Dans le même temps, le travail de l'analyseur statique WebScent est principalement réduit à démêler les lots HTML, CSS et JS - afin de détecter le code en double et les erreurs dans la syntaxe HTML.

Utilitaires pour l'analyse dynamique

JSNose est un utilitaire qui combine l'analyse statique et dynamique. Il analyse le code pour treize anti-modèles. Sept d'entre eux (y compris les objets paresseux et les fonctions longues) sont communs à tous les langages de programmation, et les six autres (odeurs de fermeture, variables globales excessives, rappels imbriqués et autres) sont spécifiques à JavaScript.

DOMpletion est un utilitaire automatisé qui aide un développeur Web à comprendre le code lors de la visualisation : explique la raison de la présence de structures DOM, effectue une analyse dynamique et fournit également une saisie semi-automatique intelligente pour le code qui interagit avec le DOM.

Clematis est un cadre qui aide à démêler les interactions d'événements complexes. Clematis capture en détail tous les événements qui se déclenchent lors de l'exécution et les visualise comme un modèle comportemental abstrait qui reflète les relations temporelles et de cause à effet entre les composants et les événements.

conclusions

Ainsi, garder une trace de ce qui se passe lorsque les scripts JS sont exécutés peut être difficile, mais armé des bons outils, vous pouvez trouver et réécrire les zones problématiques même dans le code le plus déroutant. Cependant, JavaScript ne s'arrête pas là : de nouvelles et nouvelles fonctionnalités y apparaissent, maintenant il est souvent utilisé pour écrire des applications (aussi bien mobiles que desktop), et on le retrouve aussi de plus en plus sur les serveurs (et pas seulement) grâce à Node.js. Et cela signifie que l'art d'attraper les bogues doit être porté à un nouveau niveau.