Le nouvel outil PilaiPidi détecte les vulnérabilités de débordement de tampon

Beaucoup d'applis aujourd'hui utilisent plus d'un langage de programmation. C’est souvent pour profiter des points forts de chaque langage, comme une meilleure performance ou l'accès à des bibliothèques spécifiques. Mais quand différentes langues sont combinées, ça peut rendre la recherche de bugs plus compliquée. Un problème courant qui peut survenir est le débordement de tampon, qui est une erreur qui se produit quand un programme écrit plus de données dans un tampon (une section de la mémoire) que ce qu’il peut contenir. Ça peut provoquer des plantages ou même des problèmes de sécurité.

Dans cet article, on va parler d'un nouvel outil appelé PilaiPidi. Cet outil aide les développeurs à trouver des Vulnérabilités d débordement de tampon dans des applis qui utilisent à la fois Java et C/C++. Notre approche pour résoudre ce problème est différente des méthodes existantes, car elle se concentre sur l'analyse du code source plutôt que sur le code binaire.

#Contexte

#Débordement de tampon

Un tampon, c'est un espace désigné dans la mémoire pour stocker des données. Quand un programme écrit plus de données dans un tampon qu'il ne peut en contenir, ça peut causer un débordement de tampon. Ça peut mener à divers problèmes, y compris des plantages de programme ou un accès non autorisé aux ressources système.

Les Débordements de tampon sont courants dans des langages comme C et C++ parce que ces langages ne vérifient pas automatiquement si un tampon a assez d'espace avant d'écrire des données. C’est aux programmeurs de s’assurer que le tampon est bien manipulé. Malheureusement, les programmeurs peuvent mal calculer la taille ou gérer les données de façon incorrecte, entraînant des erreurs de débordement.

#Applications multi-langages

De nombreuses applis Android utilisent à la fois Java et C/C++. Java est souvent utilisé pour la logique principale de l'application, tandis que C/C++ est utilisé pour des tâches critiques en termes de performance ou pour utiliser des bibliothèques spécifiques. Ces deux langages interagissent grâce à un mécanisme appelé l'Interface Natif Java (JNI).

Utiliser plusieurs langages permet aux développeurs de créer des applications efficaces, mais ça pose aussi des défis. Des bugs peuvent survenir quand les données passent d'un langage à l'autre. Par exemple, si une méthode Java envoie des données à une fonction C/C++, ces données peuvent provoquer un débordement de tampon côté C/C++ si elles ne sont pas bien gérées.

#Défis actuels

Les outils existants pour détecter les bugs dans les applications multi-langages se concentrent souvent sur un seul langage ou ne suivent pas correctement le Flux de données entre les langages. Certaines méthodes peuvent chercher des bugs dans Java ou C/C++ séparément, mais elles ont du mal à identifier les problèmes qui surgissent lorsque les données passent les frontières des langages.

Dans des études précédentes, des chercheurs ont essayé diverses techniques pour analyser le flux de données dans des applications cross-langues, mais beaucoup ont des limites. Certaines méthodes se concentrent sur le code compilé (binaire), rendant difficile la recherche de débordements de tampon puisqu'elles ne prennent pas en compte les détails au niveau du code source.

#L'outil PilaiPidi

On a développé PilaiPidi pour répondre aux défis de la détection des vulnérabilités de débordement de tampon dans les applications Java et C/C++. Notre outil analyse le code source des applications pour suivre les flux de données entre ces deux langages.

#Vue d'ensemble de PilaiPidi

PilaiPidi fonctionne en convertissant le code source de Java et C/C++ en un format commun. Ce format nous permet d'analyser les flux de données à l'intérieur et à travers les deux langages. Voici les principales étapes de notre outil :

1. Générateur de représentation AST : Le code source est converti en un format d'Arbre de Syntaxe Abstraite (AST), qui préserve toutes les informations originales.

2. Chercheur de symboles : Cette phase identifie les types de variables, fonctions et classes utilisées dans le code, ce qui est nécessaire pour un bon contrôle des types.

3. Générateur de profils de tranches : Ce composant crée des profils de tranches pour chaque variable dans le code source, capturant des informations sur où chaque variable est définie et utilisée.

4. Générateur de flux de données : L'outil combine la représentation AST et les profils de tranches pour construire un graphe de flux de données qui identifie les potentielles sources et puits dans le code.

5. Chercheur de chemin Source-à-Puit : Cette phase trouve des chemins de la source des données (entrées utilisateur et appels de fonction) aux puits (accès aux tampons) qui peuvent mener à des débordements de tampon.

6. Analyseur d'accès au tampon : La dernière étape vérifie si des vérifications de limites appropriées sont en place le long des chemins de flux de données identifiés.

#Réalisations de PilaiPidi

Avec PilaiPidi, on a réussi à détecter 23 vulnérabilités de débordement de tampon dans six applis Android bien connues. Parmi celles-ci, les développeurs ont confirmé 11 vulnérabilités dans trois applis différentes.

#Détails techniques

#Représentation Arbre de Syntaxe Abstraite (AST)

