Vérifier le Firmware de son Hardware Wallet : Guide Pratique

Sommaire

1. Introduction
2. Pourquoi Vérifier son Firmware ?
3. Vérification du Firmware Trezor
4. Vérification du Firmware Coldcard
5. Cas Ledger : Les Limites du Closed Source
6. Bonnes Pratiques de Mise à Jour
7. Tableau Comparatif des Vérifications
8. FAQ
9. Ressources et Outils
10. Conclusion
11. Liens Internes
12. Sources

URL suggérée : /securite/verifier-firmware-hardware-wallet

Catégorie : Tutoriels Techniques Sécurité

Résumé : Tutoriel complet pour vérifier indépendamment le firmware de votre hardware wallet (Trezor, Coldcard, Ledger). Protégez-vous contre les attaques de supply chain et les mises à jour compromises.

Introduction

Protégez-vous des supply chain attacks et des firmwares compromis

Votre hardware wallet est le gardien de vos clés privées. Mais que se passe-t-il si l'appareil lui-même a été compromis ? Un firmware malveillant pourrait enregistrer votre seed phrase, modifier les adresses de destination, ou exfiltrer vos clés à votre insu.

Cette menace n'est pas théorique. Les attaques de supply chain — où un appareil est intercepté et modifié avant d'arriver à l'utilisateur — sont documentées. Des mises à jour compromises pourraient théoriquement être diffusées par un attaquant ayant compromis l'infrastructure d'un fabricant.

La solution ? Vérifier indépendamment que le firmware exécuté sur votre appareil correspond exactement au code source public. Ce tutoriel vous guide pas à pas dans cette vérification pour les principaux hardware wallets du marché.

1. Pourquoi Vérifier son Firmware ?

Comprenez les menaces réelles qui pèsent sur votre appareil

1.1 Le risque de supply chain attack

Une attaque de supply chain cible la chaîne d'approvisionnement plutôt que l'utilisateur final :

Cas réels documentés :

• En 2020, des Ledger contrefaits ont été envoyés à des clients après la fuite de leur base de données
• Des Trezor modifiés avec des puces supplémentaires ont été identifiés sur le marché secondaire

1.2 Le risque de mise à jour compromise

Chaque mise à jour de firmware est une opportunité pour un attaquant :

• Attaque de l'infrastructure : Compromission des serveurs de distribution
• Attaque MITM : Interception de la connexion lors du téléchargement
• Ingénierie sociale : Fausse mise à jour urgente diffusée via phishing

1.3 Open source vs Closed source

La possibilité de vérifier un firmware dépend de son statut open source :

Point clé : Avec un firmware open source, vous pouvez compiler le code vous-même et comparer le résultat avec ce qui est installé sur l'appareil. Avec du closed source, vous devez faire confiance au fabricant.

2. Vérification du Firmware Trezor

Compilez le code source vous-même pour garantir son authenticité

Le Trezor est entièrement open source, ce qui permet une vérification complète.

2.1 Prérequis

• Un ordinateur sous Linux, macOS, ou Windows avec WSL
• Git installé
• Docker (pour la compilation reproductible)
• Votre Trezor connecté

2.2 Étape 1 : Télécharger le code source

# Cloner le dépôt officiel
git clone https://github.com/trezor/trezor-firmware.git
cd trezor-firmware

# Se positionner sur la version correspondant à votre firmware
# Vérifiez la version sur votre Trezor : Paramètres > Appareil > Version Firmware
git checkout core/v2.6.4  # Remplacez par votre version

2.3 Étape 2 : Vérifier les signatures GPG

Les releases officielles sont signées par les développeurs Trezor.

# Importer les clés publiques des développeurs
gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys \
    86E6792FC27BFD478860C11091F3B339B9A02A3D \
    F2BBD5F2B8C6B8B8C6B8B8C6B8B8C6B8B8C6B8B8  # Exemple - vérifiez sur trezor.io

# Vérifier la signature du tag
git verify-tag core/v2.6.4

Le résultat doit afficher "Good signature from" suivi du nom d'un développeur Trezor connu.

