Bluetooth-Attacks-CVE-2025-27840

Cet article traite de la manière dont un attaquant peut introduire une liste cachée de vulnérabilités via des mises à jour de modules, ce qui peut entraîner le compromis des appareils ESP32 et l'obtention d'un accès non autorisé aux clés privées, affectant des milliards d'appareils utilisant ce microcontrôleur. L'un des problèmes clés est la vulnérabilité CVE-2025-27840 découverte dans l'architecture ESP32. Pour garantir la sécurité du réseau Bitcoin, nous avons identifié les vulnérabilités suivantes, où la possibilité d'utiliser des clés privées invalides en raison de l'absence de vérification de la borne inférieure dans la fonction  has_invalid_privkey ; une vulnérabilité de falsification de signature de transaction dans la fonction  electrum_sig_hash due à une incompatibilité avec BIP-137 ; un problème de PRNG faible dans la fonction de génération de clé  random_key, rendant les clés privées personnelles des portefeuilles de cryptomonnaies prévisibles ; l'absence de vérification des points sur la courbe ECC dans la fonction  multiply, ce qui peut mener à des attaques de courbe invalide ; une vulnérabilité dans la fonction  ecdsa_raw_sign lors de la restauration de la coordonnée Y, pouvant conduire à une substitution de la clé publique ; et des vulnérabilités liées aux API de hachage obsolètes dans  bin_ripemd160.

• Tutorial: https://youtu.be/nBeZWm2z5o4
• Tutorial: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
• Tutorial: https://dzen.ru/video/watch/6784be61b09e46422395c236
• Google Colab: https://colab.research.google.com/drive/15lPDHeTo7FkrPY7v4qS7X6hO4x27qT2Y

Au début de mars 2025, Tarlogic Security a identifié une vulnérabilité dans le microcontrôleur ESP32, qui est largement utilisé pour connecter des appareils via WiFi et Bluetooth. Cette vulnérabilité a été enregistrée sous le numéro CVE-2025-27840. Les attaquants peuvent accéder sans autorisation aux données des portefeuilles Bitcoin en utilisant la puce ESP32 comme point d'attaque cryptographique sur les appareils fonctionnant sur les réseaux de cryptomonnaies populaires telles que Bitcoin et Ethereum. Ce problème affecte des millions d'appareils IoT qui utilisent ce microcontrôleur. L'exploitation de cette vulnérabilité permettra aux attaquants de mener des attaques déguisées en utilisateurs légitimes et d'infecter de manière permanente les appareils vulnérables. Cela menace la sécurité des appareils IoT basés sur le microcontrôleur ESP32 et peut conduire au vol des clés privées des portefeuilles Bitcoin.

L'ESP32 est un microcontrôleur largement utilisé dans les appareils IoT pour fournir une connectivité Wi-Fi et Bluetooth. Les attaquants peuvent utiliser diverses méthodes pour accéder aux données des clés privées des portefeuilles Bitcoin via l'ESP32.

Les menaces de sécurité liées au microcontrôleur ESP32 peuvent entraîner le vol des clés privées des portefeuilles Bitcoin. Les principaux problèmes incluent la présence de portes dérobées et de vulnérabilités. En utilisant ces vulnérabilités, ils peuvent manipuler la mémoire, usurper les adresses MAC et injecter du code malveillant, ce qui crée des risques de sécurité graves.

Les attaquants peuvent attaquer les appareils IoT avec un microcontrôleur ESP32 en utilisant des vulnérabilités dans les connexions Bluetooth et Wi-Fi, ce qui peut devenir un outil pour attaquer d'autres appareils sur le réseau lié à Bitcoin, ainsi que pour voler des informations confidentielles, y compris les clés privées des portefeuilles Bitcoin.

https://youtu.be/nBeZWm2z5o4

Liste cachée de vulnérabilités :

Un attaquant peut mettre à jour des modules et introduire une liste de diverses vulnérabilités dans le code, notamment :

• Une vulnérabilité dans la fonction  has_invalid_privkey qui peut être utilisée pour obtenir la clé privée.
• Une vulnérabilité dans la fonction  electrum_sig_hash permet de falsifier les signatures de transactions Bitcoin.
• Une vulnérabilité dans la fonction  random_key liée à un générateur de nombres pseudo-aléatoires faible (PRNG non déterministe).
• Une vulnérabilité dans la fonction  multiply où il n'y a pas de vérification d'un point sur la courbe ECC.
• Des vulnérabilités dans les fonctions  ecdsa_raw_sign et  bin_ripemd160.

Ces vulnérabilités peuvent être utilisées pour injecter de fausses mises à jour dans les appareils ESP32, donnant aux attaquants un accès bas niveau au système. Cela leur permettra de contourner les contrôles d'audit de code et d'obtenir l'accès aux clés privées. Actuellement, des milliards d'appareils peuvent être vulnérables en raison de fonctionnalités cachées d'un seul composant de leur architecture, qui est désigné comme CVE-2025-27840.

Vulnérabilité pour l'obtention de la clé privée dans la fonction has_invalid_privkey

Cette vulnérabilité a été trouvée dans le code de vérification de la clé privée de Bitcoin, permettant l'utilisation de clés invalides (inférieures ou égales à 0) en raison de l'absence de vérification de la borne inférieure. Cela peut entraîner une perte de fonds. Pour corriger cela, une vérification doit être ajoutée pour s'assurer que la clé privée est supérieure à 0. Le code est fourni à des fins de démonstration.

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L305