La première étape de notre outil est de convertir le code source en format AST. L'AST fournit une représentation structurée du code qui conserve des informations importantes, comme les relations entre les différents composants (classes, méthodes et variables).

En utilisant un outil open-source appelé srcML, on a généré des représentations AST de code Java et C/C++. Cela nous a permis d'analyser le code sans perdre de contexte ni de détails critiques.

#Chercheur de symboles

La phase de recherche de symboles collecte des informations sur les types pour tous les éléments du code. Elle cherche les types de variables, fonctions et classes, et construit un modèle de la structure du code. Cette information est cruciale pour comprendre comment les flux de données peuvent mener à des vulnérabilités.

La sortie inclut une hiérarchie de symboles, chaque symbole contenant son nom, son type et d'éventuels symboles parents. Ces informations structurées sont nécessaires pour construire des profils de tranches par la suite.

#Générateur de profils de tranches

Dans cette phase, on analyse la représentation AST pour créer des profils de tranches pour chaque variable. Un profil de tranche inclut des informations sur où chaque variable est définie, où elle est utilisée, et les variables dépendantes. En capturant ces informations, on peut suivre le flux de données à travers le programme.

Chaque profil de tranche inclut aussi la taille ou la valeur de la variable, ce qui est essentiel pour identifier des débordements de tampon.

#Générateur de flux de données

Le générateur de flux de données combine la représentation AST et les profils de tranches pour construire un graphe de flux de données. Ce graphe identifie comment les données se déplacent à travers l'application, des sources (comme les entrées utilisateur) aux puits (comme les accès aux tampons).

Durant cette phase, on identifie les appels de fonction et s'assure qu'ils correspondent aux paramètres attendus, réduisant ainsi les chances de faux positifs dans nos résultats.

#Chercheur de chemin Source-à-Puit

Une fois qu'on a le graphe de flux de données, on se concentre sur la recherche de chemins potentiels de sources à puits. Le chercheur de chemin source-à-puit identifie où l'entrée de données peut mener à des accès de tampon, ce qui est critique pour détecter des vulnérabilités.

On utilise un modèle d'apprentissage automatique pour classifier les fonctions dans le SDK Android comme sources ou puits. Cette classification nous aide à identifier les points d'entrée potentiels pour des données malveillantes et où ces données pourraient être mal utilisées.

#Analyseur d'accès au tampon

Dans la phase finale, on vérifie si des vérifications de limites sont en place pour les chemins identifiés. C'est essentiel pour déterminer si une vulnérabilité de débordement de tampon existe. Si on trouve des chemins où un tampon est accédé sans vérifications de limites appropriées, on les signale comme des vulnérabilités potentielles.

#Évaluation en conditions réelles

Pour évaluer l'efficacité de PilaiPidi, on l'a appliqué à plusieurs applis Android bien connues. Notre outil a détecté 23 vulnérabilités potentielles de débordement de tampon, et on a confirmé 11 de ces cas avec l'aide de développeurs.

Quand on a comparé les résultats de PilaiPidi avec d'autres outils, on a découvert que les outils existants n'avaient pas pu détecter les mêmes vulnérabilités. Flawfinder et Cppcheck, qui se concentrent uniquement sur C/C++, ont rapporté de nombreux problèmes mais aucun des confirmés trouvés par PilaiPidi.

#Avantages d'utiliser PilaiPidi

#Détection précoce des vulnérabilités

En analysant le code source à un stade précoce, PilaiPidi permet aux développeurs d'identifier les vulnérabilités de débordement de tampon avant que l'application ne soit déployée. Ça peut économiser du temps et des ressources par rapport à la correction des bugs après déploiement.

#Analyse cross-langue

La capacité d'analyser les flux de données entre Java et C/C++ est un gros avantage de PilaiPidi. Beaucoup d'outils existants ne peuvent pas gérer les vulnérabilités cross-langues, laissant les développeurs à risquer de manquer des problèmes critiques.

#Prise de conscience contextuelle

PilaiPidi fournit des informations contextuelles sur comment les données circulent dans l'application. Cela signifie que les développeurs peuvent mieux comprendre les conditions qui mènent aux vulnérabilités, leur permettant d'écrire du code plus sûr.

#Travaux futurs

Bien que PilaiPidi soit un outil prometteur, il y a encore de la place pour améliorer. Les travaux futurs pourraient impliquer d'élargir les types de vulnérabilités que nous pouvons détecter et d'affiner l'analyse pour réduire davantage les faux positifs.

Aussi, on pourrait renforcer les capacités de l'outil pour effectuer des vérifications du côté Java de l'application, puisque beaucoup de l'actuel focus est sur le côté C/C++.

#Conclusion

En résumé, PilaiPidi est un outil innovant pour détecter les vulnérabilités de débordement de tampon dans des applications Android multi-langues. En analysant le code source, il fournit aux développeurs des informations précieuses sur les flux de données et les risques potentiels.

Avec son approche unique, PilaiPidi est un pas en avant pour améliorer la sécurité des applications qui utilisent plusieurs langages de programmation, assurant que les développeurs peuvent créer des logiciels plus sûrs et plus fiables.