Formally computer-verified protections against timing-based side-channel attacks
Protections vérifiées formellement par ordinateur contre les attaques par canaux auxiliaires basées sur le temps
Résumé
Developers of high-assurance software aim to design functionally correct software with properties like confidentiality. However, confidentiality is not a direct consequence of functional correctness, as there could be unintentional side-channel leaks like execution time that might help the attacker to retrieve secret data.For example, a string-comparison algorithm that compares two strings character by character and exits in case of a mismatch or returns success when strings are equal is a functionally correct algorithm to verify a password. However, an attacker can guess the password's length by measuring the execution time of the algorithm, which means the latter is not secure against timing attacks. More generally, branching on secrets may leak secret data as the two branches may have different execution times. Modern processors use branch prediction to maximize the performance of the program. For example, if the destination of a branch condition leads to a memory read, the processor bypasses the condition check and executes the memory read operation speculatively. In case of misprediction, the processor backtracks and starts the execution again with the correct condition's result. Though backtracking corrects the misspeculated results, it still leaves a trace in the cache, which the attacker can exploit to get to the secret data (illustrated in Spectre attacks). Thus, the speculation improves overall efficiency at the expense of security.Side-channel effects are not captured in the classic formal semantics of programs, and hence, these semantics cannot be used to reason about hyperproperties like timing-based side-channel attacks. Without the notion of formal models capturing side-effects produced during a program's execution, the developers can only manually fix the program to ensure it always takes the same time to execute and assume that the compiler does not break the property while compiling the program to assembly with no formal guarantees. Tradition- ally, to defend against timing-based side-channel attacks, cryptographers have used the constant-time property to develop programs that do not perform secret-dependent memory access and branching at the source level. Unfortunately, the optimizations performed by the compiler to increase the efficiency of the program tend to break constant-time property. This calls for the existence of a formal model that captures the side effects produced during a program's execution.This thesis aims to provide formal models for capturing the side-effects produced during a program's execution together with a formal notion of security properties like constant-time and speculative constant-time. The thesis incorporates the development of a formally verified secure compiler that preserves the constant-time property and methodologies to add protections against various kinds of Spectre attacks. It defines type systems that help check the correct usage of these protections and also illustrates an efficient method to protect against Spectre v1 attacks called Selective Speculative Load Hardening. All these works are formally verified using the interactive theorem prover Coq, leading to machine-checked proofs rather than relying on human assurances.
Les développeurs de logiciels critiques cherchent à concevoir des logiciels fonctionnellement corrects, dotés de propriétés telles que la confidentialité. Cependant, la confidentialité n'est pas une conséquence directe de la correction fonctionnelle, car il peut y avoir des fuites par canaux auxiliaires, comme le temps d'exécution, qui peuvent aider l'attaquant à récupérer des données secrètes.Par exemple, un algorithme de comparaison de chaînes de caractères qui compare deux chaînes caractère par caractère et se termine en cas de non-concordance ou renvoie un succès lorsque les chaînes sont égales est un algorithme fonctionnellement correct pour vérifier un mot de passe. Cependant, un attaquant peut deviner la longueur du mot de passe en mesurant le temps d'exécution de l'algorithme, ce qui montre qu'il n'est pas protégé contre les attaques par mesure de temps. Plus généralement, le branchement sur des secrets peut entraîner une fuite de données secrètes, car les deux branches peuvent avoir des temps d'exécution différents. Les processeurs modernes utilisent la prédiction de branchement pour maximiser la performance des programmes. Par exemple, si la destination d'une condition de branchement conduit à une lecture en mémoire, le processeur contourne la vérification de la condition et exécute l'opération de lecture en mémoire de manière spéculative. En cas d'erreur de prédiction, le processeur revient en arrière et recommence l'exécution avec le résultat correct de l'évaluation de la condition. Bien que le retour en arrière corrige les résultats spéculatifs, il laisse cependant une trace dans le cache, que l'attaquant peut exploiter pour accéder aux données secrètes (illustré dans les attaques Spectre). Ainsi, la spéculation améliore la performance globale au détriment de la sécurité.Les effets des canaux auxiliaires ne sont pas pris en compte dans la sémantique formelle classique des programmes et, par conséquent, cette sémantique ne peut pas être utilisée pour raisonner sur les hyperpropriétés telles que les attaques par canaux auxiliaires basées sur le temps. Sans la notion de modèles formels prenant en compte les effets secondaires produits au cours de l'exécution d'un programme, les développeurs ne peuvent que corriger manuellement le programme pour s'assurer qu'il prenne toujours le même temps pour s'exécuter et supposer que le compilateur ne casse pas la propriété lors de la compilation, sans garantie formelle, du programme vers l'assembleur. Traditionnellement, les cryptographes ont utilisé la propriété de temps constant pour se défendre contre les attaques par canaux auxiliaires basées sur le temps. Un programme à temps constant n'effectue pas d'accès mémoire ni de branchement dépendants du secret. Malheureusement, les optimisations effectuées par le compilateur pour accroître l'efficacité du programme ont tendance à casser la propriété de temps constant. Tout ceci plaide pour l'existence d'un modèle formel qui capture les effets secondaires produits pendant l'exécution d'un programme.Cette thèse vise à fournir des modèles formels prenant en compte les effets secondaires produits lors de l'exécution d'un programme, ainsi que des définitions formelles de propriétés de sécurité, comme le temps constant et le temps constant spéculatif. La thèse inclut le développement d'un compilateur sécurisé, formellement vérifié, qui préserve la propriété de temps constant, et des méthodologies pour ajouter des protections contre différentes formes d'attaques Spectre. Elle définit des systèmes de types qui permettent de vérifier l'utilisation correcte de ces protections et illustre une méthode efficace de protection contre les attaques Spectre v1 appelée Selective Speculative Load Hardening. Tous ces travaux sont formellement vérifiés en utilisant l'assistant de preuve Coq, leur donnant la solidité des preuves vérifiées par ordinateur.
Origine : Version validée par le jury (STAR)