2.4 Étape 3 : Compiler le firmware (Docker)

Trezor utilise des builds reproductibles via Docker :

# Construire l'environnement Docker
docker build -t trezor-build .

# Lancer la compilation
docker run -it --rm -v $(pwd):/src trezor-build \
    bash -c "cd /src && poetry install && poetry run make -C core build_firmware"

La compilation produit un fichier binaire dans core/build/firmware/firmware.bin.

2.5 Étape 4 : Comparer avec le firmware installé

Obtenir le hash du firmware installé :

Utilisez l'outil trezorctl :

# Installer trezorctl
pip install trezor

# Obtenir les informations du firmware
trezorctl get-features

Calculer le hash du firmware compilé :

sha256sum core/build/firmware/firmware.bin

Comparer les deux hash :

Si les hash correspondent, votre firmware est identique au code source vérifié. Si ils diffèrent, quelque chose ne va pas — ne continuez pas à utiliser l'appareil.

2.6 Récapitulatif des commandes

# 1. Cloner
git clone https://github.com/trezor/trezor-firmware.git && cd trezor-firmware

# 2. Checkout version
git checkout core/v2.X.X

# 3. Vérifier signature
git verify-tag core/v2.X.X

# 4. Compiler
docker build -t trezor-build . && \
docker run -it --rm -v $(pwd):/src trezor-build \
    bash -c "cd /src && poetry install && poetry run make -C core build_firmware"

# 5. Hash
sha256sum core/build/firmware/firmware.bin

3. Vérification du Firmware Coldcard

Vérifiez les signatures GPG et hash pour valider votre firmware

Le Coldcard utilise une approche différente : la vérification se fait via la carte SD et des outils en ligne de commande.

3.1 Prérequis

• Python 3 installé
• L'outil ckcc-protocol de Coinkite
• Le firmware téléchargé depuis coldcard.com

3.2 Étape 1 : Télécharger le firmware officiel

Rendez-vous sur coldcard.com/docs/upgrade et téléchargez :

• Le fichier firmware (.dfu)
• Le fichier de signature (.txt ou .asc)

3.3 Étape 2 : Vérifier la signature

Coinkite signe chaque firmware avec sa clé GPG.

# Importer la clé publique Coinkite
gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys \
    A3A31BAD5A2A5B10D6B8E8F5E6C2E6D9F8A8B0C0  # Vérifiez l'ID exact sur coldcard.com

# Vérifier la signature
gpg --verify firmware-signature.txt firmware-X.X.X.dfu

3.4 Étape 3 : Utiliser verify.py

Coinkite fournit un outil Python pour vérifier le firmware :

# Installer l'outil
pip install ckcc-protocol

# Vérifier le firmware
ckcc verify firmware-X.X.X.dfu

3.5 Étape 4 : Vérification via la carte SD

La méthode la plus simple pour les utilisateurs non techniques :

1. Copiez le fichier .dfu sur une carte microSD
2. Insérez la carte dans le Coldcard
3. Allez dans : Advanced → Upgrade → From SD Card
4. Le Coldcard affiche le hash du fichier
5. Comparez avec le hash publié sur coldcard.com

3.6 Vérification du firmware actuellement installé

Sur le Coldcard, naviguez vers :

Advanced → View Identity → My Fingerprint

Cette empreinte doit correspondre à celle documentée pour votre version de firmware.

3.7 Compiler depuis les sources (avancé)

Pour les utilisateurs techniques :

# Cloner le dépôt
git clone https://github.com/Coldcard/firmware.git
cd firmware

# Vérifier le tag
git checkout v5.X.X
git verify-tag v5.X.X

# Compiler (nécessite l'environnement ARM)
make setup
make all

4. Cas Ledger : Les Limites du Closed Source

Découvrez ce que vous ne pouvez PAS vérifier avec un Secure Element propriétaire

4.1 Architecture Ledger

Le Ledger utilise une architecture en deux parties :

Le cœur du problème : le Secure Element exécute du code propriétaire que personne ne peut auditer.

4.2 Ce qu'on peut vérifier

Les applications (partiellement) :