Ce bogue permet d'utiliser de mauvaises clés privées, ce qui peut entraîner de graves problèmes, y compris une perte d'argent.

Pour corriger cela, vous devez ajouter une vérification pour garantir que la clé privée est supérieure à 0.

Imaginez que quelqu'un essaie de « pirater » le réseau Bitcoin. Il trouve un point faible dans la vérification des clés privées utilisées pour accéder à la cryptomonnaie.

Le problème est que le code vérifie seulement si la clé privée est trop grande. Si la clé est très grande, elle est rejetée. Mais le code oublie de vérifier si la clé est trop petite (inférieure ou égale à zéro).

La section de code où cela se produit :

...
...
if privkey >= N:  # Vérification uniquement de la borne supérieure
    raise Exception("Invalid privkey")

if privkey <= 0:  # La borne inférieure n'est pas vérifiée correctement
    return True
...
...

En raison de ce bogue, il est possible d'utiliser des clés privées invalides (très petites). Cette vulnérabilité se trouve dans la fonction  has_invalid_privkey.

Pour que tout cela fonctionne, vous devez installer la bibliothèque  ecdsa (elle est nécessaire pour travailler avec la cryptographie) : 

Script Python secp256k1_privkey_validator.py

!pip install ecdsa 
import ecdsa 

def has_invalid_privkey(privkey: int) -> bool: 
    """ 
    Checks if a private key is invalid, based on the absence of a lower bound check. 

    Args: 
        privkey: The private key to check. 

    Returns: 
        True if the private key is invalid (<= 0 or >= N), False otherwise. 
    """ 
    # Order of the secp256k1 elliptic curve used by Bitcoin 
    N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 

    if privkey >= N: # Check only the upper bound 
        raise Exception("Invalid privkey") 

    if privkey <= 0: # Lower bound check missing 
        return True 

    return False 

# Example usage 
privkey = 0 # Invalid private key 
is_invalid = has_invalid_privkey(privkey) 

if is_invalid: 
    print("Invalid private key!") 
else: 
    print("Valid private key.")

Explication du code :

1. Importation de la bibliothèqueecdsa : Bien qu'elle ne soit pas utilisée directement dans cet exemple, dans des scénarios réels impliquant Bitcoin et ECDSA (algorithme de signature numérique à courbe elliptique), cette bibliothèque peut être nécessaire pour effectuer des opérations cryptographiques.
2. Fonctionhas_invalid_privkey(privkey: int) -> bool :
   • privkeyAccepte une clé privée sous forme d'entier en entrée.
   • Définit une constante Nqui représente l'ordre de la courbe elliptique secp256k1 utilisée dans Bitcoin.
   • Vérifie si privkeyest supérieur ou égal à N. Si c'est le cas, lève une exception indiquant que la clé privée est invalide.
   • Vérifie si privkeyest inférieur ou égal à 0. Si c'est le cas, retourne True, indiquant que la clé privée est invalide en raison de l'absence de vérification de la borne inférieure.
   • Si les deux vérifications échouent, retourne False.
3. Exemple d'utilisation :
   • Définit la valeur à , qui est une clé privée invalide.

Vulnérabilité :

Le code contient une vulnérabilité liée à une vérification insuffisante de la clé privée. Plus précisément, il n'y a pas de vérification de la borne inférieure (privkey <= 0). Cela permet l'utilisation de clés privées invalides, ce qui peut entraîner des conséquences imprévisibles, y compris une perte de fonds.

Comment la corriger :

Il faut ajouter une vérification de la borne inférieure de la clé privée pour s'assurer qu'elle est supérieure à 0.

Vulnérabilité de falsification de signature de transaction Bitcoin dans la fonction electrum_sig_hash

La fonction  electrum_sig_hash dans Electrum utilise une méthode de hachage de message non standard, ce qui la rend vulnérable aux attaques de falsification de signature en raison de son incompatibilité avec BIP-137.

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L425

Un attaquant ciblant le réseau Bitcoin peut découvrir la méthode de hachage de message non standard utilisée par Electrum via la fonction  electrum_sig_hash. Cette fonction crée un hachage de message d'une manière qui peut conduire à des attaques de falsification de signature en raison de son incompatibilité avec BIP-137. Le script Python fourni montre comment un attaquant peut générer le hachage de message utilisé par Electrum pour exploiter la vulnérabilité d'incompatibilité BIP-137. La fonction  electrum_sig_hash prépare le message en le préfixant et en encodant sa longueur avant de le hacher deux fois avec SHA256.

Un script Python démontrant comment un attaquant peut trouver un hachage de message non standard utilisé par Electrum pour effectuer des attaques de falsification de signature en raison de l'incompatibilité BIP-137.

Script Python bitcoin_sign_hash.py

!pip install ecdsa 
import hashlib 

def num_to_var_int(i): 
    if i < 0xfd: 
        return i.to_bytes(1, 'little') 
    elif i <= 0xffff: 
        return b'\xfd' + i.to_bytes(2, 'little') 
    elif i <= 0xffffffff: 
        return b'\xfe' + i.to_bytes(4, 'little') 
    else: 
        return b'\xff' + i.to_bytes(8, 'little') 

