demining/bluetooth-attacks-cve-2025-27840Crittanalisi Bitcoin: la vulnerabilità CVE-2025-27840 nei microcontrollori ESP32 mette a rischio miliardi di dispositivi IoT tramite Wi-Fi e Bluetooth
Il presente documento illustra come un attaccante possa introdurre un elenco nascosto di vulnerabilità attraverso gli aggiornamenti dei moduli, il che può portare al compromesso dei dispositivi ESP32 e all'ottenimento di accesso non autorizzato alle chiavi private, colpendo miliardi di dispositivi che utilizzano questo microcontrollore. Uno dei problemi principali è la vulnerabilità CVE-2025-27840 scoperta nell'architettura ESP32. Per garantire la sicurezza della rete Bitcoin, abbiamo identificato le seguenti vulnerabilità: la possibilità di utilizzare chiavi private non valide a causa della mancanza di un controllo del limite inferiore nella funzione has_invalid_privkey; una vulnerabilità nella contraffazione delle firme delle transazioni nella funzione electrum_sig_hash dovuta all'incompatibilità con BIP-137; un problema di PRNG debole nella funzione di generazione delle chiavi random_key, che rende prevedibili le chiavi private personali dei portafogli di criptovaluta; la mancanza di verifica dei punti sulla curva ECC nella funzione multiply, che può portare ad attacchi di curva non valida; una vulnerabilità nella funzione ecdsa_raw_sign durante il ripristino della coordinata Y, che può potenzialmente portare alla sostituzione della chiave pubblica; e vulnerabilità relative alle API di hashing deprecate in bin_ripemd160.
All'inizio di marzo 2025, Tarlogic Security ha identificato una vulnerabilità nel microcontrollore ESP32, ampiamente utilizzato per connettere i dispositivi tramite WiFi e Bluetooth. Questa vulnerabilità è stata registrata con il numero CVE-2025-27840 . Gli attaccanti possono accedere senza autorizzazione ai dati dei portafogli Bitcoin utilizzando il chip ESP32 come punto di partenza per attacchi crittografici sui dispositivi che operano sulle reti di criptovalute popolari come Bitcoin ed Ethereum. Il problema riguarda milioni di dispositivi IoT che utilizzano questo microcontrollore. Lo sfruttamento di questa vulnerabilità consentirà agli attaccanti di condurre attacchi mascherandosi da utenti legittimi e di infettare permanentemente i dispositivi vulnerabili. Ciò minaccia la sicurezza dei dispositivi IoT basati sul microcontrollore ESP32 e può portare al furto delle chiavi private dei portafogli Bitcoin.
ESP32 è un microcontrollore ampiamente utilizzato nei dispositivi IoT per fornire connettività Wi-Fi e Bluetooth. Gli attaccanti possono utilizzare vari metodi per ottenere l'accesso ai dati delle chiavi private dei portafogli Bitcoin tramite ESP32.
Le minacce alla sicurezza legate al microcontrollore ESP32 possono portare al furto delle chiavi private dei portafogli Bitcoin. I problemi principali includono la presenza di backdoor e vulnerabilità. Sfruttando tali vulnerabilità, gli attaccanti possono manipolare la memoria, falsificare gli indirizzi MAC e iniettare codice dannoso, creando seri rischi per la sicurezza.
Gli attaccanti possono colpire i dispositivi IoT dotati di microcontrollore ESP32 sfruttando le vulnerabilità nelle connessioni Bluetooth e Wi-Fi, che possono diventare uno strumento per attaccare altri dispositivi sulla rete correlata a Bitcoin, oltre che per rubare informazioni riservate, incluse le chiavi private dei portafogli Bitcoin.
Un attaccante può aggiornare i moduli e introdurre nel codice un elenco di varie vulnerabilità, tra cui:
has_invalid_privkey che può essere utilizzata per ottenere la chiave privata.electrum_sig_hash consente di contraffare le firme delle transazioni Bitcoin.random_key legata a un generatore di numeri pseudo-casuali debole (PRNG non deterministico).multiply in cui non viene effettuato alcun controllo di un punto sulla curva ECC.ecdsa_raw_sign e bin_ripemd160.Queste vulnerabilità possono essere utilizzate per iniettare aggiornamenti falsi nei dispositivi ESP32, offrendo agli attaccanti un accesso di basso livello al sistema. Ciò consentirà loro di aggirare i controlli di audit del codice e di ottenere l'accesso alle chiavi private. Attualmente, miliardi di dispositivi potrebbero essere vulnerabili a causa delle funzionalità nascoste di un singolo componente nella loro architettura, designato come CVE-2025-27840.
has_invalid_privkeyQuesta vulnerabilità è stata riscontrata nel codice di verifica delle chiavi private di Bitcoin e consente l'utilizzo di chiavi non valide (minori o uguali a 0) a causa della mancanza di un controllo del limite inferiore. Ciò può portare alla perdita di fondi. Per risolvere il problema, è necessario aggiungere un controllo che verifichi che la chiave privata sia maggiore di 0. Il codice è fornito a scopo dimostrativo.
Questo bug consente l'utilizzo di chiavi private non valide, il che può portare a seri problemi, inclusa la perdita di denaro.
Per risolvere il problema, è necessario aggiungere un controllo che verifichi che la chiave privata sia maggiore di 0.
Immaginate che qualcuno cerchi di “hackerare” la rete Bitcoin. Trova un punto debole nella verifica delle chiavi private utilizzate per accedere alla criptovaluta.
Il problema è che il codice controlla solo se la chiave privata è troppo grande. Se la chiave è molto grande, viene respinta. Ma il codice dimentica di verificare se la chiave è troppo piccola (minore o uguale a zero).
La sezione di codice in cui ciò accade:
...
...if privkey >= N: #Controlla solo il limite superioreIl limite inferiore non viene controllato correttamente
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
A causa di questo bug, è possibile utilizzare chiavi private non valide (molto piccole). Questa vulnerabilità si trova nella funzione has_invalid_privkey.
Affinché tutto ciò funzioni, è necessario installare la libreria ecdsa (serve per lavorare con la crittografia):
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.")
Spiegazione del codice:
ecdsa : sebbene non venga utilizzata direttamente in questo esempio, in scenari reali che coinvolgono Bitcoin ed ECDSA (Elliptic Curve Digital Signature Algorithm), questa libreria potrebbe essere necessaria per eseguire operazioni crittografiche.has_invalid_privkey(privkey: int) -> bool :
privkey accetta una chiave privata come intero in input.N che rappresenta l'ordine della curva ellittica secp256k1 utilizzata in Bitcoin.privkey è maggiore o uguale a N. In tal caso, genera un'eccezione indicando che la chiave privata non è valida.privkey è minore o uguale a 0. In tal caso, restituisce True, indicando che la chiave privata non è valida a causa della mancanza del controllo del limite inferiore.False.privkey = 0, che è una chiave privata non valida.Vulnerabilità :
Il codice contiene una vulnerabilità legata a una verifica insufficiente della chiave privata. In particolare, manca il controllo del limite inferiore (privkey <= 0). Ciò consente l'utilizzo di chiavi private non valide, il che può portare a conseguenze imprevedibili, inclusa la perdita di fondi.
Come risolverlo :
È necessario aggiungere un controllo del limite inferiore sulla chiave privata per garantire che sia maggiore di 0.
electrum_sig_hashLa funzione electrum_sig_hash in Electrum utilizza un metodo di hashing del messaggio non standard, rendendola vulnerabile ad attacchi di contraffazione delle firme a causa della sua incompatibilità con BIP-137.
Un attaccante che prende di mira la rete Bitcoin può scoprire il metodo di hashing del messaggio non standard utilizzato da Electrum tramite la electrum_sig_hash. Questa funzione crea un hash del messaggio in un modo che può portare ad attacchi di contraffazione delle firme a causa della sua incompatibilità con BIP-137. Lo script Python fornito dimostra come un attaccante possa generare l'hash del messaggio utilizzato da Electrum per sfruttare la vulnerabilità di incompatibilità con BIP-137. La funzione electrum_sig_hash prepara il messaggio anteponendo un prefisso e codificandone la lunghezza prima di applicare il doppio hash SHA256.
Uno script Python che dimostra come un attaccante possa trovare un hash del messaggio non standard utilizzato da Electrum per eseguire attacchi di contraffazione delle firme a causa dell'incompatibilità con 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()}")
In questo script:
num_to_var_int(i): converte un intero nel formato a lunghezza variabile utilizzato in Bitcoin.from_string_to_bytes(s): codifica una stringa in byte utilizzando la codifica UTF-8.bin_dbl_sha256(s): esegue un doppio hashing SHA256 sull'input.electrum_sig_hash(message): simula il metodo non standard di hashing dei messaggi di Electrum, soggetto all'incompatibilità con BIP-137.random_key con PRNG debole nella generazione delle chiavi (PRNG non deterministico)Il problema sorge quando Bitcoin utilizza una funzione random_key che si basa sul modulo random per creare le chiavi. Il modulo random non è destinato a scopi crittografici perché non genera numeri sufficientemente casuali, rendendo le chiavi private prevedibili per gli attaccanti. Ciò lascia la rete Bitcoin vulnerabile.
Uno script Python che rende vulnerabile la rete Bitcoin utilizzando random invece di secrets o os.urandom, rendendo le chiavi private prevedibili per un attaccante 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():
# Gotta be secure after that java.SecureRandom fiasco...
entropy = random_string(32) \
+ str(random.randrange(2**256)) \
+ str(int(time.time() * 1000000))
return sha256(entropy.encode('utf-8')).hexdigest()
# Example usage: generate a private key
private_key = random_key()
print("Generated Private Key:", private_key)Questo script utilizza il modulo random per generare le chiavi, il che lo rende vulnerabile. L'utilizzo del modulo random non è adatto a scopi crittografici perché non genera numeri sufficientemente casuali.
Per creare una chiave più sicura, puoi utilizzare il modulo secrets o os.urandom. Ecco un esempio di utilizzo del modulo secrets:
import secrets
import hashlib
def secure_random_key():
# Generate a random number with enough entropy
random_bytes = secrets.token_bytes(32) # 32 bytes = 256 bits
# Hash the random bytes to create a private key
private_key = hashlib.sha256(random_bytes).hexdigest()
return private_key
# Example usage: generate a secure private key
secure_private_key = secure_random_key()
print("Generated Secure Private Key:", secure_private_key)In questo esempio, il modulo secrets viene utilizzato per generare un numero casuale con entropia sufficiente. Il numero casuale viene poi sottoposto a hash per creare una chiave privata personale. Questo metodo è molto più sicuro rispetto all'utilizzo del modulo random.
Una vulnerabilità nella funzione ecdsa_raw_sign durante il ripristino della coordinata Y può portare alla sostituzione di una chiave pubblica nella rete Bitcoin. Esiste un alto rischio che un attaccante possa sfruttare la peculiarità del ripristino della coordinata Y quando lavora con una curva ellittica. Questa ambiguità può portare al fatto che la chiave pubblica venga ripristinata in modo errato .
L'esempio di codice, fornito utilizzando la libreria pycryptodome, dimostra come questa situazione possa essere simulata sostituendo la coordinata Y per ottenere una chiave pubblica diversa e non valida. È importante notare che l'esempio di codice è semplificato e non è un'implementazione completa dell'attacco , ma ne mostra solo il principio.
Un attaccante può sfruttare l'ambiguità del recupero della coordinata Y nella rete Bitcoin, il che può portare a errori nel recupero della chiave pubblica. Ecco un esempio di come ciò possa essere fatto utilizzando l'operazione XOR bit a bit.
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
# Elliptic curve parameters secp256k1
# PyCryptodome does not provide a convenient way to directly specify the parameters of the secp256k1 curve.
# Therefore, we will use the standard ECC curve.
# For production code, be careful when choosing the curve and its parameters.
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 # Removed % N, since N is no longer a defined constant
return k
def ecdsa_raw_sign(msghash, priv_key_int):
z = hash_to_int(msghash)
k = deterministic_generate_k(msghash, priv_key_int)
# Generate private key object
key = ECC.construct(curve='P-256', d=priv_key_int)
# Calculate point R = kG
# PyCryptodome does not provide direct access to the coordinates of point R
# Therefore, the signature will be calculated in a different way, using DSS
# s = pow(k, -1, N) * (z + r * private_key_int) % N # N is no longer defined
# v = 27 + ((y % 2) ^ (0 if s * 2 < N else 1)) # y is not available
return key, z, k # Return the key, hash, and k for further use in signing
def recover_pubkey(msghash, signature, key):
# WARNING: This is a VERY SIMPLIFIED example of public key recovery.
# In real life, ECDSA public key recovery is a complex process.
# This code is intended only to demonstrate the principle.
# PyCryptodome does not have a simple way to recover PublicKey from r and s directly.
# This code does not perform real recovery, but creates a new PublicKey from the private key.
# In a real attack scenario, you need to try to guess the y-coordinate to get a valid PublicKey.
# But this requires a more complex logic to work with the elliptic curve. return key.public_key()def emulate_attack(msghash, priv): # 1. Sign the 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. Attempt to recover the public key (incorrectly) Q = recover_pubkey(msghash, signature, key) # 3. Simulate a situation where the Y coordinate is recovered incorrectly # In a real attack scenario, an attacker will try to iterate through different y-coordinates. # In this example, we simply change the x-coordinate slightly tampered_key = ECC.construct(curve='P-256', d=priv_key_int + 1) # EXAMPLE! DO NOT DO THIS IN REAL CODE! Q_tampered = tampered_key.public_key() return Q, Q_tampered # Example usage msghash = "Message example" # Generate a random private key private_key = ECC.generate(curve='P-256') priv = hex(private_key.d) # Store private key as a hex string # Example usage 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)
Questo script dimostra come la coordinata Y possa essere modificata per produrre una chiave pubblica non valida.
Tieni presente che questo è solo un esempio e un attacco reale potrebbe essere molto più complesso.
Oltre allo script di cui sopra, ecco alcuni punti aggiuntivi da considerare:
Le API di hashing legacy sulla rete Bitcoin, soprattutto in assenza di RIPEMD-160, possono essere vulnerabili. Gli attaccanti possono identificare e sfruttare implementazioni deboli, evidenziando l'importanza di utilizzare librerie crittografiche aggiornate e aggiornamenti di sicurezza regolari.
Un attaccante sulla rete Bitcoin potrebbe trovare una vulnerabilità nell'API di hashing legacy, soprattutto se alcuni sistemi non dispongono di un'implementazione di RIPEMD-160. Il problema è in una funzione bin_ripemd160 che tenta di utilizzare hashlib per l'hashing, ma se ciò fallisce, passa alla propria implementazione, potenzialmente più debole.
Lo script Python fornito dimostra come un attaccante possa testare un nodo Bitcoin per verificare la presenza di un'implementazione API debole. Se hashlib non supporta RIPEMD-160, viene utilizzata un'implementazione semplificata, che può portare a collisioni di hash e ad altre vulnerabilità. Lo script simula l'attacco eseguendo l'hashing dei dati e stampando un avviso se viene utilizzata un'implementazione debole.
I rischi includono la possibilità di falsificazione delle transazioni e lo sfruttamento di vulnerabilità note nelle API legacy. Per proteggerti, si consiglia di utilizzare librerie crittografiche aggiornate e testate, aggiornare regolarmente il software Bitcoin e verificare l'output delle operazioni crittografiche.
Uno script Python in cui un attaccante Bitcoin trova un'API di hashing deprecata e discute il rischio di non implementare RIPEMD-160 in determinati ambienti:
Script Python ripemd160_vulnerability.py
RIPEMD160 simula un'implementazione di RIPEMD160. In realtà, dovrebbe implementare l'algoritmo di hashing RIPEMD160. A scopo dimostrativo, restituisce un hash fittizio.bin_ripemd160(string):
check_for_weak_api(data):
bin_ripemd160 per l'hashing dei dati.if __name__ == "__main__":, specifica dati di esempio e chiama check_for_weak_api con quei dati.hashlib per l'hashing RIPEMD160. Se questo fallisce (perché hashlib nell'ambiente particolare non supporta RIPEMD160), ripiega su un'implementazione personalizzata (che in questo esempio è una versione semplificata).multiply: nessun controllo di un punto sulla curva ECCBitcoin presenta una potenziale vulnerabilità nella sua funzione multiply a causa di una validazione insufficiente dei punti sulla curva ECC. Questo potrebbe consentire a un attaccante di eseguire attacchi con curva non valida, sebbene le moderne librerie crittografiche come pycryptodome rendano difficile tale sfruttamento. L'attacco è possibile tramite manipolazione della curva jacobiana, che potrebbe portare a firme contraffatte e alla manipolazione della rete.
Nella rete Bitcoin, un attaccante può trovare una vulnerabilità nella funzione multiply, che non esegue un controllo completo che un punto sia su una curva ellittica (ECC). Nel codice, il controllo viene eseguito solo per i punti non nulli, il che apre la possibilità di attacchi che utilizzano curve non valide (invalid curve attacks).
Il codice di esempio dell'attaccante mostra come questa vulnerabilità possa essere sfruttata. Dimostra una funzione multiply che non esegue un controllo affidabile che un punto si trovi su una curva, e una funzione invalid_curve_attack che tenta di sfruttare questa debolezza. Il codice utilizza anche le librerie pycryptodome per le operazioni crittografiche.
Con pycryptodome è più difficile eseguire direttamente tali attacchi a causa dei meccanismi di sicurezza integrati. Il codice mostra come si possa creare una curva “errata” e tentare di eseguire una moltiplicazione, ma viene sottolineato che questo è insicuro e richiede una profonda comprensione della crittografia.
Sfruttando una vulnerabilità nella funzione
multiply, un attaccante può eseguire un attacco con curva non valida per compromettere le chiavi private sulla rete Bitcoin. Di seguito è riportato uno script Python di esempio che dimostra questo attacco.
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)
Spiegazione del codice:
multiply controlla che un punto sia sulla curva ECC solo se non è un punto all'infinito. Questo consente di utilizzare punti che non sono sulla curva principale, ma sono sulla curva twist.invalid_curve_attack: Questa funzione prende una chiave pubblica e parametri di curva malformata. Crea un punto sulla curva malformata e utilizza la funzione vulnerabile multiply per eseguire la moltiplicazione.Come funziona l'attacco al piccolo sottogruppo:
Q di ordine basso sulla curva o sulla twist della curva.Q alla vittima, spacciandolo per la sua chiave pubblica.nQ, dove n è la chiave segreta della vittima.Q ha un ordine piccolo, esiste un numero limitato di valori possibili per nQ. Un attaccante può forzare a forza bruta tutti questi valori e verificare quale corrisponde ai dati crittografati espandendo n modulo l'ordine di Q.Raccomandazioni:
Decodifica una transazione RawTX vulnerabile utilizzando la funzione di servizio SMALL SUBGROUP ATTACK
Il risultato è il valore K della chiave segreta Nonce in formato HEX
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2Per ottenere tutti gli altri valori dalla transazione RawTX vulnerabile, utilizzeremo il servizio RSZ Signature Decoder.
Valori risultanti per R, S, Z in formato HEX
R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8Per ottenere il valore X della chiave privata dalla formula: priv_key = ((((S * K) - Z) * modinv(R, N)) % N) utilizzeremo il software Dockeyhunt Private Key Calculator
Di conseguenza, otteniamo il valore X della chiave privata in formato HEX
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34Avviamo BitcoinChatGPT
%run BitcoinChatGPTApply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency
Infine, il modulo BitcoinChatGPT restituisce la risposta nel file: KEYFOUND.privkey memorizzando la chiave privata nei due formati più utilizzati 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 =============================Per implementare il codice, installeremo il pacchetto Bitcoin . Questa libreria consente di creare wallet, interagire con la blockchain, creare e firmare transazioni e lavorare con vari formati di indirizzo e chiavi private della criptovaluta Bitcoin.
!pip3 install bitcoinEseguiamo il codice per verificare la corrispondenza dell'indirizzo Bitcoin:
__________________________________________________
Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________Esatto! La chiave privata corrisponde al Bitcoin Wallet.
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Nell'ambiente digitale odierno, proteggere dispositivi e reti è fondamentale. Questo articolo analizza una serie di vulnerabilità riscontrate in vari componenti, inclusi i dispositivi ESP32 e il software per lavorare con criptovalute come Bitcoin. Esaminiamo i difetti nel codice di verifica delle chiavi private, nei metodi di hashing delle transazioni, nella generazione casuale delle chiavi, nella verifica dei punti della curva ECC, nel recupero della coordinata Y e nelle API di hashing obsolete. Particolare attenzione è rivolta alla vulnerabilità CVE-2025-27840 nei microcontrollori ESP32, che consente agli attaccanti di iniettare aggiornamenti falsi e ottenere accesso a basso livello al sistema. Vengono discusse le potenziali implicazioni di queste vulnerabilità, tra cui la possibilità di bypassare i controlli di audit del codice, ottenere accesso alle chiavi private e condurre attacchi alla supply chain. L'articolo si conclude con raccomandazioni per rafforzare la sicurezza e prevenire potenziali attacchi.
Miliardi di dispositivi potrebbero ora essere vulnerabili a difetti di progettazione nascosti in un singolo componente, identificato come CVE-2025-27840. Le vulnerabilità potrebbero consentire agli attaccanti di falsificare gli indirizzi MAC, ottenere accesso non autorizzato alla memoria del dispositivo e condurre attacchi tramite Bluetooth.
has_invalid_privkey : La mancanza di controllo del limite inferiore per le chiavi private Bitcoin consente l'uso di chiavi non valide (minori o uguali a 0), il che può portare alla perdita di fondi.electrum_sig_hash : L'uso da parte di Electrum di un metodo di hashing dei messaggi non standard lo rende vulnerabile ad attacchi di falsificazione delle firme a causa della sua incompatibilità con BIP-137.random_key(PRNG debole nella generazione delle chiavi) : L'uso del modulo randomper la generazione delle chiavi nella rete Bitcoin rende le chiavi private prevedibili per gli attaccanti, poiché questo modulo non è destinato a scopi crittografici.multiply(Mancanza di validazione dei punti della curva ECC) : Una validazione insufficiente dei punti sulla curva ECC può consentire a un attaccante di condurre attacchi con curve non valide, il che può portare a firme contraffatte e manipolazione della rete.ecdsa_raw_sign : Il ripristino errato della coordinata Y può portare alla sostituzione di una chiave pubblica nella rete Bitcoin.bin_ripemd160 : Le API di hashing legacy, specialmente quelle prive di RIPEMD-160, possono essere vulnerabili ad attacchi, evidenziando l'importanza di utilizzare librerie crittografiche aggiornate e aggiornamenti di sicurezza regolari.
random_keye ecdsa_raw_signmigliora la sicurezza complessiva della rete Bitcoin e previene potenziali attacchi a transazioni e firme.L'identificazione e l'analisi delle vulnerabilità presentate in questo articolo evidenziano la necessità di un monitoraggio continuo e di un miglioramento della sicurezza di dispositivi e software. Affrontare queste vulnerabilità non solo previene potenziali attacchi e perdite finanziarie, ma aiuta anche a costruire la fiducia degli utenti e a rispettare gli standard di sicurezza. L'implementazione di robusti meccanismi di protezione e aggiornamenti di sicurezza regolari sono elementi chiave per garantire un funzionamento sicuro e affidabile dei sistemi digitali. La necessità di migliorare la sicurezza in dispositivi e reti come l'ESP32 sta diventando sempre più urgente.
Questo materiale è stato creato per il CRYPTO DEEP TECH portale per garantire la sicurezza dei dati finanziari e la crittografia sulle curve ellittiche secp256k1 contro le deboli ECDSA firme nella BITCOIN criptovaluta . I creatori del software non sono responsabili dell'uso dei materiali.
Telegram: https://t.me/cryptodeeptech
Materiale video: https://youtu.be/nBeZWm2z5o4
Tutorial video: https://dzen.ru/video/watch/6784be61b09e46422395c236
Sorgente: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
has_invalid_privkey per verificare privkey.