• Le code des applications (Bitcoin app, etc.) est sur GitHub
• Vous pouvez compiler et comparer les hash
• Mais le chargement sur l'appareil passe par BOLOS (closed source)

Ledger Live :

• Le code est open source sur GitHub
• Vous pouvez compiler votre propre version
• Vérifie les signatures des applications

4.3 Ce qu'on ne peut pas vérifier

• Le système d'exploitation BOLOS
• Le comportement réel du Secure Element
• L'absence de backdoor hardware

4.4 Pourquoi c'est problématique

Sans accès au code du Secure Element, vous devez faire confiance à Ledger sur :

• L'absence de backdoor volontaire ou contrainte (pression gouvernementale)
• La qualité du code et l'absence de vulnérabilités
• Le fait que les clés générées sont vraiment aléatoires

4.5 Vérifications possibles malgré tout

Attestation de l'appareil :

Ledger Live vérifie que l'appareil est authentique via un certificat signé par Ledger :

1. Connectez votre Ledger à Ledger Live
2. Accédez aux paramètres de l'appareil
3. Cliquez sur "Vérifier l'authenticité"

Cette vérification confirme que l'appareil vient de l'usine Ledger, mais pas que le firmware est sain.

Vérifier les applications :

# Cloner le dépôt des applications
git clone https://github.com/LedgerHQ/app-bitcoin.git
cd app-bitcoin

# Compiler (nécessite le SDK Ledger)
make

# Comparer le hash de l'application compilée
# avec celle installée sur l'appareil

4.6 Recommandation

Pour les utilisateurs privilégiant la vérifiabilité, préférez :

• Coldcard ou Trezor comme signataires principaux
• Le Ledger peut servir de clé de backup dans un setup multisig
• Évitez de dépendre uniquement d'un Ledger pour des montants significatifs

5. Bonnes Pratiques de Mise à Jour

Adoptez une approche prudente face aux nouvelles versions de firmware

5.1 Ne jamais mettre à jour automatiquement

Pourquoi attendre ?

• La communauté peut détecter des problèmes
• Les vulnérabilités dans les nouvelles versions peuvent être découvertes
• En cas de compromission du fabricant, le temps permet la détection

5.2 Checklist avant mise à jour

Avant d'appliquer toute mise à jour de firmware :

• Vérifiez l'annonce officielle (site web, Twitter, GitHub)
• Recherchez des discussions sur Reddit, Twitter, forums
• Attendez 1-2 semaines après la release
• Vérifiez la signature GPG du firmware
• Assurez-vous d'avoir accès à votre seed phrase (en cas de problème)
• Testez sur un appareil secondaire si possible

5.3 En cas de doute

Si quelque chose vous semble suspect :

1. Ne mettez pas à jour - Attendez plus d'informations
2. Contactez la communauté - Reddit, Twitter, forums dédiés
3. Vérifiez les sources officielles - Site web, GitHub, comptes sociaux vérifiés
4. Considérez un nouvel appareil - En cas de suspicion de compromission

5.4 Procédure de mise à jour sécurisée

Pour Trezor :

1. Téléchargez le firmware depuis GitHub (pas Trezor Suite directement)
2. Vérifiez les signatures GPG
3. Utilisez trezorctl pour flasher : trezorctl firmware-update -f firmware.bin

Pour Coldcard :

1. Téléchargez depuis coldcard.com
2. Vérifiez les signatures
3. Transférez via carte SD
4. Appliquez depuis le menu Advanced → Upgrade

Pour Ledger :

1. Vérifiez les annonces officielles
2. Attendez quelques jours
3. Mettez à jour via Ledger Live
4. Vérifiez l'attestation après mise à jour

6. Tableau Comparatif des Vérifications

Évaluez d'un coup d'œil les possibilités de vérification par appareil

FAQ

Q1 : La vérification de firmware est-elle vraiment nécessaire pour un particulier ?

Pour la majorité des utilisateurs achetant directement chez le fabricant, le risque est faible. Cependant, la vérification devient cruciale si vous :

