Данная статья посвящена рассмотрению возможности внедрения злоумышленником скрытого списка уязвимостей через обновление модулей, что может привести к компрометации устройств ESP32 и получению несанкционированного доступа к приватным ключам, что затрагивает миллиарды устройств, использующих данный микроконтроллер. Одной из ключевых проблем является уязвимость CVE-2025-27840, обнаруженная в архитектуре ESP32. Для обеспечение безопасности для сети Биткоин мы выявили следующие уязвимости, где возможность использования недействительных приватных ключей из-за отсутствия проверки нижней границы в функции has_invalid_privkey; уязвимость подделки подписей транзакций в функции electrum_sig_hash из-за несовместимости с BIP-137; проблема слабого PRNG в генерации ключей функцией random_key, делающая личные приватные ключи для криптовалютных кошельков предсказуемыми ; отсутствие проверки точек на кривой ECC в функции multiply, что может привести к invalid curve attacks; уязвимость в функции ecdsa_raw_sign при восстановлении Y-координаты, потенциально приводящая к подмене публичного ключа; и уязвимости, связанные с устаревшими API хеширования в функции bin_ripemd160.
В начале марта 2025 года компания Tarlogic Security выявила уязвимость в микроконтроллере ESP32, который широко используется для подключения устройств через WiFi и 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: #Checking only the upper boundLower bound is not checked properly
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:
"""
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 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
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.")
Объяснение кода:
- Импорт библиотеки
ecdsa: Хотя в данном примере она не используется напрямую, в реальных сценариях работы с Биткоином и ECDSA (Elliptic Curve Digital Signature Algorithm) эта библиотека может понадобиться для выполнения криптографических операций. - Функция
has_invalid_privkey(privkey: int) -> bool:- Принимает на вход приватный ключ
privkeyв виде целого числа. - Определяет константу
N, которая представляет собой порядок эллиптической кривой secp256k1, используемой в Биткоине. - Проверяет, что
privkeyбольше или равенN. Если это так, вызывает исключение, указывающее на невалидность приватного ключа. - Проверяет, что
privkeyменьше или равен0. Если это так, возвращаетTrue, что указывает на невалидность приватного ключа из-за отсутствия проверки нижней границы. - Если обе проверки не выявили невалидность, возвращает
False.
- Принимает на вход приватный ключ
- Пример использования:
- Устанавливает значение
privkey = 0, что является невалидным приватным ключом. - Вызывает функцию
has_invalid_privkeyдля проверкиprivkey. - В зависимости от результата выводит сообщение о том, является ли приватный ключ валидным или нет.
- Устанавливает значение
Уязвимость:
В коде присутствует уязвимость, связанная с недостаточной проверкой приватного ключа. А именно, отсутствует проверка нижней границы (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)
# Usage example
message = "Example message for signing"
message_hash = electrum_sig_hash(message)
print(f"Electrum message hash: {message_hash.hex()}")
В этом скрипте:
num_to_var_int(i): преобразует целое число в формат переменной длины, используемый в Bitcoin.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, в котором сеть Биткоин уязвима из-за использования random вместо secrets или os.urandom, что делает личные приватные ключи предсказуемыми для злоумышленника сети Биткоин:
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
Уязвимость в функции ecdsa_raw_sign при восстановлении Y-координаты может привести к подмене публичного ключа в сети Биткоин. Существует большой риск, когда злоумышленник может воспользоваться особенностью восстановления Y-координаты при работе с эллиптической кривой. Эта неоднозначность может привести к тому, что публичный ключ будет восстановлен неверно.
В примере кода, представленном с использованием библиотеки pycryptodome, демонстрируется, как можно смоделировать эту ситуацию, подменив Y-координату, чтобы получить другой, недействительный публичный ключ. Важно отметить, что пример кода упрощен и не является полноценной реализацией атаки, а лишь показывает её принцип.
Злоумышленник может использовать неоднозначность восстановления Y-координаты в сети Биткоин, что может привести к ошибкам при восстановлении публичного ключа. Вот пример того, как это можно сделать с помощью побитовой операции 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 = "Пример сообщения"
# 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-координату, чтобы получить неверный публичный ключ.
Обратите внимание, что это всего лишь пример, и реальная атака может быть гораздо сложнее.
Помимо представленного выше скрипта, вот несколько дополнительных моментов, которые следует учитывать:
- Frey-Rück Attack: Эта атака использует уязвимости в подписи ECDSA для извлечения секретного ключа «K» (nonce), что в конечном итоге может привести к восстановлению Биткоин-кошелька.
- Побитовые операции: XOR является ценным инструментом для шифрования данных и может использоваться в сочетании с другими операциями для повышения безопасности.
- Атака 51%: Хотя это и не связано напрямую с восстановлением Y-координат, важно понимать, что злоумышленник, контролирующий более 50% вычислительной мощности сети, может потенциально манипулировать блокчейном.
- Манипуляции с координатами кривой Jacobian: Злоумышленники могут манипулировать математическими свойствами координат Jacobian для создания поддельных цифровых подписей.
- Обновление ПО: Крайне важно всегда обновлять программное обеспечение и использовать только проверенные устройства, чтобы предотвратить потенциальную потерю монет BTC из-за критических уязвимостей.
Уязвимость в функции bin_ripemd160
Устаревшие API хеширования в сети Биткоин, особенно при отсутствии RIPEMD-160, могут быть уязвимы. Злоумышленники могут выявлять и использовать слабые реализации, что подчеркивает важность использования актуальных криптографических библиотек и регулярных обновлений безопасности
Атакующий в сети Биткоин может найти уязвимость в устаревшем API хеширования, особенно если в некоторых системах отсутствует реализация RIPEMD-160. Проблема заключается в функции bin_ripemd160, которая пытается использовать hashlib для хеширования, но при неудаче переключается на собственную, потенциально слабую реализацию.
В предоставленном Python-скрипте демонстрируется, как злоумышленник может проверить узел сети Биткоин на наличие такой слабой реализации API. Если hashlib не поддерживает RIPEMD-160, используется упрощенная реализация, что может привести к коллизиям хешей и другим уязвимостям. Скрипт имитирует атаку, хешируя данные и выводя предупреждение, если используется слабая реализация.
Риски включают возможность подделки транзакций и использование известных уязвимостей в устаревших API. Для защиты рекомендуется использовать актуальные и проверенные криптографические библиотеки, регулярно обновлять программное обеспечение Биткоин и проверять выходные данные криптографических операций.
Python-скрипт, в котором атакующий в сети Биткоин находит устаревший API хеширования и рассматривает риск отсутствия реализации RIPEMD-160 в определенных средах:
Python-скрипт ripemd160_vulnerability.py
import hashlib
import binascii
# RIPEMD160 implementation (if hashlib doesn't have it)
class RIPEMD160:
def __init__(self, data):
self.data = data
def digest(self):
# This is a placeholder. In a real implementation, you would perform the RIPEMD160 hashing algorithm.
# For demonstration purposes, we will return a dummy hash.
return b'\x00' * 20 # Returns 20 bytes of zeros
def bin_ripemd160(string):
"""
Hashes the input string using RIPEMD160.
It attempts to use hashlib's implementation first and falls back to a custom implementation if necessary.
"""
try:
digest = hashlib.new('ripemd160', string).digest()
except ValueError:
print("RIPEMD160 not supported in hashlib, falling back to custom implementation.")
digest = RIPEMD160(string).digest()
return digest
def check_for_weak_api(data):
"""
Simulates an attacker probing a Bitcoin network node for weak API implementations.
"""
print("Attacker: Probing node for weak API...")
# Simulate data that needs to be hashed (e.g., part of a transaction)
data_to_hash = data.encode('utf-8')
# Attempt to hash the data using RIPEMD160
hashed_data = bin_ripemd160(data_to_hash)
print("Attacker: Data hashed (potentially using a weak or custom RIPEMD160 implementation).")
print("Attacker: Hash value:", binascii.hexlify(hashed_data).decode('utf-8'))
# Here, an attacker would potentially exploit the weak implementation.
# For demonstration, we'll just print a warning.
if hashed_data == b'\x00' * 20: # This is the dummy hash from our custom RIPEMD160
print("Attacker: WARNING: Node is using a weak or custom RIPEMD160 implementation!")
print("Attacker: EXPLOITABLE: This could allow for hash collisions or other vulnerabilities.")
else:
print("Attacker: Node appears to be using a standard RIPEMD160 implementation.")
# Example usage:
if __name__ == "__main__":
data = "Example Bitcoin transaction data"
check_for_weak_api(data)
Подробное объяснение:
- Реализация RIPEMD160 (при отсутствии в hashlib):
- Класс
RIPEMD160имитирует реализацию RIPEMD160. В действительности он должен выполнять алгоритм хеширования RIPEMD160. В демонстрационных целях он возвращает фиктивный хеш.
- Класс
- Функция
bin_ripemd160(string):- Пытается хешировать входную строку с помощью RIPEMD160.
- Сначала пытается использовать реализацию hashlib, а при необходимости возвращается к пользовательской реализации.
- Если hashlib не поддерживает RIPEMD160, она захватывает исключение ValueError и использует пользовательскую реализацию.
- Функция
check_for_weak_api(data):- Эта функция имитирует злоумышленника, проверяющего узел сети Биткоин на наличие слабых реализаций API.
- Выводит, что злоумышленник проверяет узел на наличие слабого API.
- Кодирует данные в формат utf-8.
- Вызывает
bin_ripemd160для хеширования данных. - Выводит, что данные были хешированы, и показывает значение хеша.
- Если хеш представляет собой фиктивный хеш (20 байт нулей), выводит предупреждение о том, что узел использует слабую или пользовательскую реализацию RIPEMD160, что может привести к коллизиям хешей или другим уязвимостям.
- Пример использования:
- В блоке
if __name__ == "__main__":, он задает пример данных и вызываетcheck_for_weak_apiс этими данными.
- В блоке
Как это работает:
- Имитация атаки:
- Скрипт имитирует атакующего, который пытается идентифицировать узлы в сети Биткоин, использующие устаревшие или слабые API для хеширования RIPEMD160.
- Проверка реализации RIPEMD160:
- Он пытается использовать стандартную библиотеку
hashlibдля хеширования RIPEMD160. Если это не удается (потому чтоhashlibв конкретной среде не поддерживает RIPEMD160), он возвращается к пользовательской реализации (которая в этом примере является упрощенной версией).
- Он пытается использовать стандартную библиотеку
- Идентификация слабых мест:
- Пользовательская реализация (в этом примере) намеренно слабая. Атакующий может использовать эту слабость, если узел использует эту реализацию.
- Возможные риски:
- Коллизии хешей: Слабая реализация хеша RIPEMD160 может быть подвержена коллизиям хешей. Злоумышленник может использовать это, чтобы подделать транзакции или данные.
- Уязвимости безопасности: Устаревшие API могут содержать известные уязвимости, которые злоумышленник может использовать.
Как смягчить:
- Использование актуальных библиотек:
- Убедитесь, что вы используете актуальные и проверенные библиотеки для криптографических операций.
- Если RIPEMD160 необходим, используйте надежную и актуальную реализацию.
- Регулярные обновления:
- Поддерживайте актуальность программного обеспечения Биткоин, чтобы пользоваться исправлениями безопасности и улучшениями.
- Валидация:
- Всегда проверяйте выходные данные криптографических операций, чтобы убедиться, что они соответствуют ожидаемым стандартам.
Уязвимость в функции multiply Отсутствие проверки точки на кривой ECC
В Биткоин существует потенциальная уязвимость в функции multiply из-за недостаточной проверки точек на кривой ECC. Это может позволить злоумышленнику проводить invalid curve attacks, хотя современные криптографические библиотеки, такие как pycryptodome, затрудняют такую эксплуатацию. Атака возможна через манипулирование кривой Jacobian, что может привести к поддельным подписям и манипуляциям в сети.
В сети Биткоин злоумышленник может найти уязвимость в функции multiply, которая заключается в отсутствии полной проверки, что точка находится на эллиптической кривой (ECC). В коде проверка выполняется только для ненулевых точек, что открывает возможность для атак с использованием недействительных кривых (invalid curve attacks).
Пример кода для атакующего показывает, как можно использовать эту уязвимость. В нем демонстрируется функция multiply, где отсутствует надежная проверка точки на кривой, и функция invalid_curve_attack, которая пытается использовать эту слабость. В коде также используются библиотеки pycryptodome для криптографических операций.
В pycryptodome сложнее проводить такие атаки напрямую из-за встроенных механизмов безопасности. Код показывает, как можно создать «неправильную» кривую и попытаться выполнить умножение, но подчеркивается, что это небезопасно и требует глубокого понимания криптографии.
Используя уязвимость в функции
multiply, злоумышленник может провести invalid curve attack, чтобы скомпрометировать секретные ключи в сети 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, только если она не является точкой в бесконечности. Это позволяет использовать точки, которые не находятся на основной кривой, но находятся на «скрученной» кривой (twist curve). - Invalid Curve Attack: Атака заключается в использовании точки на другой кривой (malformed curve), чтобы получить информацию о секретном ключе. Поскольку проверка кривой не выполняется для всех точек, можно передать точку с другой кривой и использовать результат для восстановления части секретного ключа.
- Функция
invalid_curve_attack: Эта функция принимает публичный ключ и параметры malformed curve. Она создает точку на malformed curve и использует уязвимую функциюmultiplyдля выполнения умножения.
Как работает атака малой подгруппы (Small Subgroup Attack):
- Выбор точки малого порядка: Злоумышленник выбирает точку
Qмалого порядка на кривой или на twist кривой. - Отправка точки: Злоумышленник отправляет эту точку
Qжертве, выдавая её за свой публичный ключ. - Вычисление общего секрета: Жертва вычисляет
nQ, гдеn— секретный ключ жертвы. - Перебор вариантов: Поскольку
Qимеет малый порядок, существует небольшое количество возможных значений дляnQ. Злоумышленник может перебрать все эти значения и проверить, какое из них соответствует зашифрованным данным, раскрываяnпо модулю порядкаQ.
Рекомендации:
- Всегда проверяйте, что входные точки действительно находятся на кривой ECC.
- Используйте библиотеки, которые обеспечивают надежную проверку кривой и защиту от invalid curve attacks.
Small Subgroup Attack
Декодируем уязвимую RawTX транзакцию с помощью функции сервиса SMALL SUBGROUP ATTACK
Результат значение K секретного ключа Nonce в формате HEX
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2Для получение всех остальных значении из уязвимой RawTX транзакции воспользуемся сервисом RSZ Signature Decoder
Результат значении для 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 BitcoinChatGPTApply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency
В конечном итоге модуль BitcoinChatGPT выдает ответ в файл: KEYFOUND.privkey сохранив приватный ключ в двух наиболее используемых форматах 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 =============================Для реализации кода установим пакет Bitcoin. Эта библиотека позволяет создавать кошельки, взаимодействовать с блокчейном, создавать и подписывать транзакции, а также работать с различными форматами адресов и приватных ключей криптовалюты Биткоин.
!pip3 install bitcoinЗапустим код для проверки соответствие Биткоин Адреса:
__________________________________________________
Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________Все верно! Приватный ключ соответствует Биткоин Кошельку.
Откроем bitaddress и проверим:
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Итоги и шаги по уменьшению угрозы
В современной цифровой среде критически важным становится обеспечение безопасности устройств и сетей. Данная статья посвящена анализу ряда уязвимостей, обнаруженных в различных компонентах, включая устройства ESP32 и программное обеспечение для работы с криптовалютами, таким как Биткоин. Рассматриваются недостатки в коде проверки приватных ключей, методах хеширования транзакций, генерации случайных ключей, проверке точек на кривой ECC, восстановлении Y-координаты, а также в устаревших API хеширования. Особое внимание уделяется уязвимости CVE-2025-27840 в микроконтроллерах ESP32, которая позволяет злоумышленникам внедрять поддельные обновления и получать низкоуровневый доступ к системе. Обсуждаются потенциальные последствия этих уязвимостей, включая возможность обхода средств контроля аудита кода, получения доступа к приватным ключам и проведения атак на цепочки поставок. В заключение предлагаются рекомендации по усилению безопасности и предотвращению возможных атак.
Актуальность
В настоящее время миллиарды устройств могут оказаться уязвимыми из-за скрытых особенностей в архитектуре одного компонента, что обозначено как CVE-2025-27840. Обнаруженные уязвимости позволяют злоумышленникам подменять MAC-адреса, получать несанкционированный доступ к памяти устройства и проводить атаки через Bluetooth.
Уязвимости и их анализ
- Уязвимость для получения приватного ключа в функции
has_invalid_privkey: Отсутствие проверки нижней границы приватных ключей Биткоин позволяет использовать недействительные ключи (меньше или равные 0), что может привести к потере средств. - Уязвимость подделки подписей транзакции Биткоин в функции
electrum_sig_hash: Использование нестандартного метода хеширования сообщений в Electrum делает её уязвимой для атак подделки подписи из-за несовместимости с BIP-137. - Уязвимость в функции
random_key(Слабый PRNG в генерации ключей): Использование модуляrandomдля создания ключей в сети Биткоин делает личные ключи предсказуемыми для злоумышленников, так как этот модуль не предназначен для криптографических целей. - Уязвимость в функции
multiply(Отсутствие проверки точки на кривой ECC): Недостаточная проверка точек на кривой ECC может позволить злоумышленнику проводить invalid curve attacks, что может привести к поддельным подписям и манипуляциям в сети. - Уязвимость в функции
ecdsa_raw_sign: Некорректное восстановление Y-координаты может привести к подмене публичного ключа в сети Биткоин. - Уязвимость в функции
bin_ripemd160: Устаревшие API хеширования, особенно при отсутствии RIPEMD-160, могут быть уязвимы для атак, что подчеркивает важность использования актуальных криптографических библиотек и регулярных обновлений безопасности.
Преимущества выявления и устранения уязвимостей
- Предотвращение финансовых потерь: Устранение уязвимостей, связанных с приватными ключами и подделкой подписей, помогает предотвратить потерю средств пользователей криптовалют.
- Защита конфиденциальных данных: Устранение уязвимостей в устройствах ESP32 предотвращает несанкционированный доступ к памяти и подмену MAC-адресов, что защищает конфиденциальные данные пользователей.
- Повышение безопасности сети: Устранение уязвимостей в криптографических функциях, таких как
random_keyиecdsa_raw_sign, повышает общую безопасность сети Биткоин и предотвращает возможные атаки на транзакции и подписи. - Укрепление доверия пользователей: Своевременное выявление и устранение уязвимостей способствует укреплению доверия пользователей к устройствам и программному обеспечению, что особенно важно в сфере криптовалют и IoT.
- Соблюдение стандартов безопасности: Регулярное обновление криптографических библиотек и API, а также следование современным стандартам безопасности помогает предотвратить использование устаревших и уязвимых компонентов.
Заключение
Выявление и анализ уязвимостей, представленные в данной статье, подчеркивают необходимость постоянного мониторинга и улучшения безопасности устройств и программного обеспечения. Устранение этих уязвимостей не только предотвращает возможные атаки и финансовые потери, но и способствует укреплению доверия пользователей и соблюдению стандартов безопасности. Внедрение надежных механизмов защиты и регулярные обновления безопасности являются ключевыми элементами для обеспечения безопасной и надежной работы цифровых систем. Необходимость повышения безопасности в устройствах и сетях, таких как ESP32, становится все более актуальной.
References:
- Recommendations for Eliminating Vulnerabilities in Bitcoin Code and ESP32 Devices
- Weaknesses in Bitcoin Implementation: How Vulnerabilities in random_key and ecdsa_raw_sign Compromise Security
- Analysis of the has_invalid_privkey Function Vulnerability: Problems with Bitcoin Private Key Verification and Recommendations for Correction
- Public Key Substitution: Vulnerability of the ecdsa_raw_sign Function, Risks Associated with Y-Coordinate Recovery, Code Examples to Demonstrate the Vulnerability
- Bitcoin Security: Examining Risks Associated with Incorrect ECC Verification and Obsolete Hashing APIs
- Security Risk Analysis: Vulnerabilities in ESP32 Devices and the Bitcoin Network
- Obsolete Hashing APIs in Bitcoin: Vulnerabilities of the bin_ripemd160 Function
- Fake Updates and Access to Private Keys: ESP32 Vulnerabilities and Their Consequences
- Bitcoin Security Risks: Vulnerabilities in Key Verification and Transaction Generation Functions
- Problems with Key Generation: random_key Function Vulnerability, Weak Pseudo-Random Number Generator and its Consequences
- Shortcomings of Cryptographic Functions in Bitcoin and Potential Threats to the Network
- Attacks on Elliptic Curve: multiply Function Vulnerability, Insufficient Verification of Points on the ECC Curve, Possible Attack Vectors
- The Importance of Current Cryptographic Libraries and Regular Updates Conclusion: The Need to Improve Security in Networks and Devices
- Potential Attacks Using Invalid Curves Public Key Substitution: Vulnerability of the ecdsa_raw_sign Function
- Recommendations for Eliminating Vulnerabilities and Improving Protection Each title reflects key aspects of the article and can be used to structure the research
- Weak PRNG in Bitcoin Key Generation: Consequences of Using a Non-Deterministic random_key
- Analysis of Vulnerability CVE-2025-27840: How Architectural Flaws Can Threaten Billions of Devices Vulnerability of the has_invalid_privkey Function
- Impact of Vulnerabilities in ESP32 Microcontrollers on the Security of IoT Devices
- Methods for Exploiting Vulnerabilities in ESP32 Microcontrollers: Attacks via Bluetooth and Wi-Fi
- Hidden Vulnerabilities in ESP32 and Their Impact on the Security of IoT Devices
- Security Issues in ESP32 Devices: Disclosure of Vulnerability CVE-2025-27840
- ESP32 Architectural Vulnerabilities: Revealing Hidden Commands and Their Impact on IoT Security
- Vulnerabilities in Bitcoin Code: Technical Analysis and Exploitation Methods
- Analysis of Vulnerabilities in Bitcoin: From Cryptographic Shortcomings to Obsolete APIs
- CVE-2025-27840 Vulnerabilities in ESP32 Microcontrollers: Exposing Billions of IoT Devices to Risk
- Non-Standard Hashing Methods and Their Vulnerabilities Problems with Key Generation: random_key Vulnerability
- Lack of ECC Point Verification as a Potential Vulnerability in the Bitcoin multiply Function
- Risks of Recovering the Y-Coordinate in Elliptic-Curve Cryptography Obsolete Hashing APIs: bin_ripemd160 Function Vulnerability
- Vulnerability in the ecdsa_raw_sign Function: Risk of Public Key Substitution During Y-Coordinate Recovery
- Hidden Vulnerabilities: A Threat to Modern Technologies CVE-2025-27840: Overview of Vulnerabilities in the ESP32 Architecture
- Overview of Current Security Threats Hidden List of Vulnerabilities: Potential Risks for ESP32 Implementation of Fake Updates and Low-Level Access
- Problems with Private Key Verification and Their Consequences Forgery of Transaction Signatures: electrum_sig_hash Vulnerability
- Vulnerability of Bitcoin Transaction Signature Forgery Due to Non-Standard Hashing in Electrum
- Risks of Using Unreliable PRNGs in Bitcoin Insufficient ECC Point Verification: multiply Function Vulnerability
- Overview of Vulnerabilities in Bitcoin: Potential Risks for Private Keys and Transactions
- Critical Security Analysis of ESP32 and Bitcoin: Vulnerabilities and Methods of Protection
- Obsolete Hashing APIs: bin_ripemd160 Function Vulnerability Problems with RIPEMD-160 Implementation Importance of Current Cryptographic Libraries
- Vulnerability of the electrum_sig_hash Function: Bitcoin Transaction Signature Forgery Non-Standard Hashing Method and its Consequences Examples of Attacks Based on Incompatibility with BIP-137
- Analysis of Vulnerabilities in Bitcoin Implementation: From Key Generation to Signature Forgery
- CVE-2025-27840: Vulnerability in ESP32, Allowing Unauthorized Firmware Updates and Access to Private Keys
- Vulnerability in Bitcoin Private Key Verification: Bypassing Lower Bound Control
Данный материал создан для портала CRYPTO DEEP TECH для обеспечения финансовой безопасности данных и криптографии на эллиптических кривых secp256k1 против слабых подписей ECDSA в криптовалюте BITCOIN. Создатели программного обеспечения не несут ответственность за использование материалов.
Telegram: https://t.me/cryptodeeptech
Видеоматериал: https://youtu.be/nBeZWm2z5o4
Video tutorial: https://dzen.ru/video/watch/6784be61b09e46422395c236
Источник: https://cryptodeeptool.ru/bitcoin-bluetooth-attacks