def from_string_to_bytes(s): 
    return s.encode('utf-8') 

def bin_dbl_sha256(s): 
    hash1 = hashlib.sha256(s).digest() 
    hash2 = hashlib.sha256(hash1).digest() 
    return hash2 

def electrum_sig_hash(message): 
    padded = b"\x18Bitcoin Signed Message:\n" + num_to_var_int(len(message)) + from_string_to_bytes(message) 
    return bin_dbl_sha256(padded) 

# Usage example 
message = "Example message for signing" 
message_hash = electrum_sig_hash(message) 
print(f"Electrum message hash: {message_hash.hex()}")

Dans ce script :

• num_to_var_int(i) : convertit un entier au format de longueur variable utilisé dans Bitcoin.
• from_string_to_bytes(s) : encode une chaîne en octets en utilisant l'encodage UTF-8.
• bin_dbl_sha256(s) : effectue un double hachage SHA256 sur l'entrée.
• electrum_sig_hash(message) : simule la manière non standard d'Electrum de hacher les messages, qui est sujette à une incompatibilité avec BIP-137.

Vulnérabilité dans la fonction random_key PRNG faible dans la génération de clé (PRNG non déterministe)

Le problème survient lorsque Bitcoin utilise une fonction  random_key qui repose sur le module random pour créer des clés. Le module  random n'est pas destiné à des fins cryptographiques car il ne génère pas de nombres suffisamment aléatoires, rendant les clés privées prévisibles pour les attaquants. Cela rend le réseau Bitcoin vulnérable.

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L432

Un script Python qui rend le réseau Bitcoin vulnérable en utilisant random au lieu de secrets ou os.urandom, rendant les clés privées prévisibles pour un attaquant Bitcoin :

Script Python privkey_generate.py

import random
import time
from hashlib import sha256

def random_string(length):
    return ''.join(random.choice('0123456789abcdef') for i in range(length))

def random_key():
    # Il faut être sécurisé après le fiasco java.SecureRandom...
    entropy = random_string(32) \
        + str(random.randrange(2**256)) \
        + str(int(time.time() * 1000000))
    return sha256(entropy.encode('utf-8')).hexdigest()

# Exemple d'utilisation : générer une clé privée
private_key = random_key()
print("Generated Private Key:", private_key)

Ce script utilise le module random pour générer des clés, ce qui le rend vulnérable. L'utilisation du module random n'est pas adaptée à des fins cryptographiques car il ne génère pas de nombres suffisamment aléatoires.

Pour créer une clé plus sécurisée, vous pouvez utiliser le module secrets ou os.urandom. Voici un exemple d'utilisation du module secrets :

import secrets
import hashlib

def secure_random_key():
    # Générer un nombre aléatoire avec suffisamment d'entropie
    random_bytes = secrets.token_bytes(32)  # 32 octets = 256 bits
    
    # Hacher les octets aléatoires pour créer une clé privée
    private_key = hashlib.sha256(random_bytes).hexdigest()
    return private_key

# Exemple d'utilisation : générer une clé privée sécurisée
secure_private_key = secure_random_key()
print("Generated Secure Private Key:", secure_private_key)

Dans cet exemple, le module secrets est utilisé pour générer un nombre aléatoire avec suffisamment d'entropie. Le nombre aléatoire est ensuite haché pour créer une clé privée personnelle. Cette méthode est bien plus sécurisée que l'utilisation du module random.

Vulnérabilité dans la fonction ecdsa_raw_sign

Une vulnérabilité dans la fonction ecdsa_raw_sign lors de la restauration de la coordonnée Y peut conduire à la substitution d'une clé publique dans le réseau Bitcoin. Il existe un risque élevé qu'un attaquant exploite la particularité de la restauration de la coordonnée Y lorsqu'il travaille avec une courbe elliptique. Cette ambiguïté peut conduire au fait que la clé publique est restaurée incorrectement.

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L543

L'exemple de code, fourni à l'aide de la bibliothèque pycryptodome, montre comment cette situation peut être simulée en remplaçant la coordonnée Y pour obtenir une clé publique différente et invalide. Il est important de noter que l'exemple de code est simplifié et ne constitue pas une implémentation complète de l'attaque, mais en montre seulement le principe.

Un attaquant peut exploiter l'ambiguïté de la récupération de la coordonnée Y dans le réseau Bitcoin, ce qui peut conduire à des erreurs dans la récupération de la clé publique. Voici un exemple de la façon dont cela peut être fait en utilisant l'opération binaire XOR.

Script Python weak_key_recovery.py

!pip install pycryptodome 
from hashlib import sha256 
from Crypto.PublicKey import ECC 
from Crypto.Signature import DSS 
from Crypto.Hash import SHA256 
import secrets 

# Paramètres de la courbe elliptique secp256k1 
# PyCryptodome ne fournit pas de moyen pratique pour spécifier directement les paramètres de la courbe secp256k1. 
# Par conséquent, nous utiliserons la courbe ECC standard. 
# Pour le code de production, soyez prudent lors du choix de la courbe et de ses paramètres. 

def hash_to_int(msghash): 
    return int(sha256(msghash.encode('utf-8')).hexdigest(), 16) 

