Les coroutines en C++ représentent une avancée significative dans la programmation, facilitant la gestion asynchrone et la manipulation efficace des fonctions. Cependant, cette fonctionnalité récente, bien que de plus en plus adoptée dans des projets sur des plateformes populaires, n’est pas à l’abri des vulnérabilités. Une étude récente a révélé que ces coroutines sont sujettes à des attaques de réutilisation de code, connues sous le nom de CFOP, qui exploitent des failles dans l’implémentation des trois principaux compilateurs. Même en présence de mesures d’intégrité du flux de contrôle (CFI), les protections existantes s’avèrent insuffisantes, ouvrant la voie à des manipulations malveillantes des applications utilisant cette fonctionnalité.
Les coroutines en C++ sont devenues un élément populaire de la programmation, facilitant la pause et la reprise des fonctions, ce qui est particulièrement utile dans des contextes tels que les serveurs et le développement asynchrone. Cependant, une nouvelle recherche a révélé que ces coroutines sont vulnérables à des attaques de réutilisation de code, connues sous le nom de coroutine frame-oriented programming (CFOP), et ce même en présence de dispositifs de protection avancés tels que l’intégrité du flux de contrôle (CFI). Cet article explorera les implications de cette découverte et les mécanismes par lesquels ces vulnérabilités peuvent être exploitées.
Vulnérabilités des coroutines C++
Le CFOP est une technique d’attaque qui exploite les fonctions existantes au sein des applications, permettant aux attaquants d’exécuter du code arbitraire sans injecter de nouveaux codes. Cette méthode se distingue des attaques traditionnelles en ciblant spécifiquement les structures de mémoire interne des coroutines en C++. Les chercheurs de CISPA ont démontré que les mises en œuvre actuelles de coroutines en C++, utilisées dans des compilateurs majeurs tels que Clang/LLVM, GCC et MSVC, sont toutes vulnérables à cette forme d’attaque.
Mécanisme de l’attaque CFOP
Lorsqu’un attaquant exploite le CFOP, il s’agit de la réutilisation de fonctions entières, ce qui complexifie la gestion de la protection par CFI. Les coroutines, qui servent à créer des générateurs ou à pauser des processus, peuvent être manipulées pour interférer avec le comportement prévu d’une application. En se servant des fonctions existantes dans le programme, un attaquant parvient à altérer le flux d’exécution sans nécessiter de nouvelles injections de code.
Rendement des dispositifs de protection CFI
Bien que les dispositifs CFI soient conçus pour empêcher ce type d’attaques en garantissant que le flux d’exécution se déroule comme prévu, il a été démontré que seuls 7 des 15 schémas CFI examinés étaient compatibles avec les coroutines. Parmi ces sept, seuls deux ont offert une protection partielle. Cela signifie que les dispositifs CFI sont souvent incapables de gérer les paradigmes de programmation qui évoluent avec le temps, ce qui rend les coroutines particulièrement sensibles aux attaques.
Problème structurel des coroutines
Les structures de mémoire des coroutines en C++ ont été identifiées comme un point faible essentiel. La popularité croissante des coroutines, introduites dans le langage en 2020, accentue le risque associé à cette vulnérabilité. Les chercheurs ont constaté que la mise en œuvre structurelle des coroutines dans les compilateurs actuels les rendait vulnérables et qu’une correction ne se résume pas à un simple patch du code, mais nécessitera une réévaluation approfondie de leur fonctionnement interne.
Alternatives proposées et chemin vers une sécurité renforcée
Les chercheurs de CISPA ont développé des alternatives d’implémentation pour les coroutines qui visent à atténuer ces préoccupations de sécurité. Ces solutions ont été rapportées aux principaux développements des compilateurs dans le but d’améliorer la sécurité des applications utilisant les coroutines en C++. Cependant, ces ajustements nécessitent une compréhension approfondie des structures internes de l’application, rendant leur mise en œuvre plus complexe.
Conclusion ouverte
Les coroutines en C++ offrent des avantages considérables pour la programmation moderne, mais leur vulnérabilité à des attaques de réutilisation de code comme le CFOP souligne l’importance d’une refonte des mécanismes de protection existants. Avec le paysage en constante évolution de la programmation, la lutte contre ces vulnérabilités nécessite une vigilance continue et une innovation constante dans les stratégies de sécurité.
EN BREF
|
