Open source·

La fin de l'open source dans Bitcoin

Comment des mainteneurs mettent fin à l'open source au nom de la sécurité

J'ai remarqué une tendance récente dans les projets open source liés à Bitcoin : passer à des versions (temporairement) fermées au nom de la sécurité. C'est une tendance dangereuse, qui peut avoir des effets dangereux à long terme.

Dans cet article, je veux montrer les dangers de cette approche et la façon dont nous devrions, selon moi, gérer ces vulnérabilités, du point de vue d'un mainteneur open source, chercheur en sécurité et joueur occasionnel de CTF.

Comment l'IA change la sécurité

Daniel Stenberg, le mainteneur de curl, a déjà écrit sur ce sujet, par exemple en 2025, lorsque le projet curl devait gérer de nombreux signalements « slop » qui n'étaient pas de vraies vulnérabilités, puis de nouveau en 2026, lorsque la qualité des signalements s'était nettement améliorée.

Je n'ai pas grand-chose à ajouter, mais de manière générale, il reste beaucoup de « chercheurs » qui inondent les projets de signalements « slop », parce qu'ils n'ont absolument aucune idée de l'informatique, de la programmation ou de la sécurité. C'est un énorme problème pour les mainteneurs, et j'ai déjà vu des mainteneurs apporter des modifications de code compliquées pour « corriger » des problèmes qui n'en sont pas.

Je pense que les LLM sont une occasion pour davantage de personnes de faire assez rapidement des choses « amusantes » en cybersécurité. Mais sans comprendre ce qui se passe, il est difficile de déterminer ce qui est réellement une vulnérabilité.

La Bitcoin Red Team

Je n'ai pas eu affaire à la Bitcoin Red Team, mais il s'agit d'une équipe qui utilise l'IA pour « scanner » les projets liés à Bitcoin à la recherche de vulnérabilités.

En soi, cela peut être très utile. Mais si les vulnérabilités ne sont pas correctement examinées par des personnes qui savent ce qu'elles font, cela peut submerger les mainteneurs en leur fournissant un rapport très complet, mais en partie faux, ou qui présente au moins les problèmes de manière trompeuse.

J'espère que l'équipe fait attention à ce qu'elle envoie aux mainteneurs, pour éviter de les submerger.

De mauvais exemples

Je veux présenter les deux exemples les plus marquants d'une « mauvaise gestion » des signalements de sécurité.

Cas n° 1 : BTCPayServer

BTCPayServer est un processeur de paiement anciennement open source, principalement axé sur Bitcoin comme moyen de paiement. Il est très populaire pour accepter des paiements en Bitcoin et est écrit en C#.

Il a récemment publié deux versions corrigeant des failles de sécurité critiques : 2.4.2 et 2.4.3.

Pour la 2.4.2, l'équipe a choisi une stratégie plutôt raisonnable : publier tout le code, mais sans nommer la vulnérabilité corrigée, en ne mentionnant dans l'annonce que quelques vulnérabilités mineures. Si cela a semé la confusion chez certains utilisateurs et développeurs (par exemple, l'équipe d'Umbrel a affirmé qu'il ne s'agissait que d'un contournement de l'authentification à deux facteurs dans ses notes de version), cela a globalement permis de diffuser la mise à jour très rapidement.

Pour la 2.4.3, qui contenait de nombreux correctifs mineurs, l'équipe de BTCPay a opté pour une autre stratégie. Elle a publié un nouveau conteneur Docker btcpayserver/btcpayserver-internal avec une « release candidate » compilée à partir d'un dépôt non public. Seuls des binaires ont été publiés, distribués uniquement dans cette image de conteneur. Leur système de déploiement officiel a été modifié pour passer à cette version fermée. Dans l'annonce initiale, l'équipe promettait une publication sous 48 heures si aucun autre bug important n'était découvert. Il s'est ensuite avéré que la version présentait quelques petits problèmes, et l'équipe a décidé de repousser encore la publication du code source.

Comme je trouvais inquiétante cette pratique consistant à simplement exécuter un binaire fermé, j'ai décidé de faire de la rétro-ingénierie sur le code. Le C# est normalement compilé dans un langage intermédiaire extrêmement facile à « décompiler » (c'est-à-dire à retransformer en code source), par exemple avec ILSpy. Pour savoir ce qui avait changé, j'ai donc lancé le même décompilateur sur BTCPay 2.4.2 et 2.4.3.

La comparaison des résultats entre ces deux versions m'a déjà donné une liste de changements en grande partie lisible. J'ai ensuite parcouru ces changements et les ai reportés à la main dans la dernière version open source de BTCPay (2.4.2), avec quelques nettoyages, puis j'ai publié le tout sur GitHub. Cela m'a pris environ une heure et demie après avoir eu connaissance de la version. Un LLM aurait probablement pu faire de même bien plus rapidement.

À ce moment-là, BTCPay n'avait toujours publié aucun code source depuis plusieurs jours, alors que cela montrait clairement qu'il ne servait à rien de garder le code fermé.

Cas n° 2 : Core Lightning

Core Lightning est une implémentation du Lightning Network en C.