def deterministic_generate_k(msghash, priv_key_int): 
    k = 0 
    while k == 0: 
        v = b'\x01' * 32 
        k = b'\x00' * 32 
        k = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest() 
        v = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest() 
        k = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest() 
        v = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest() 
        k = int.from_bytes(sha256(v + k).digest(), 'big') # % N # Supprimé % N, car N n'est plus une constante définie 
    return k 

def ecdsa_raw_sign(msghash, priv_key_int): 
    z = hash_to_int(msghash) 
    k = deterministic_generate_k(msghash, priv_key_int) 

    # Générer un objet de clé privée 
    key = ECC.construct(curve='P-256', d=priv_key_int) 

    # Calculer le point R = kG 
    # PyCryptodome ne donne pas d'accès direct aux coordonnées du point R 
    # Par conséquent, la signature sera calculée d'une manière différente, en utilisant DSS 

    # s = pow(k, -1, N) * (z + r * private_key_int) % N # N n'est plus défini 
    # v = 27 + ((y % 2) ^ (0 if s * 2 < N else 1)) # y n'est pas disponible 

    return key, z, k # Renvoie la clé, le hachage et k pour une utilisation ultérieure dans la signature 

def recover_pubkey(msghash, signature, key): 
    # ATTENTION : Ceci est un exemple TRÈS SIMPLIFIÉ de récupération de clé publique. 
    # Dans la réalité, la récupération de clé publique ECDSA est un processus complexe. 
    # Ce code est uniquement destiné à démontrer le principe. 

    # PyCryptodome n'a pas de moyen simple de récupérer PublicKey à partir de r et s directement. 
    # Ce code n'effectue pas une véritable récupération, mais crée une nouvelle PublicKey à partir de la clé privée. 
    # Dans un scénario d'attaque réel, vous devez essayer de deviner la coordonnée y pour obtenir une PublicKey valide.     # Mais cela nécessite une logique plus complexe pour travailler avec la courbe elliptique.    return key.public_key()def emulate_attack(msghash, priv):     # 1. Signer le message     priv_key_int = int(priv, 16)     key, z, k = ecdsa_raw_sign(msghash, priv_key_int)     signer = DSS.new(key, 'fips-186-3')     hash_obj = SHA256.new(msghash.encode('utf-8'))     signature = signer.sign(hash_obj)     # 2. Tenter de récupérer la clé publique (incorrectement)     Q = recover_pubkey(msghash, signature, key)     # 3. Simuler une situation où la coordonnée Y est récupérée incorrectement     # Dans un scénario d'attaque réel, un attaquant essaiera de parcourir différentes coordonnées y.     # Dans cet exemple, nous modifions simplement légèrement la coordonnée x     tampered_key = ECC.construct(curve='P-256', d=priv_key_int + 1) # EXEMPLE ! NE PAS FAIRE CECI DANS LE CODE RÉEL !     Q_tampered = tampered_key.public_key()     return Q, Q_tampered # Exemple d'utilisation msghash = "Message example" # Générer une clé privée aléatoire private_key = ECC.generate(curve='P-256') priv = hex(private_key.d) # Stocker la clé privée sous forme de chaîne hexadécimale # Exemple d'utilisation Q, Q_tampered = emulate_attack(msghash, priv) print("Original Public Key:", Q) print("Tampered Public Key:", Q_tampered) print("Are the keys equal?", Q == Q_tampered)

Ce script montre comment la coordonnée Y peut être modifiée pour produire une clé publique invalide.

Veuillez noter que ce n'est qu'un exemple et qu'une véritable attaque peut être beaucoup plus complexe.

En plus du script ci-dessus, voici quelques points supplémentaires à considérer :

• Attaque Frey-Rück : Cette attaque exploite les vulnérabilités de la signature ECDSA pour extraire la clé privée « K » (nonce), ce qui peut finalement conduire à la récupération du portefeuille Bitcoin.
• Opérations binaires : XOR est un outil précieux pour le chiffrement des données et peut être utilisé en combinaison avec d'autres opérations pour améliorer la sécurité.
• Attaque des 51 % : Bien que non directement liée à la récupération de la coordonnée Y, il est important de comprendre qu'un attaquant qui contrôle plus de 50 % de la puissance de calcul du réseau peut potentiellement manipuler la blockchain.
• Manipulation des coordonnées de la courbe jacobienne : Les attaquants peuvent manipuler les propriétés mathématiques des coordonnées jacobiennes pour créer de fausses signatures numériques.
• Mise à jour logicielle : Il est extrêmement important de toujours mettre à jour votre logiciel et d'utiliser uniquement des appareils de confiance pour éviter une perte potentielle de pièces BTC due à des vulnérabilités critiques.

Vulnérabilité dans la fonction bin_ripemd160

Les API de hachage héritées sur le réseau Bitcoin, surtout en l'absence de RIPEMD-160, peuvent être vulnérables. Les attaquants peuvent identifier et exploiter des implémentations faibles, soulignant l'importance d'utiliser des bibliothèques cryptographiques à jour et des mises à jour de sécurité régulières.

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L378

Un attaquant sur le réseau Bitcoin pourrait trouver une vulnérabilité dans l'API de hachage héritée, surtout si certains systèmes manquent d'une implémentation RIPEMD-160. Le problème réside dans une fonction bin_ripemd160 qui tente d'utiliser hashlib pour le hachage, mais si cela échoue, elle bascule vers sa propre implémentation potentiellement plus faible.

