constant-time-testing

Vue d’ensemble de constant-time-testing

constant-time-testing est une compétence pratique pour auditer du code cryptographique à la recherche de fuites de timing. Utilisez la compétence constant-time-testing lorsque vous devez vérifier si des branches dépendantes des secrets, des schémas d’accès mémoire ou des comportements microarchitecturaux pourraient divulguer des clés, des nonces ou d’autres valeurs sensibles.

Qui devrait utiliser constant-time-testing

Cette compétence est particulièrement adaptée aux auditeurs sécurité, aux ingénieurs crypto et aux relecteurs de cryptographie au niveau implémentation. Elle est surtout utile lorsque vous avez déjà du code, un banc d’essai ou un chemin critique suspect, et que vous avez besoin d’un guide ciblé de constant-time-testing plutôt que d’une simple checklist de codage sécurisé.

Quel problème elle résout

Le vrai enjeu n’est pas de « comprendre les attaques de timing en théorie », mais de « déterminer si ce code se comporte différemment quand les secrets changent ». constant-time-testing vous aide à transformer cette question en un workflow de revue répétable : identifier les entrées sensibles, inspecter les chemins de code qu’elles influencent, puis concevoir des tests capables de révéler une fuite.

Ce qui la rend utile

La principale valeur, c’est la précision. Une bonne compétence constant-time-testing doit vous orienter vers :

• les zones de code exactes qui comptent le plus,
• les types de comparaisons et de recherches qui fuient souvent,
• et les preuves dont vous avez besoin avant de conclure qu’un signalement est fondé.

Comment utiliser la compétence constant-time-testing

Installer et ouvrir les fichiers source

Pour l’installation de constant-time-testing, ajoutez la compétence depuis trailofbits/skills, puis lisez d’abord SKILL.md. Si vous l’utilisez dans un workflow agentique, examinez aussi les fichiers du dépôt voisins qui définissent le comportement ou les conventions avant de rédiger votre prompt.

Commencer avec le bon format d’entrée

La compétence fonctionne mieux si vous fournissez une cible concrète, pas une demande vague. De bons éléments d’entrée incluent :

• le dépôt ou le chemin de fichier à examiner,
• les valeurs secrètes ou les appels d’API qui doivent rester cachés,
• le modèle de menace, par exemple un attaquant local, un observateur de timing distant ou le bruit de benchmark,
• et le langage ou la plateforme, car C, Rust, l’assembleur et le code de plus haut niveau ne fuient pas de la même façon.

Un bon prompt ressemble à ceci : « Utilise constant-time-testing sur src/crypto.rs pour vérifier si verify_tag() branche selon des octets secrets. Suppose un attaquant distant et signale les points de fuite probables, les idées de tests et les faux positifs. »

Workflow de revue recommandé

Un schéma d’utilisation pratique de constant-time-testing consiste à :

1. Identifier les secrets et tous les chemins de code qu’ils influencent.
2. Rechercher les branches, retours anticipés, consultations de tables et primitives à durée variable.
3. Tester si le comportement change avec des entrées dépendantes des secrets.
4. Distinguer les vraies fuites du compilateur, de l’environnement d’exécution ou du bruit de mesure.
5. Rendre les conclusions avec les entrées exactes, les emplacements de code et le niveau de confiance.

Lire d’abord pour de meilleurs résultats

Commencez par SKILL.md, puis consultez les éventuels exemples de vérification constant-time, scripts de mesure ou notes de politique présents dans le dépôt. Si le dépôt contient plusieurs cibles d’implémentation, lisez d’abord celle qui se rapproche le plus de votre stack de production afin que le guide constant-time-testing reste aligné sur votre environnement.

FAQ sur la compétence constant-time-testing

constant-time-testing est-il réservé aux bibliothèques cryptographiques ?

Non. Il s’applique à tout code pour lequel un timing dépendant d’un secret peut poser problème, y compris les vérifications d’authentification, les comparaisons de clés, l’analyse de formats contenant des secrets et la logique de protocole. Le cas d’usage constant-time-testing pour l’audit sécurité est plus large que la cryptographie pure.

Faut-il un dispositif de benchmark avant de l’utiliser ?

Pas toujours. Vous pouvez commencer par une revue statique et des tests ciblés, puis ajouter des mesures de timing si le chemin de code paraît suspect. Dans beaucoup d’audits, la première passe sert surtout à réduire l’espace où une fuite pourrait exister.

En quoi est-ce différent d’un prompt classique ?

Un prompt classique demande souvent une explication générique des attaques de timing. constant-time-testing est plus actionnable : il est conçu pour guider la revue d’une base de code précise, d’un secret précis et d’un modèle de menace précis, ce qui produit généralement de meilleurs résultats d’audit.

Quand ne pas l’utiliser ?

Ne vous reposez pas sur cette compétence si vous avez besoin d’une infrastructure complète d’analyse dynamique, de vérification formelle ou d’une certification spécifique au matériel. Elle est surtout utile comme guide de revue et de test ciblé, pas comme substitut à des méthodes d’assurance plus poussées.

Comment améliorer la compétence constant-time-testing

Donner à la compétence les secrets et les invariants

Le gain de qualité le plus important vient du fait de préciser ce qui doit rester secret et ce qui ne doit pas changer. Dites au modèle quelles valeurs sont sensibles, quelles opérations sont autorisées à varier et quels chemins de code sont critiques pour la sécurité. La compétence constant-time-testing devient alors beaucoup plus précise.

Partager les emplacements de code et les schémas suspectés

Si vous soupçonnez déjà une fonction, une branche ou une table de recherche, pointez-la directement. Exemple : « Examine verify(), ct_eq() et la recherche S-box dans src/aes.c. » Cela réduit les approximations et aide la réponse à se concentrer sur les chemins de fuite les plus risqués.

Demander des preuves, pas seulement un verdict

De bons résultats incluent généralement un plan de test concret : paires d’entrées à comparer, points d’instrumentation, critères de fuite et manière d’interpréter des mesures bruitées. Demandez explicitement ces éléments pour que la réponse aille au-delà de « semble constant-time » ou « ne l’est pas ».

Itérer après le premier passage

Servez-vous du premier résultat pour resserrer le périmètre. Si une branche est signalée, demandez une vérification constant-time-testing plus ciblée sur cette fonction seule ; si tout paraît propre, demandez d’examiner les helpers adjacents, les effets du compilateur ou les comportements spécifiques à la plateforme qui pourraient encore fuir.