A Quantitative Flavour of Robust Reachability

Many software analysis techniques attempt to determine whether bugs are reachable, but for security purpose this is only part of the story as it does not indicate whether the bugs found could be easily triggered by an attacker. The recently introduced notion of robust reachability aims at filling this gap by distinguishing the input controlled by the attacker from those that are not. Yet, this qualitative notion may be too strong in practice, leaving apart bugs which are mostly but not fully replicable. We aim here at proposing a quantitative version of robust reachability, more flexible and still amenable to automation. We propose quantitative robustness, a metric expressing how easily an attacker can trigger a bug while taking into account that he can only influence part of the program input, together with a dedicated quantitative symbolic execution technique (QRSE). Interestingly, QRSE relies on a variant of model counting (namely, functional E-MAJSAT) unseen so far in formal verification, but which has been studied in AI domains such as Bayesian network, knowledge representation and probabilistic planning. Yet, the existing solving methods from these fields turn out to be unsatisfactory for formal verification purpose, leading us to propose a novel parametric method. These results have been implemented and evaluated over two security-relevant case studies, allowing to demonstrate the feasibility and relevance of our ideas

Atteignabilité robuste et comptage de modèles pour la sécurité logicielle

Modern bug-finding techniques have become effective enough that the bottleneck is not finding bugs but finding the time to fix them. A popular way to address this problem is to focus first on bugs with a security impact, also known as vulnerabilities. This leads to the question of vulnerability assessment: could an attacker take advantage of a bug? In this thesis we attempt to assess one particular dimension contributing to the security impact of a bug: whether an attacker could trigger it reliably. We call this property replicability. Our goal is to formalize replicability to design bug-finding techniques which only report bugs which are replicable enough. We do so by considering a threat model where inputs to the program which the attacker can choose (like network inputs) are distinguished from inputs which the attacker does not control nor know (like entropy sources). We propose two approaches to replicability. Firstly, we define robust reachability, a qualitative property that expresses that a bug is not only reachable, but that when he chooses the right inputs, the attacker triggers the bug whatever the values of the program inputs he does not control. Secondly, we refine robust reachability quantitatively as the proportion of uncontrolled inputs that let the optimal attacker trigger the bug. We adapt symbolic execution to prove robust reachability and compute this proportion. Robust reachability is more coarse-grained because it is all-or-nothing but scales better than the quantitative approach. We illustrate in case studies the potential applications of these techniques, notably in terms of vulnerability assessment.Les techniques modernes de recherche de bugs sont devenues si efficaces que le problème n'est plus de trouver des bugs mais de trouver le temps de les corriger. Une façon répandue d'éluder ce problème est de concentrer l'effort de correction de bug prioritairement sur les bugs ayant un impact en termes de sécurité, aussi désignés sous le nom de vulnérabilités. Cela conduit naturellement à la question de l'évaluation de cet impact: un attaquant pourrait-il tirer parti de tel ou tel bug ? Cette thèse se concentre sur une dimension particulière de ce problème: un attaquant serait-il capable de déclencher ce bug ? Nous appelons cette propriété la réplicabilité. Nous nous fixons pour objectif de concevoir des méthodes de recherches de bugs qui ne détectent que des bugs suffisamment réplicables. Le point de départ est de considérer des modèles de menace où l'on distingue les entrées du programme qui peuvent être choisies par l'attaquant (comme les entrées réseau) de celle qui ne peuvent ni être contrôlées ni connues de lui (comme les sources d'entropie). Nous proposons deux approches pour évaluer la réplicabilité. D'abord, nous définissons l'atteignabilité robuste, une propriété qualitative qui exprime qu'un bug est non seulement atteignable mais que lorsqu'il choisit les entrées qu'il peut correctement, l'attaquant déclenche toujours le bug, indépendamment des valeurs des entrées qu'il ne peut pas choisir. Dans un second temps, nous affinons cette approche en une approche quantitative où nous déterminons la proportion d'entrées non contrôlées qui permettent à l'attaquant optimal de déclencher le bug. Nous adaptons ensuite l'exécution symbolique pour prouver l'atteignabilité robuste ou bien calculer cette proportion. L'atteignabilité robuste est une analyse moins fine que cette approche quantitative parce qu'elle est "tout ou rien", mais en contrepartie elle passe mieux à l'échelle. Enfin nous illustrons dans des études de cas les applications potentielles de ces concepts, en particulier à l'évaluation de vulnérabilité

Atteignabilité robuste et comptage de modèles pour la sécurité logicielle

Modern bug-finding techniques have become effective enough that the bottleneck is not finding bugs but finding the time to fix them. A popular way to address this problem is to focus first on bugs with a security impact, also known as vulnerabilities. This leads to the question of vulnerability assessment: could an attacker take advantage of a bug? In this thesis we attempt to assess one particular dimension contributing to the security impact of a bug: whether an attacker could trigger it reliably. We call this property replicability. Our goal is to formalize replicability to design bug-finding techniques which only report bugs which are replicable enough. We do so by considering a threat model where inputs to the program which the attacker can choose (like network inputs) are distinguished from inputs which the attacker does not control nor know (like entropy sources). We propose two approaches to replicability. Firstly, we define robust reachability, a qualitative property that expresses that a bug is not only reachable, but that when he chooses the right inputs, the attacker triggers the bug whatever the values of the program inputs he does not control. Secondly, we refine robust reachability quantitatively as the proportion of uncontrolled inputs that let the optimal attacker trigger the bug. We adapt symbolic execution to prove robust reachability and compute this proportion. Robust reachability is more coarse-grained because it is all-or-nothing but scales better than the quantitative approach. We illustrate in case studies the potential applications of these techniques, notably in terms of vulnerability assessment.Les techniques modernes de recherche de bugs sont devenues si efficaces que le problème n'est plus de trouver des bugs mais de trouver le temps de les corriger. Une façon répandue d'éluder ce problème est de concentrer l'effort de correction de bug prioritairement sur les bugs ayant un impact en termes de sécurité, aussi désignés sous le nom de vulnérabilités. Cela conduit naturellement à la question de l'évaluation de cet impact: un attaquant pourrait-il tirer parti de tel ou tel bug ? Cette thèse se concentre sur une dimension particulière de ce problème: un attaquant serait-il capable de déclencher ce bug ? Nous appelons cette propriété la réplicabilité. Nous nous fixons pour objectif de concevoir des méthodes de recherches de bugs qui ne détectent que des bugs suffisamment réplicables. Le point de départ est de considérer des modèles de menace où l'on distingue les entrées du programme qui peuvent être choisies par l'attaquant (comme les entrées réseau) de celle qui ne peuvent ni être contrôlées ni connues de lui (comme les sources d'entropie). Nous proposons deux approches pour évaluer la réplicabilité. D'abord, nous définissons l'atteignabilité robuste, une propriété qualitative qui exprime qu'un bug est non seulement atteignable mais que lorsqu'il choisit les entrées qu'il peut correctement, l'attaquant déclenche toujours le bug, indépendamment des valeurs des entrées qu'il ne peut pas choisir. Dans un second temps, nous affinons cette approche en une approche quantitative où nous déterminons la proportion d'entrées non contrôlées qui permettent à l'attaquant optimal de déclencher le bug. Nous adaptons ensuite l'exécution symbolique pour prouver l'atteignabilité robuste ou bien calculer cette proportion. L'atteignabilité robuste est une analyse moins fine que cette approche quantitative parce qu'elle est "tout ou rien", mais en contrepartie elle passe mieux à l'échelle. Enfin nous illustrons dans des études de cas les applications potentielles de ces concepts, en particulier à l'évaluation de vulnérabilité

Atteignabilité robuste et comptage de modèles pour la sécurité logicielle

Les techniques modernes de recherche de bugs sont devenues si efficaces que le problème n'est plus de trouver des bugs mais de trouver le temps de les corriger. Une façon répandue d'éluder ce problème est de concentrer l'effort de correction de bug prioritairement sur les bugs ayant un impact en termes de sécurité, aussi désignés sous le nom de vulnérabilités. Cela conduit naturellement à la question de l'évaluation de cet impact: un attaquant pourrait-il tirer parti de tel ou tel bug ? Cette thèse se concentre sur une dimension particulière de ce problème: un attaquant serait-il capable de déclencher ce bug ? Nous appelons cette propriété la réplicabilité. Nous nous fixons pour objectif de concevoir des méthodes de recherches de bugs qui ne détectent que des bugs suffisamment réplicables. Le point de départ est de considérer des modèles de menace où l'on distingue les entrées du programme qui peuvent être choisies par l'attaquant (comme les entrées réseau) de celle qui ne peuvent ni être contrôlées ni connues de lui (comme les sources d'entropie). Nous proposons deux approches pour évaluer la réplicabilité. D'abord, nous définissons l'atteignabilité robuste, une propriété qualitative qui exprime qu'un bug est non seulement atteignable mais que lorsqu'il choisit les entrées qu'il peut correctement, l'attaquant déclenche toujours le bug, indépendamment des valeurs des entrées qu'il ne peut pas choisir. Dans un second temps, nous affinons cette approche en une approche quantitative où nous déterminons la proportion d'entrées non contrôlées qui permettent à l'attaquant optimal de déclencher le bug. Nous adaptons ensuite l'exécution symbolique pour prouver l'atteignabilité robuste ou bien calculer cette proportion. L'atteignabilité robuste est une analyse moins fine que cette approche quantitative parce qu'elle est "tout ou rien", mais en contrepartie elle passe mieux à l'échelle. Enfin nous illustrons dans des études de cas les applications potentielles de ces concepts, en particulier à l'évaluation de vulnérabilité.Modern bug-finding techniques have become effective enough that the bottleneck is not finding bugs but finding the time to fix them. A popular way to address this problem is to focus first on bugs with a security impact, also known as vulnerabilities. This leads to the question of vulnerability assessment: could an attacker take advantage of a bug? In this thesis we attempt to assess one particular dimension contributing to the security impact of a bug: whether an attacker could trigger it reliably. We call this property replicability. Our goal is to formalize replicability to design bug-finding techniques which only report bugs which are replicable enough. We do so by considering a threat model where inputs to the program which the attacker can choose (like network inputs) are distinguished from inputs which the attacker does not control nor know (like entropy sources). We propose two approaches to replicability. Firstly, we define robust reachability, a qualitative property that expresses that a bug is not only reachable, but that when he chooses the right inputs, the attacker triggers the bug whatever the values of the program inputs he does not control. Secondly, we refine robust reachability quantitatively as the proportion of uncontrolled inputs that let the optimal attacker trigger the bug. We adapt symbolic execution to prove robust reachability and compute this proportion. Robust reachability is more coarse-grained because it is all-or-nothing but scales better than the quantitative approach. We illustrate in case studies the potential applications of these techniques, notably in terms of vulnerability assessment

Atteignabilité robuste et comptage de modèles pour la sécurité logicielle

Modern bug-finding techniques have become effective enough that the bottleneck is not finding bugs but finding the time to fix them. A popular way to address this problem is to focus first on bugs with a security impact, also known as vulnerabilities. This leads to the question of vulnerability assessment: could an attacker take advantage of a bug? In this thesis we attempt to assess one particular dimension contributing to the security impact of a bug: whether an attacker could trigger it reliably. We call this property replicability. Our goal is to formalize replicability to design bug-finding techniques which only report bugs which are replicable enough. We do so by considering a threat model where inputs to the program which the attacker can choose (like network inputs) are distinguished from inputs which the attacker does not control nor know (like entropy sources). We propose two approaches to replicability. Firstly, we define robust reachability, a qualitative property that expresses that a bug is not only reachable, but that when he chooses the right inputs, the attacker triggers the bug whatever the values of the program inputs he does not control. Secondly, we refine robust reachability quantitatively as the proportion of uncontrolled inputs that let the optimal attacker trigger the bug. We adapt symbolic execution to prove robust reachability and compute this proportion. Robust reachability is more coarse-grained because it is all-or-nothing but scales better than the quantitative approach. We illustrate in case studies the potential applications of these techniques, notably in terms of vulnerability assessment.Les techniques modernes de recherche de bugs sont devenues si efficaces que le problème n'est plus de trouver des bugs mais de trouver le temps de les corriger. Une façon répandue d'éluder ce problème est de concentrer l'effort de correction de bug prioritairement sur les bugs ayant un impact en termes de sécurité, aussi désignés sous le nom de vulnérabilités. Cela conduit naturellement à la question de l'évaluation de cet impact: un attaquant pourrait-il tirer parti de tel ou tel bug ? Cette thèse se concentre sur une dimension particulière de ce problème: un attaquant serait-il capable de déclencher ce bug ? Nous appelons cette propriété la réplicabilité. Nous nous fixons pour objectif de concevoir des méthodes de recherches de bugs qui ne détectent que des bugs suffisamment réplicables. Le point de départ est de considérer des modèles de menace où l'on distingue les entrées du programme qui peuvent être choisies par l'attaquant (comme les entrées réseau) de celle qui ne peuvent ni être contrôlées ni connues de lui (comme les sources d'entropie). Nous proposons deux approches pour évaluer la réplicabilité. D'abord, nous définissons l'atteignabilité robuste, une propriété qualitative qui exprime qu'un bug est non seulement atteignable mais que lorsqu'il choisit les entrées qu'il peut correctement, l'attaquant déclenche toujours le bug, indépendamment des valeurs des entrées qu'il ne peut pas choisir. Dans un second temps, nous affinons cette approche en une approche quantitative où nous déterminons la proportion d'entrées non contrôlées qui permettent à l'attaquant optimal de déclencher le bug. Nous adaptons ensuite l'exécution symbolique pour prouver l'atteignabilité robuste ou bien calculer cette proportion. L'atteignabilité robuste est une analyse moins fine que cette approche quantitative parce qu'elle est "tout ou rien", mais en contrepartie elle passe mieux à l'échelle. Enfin nous illustrons dans des études de cas les applications potentielles de ces concepts, en particulier à l'évaluation de vulnérabilité

Atteignabilité robuste et comptage de modèles pour la sécurité logicielle

Modern bug-finding techniques have become effective enough that the bottleneck is not finding bugs but finding the time to fix them. A popular way to address this problem is to focus first on bugs with a security impact, also known as vulnerabilities. This leads to the question of vulnerability assessment: could an attacker take advantage of a bug? In this thesis we attempt to assess one particular dimension contributing to the security impact of a bug: whether an attacker could trigger it reliably. We call this property replicability. Our goal is to formalize replicability to design bug-finding techniques which only report bugs which are replicable enough. We do so by considering a threat model where inputs to the program which the attacker can choose (like network inputs) are distinguished from inputs which the attacker does not control nor know (like entropy sources). We propose two approaches to replicability. Firstly, we define robust reachability, a qualitative property that expresses that a bug is not only reachable, but that when he chooses the right inputs, the attacker triggers the bug whatever the values of the program inputs he does not control. Secondly, we refine robust reachability quantitatively as the proportion of uncontrolled inputs that let the optimal attacker trigger the bug. We adapt symbolic execution to prove robust reachability and compute this proportion. Robust reachability is more coarse-grained because it is all-or-nothing but scales better than the quantitative approach. We illustrate in case studies the potential applications of these techniques, notably in terms of vulnerability assessment.Les techniques modernes de recherche de bugs sont devenues si efficaces que le problème n'est plus de trouver des bugs mais de trouver le temps de les corriger. Une façon répandue d'éluder ce problème est de concentrer l'effort de correction de bug prioritairement sur les bugs ayant un impact en termes de sécurité, aussi désignés sous le nom de vulnérabilités. Cela conduit naturellement à la question de l'évaluation de cet impact: un attaquant pourrait-il tirer parti de tel ou tel bug ? Cette thèse se concentre sur une dimension particulière de ce problème: un attaquant serait-il capable de déclencher ce bug ? Nous appelons cette propriété la réplicabilité. Nous nous fixons pour objectif de concevoir des méthodes de recherches de bugs qui ne détectent que des bugs suffisamment réplicables. Le point de départ est de considérer des modèles de menace où l'on distingue les entrées du programme qui peuvent être choisies par l'attaquant (comme les entrées réseau) de celle qui ne peuvent ni être contrôlées ni connues de lui (comme les sources d'entropie). Nous proposons deux approches pour évaluer la réplicabilité. D'abord, nous définissons l'atteignabilité robuste, une propriété qualitative qui exprime qu'un bug est non seulement atteignable mais que lorsqu'il choisit les entrées qu'il peut correctement, l'attaquant déclenche toujours le bug, indépendamment des valeurs des entrées qu'il ne peut pas choisir. Dans un second temps, nous affinons cette approche en une approche quantitative où nous déterminons la proportion d'entrées non contrôlées qui permettent à l'attaquant optimal de déclencher le bug. Nous adaptons ensuite l'exécution symbolique pour prouver l'atteignabilité robuste ou bien calculer cette proportion. L'atteignabilité robuste est une analyse moins fine que cette approche quantitative parce qu'elle est "tout ou rien", mais en contrepartie elle passe mieux à l'échelle. Enfin nous illustrons dans des études de cas les applications potentielles de ces concepts, en particulier à l'évaluation de vulnérabilité

Introducing robust reachability

International audienceWe introduce a new property called robust reachability which refines the standard notion of reachability in order to take replicability into account. A bug is robustly reachable if a controlled input can make it so the bug is reached whatever the value of uncontrolled input. Robust reachability is better suited than standard reachability in many realistic situations related to security (e.g., criticality assessment or bug prioritization) or software engineering (e.g., replicable test suites and flakiness). We propose a formal treatment of the concept, and we revisit existing symbolic bug finding methods through this new lens. Remarkably, robust reachability allows differentiating bounded model checking from symbolic execution while they have the same deductive power in the standard case. Finally, we propose the first symbolic verifier dedicated to robust reachability: we use it for criticality assessment of 5 existing vulnerabilities, and compare it with standard symbolic execution

Not all bugs are created equal, but robust reachability can tell the difference

CAV 2021: Computer Aided Verification - International Conference on Computer Aided Verification , July 2021, virtuel (USA)International audienceThis paper introduces a new property called robust reachability which refines the standard notion of reachability in order to take replicability into account. A bug is robustly reachable if a controlled input can make it so the bug is reached whatever the value of uncontrolled input. Robust reachability is better suited than standard reachability in many realistic situations related to security (e.g., criticality assessment or bug prioritization) or software engineering (e.g., replicable test suites and flakiness). We propose a formal treatment of the concept, and we revisit existing symbolic bug finding methods through this new lens. Remarkably, robust reachability allows differentiating bounded model checking from symbolic execution while they have the same deductive power in the standard case. Finally, we propose the first symbolic verifier dedicated to robust reachability: we use it for criticality assessment of 4 existingvulnerabilities, and compare it with standard symbolic execution