Evaluating Cryptographic API Misuse Detectors for Go
Cet article présente la première étude complète des mauvaises utilisations des API cryptographiques en Go en établissant une taxonomie de 14 classes de mauvaises utilisations, en évaluant quatre outils de détection sur 328 projets et en identifiant 7 473 vulnérabilités afin de mettre en évidence des lacunes significatives dans la couverture de détection actuelle.
Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète
Imaginez que vous construisez une forteresse. Vous possédez les meilleurs et les plus sûrs verrous au monde (les API cryptographiques) pour protéger votre trésor. Mais si vous installez le verrou à l'envers, utilisez une clé fragile ou oubliez de verrouiller la porte, votre forteresse est tout aussi vulnérable que si vous n'aviez aucun verrou. C'est ce qui se produit lorsque les développeurs « abusent » des outils cryptographiques : ils pensent être en sécurité parce qu'ils ont utilisé la bonne technologie, mais ils ont commis une erreur dans la manière dont ils l'ont utilisée.
Ce document est comparable à une inspection de contrôle qualité pour un type spécifique de matériau de construction : le langage de programmation Go. Go est le langage utilisé pour construire certaines des infrastructures les plus critiques d'Internet (comme les systèmes qui gèrent le trafic Internet ou sécurisent les centres de données). Alors que des experts étudient ces « erreurs d'installation de verrous » dans d'autres langages (comme Java) depuis des années, personne n'avait vraiment inspecté les chantiers de construction Go jusqu'à présent.
Voici ce que les chercheurs ont fait, expliqué simplement :
1. Les Inspecteurs (Les Outils)
Les chercheurs ont réuni quatre « inspecteurs de sécurité » différents (des outils logiciels) pour analyser le code Go à la recherche de ces erreurs :
- CodeQL : Un inspecteur puissant, de style académique, qui examine comment les données circulent dans le code.
- Gopher : Un outil spécialisé conçu uniquement pour Go, connu pour être très agressif dans la détection des problèmes potentiels.
- Gosec : Un outil populaire, développé par la communauté, qui vérifie les erreurs de sécurité courantes.
- Snyk Code : Un outil commercial qui utilise l'intelligence artificielle et l'analyse statique pour détecter les bogues.
2. Le Plan (La Taxonomie)
Avant de commencer l'analyse, les chercheurs ont créé une liste de contrôle principale de 14 façons différentes dont un développeur peut faire des erreurs en cryptographie. Considérez cela comme une liste d'erreurs courantes, telles que :
- Utiliser un verrou trop ancien et faible (Algorithmes non sécurisés).
- Utiliser une clé trop courte ou facile à deviner (Longueur de clé insuffisante).
- Oublier de vérifier si la personne à la porte est bien celle qu'elle prétend être (Absence de validation de la clé hôte).
- Utiliser un motif prévisible pour le mécanisme du verrou (Vecteurs d'initialisation prévisibles).
3. L'Inspection (L'Expérience)
Ils ont pris 328 projets Go réels et populaires (comme le logiciel qui exécute Kubernetes ou Terraform) et ont fait fonctionner les quatre inspecteurs sur chacun d'eux.
- Le Résultat : Les inspecteurs ont détecté un total de 7 473 erreurs.
- La Surprise : Les inspecteurs n'étaient pas du tout d'accord entre eux.
- Gosec était le plus actif, détectant le plus d'erreurs, mais il signalait également de nombreuses choses qui n'étaient pas réellement dangereuses (comme trouver un « verrou faible » dans un fichier de code exemple que personne n'utiliserait jamais dans la vie réelle).
- Gopher a détecté un ensemble unique d'erreurs que les autres avaient manquées, mais il se bloquait parfois ou échouait à s'exécuter sur certains projets.
- Snyk Code était très rapide et précis, détectant moins d'erreurs mais étant très certain de celles qu'il trouvait.
- CodeQL était le plus lent (il faut beaucoup de temps pour configurer sa « base de données » du code) mais a détecté certaines erreurs très spécifiques et complexes que les autres avaient manquées.
4. Le Verdict
La conclusion principale est qu'aucun inspecteur unique n'est parfait.
- Si vous n'utilisez qu'un seul outil, vous risquez de manquer un énorme trou dans votre mur parce que cet outil ne savait pas comment le chercher.
- Si vous les utilisez tous, vous obtenez beaucoup de « fausses alertes » (avertissements concernant des choses qui ne sont pas réellement défectueuses), ce qui peut être accablant.
Les chercheurs ont constaté que les outils étaient souvent en désaccord sur le fait qu'un morceau de code spécifique constituait réellement une erreur. Par exemple, un outil pourrait dire : « Cette clé est trop courte ! » tandis qu'un autre dirait : « Ce n'est pas grave. »
La Conclusion
Cette étude est la première fois que quelqu'un vérifie systématiquement dans quelle mesure nous pouvons détecter ces erreurs de sécurité spécifiques dans le code Go. Ils ont découvert que, bien que nous disposions d'outils pour aider, ils sont actuellement comme un groupe d'inspecteurs qui parlent des langues différentes et ont des définitions différentes de ce à quoi ressemble un « verrou cassé ».
Pour maintenir la sécurité des systèmes basés sur Go, les ingénieurs en sécurité ne devraient pas se fier à un seul outil. Au lieu de cela, ils devraient utiliser une combinaison de ces outils (un « ensemble ») pour couvrir le plus large éventail d'erreurs, tout en comprenant qu'ils devront examiner manuellement les résultats pour distinguer les dangers réels des fausses alertes.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.