Le script Python fourni montre comment un attaquant peut tester un nœud Bitcoin pour une telle implémentation d'API faible. Si hashlib ne supporte pas RIPEMD-160, une implémentation simplifiée est utilisée, ce qui peut conduire à des collisions de hachage et à d'autres vulnérabilités. Le script simule l'attaque en hachant les données et en imprimant un avertissement si une implémentation faible est utilisée.

Les risques incluent la possibilité de falsification de transaction et l'exploitation de vulnérabilités connues dans les API héritées. Pour vous protéger, il est recommandé d'utiliser des bibliothèques cryptographiques à jour et testées, de mettre régulièrement à jour le logiciel Bitcoin et de vérifier la sortie des opérations cryptographiques.

Un script Python dans lequel un attaquant Bitcoin trouve une API de hachage obsolète et discute du risque de ne pas implémenter RIPEMD-160 dans certains environnements :

Script Python ripemd160_vulnerability.py

Explication détaillée :

1. Implémentation RIPEMD160 (si elle n'est pas dans hashlib) :
   • La classe RIPEMD160 simule une implémentation de RIPEMD160. En réalité, elle devrait implémenter l'algorithme de hachage RIPEMD160. À des fins de démonstration, elle renvoie un hachage factice.
2. Fonction bin_ripemd160(string) :
   • Tente de hacher la chaîne d'entrée en utilisant RIPEMD160.
   • Essaie d'abord d'utiliser l'implémentation hashlib, et utilise l'implémentation personnalisée si nécessaire.
   • Si hashlib ne supporte pas RIPEMD160, il attrape l'exception ValueError et utilise une implémentation personnalisée.
3. Fonction check_for_weak_api(data) :
   • Cette fonction simule un attaquant testant un nœud du réseau Bitcoin pour des implémentations API faibles.
   • Indique que l'attaquant teste le nœud pour une API faible.
   • Encode les données au format utf-8.
   • Appelle bin_ripemd160 pour hacher les données.
   • Indique que les données ont été hachées et affiche la valeur du hachage.
   • Si le hachage est un faux hachage (20 octets de zéros), imprime un avertissement indiquant que le nœud utilise une implémentation faible ou personnalisée de RIPEMD160, ce qui peut entraîner des collisions de hachage ou d'autres vulnérabilités.
4. Exemple d'utilisation :
   • Dans le bloc if __name__ == "__main__":, il spécifie des données d'exemple et appelle check_for_weak_api avec ces données.

Comment cela fonctionne-t-il :

1. Simuler une attaque :
   • Le script simule un attaquant qui tente d'identifier les nœuds du réseau Bitcoin utilisant des API de hachage RIPEMD160 obsolètes ou faibles.
2. Vérification de l'implémentation RIPEMD160 :
   • Il essaie d'utiliser la bibliothèque standard hashlib pour le hachage RIPEMD160. En cas d'échec (car hashlib dans cet environnement particulier ne supporte pas RIPEMD160), il utilise une implémentation personnalisée (qui dans cet exemple est une version simplifiée).
3. Identification des faiblesses :
   • L'implémentation personnalisée (dans cet exemple) est intentionnellement faible. Un attaquant peut exploiter cette faiblesse si un nœud utilise cette implémentation.
4. Risques possibles :
   • Collisions de hachage : Une implémentation faible du hachage RIPEMD160 peut être sensible aux collisions. Un attaquant peut l'utiliser pour altérer des transactions ou des données.
   • Vulnérabilités de sécurité : Les API obsolètes peuvent contenir des vulnérabilités connues qu'un attaquant pourrait exploiter.

Comment atténuer :

1. Utiliser des bibliothèques à jour :
   • Assurez-vous d'utiliser des bibliothèques à jour et testées pour les opérations cryptographiques.
   • Si RIPEMD160 est nécessaire, utilisez une implémentation fiable et à jour.
2. Mises à jour régulières :
   • Maintenez votre logiciel Bitcoin à jour pour bénéficier des correctifs de sécurité et des améliorations.
3. Validation :
   • Vérifiez toujours la sortie des opérations cryptographiques pour vous assurer qu'elles répondent aux normes attendues.

Vulnérabilité dans la fonction multiply : absence de vérification d'un point sur la courbe ECC

Bitcoin présente une vulnérabilité potentielle dans sa fonction  multiply en raison d'une validation insuffisante des points sur la courbe ECC. Cela pourrait permettre à un attaquant de réaliser des attaques par courbes invalides, bien que les bibliothèques cryptographiques modernes telles que  pycryptodome rendent une telle exploitation difficile. L'attaque est possible via la manipulation de la courbe jacobienne , ce qui pourrait conduire à des signatures falsifiées et à une manipulation du réseau.

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L275

Dans le réseau Bitcoin, un attaquant peut trouver une vulnérabilité dans la fonction  multiply qui manque d'une vérification complète qu'un point se trouve sur une courbe elliptique (ECC). Dans le code, la vérification n'est effectuée que pour les points non nuls, ce qui ouvre la possibilité d'attaques utilisant des courbes invalides (invalid curve attacks).

Le code d'exemple de l'attaquant montre comment cette vulnérabilité peut être exploitée. Il présente une fonction  multiply qui manque d'une vérification fiable d'un point sur une courbe, et une fonction  invalid_curve_attack qui tente d'exploiter cette faiblesse. Le code utilise également les bibliothèques  pycryptodome pour les opérations cryptographiques.

Il est  pycryptodome plus difficile d'effectuer de telles attaques directement en raison des mécanismes de sécurité intégrés. Le code montre comment créer une courbe « incorrecte » et tenter d'effectuer une multiplication, mais il est souligné que cela n'est pas sécurisé et nécessite une connaissance approfondie de la cryptographie.

En exploitant une vulnérabilité dans la fonction multiply, un attaquant peut effectuer une attaque par courbe invalide pour compromettre les clés privées sur le réseau Bitcoin. Voici un exemple de script Python démontrant cette attaque.

Script Python ecdsa_curve_attack.py

!pip install pycryptodome 
from Crypto.Hash import SHA256 
from Crypto.Signature import DSS 
from Crypto.PublicKey import ECC 
from Crypto.Math import * 

class Exploit: 
    def __init__(self): 
        self.msg = "ATTACK!" 
        self.hash = hash_msg(self.msg) 

    def sign_message(self, private_key): 
        signer = DSS.new(private_key, 'fips-186-3') 
        signature = signer.sign(self.hash) 
        return signature 

    def verify_signature(self, public_key, signature): 
        verifier = DSS.new(public_key, 'fips-186-3') 
        try: 
            verifier.verify(self.hash, signature) 
            return True 
        except ValueError: 
            return False 

def hash_msg(msg): 
    hasher = SHA256.new(msg.encode('utf-8')) 
    return hasher.digest() 

# Elliptic curve parameters (example, must be replaced with the parameters of the curve being used) 
# WARNING: IN REAL CODE, YOU MUST USE SECURE CURVES AND THEIR PARAMETERS! 
# EXAMPLE FOR DEMONSTRATION, DO NOT USE IN PRODUCTION! 
curve = 'secp256r1' # Or another curve 

# Vulnerable function (EXAMPLE! PyCryptodome HAS NO DIRECT EQUIVALENT to fast_multiply) 
# This function is here to demonstrate the vulnerability, but requires adaptation to specific needs and cryptographic primitives. 
def multiply(pubkey, privkey): 
    # WARNING: THIS IS A VERY SIMPLIFIED EXAMPLE, NOT SAFE! 
    # IN REAL CODE, YOU NEED TO USE CRYPTOGRAPHICALLY SECURE METHODS! 
    # Checking if the point is on the curve. In PyCryptodome, this is done automatically. 
    
    #Performing multiplication 
    result = privkey.d * pubkey.pointQ 
    
    return result 

# Example of invalid curve attack (adapted for pycryptodome) 
def invalid_curve_attack(public_key, malformed_curve_parameters): 
    # Creating a "wrong" curve (example!) 
    #malformed_curve = ECC.CurveObj(malformed_curve_parameters['name'], 
    # malformed_curve_parameters['oid'], 
    # malformed_curve_parameters['field'], 
    # malformed_curve_parameters['a'], 
    # malformed_curve_parameters['b'], 
    # malformed_curve_parameters['generator'], 
    # malformed_curve_parameters['order']) 

    # Creating a public key on the "wrong" curve (example!)
    #attacker_key = ECC.EccPoint(malformed_curve_parameters['generator'].x, malformed_curve_parameters['generator'].y, malformed_curve) 
    
    # Creating a fake private key (example!)     #attacker_private_key = ECC.construct(curve=malformed_curve, pointQ=attacker_key)     # WARNING: In PyCryptodome, it is more difficult to directly manipulate curves and points     # to demonstrate invalid curve attack. This code is left commented out,     # because correct operation requires a deep understanding of ECC and unsafe operations.     # It is recommended to use standard curves and avoid creating your own.     # Performing multiplication using the vulnerable function (EXAMPLE! NOT SAFE!)     # result = multiply(attacker_key, attacker_private_key)     # return result     return None # Returning None to avoid an error # Example of "wrong" curve parameters (NEVER USE IN PRODUCTION!) # This is just an example showing the data structure. Real parameters should be carefully selected. # These parameters are commented out to avoid an error when creating EccPoint with curve=None malformed_curve_parameters = {     #'name': "MalformedCurve",     #'oid': "1.2.3.4",     #'field': 17,     #'a': 2,     #'b': 3,     #'generator': ECC.EccPoint(5, 1), # Removed None because it causes an error     #'order': 19 } # Creating a private key (for example) private_key = ECC.generate(curve=curve) public_key = private_key.public_key() # Example of using invalid curve attack attack_result = invalid_curve_attack(public_key, malformed_curve_parameters) print(attack_result)

Explication du code :

• Vulnérabilité : La fonction multiply vérifie qu'un point est sur la courbe ECC uniquement s'il n'est pas un point à l'infini. Cela permet d'utiliser des points qui ne sont pas sur la courbe principale, mais sur la courbe tordue.
• Attaque par courbe invalide : L'attaque consiste à utiliser un point sur une autre courbe (courbe malformée) pour obtenir des informations sur la clé secrète. Comme la vérification de la courbe n'est pas effectuée pour tous les points, il est possible de passer un point d'une autre courbe et d'utiliser le résultat pour récupérer une partie de la clé secrète.
• Fonction invalid_curve_attack : Cette fonction prend une clé publique et des paramètres de courbe malformés. Elle crée un point sur la courbe malformée et utilise la fonction vulnérable multiply pour effectuer la multiplication.

Comment fonctionne l'attaque par petit sous-groupe :

1. Sélection d'un point de faible ordre : L'attaquant sélectionne un point Q de faible ordre sur la courbe ou sur la torsion de la courbe.
2. Envoi d'un point : L'attaquant envoie ce point Q à la victime, en le faisant passer pour sa clé publique.
3. Calcul du secret partagé : La victime calcule nQ, où n est la clé secrète de la victime.
4. Force brute : Comme Q a un petit ordre, il y a un petit nombre de valeurs possibles pour nQ. Un attaquant peut essayer par force brute toutes ces valeurs et vérifier laquelle correspond aux données chiffrées en déterminant n modulo l'ordre de Q.

Recommandations :

• Vérifiez toujours que les points d'entrée sont effectivement sur la courbe ECC.
• Utilisez des bibliothèques qui offrent une vérification robuste des courbes et une protection contre les attaques par courbes invalides.

Small Subgroup Attack

Décodez une transaction RawTX vulnérable à l'aide de la fonction de service SMALL SUBGROUP ATTACK

Le résultat est la valeur K de la clé secrète Nonce au format HEX

K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2

Pour obtenir toutes les autres valeurs de la transaction RawTX vulnérable, nous utiliserons le service de décodage de signature RSZ.

Valeurs résultantes pour R, S, Z au format HEX

R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8

Pour obtenir la valeur X de la clé privée à partir de la formule : priv_key = ((((S * K) - Z) * modinv(R, N)) % N), nous utiliserons le logiciel Dockeyhunt Private Key Calculator

En conséquence, nous obtenons la valeur de la clé privée X au format HEX

X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34

Vérifions le résultat de la clé privée obtenue à l'aide de l'apprentissage automatique

Lançons BitcoinChatGPT

%run BitcoinChatGPT

Apply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency

---

Enfin, le module BitcoinChatGPT envoie la réponse au fichier : KEYFOUND.privkey stockant la clé privée dans les deux formats les plus utilisés HEX & WIF

https://github.com/demining/CryptoDeepTools/blob/main/39BluetoothAttacks/KEYFOUND.privkey

============================= KEYFOUND.privkey =============================

Private Key HEX: 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34

Private Key WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ

Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ

Balance: 10.00000000 BTC

============================= KEYFOUND.privkey =============================

Pour implémenter le code, nous installerons le package Bitcoin. Cette bibliothèque permet de créer des portefeuilles, d'interagir avec la blockchain, de créer et signer des transactions, et de travailler avec divers formats d'adresse et clés privées de la cryptomonnaie Bitcoin.

!pip3 install bitcoin

Exécutons  le code  pour vérifier la correspondance de l'adresse Bitcoin :

__________________________________________________

Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received 	= 10.00000000 Bitcoin
__________________________________________________

C'est exact ! La clé privée correspond au portefeuille Bitcoin.

Ouvrons  bitaddress  et vérifions :

ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF:  5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX:  12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34

Résultats et mesures pour réduire la menace

Dans l'environnement numérique actuel, la sécurisation des appareils et des réseaux est cruciale. Cet article analyse un certain nombre de vulnérabilités trouvées dans divers composants, notamment les appareils ESP32 et les logiciels de travail avec les cryptomonnaies comme Bitcoin. Nous examinons les failles dans le code de vérification des clés privées, les méthodes de hachage des transactions, la génération de clés aléatoires, la vérification des points de courbe ECC, la récupération de la coordonnée Y, et les API de hachage obsolètes. Une attention particulière est portée à la vulnérabilité CVE-2025-27840 dans les microcontrôleurs ESP32, qui permet aux attaquants d'injecter de fausses mises à jour et d'obtenir un accès bas niveau au système. Les implications potentielles de ces vulnérabilités sont discutées, notamment la possibilité de contourner les contrôles d'audit de code, d'accéder aux clés privées et de mener des attaques sur la chaîne d'approvisionnement. L'article conclut par des recommandations pour renforcer la sécurité et prévenir les attaques potentielles.

Pertinence

Des milliards d'appareils pourraient désormais être vulnérables à des défauts de conception cachés dans un seul composant, identifié comme CVE-2025-27840. Les vulnérabilités pourraient permettre aux attaquants d'usurper des adresses MAC, d'obtenir un accès non autorisé à la mémoire de l'appareil et de mener des attaques via Bluetooth.

Vulnérabilités et leur analyse

• Vulnérabilité de dérivation de clé privée danshas_invalid_privkey : L'absence de vérification de la limite inférieure pour les clés privées Bitcoin permet d'utiliser des clés invalides (inférieures ou égales à 0), ce qui peut entraîner une perte de fonds.
• Vulnérabilité de falsification de signature de transaction Bitcoin dans la fonctionelectrum_sig_hash : L'utilisation par Electrum d'une méthode de hachage de message non standard la rend vulnérable aux attaques de falsification de signature en raison de son incompatibilité avec BIP-137.
• Vulnérabilité de la fonction random_key(PRNG faible dans la génération de clés) : L'utilisation du module de génération de clés randomdans le réseau Bitcoin rend les clés privées prévisibles pour les attaquants, car ce module n'est pas destiné à des fins cryptographiques.
• Vulnérabilité dans la fonction multiply(Absence de validation des points de courbe ECC) : Une validation insuffisante des points sur la courbe ECC peut permettre à un attaquant de mener des attaques par courbe invalide, ce qui peut entraîner des signatures falsifiées et une manipulation du réseau.
• Vulnérabilité dans la fonctionecdsa_raw_sign : Une restauration incorrecte de la coordonnée Y peut entraîner la substitution d'une clé publique dans le réseau Bitcoin.
• Vulnérabilité de la fonctionbin_ripemd160 : Les API de hachage obsolètes, en particulier celles qui manquent de RIPEMD-160, peuvent être vulnérables aux attaques, soulignant l'importance d'utiliser des bibliothèques cryptographiques à jour et des mises à jour régulières de sécurité.

Avantages de l'identification et de la correction des vulnérabilités

1. Prévention des pertes financières : La correction des vulnérabilités liées aux clés privées et à la falsification de signature aide à empêcher les utilisateurs de cryptomonnaies de perdre des fonds.
2. Protection des données confidentielles : La correction des vulnérabilités dans les appareils ESP32 empêche l'accès non autorisé à la mémoire et l'usurpation d'adresse MAC, ce qui protège les données confidentielles des utilisateurs.
3. Amélioration de la sécurité du réseau : La correction des vulnérabilités dans les fonctions cryptographiques telles que random_keyet ecdsa_raw_signaméliore la sécurité globale du réseau Bitcoin et prévient les attaques potentielles sur les transactions et les signatures.
4. Renforcement de la confiance des utilisateurs : L'identification et la correction en temps opportun des vulnérabilités aident à renforcer la confiance des utilisateurs dans les appareils et les logiciels, ce qui est particulièrement important dans le domaine des cryptomonnaies et de l'IoT.
5. Maintien des normes de sécurité : Maintenir à jour les bibliothèques cryptographiques et les API, et suivre les normes de sécurité modernes, aide à prévenir l'utilisation de composants obsolètes et vulnérables.

Conclusion

L'identification et l'analyse des vulnérabilités présentées dans cet article soulignent la nécessité d'une surveillance et d'une amélioration continues de la sécurité des appareils et des logiciels. Corriger ces vulnérabilités permet non seulement de prévenir les attaques potentielles et les pertes financières, mais aussi de renforcer la confiance des utilisateurs et de se conformer aux normes de sécurité. La mise en œuvre de mécanismes de protection robustes et de mises à jour régulières de la sécurité est essentielle pour garantir un fonctionnement sûr et fiable des systèmes numériques. La nécessité d'améliorer la sécurité des appareils et des réseaux tels que l'ESP32 devient de plus en plus urgente.

Références :

1. Recommandations pour éliminer les vulnérabilités dans le code Bitcoin et les appareils ESP32
2. Faiblesses dans l'implémentation de Bitcoin : comment les vulnérabilités de random_key et ecdsa_raw_sign compromettent la sécurité
3. Analyse de la vulnérabilité de la fonction has_invalid_privkey : problèmes de vérification des clés privées Bitcoin et recommandations de correction
4. Substitution de clé publique : vulnérabilité de la fonction ecdsa_raw_sign, risques liés à la récupération de la coordonnée Y, exemples de code pour démontrer la vulnérabilité
5. Sécurité Bitcoin : examen des risques liés à une vérification ECC incorrecte et aux API de hachage obsolètes
6. Analyse des risques de sécurité : vulnérabilités dans les appareils ESP32 et le réseau Bitcoin
7. API de hachage obsolètes dans Bitcoin : vulnérabilités de la fonction bin_ripemd160
8. Fausses mises à jour et accès aux clés privées : vulnérabilités ESP32 et leurs conséquences
9. Risques de sécurité Bitcoin : vulnérabilités dans les fonctions de vérification des clés et de génération de transactions
10. Problèmes de génération de clés : vulnérabilité de la fonction random_key, générateur de nombres pseudo-aléatoires faible et ses conséquences
11. Lacunes des fonctions cryptographiques dans Bitcoin et menaces potentielles pour le réseau
12. Attaques sur courbe elliptique : vulnérabilité de la fonction multiply, vérification insuffisante des points sur la courbe ECC, vecteurs d'attaque possibles

Ce matériel a été créé pour le portail  CRYPTO DEEP TECH pour assurer la sécurité des données financières et la cryptographie sur courbes elliptiques  secp256k1  contre les signatures  ECDSA faibles dans la cryptomonnaie  BITCOIN. Les créateurs du logiciel ne sont pas responsables de l'utilisation des matériaux.

Code source

Google Colab

BitcoinChatGPT

Attaque par sous-groupe restreint

Dockeyhunt Deep Learning

Telegram : https://t.me/cryptodeeptech

Vidéo : https://youtu.be/nBeZWm2z5o4

Tutoriel vidéo : https://dzen.ru/video/watch/6784be61b09e46422395c236

Source : https://cryptodeeptech.ru/bitcoin-bluetooth-attacks