• Avez acheté d'occasion ou via un revendeur tiers
• Détenez des montants significatifs (>10 000€)
• Êtes une cible potentielle (personnalité publique, figure crypto)
• Avez des exigences de sécurité professionnelles

Q2 : Que faire si la vérification échoue ?

1. Ne transférez pas de fonds vers cet appareil
2. Ne révélez pas de seed phrase à l'appareil
3. Contactez le fabricant avec les détails
4. Considérez l'appareil comme potentiellement compromis
5. Achetez un nouvel appareil via le canal officiel

Q3 : Les builds reproductibles garantissent-ils à 100% la sécurité ?

Non. Ils garantissent que le code compilé correspond au code source publié. Mais :

• Le code source lui-même pourrait contenir des vulnérabilités
• Le compilateur pourrait être compromis (attaque "Ken Thompson")
• Le matériel pourrait avoir des backdoors

Les builds reproductibles sont une couche de vérification essentielle, pas une garantie absolue.

Q4 : Puis-je vérifier un firmware sur Windows ?

Oui, mais c'est plus complexe. Recommandations :

• Utilisez WSL2 (Windows Subsystem for Linux) pour les commandes Linux
• Installez Docker Desktop pour la compilation
• Ou utilisez une machine virtuelle Linux

Q5 : Faut-il vérifier à chaque mise à jour ?

Idéalement oui. En pratique, faites-le au minimum :

• À la première utilisation d'un nouvel appareil
• Après toute mise à jour majeure
• Si vous avez un doute sur l'intégrité
• Périodiquement (tous les 6-12 mois)

📚 Articles Connexes — Sécurité Technique

• Multisig 2 Of 3 Bitcoin Tutoriel
• Seedsigner Diy Tutoriel Complet
• Passphrase 25Eme Mot Bitcoin
• Guide Coldcard Air Gapped Bitcoin

Ressources et Outils

Dépôts GitHub officiels

Clés GPG officielles

• Trezor : trezor.io/security
• Coldcard : coldcard.com/docs/verify
• Ledger : ledger.com/pgp

Outils de vérification

• GPG : gnupg.org
• SHA256 : Intégré aux systèmes Unix (sha256sum)
• Docker : docker.com
• trezorctl : pip install trezor
• ckcc-protocol : pip install ckcc-protocol

Conclusion

La vérifiabilité est le prix de la vraie souveraineté numérique

La vérification du firmware est une pratique de sécurité avancée mais accessible. Pour les utilisateurs soucieux de minimiser leur dépendance envers les fabricants, c'est une étape essentielle.

Points clés à retenir :

1. Préférez les appareils open source (Trezor, Coldcard, SeedSigner)
2. Vérifiez toujours les signatures GPG avant mise à jour
3. Attendez quelques jours avant d'appliquer une nouvelle version
4. Si vous ne pouvez pas vérifier complètement (Ledger), utilisez en multisig avec des appareils vérifiables
5. La vérification prend du temps, mais vos bitcoins le méritent

Liens Internes

Complétez votre arsenal de sécurité avec ces ressources essentielles

• Guide Coldcard Air-Gapped — Configuration complète du Coldcard
• Construire son SeedSigner — Hardware wallet 100% vérifiable
• Multisig 2-of-3 — Diversifiez vos signataires
• La Passphrase (25ème mot) — Couche de sécurité supplémentaire
• Travel Rule et Transferts — Contexte réglementaire

Sources

Documentation officielle

• Trezor Security : trezor.io/security
• Coldcard Docs : coldcard.com/docs
• Ledger Security : ledger.com/academy/security

Recherches et analyses

• Wallet.fail : Présentations de sécurité sur les hardware wallets
• Kraken Security Labs : Analyses de vulnérabilités
• Ledger Donjon : Recherche interne Ledger (open source partiel)

Communauté

• Bitcoin Stack Exchange : bitcoin.stackexchange.com
• Reddit r/Bitcoin : Discussions et retours d'expérience
• Twitter/X : Comptes des chercheurs en sécurité

Article rédigé en décembre 2025. Les commandes et procédures peuvent évoluer avec les nouvelles versions de firmware. Consultez toujours la documentation officielle pour les instructions à jour.