Le 26 août, l'équipe de Core Lightning a conseillé aux utilisateurs d'arrêter leur nœud et de le redémarrer en mode hors ligne, et les a informés d'une prochaine version de sécurité qui ne serait fournie que sous forme binaire.

Le 28 août, cette version a finalement été publiée, avec uniquement des binaires sur GitHub et aucun code source disponible.

Là encore, j'ai essayé de comprendre ce qui avait changé, pour m'assurer qu'il n'y avait pas de porte dérobée.

Comme Core Lightning est écrit en C, il est plus difficile à « décompiler » que du C#. Heureusement, les binaires fournis contenaient les symboles de débogage, ce qui nous indiquait quelles instructions assembleur correspondent à quelles fonctions C, et même à quelles lignes du fichier source.

Il était ainsi plus facile de reproduire exactement les changements. Comme la comparaison de ces binaires restait difficile, j'ai confié la tâche à Claude Opus 5, qui l'a accomplie en quelques heures et m'a fourni un patch permettant de reproduire exactement les binaires publiés.

Au moment où j'écris ces lignes, leur « embargo » est toujours en cours, mais j'ai publié du code qui reproduit l'ensemble des correctifs ici.

Les problèmes de cette approche

Comme on l'a vu, dès que les binaires sont accessibles au public, quel que soit le degré d'obfuscation appliqué à ces binaires, les informations sur ce qui a changé deviennent de fait publiques (avec un très léger délai, le temps que quelqu'un identifie réellement les changements).

Si les modifications du code source peuvent être reconstituées, il n'y a aucun intérêt à garder ces informations secrètes.

L'open source, et Bitcoin en particulier, reposent sur l'idée « Don't trust, verify! » (« Ne faites pas confiance, vérifiez ! »).

Or, les mainteneurs, qui fournissent l'application, veulent soudain que les utilisateurs leur fassent simplement confiance, sans pouvoir vérifier facilement ce qui a changé dans une version. Cela va clairement à l'encontre du principe « don't trust, verify ».

Pourquoi je brise ces embargos

Vous pouvez trouver contraire à l'éthique le fait de briser des embargos sur le code source. Et sur certains points, je peux être d'accord.

Lorsque je découvre moi-même une vulnérabilité, je ne la divulgue pas publiquement, je la signale aux mainteneurs. Si je participe au développement d'un correctif, je ne partage pas le patch publiquement avant sa publication.

Je ne partagerais aucun code source qui m'a été fourni de manière confidentielle.

Cette situation est toutefois différente : j'ai brisé ces embargos pour démontrer qu'ils sont inutiles. Je ne suis pas un attaquant chevronné qui cherche à exploiter cela avec des outils spécialisés, je suis un développeur moyen. Et si une personne moyenne peut reproduire ces changements, comme pour BTCPay, en une heure environ, voire plus vite, à quoi bon ces embargos ? Un attaquant chevronné, dont le but n'est pas de reproduire les binaires mais simplement de les exploiter, pourrait trouver les vulnérabilités encore plus vite.

Le second avantage de briser ces embargos est d'aider les utilisateurs à retrouver la confiance.

Ces embargos pénalisent les utilisateurs qui ne veulent pas exécuter n'importe quel binaire sur leurs serveurs. Ils doivent soit exécuter un binaire auquel ils ne peuvent pas se fier, soit garder sur leur système des vulnérabilités qu'un attaquant peut facilement identifier. C'est très dangereux pour ces utilisateurs.

Cela pénalise aussi les utilisateurs de systèmes où chaque changement est normalement compilé à partir du code source (comme NixOS), car les paquets n'y sont parfois pas mis à jour tant que le code source n'est pas publié.

Ce qui pourrait être fait à la place

Si nous ne pouvons pas éviter la fuite d'informations, il nous faut une autre stratégie pour gérer les vulnérabilités.

Dans la plupart des cas, il est judicieux de ne pas publier immédiatement une version après avoir reçu le signalement d'une vulnérabilité.

De nombreux projets regroupent plutôt les signalements pour publier une version de sécurité. Jusque-là, les patchs et les binaires devraient rester secrets et n'être partagés qu'avec les personnes impliquées dans le projet ou celles qui ont découvert la vulnérabilité, pour une première relecture.

Au moment de publier une version, il est raisonnable de compiler d'abord les binaires en local, si les builds sont reproductibles.

Ainsi, le code source et les binaires peuvent être publiés en même temps, sans aucun délai de compilation. Cela aide beaucoup les utilisateurs à mettre à jour plus rapidement.

Il peut aussi être pertinent d'annoncer aux utilisateurs, avant la publication, la date de sortie d'une version de sécurité, mais cela pourrait aussi aider les attaquants, qui sauraient alors que votre application présente une vulnérabilité. J'éviterais donc de le faire.


La façon dont les mainteneurs gèrent aujourd'hui la sécurité dans l'écosystème Bitcoin est malavisée, dangereuse pour l'open source et en plus totalement inutile.

Publier le code source en même temps que des binaires reproductibles protège tout le monde, pas seulement celles et ceux qui font aveuglément confiance aux mainteneurs.