Comment vérifier la sécurité du code source?
Comment vérifier si le code source d'un projet open source ne contient aucun contenu malveillant? Par exemple, dans un ensemble de fichiers de code source avec au total 30 000 lignes, il peut y avoir 1 à 2 lignes contenant une instruction malveillante (par exemple, en appelant curl http://... | bash).
Ces projets ne sont pas bien connus et on ne peut pas supposer qu'ils sont bien entretenus. Par conséquent, la sécurité de la réutilisation du code source de leur projet ne peut pas simplement reposer sur une confiance aveugle (alors qu'il devrait être raisonnable de supposer qu'il serait sûr de télécharger, vérifier, compiler et exécuter cmake directement, cela ne sonne pas bon d'utiliser aveuglément une bibliothèque arbitraire hébergée sur GitHub).
Quelqu'un m'a suggéré de filtrer le code source et de supprimer tous les caractères non ASCII et invisibles (à l'exception de quelques caractères triviaux comme les sauts de ligne). Ouvrez ensuite chaque fichier avec un éditeur de texte et lisez manuellement chaque ligne. Cela prend un peu de temps, nécessite une attention particulière lorsque je lis le code et est en fait assez sujet aux erreurs.
En tant que tel, je recherche des méthodes générales pour gérer ce genre de situations. Par exemple, existe-t-il des outils standard disponibles? A quoi dois-je faire attention si je dois vraiment lire manuellement?
Il existe des approches automatisées et manuelles.
Pour automatisé, vous pouvez commencer avec lgtm - un analyseur de code statique gratuit pour les projets open source, puis passer à des solutions SAST plus complexes.
Pour le manuel - vous pouvez créer un modèle de menace de votre application et l'exécuter via la liste de contrôle OWASP ASVS à partir de ses parties les plus critiques. S'il y a suppression de fichiers dans votre modèle de menace, appelez simplement quelque chose comme ceci: grep -ir 'os.remove('.
Bien sûr, il est préférable de les combiner.
Vous le faites vous-même ou faites confiance à quelqu'un d'autre
Comme pour la plupart des choses de la vie, vous devez le faire vous-même ou faire confiance à quelqu'un d'autre. Ici faire confiance couvre à la fois l'absence d'intention malveillante et la compétence suffisante pour effectuer correctement la tâche.
Par exemple, vous pouvez déposer vos impôts vous-même ou faire confiance un conseiller fiscal pour le faire (qui non seulement ne devrait pas tenter de vous frauder, mais aussi savoir comment pour déposer les taxes!).
Si vous êtes une entreprise, le faire par lui-même sera en fait exécuté par un ou plusieurs de vos employés, qui à leur tour doivent faire confiance.
Le tiers en qui vous avez confiance n'a pas non plus besoin d'être une seule personne. Il peut s'agir de Équipe de développement Microsoft Windows, ou Développeurs principaux de Wordpress.
En ce qui concerne la sécurité du code source, vous voulez que l'expert soit non seulement bien intentionné, mais également compétent pour coder le programme de manière sécurisée/trouver tout problème de sécurité potentiel qui pourrait y être.
(ainsi que quelques systèmes de frontières supplémentaires lorsqu'ils sont traités dans leur ensemble, par exemple, vous voulez que leur code ne soit pas compromis pendant qu'il l'a téléchargé dans le référentiel, ou l'e-mail de votre employé indiquant les résultats étant remplacé par un pirate malveillant à l'intérieur de votre réseau dire que la demande était bonne)
Vous devrez évaluer vos options, évaluer le risque associé à chacune d'elles et choisir la voie qui correspond le mieux à vos intérêts (et à votre budget!).
Si je devais vérifier la sécurité du code source d'un blog qui utilisait Wordpress, je voudrais généralement faire confiance que le code d'origine était bien1¹ et vérifier les différences entre la version officielle et la version utilisée. Si le site Web était compromis, cela le rendrait beaucoup plus facile à découvrir.
¹ Vérification évidente du journal des modifications des versions ultérieures s'il en utilise un obsolète.
Cependant, s'il a été développé par le neveu du propriétaire, je m'attendrais à y trouver de nombreuses vulnérabilités et je recommanderais une vérification approfondie de tout.
Dans votre cas, vous devez évaluer le risque et le coût de développement de l'équivalent de cette bibliothèque (prenez en compte que le risque de problèmes dans votre produit interne n'est pas non plus nul, et cela dépendra - entre autres choses - de la qualité de les personnes impliquées) par rapport au risque et au coût de l'audit et de l'utilisation de cette bibliothèque.
Maintenant, il peut y avoir des facteurs atténuants qui simplifient l'audit. Par exemple, si le code non approuvé peut s'exécuter sur une machine virtuelle isolée, cela peut suffire pour ne pas nécessiter d'audits supplémentaires (même ici, vous faites confiance à l'implémentation VM). Ou il peut être envisagé suffisant pour auditer les parties de ce programme qui s'exécutent en tant que root.
Pour auditer une bibliothèque, les analyseurs de code peuvent aider à signaler les parties problématiques (comme indiqué), mais afin de la considérer comme propre, je demanderais à quelqu'un de lire et de comprendre le code, même si superficiellement.
Par exemple, la possibilité de supprimer des fichiers arbitraires n'est pas malveillante en soi. Vous devez comprendre le programme afin de savoir s'il a du sens.
Encore une fois, c'est une question de menaces et de risques pour ce que vous faites. Si vous ne vous préoccupez que de l'exfiltration des données de la bibliothèque, le filtrage des connexions au niveau du pare-feu pourrait suffire. Si vous souhaitez que la bibliothèque supprime des fichiers importants (et pour une raison étrange, vous ne pouvez pas refuser une telle autorisation), vous pouvez simplement faire défiler un tas de code qui ne fait que des calculs mathématiques. Si cette bibliothèque calcule les paramètres de lancement d'une fusée ... eh bien, vous feriez mieux de vous assurer que ces calculs sont également corrects!
Utilisez un service
Il existe des services professionnels tels que Black Duck et Whitesource qui auditent les dépendances open-source.
Si vous utilisez du code obsolète, vous êtes plus ou moins à la merci des mécanismes d'intégrité fournis par les responsables - c'est vrai pour tous les logiciels, pas seulement pour l'open source.
Pour les logiciels open source commerciaux et packagés (c'est-à-dire rpm, deb, etc.), la signature de code est courante - cela prouve que vous avez reçu ce que le signataire voulait que vous receviez.
Dans le cas du code source, des sommes de contrôle sont généralement utilisées. Mais cela a peu de valeur à moins que la somme de contrôle soit accessible à partir d'une source différente du code source.
Notez que ceux-ci sont uniquement destinés à protéger contre une attaque de type MITM sur l'application.
utiliser une bibliothèque arbitraire hébergée sur GitHub
... auquel cas tous les fichiers/versions ont un hachage publié sur Github - afin de renverser cela, un attaquant devrait subvertir Github lui-même ou le compte Github du responsable - je peux tout fourcher sur Github mais il est ensuite attribué à moi et le référentiel d'origine n'est pas affecté, sauf si le responsable accepte mes demandes d'extraction. Vous pouvez avoir plus confiance en l'intégrité de Github que les responsables du code, auquel cas il serait raisonnable de faire confiance à un hachage publié au même endroit que le code source.
Aucun de ces mécanismes n'offre une protection contre les logiciels malveillants qui ont été injectés avant l'application de la vérification d'intégrité.
Lorsque vous avez accès au code source, vous avez alors la possibilité d'examiner le code (ce qui est beaucoup plus facile que d'examiner les exécutables) et il existe des outils automatisés pour le faire, comme ceux suggérés par odo.
Les analyseurs statiques ne fonctionnent pas toujours
La vérification de os.remove N'importe où dans le code ne fonctionnera pas sur tous les attaquants, car certains peuvent simplement faire eval("os" + ".remove"). Des expressions rationnelles encore plus avancées peuvent être créées, mais l'attaquant peut toujours rendre son code plus compliqué, par exemple:
x = "r"
eval("os." + x + "emove")
Plus théoriquement, en raison du problème d'arrêt, il est impossible de vérifier tous les états potentiels pour voir si un appel système dangereux est appelé.
Un attaquant peut éviter les analyseurs de code statiques assez facilement en construisant un petit interpréteur pour un langage personnalisé qui effectue les opérations malveillantes.
Exécuter le code dans un conteneur/pot de miel
Tous les logiciels interagissent finalement avec le système d'exploitation. En exécutant le logiciel dans un conteneur ou un pot de miel avec strace ou un outil similaire, vous pouvez voir les informations que le programme ou la bibliothèque tente de recueillir.
Le programme essaie-t-il de déterminer s'il s'exécute à l'intérieur d'un conteneur? Lit-t-il des fichiers qu'il n'est pas censé ou même les modifie? Ensuite, vous pouvez avoir un logiciel malveillant.
Cela ne fonctionnera pas toujours, une inspection manuelle peut être nécessaire
Certains codes malveillants ne se déclenchent qu'à des dates spécifiques, mais au moins vous verrez que cela est accessible. De là, vous pouvez vérifier où cela se produit dans le code et pourquoi.