demining/bluetooth-attacks-cve-2025-27840Criptoanálise Bitcoin: Vulnerabilidade CVE-2025-27840 em Microcontroladores ESP32 Coloca Bilhões de Dispositivos IoT em Risco via Wi-Fi & Bluetooth
Este artigo discute como um atacante pode introduzir uma lista oculta de vulnerabilidades por meio de atualizações de módulos, o que pode levar ao comprometimento de dispositivos ESP32 e à obtenção de acesso não autorizado a chaves privadas, afetando bilhões de dispositivos que usam este microcontrolador. Uma das questões-chave é a CVE-2025-27840 vulnerabilidade descoberta na arquitetura do ESP32. Para garantir a segurança da rede Bitcoin, identificamos as seguintes vulnerabilidades, incluindo a possibilidade de usar chaves privadas inválidas devido à falta de verificação do limite inferior na função has_invalid_privkey; uma vulnerabilidade na falsificação de assinaturas de transações na função electrum_sig_hash devido à incompatibilidade com BIP-137; um problema de PRNG fraco na função de geração de chaves random_key, tornando previsíveis as chaves privadas pessoais de carteiras de criptomoedas; falta de verificação de pontos na curva ECC na função multiply, o que pode levar a ataques de curva inválida; uma vulnerabilidade na função ecdsa_raw_sign ao restaurar a coordenada Y, potencialmente levando à substituição da chave pública; e vulnerabilidades relacionadas a APIs de hash obsoletas em bin_ripemd160.
No início de março de 2025, a Tarlogic Security identificou uma vulnerabilidade no microcontrolador ESP32, amplamente utilizado para conectar dispositivos via Wi-Fi e Bluetooth. Essa vulnerabilidade foi registrada sob o número CVE-2025-27840 . Os atacantes podem acessar sem autorização os dados de carteiras Bitcoin usando o chip ESP32 como ponto de partida para ataques criptográficos em dispositivos que operam nas redes de criptomoedas populares como Bitcoin e Ethereum. Esse problema afeta milhões de dispositivos IoT que usam este microcontrolador. Explorar essa vulnerabilidade permitirá que os atacantes realizem ataques disfarçados de usuários legítimos e infectem permanentemente os dispositivos vulneráveis. Isso ameaça a segurança dos dispositivos IoT baseados no microcontrolador ESP32 e pode levar ao roubo de chaves privadas de carteiras Bitcoin.
ESP32 é um microcontrolador amplamente utilizado em dispositivos IoT para fornecer conectividade Wi-Fi e Bluetooth. Os atacantes podem usar vários métodos para obter acesso aos dados de chaves privadas de carteiras Bitcoin por meio do ESP32.
As ameaças de segurança relacionadas ao microcontrolador ESP32 podem levar ao roubo de chaves privadas de carteiras Bitcoin. Os principais problemas incluem a presença de backdoors e vulnerabilidades. Usando tais vulnerabilidades, eles podem manipular a memória, falsificar endereços MAC e injetar código malicioso, o que cria sérios riscos de segurança.
Os atacantes podem atacar dispositivos IoT com microcontrolador ESP32 usando vulnerabilidades nas conexões Bluetooth e Wi-Fi, que podem se tornar uma ferramenta para atacar outros dispositivos na rede relacionada ao Bitcoin, bem como roubar informações confidenciais, incluindo chaves privadas de carteiras Bitcoin.
Um atacante pode atualizar módulos e introduzir uma lista de várias vulnerabilidades no código, incluindo:
has_invalid_privkeyque pode ser usada para obter a chave privada.electrum_sig_hashpermite forjar assinaturas de transações Bitcoin.random_keyrelacionada a um gerador fraco de números pseudoaleatórios (PRNG não determinístico).multiplyonde não há verificação de um ponto na curva ECC.ecdsa_raw_sign e bin_ripemd160.Essas vulnerabilidades podem ser usadas para injetar atualizações falsas em dispositivos ESP32, dando aos atacantes acesso de baixo nível ao sistema. Isso permitirá que eles contornem os controles de auditoria de código e obtenham acesso às chaves privadas. Atualmente, bilhões de dispositivos podem estar vulneráveis devido a recursos ocultos de um único componente em sua arquitetura, designado como CVE-2025-27840.
has_invalid_privkeyEsta vulnerabilidade foi encontrada no código de verificação de chaves privadas do Bitcoin, permitindo que chaves inválidas (menores ou iguais a 0) sejam usadas devido à falta de verificação do limite inferior. Isso pode levar à perda de fundos. Para corrigir, é necessário adicionar uma verificação para garantir que a chave privada seja maior que 0. O código é fornecido para fins de demonstração.
Esse bug permite que chaves privadas inválidas sejam usadas, o que pode levar a sérios problemas, incluindo perda de dinheiro.
Para corrigir isso, você precisa adicionar uma verificação para garantir que a chave privada seja maior que 0.
Imagine que alguém está tentando “invadir” a rede Bitcoin. Eles encontram um ponto fraco na verificação das chaves privadas usadas para acessar a criptomoeda.
O problema é que o código só verifica se a chave privada é grande demais. Se a chave for muito grande, ela é rejeitada. Mas o código esquece de verificar se a chave é pequena demais (menor ou igual a zero).
A seção do código onde isso acontece:
...
...if privkey >= N: #Verificando apenas o limite superiorO limite inferior não é verificado corretamente
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
Devido a esse bug, é possível usar chaves privadas inválidas (muito pequenas). Esta vulnerabilidade está localizada na função has_invalid_privkey.
Para que tudo isso funcione, você precisa instalar a biblioteca ecdsa (ela é necessária para trabalhar com criptografia):
Script Python secp256k1_privkey_validator.py
!pip install ecdsa
import ecdsa
def has_invalid_privkey(privkey: int) -> bool:
"""
Checks if a private key is invalid, based on the absence of a lower bound check.
Args:
privkey: The private key to check.
Returns:
True if the private key is invalid (<= 0 or >= N), False otherwise.
"""
# Order of the secp256k1 elliptic curve used by Bitcoin
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
if privkey >= N: # Check only the upper bound
raise Exception("Invalid privkey")
if privkey <= 0: # Lower bound check missing
return True
return False
# Example usage
privkey = 0 # Invalid private key
is_invalid = has_invalid_privkey(privkey)
if is_invalid:
print("Invalid private key!")
else:
print("Valid private key.")
Explicação do código:
ecdsa : Embora não seja usada diretamente neste exemplo, em cenários do mundo real envolvendo Bitcoin e ECDSA (Algoritmo de Assinatura Digital de Curva Elíptica), essa biblioteca pode ser necessária para realizar operações criptográficas.has_invalid_privkey(privkey: int) -> bool :
privkeyAceita uma chave privada como um inteiro como entrada .Nque representa a ordem da curva elíptica secp256k1 usada no Bitcoin.privkeyé maior ou igual a N. Se for, gera uma exceção indicando que a chave privada é inválida.privkeyé menor ou igual a 0. Se for, retorna True, indicando que a chave privada é inválida devido à falta de verificação do limite inferior.False.privkey = 0, que é uma chave privada inválida.Vulnerabilidade :
O código contém uma vulnerabilidade relacionada à verificação insuficiente da chave privada. Ou seja, não há verificação do limite inferior (privkey <= 0). Isso permite o uso de chaves privadas inválidas, o que pode levar a consequências imprevisíveis, incluindo perda de fundos.
Como corrigir :
É necessário adicionar uma verificação do limite inferior da chave privada para garantir que ela seja maior que 0.
electrum_sig_hashA função electrum_sig_hash no Electrum usa um método não padronizado de hash de mensagens, tornando-a vulnerável a ataques de falsificação de assinatura devido à sua incompatibilidade com BIP-137.
Um atacante que visa a rede Bitcoin pode descobrir o método não padronizado de hash de mensagens usado pelo Electrum por meio da função electrum_sig_hash. Essa função cria um hash de mensagem de uma forma que pode levar a ataques de falsificação de assinatura devido à sua incompatibilidade com BIP-137. O script Python fornecido demonstra como um atacante pode gerar o hash de mensagem usado pelo Electrum para explorar a vulnerabilidade de incompatibilidade com BIP-137. A função electrum_sig_hash prepara a mensagem adicionando um prefixo e codificando seu comprimento antes de aplicar o hash duplo com SHA256.
Um script Python demonstrando como um atacante pode encontrar um hash de mensagem não padronizado usado pelo Electrum para realizar ataques de falsificação de assinatura devido à incompatibilidade com BIP-137.
Script Python bitcoin_sign_hash.py
!pip install ecdsa
import hashlib
def num_to_var_int(i):
if i < 0xfd:
return i.to_bytes(1, 'little')
elif i <= 0xffff:
return b'\xfd' + i.to_bytes(2, 'little')
elif i <= 0xffffffff:
return b'\xfe' + i.to_bytes(4, 'little')
else:
return b'\xff' + i.to_bytes(8, 'little')
def from_string_to_bytes(s):
return s.encode('utf-8')
def bin_dbl_sha256(s):
hash1 = hashlib.sha256(s).digest()
hash2 = hashlib.sha256(hash1).digest()
return hash2
def electrum_sig_hash(message):
padded = b"\x18Bitcoin Signed Message:\n" + num_to_var_int(len(message)) + from_string_to_bytes(message)
return bin_dbl_sha256(padded)
# Usage example
message = "Example message for signing"
message_hash = electrum_sig_hash(message)
print(f"Electrum message hash: {message_hash.hex()}")
Neste script:
num_to_var_int(i): converte um número inteiro para o formato de comprimento variável usado no Bitcoin.from_string_to_bytes(s): codifica uma string em bytes usando a codificação UTF-8.bin_dbl_sha256(s): Executa hash duplo SHA256 na entrada.electrum_sig_hash(message): simula a forma não padronizada do Electrum de aplicar hash em mensagens, que está sujeita à incompatibilidade com BIP-137.random_keyFunção PRNG fraca na geração de chaves (PRNG não determinístico)O problema surge quando o Bitcoin usa uma função random_key que depende do módulo para criar chaves random. O módulo random não é destinado a fins criptográficos porque não gera números suficientemente aleatórios, tornando as chaves privadas previsíveis para os atacantes. Isso deixa a rede Bitcoin vulnerável.
Um script Python que torna a rede Bitcoin vulnerável ao usar random em vez de secrets ou os.urandom, tornando as chaves privadas previsíveis para um invasor Bitcoin:
Script Python privkey_generate.py
import random
import time
from hashlib import sha256
def random_string(length):
return ''.join(random.choice('0123456789abcdef') for i in range(length))
def random_key():
# Gotta be secure after that java.SecureRandom fiasco...
entropy = random_string(32) \
+ str(random.randrange(2**256)) \
+ str(int(time.time() * 1000000))
return sha256(entropy.encode('utf-8')).hexdigest()
# Example usage: generate a private key
private_key = random_key()
print("Generated Private Key:", private_key)Este script random usa o módulo para gerar chaves, o que o torna vulnerável. O uso do módulo random não é adequado para fins criptográficos porque não gera números suficientemente aleatórios.
Para criar uma chave mais segura, você pode usar o módulo secrets ou os.urandom. Aqui está um exemplo de uso do 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)Neste exemplo, o módulo secrets é usado para gerar um número aleatório com entropia suficiente. O número aleatório é então submetido a hash para criar uma chave privada pessoal. Este método é muito mais seguro do que usar o módulo random.
Uma vulnerabilidade na função ecdsa_raw_sign ao restaurar a coordenada Y pode levar à substituição de uma chave pública na rede Bitcoin. Existe um alto risco de um invasor explorar a peculiaridade da restauração da coordenada Y ao trabalhar com uma curva elíptica. Essa ambiguidade pode fazer com que a chave pública seja restaurada incorretamente .
O exemplo de código, fornecido usando a biblioteca pycryptodome, demonstra como essa situação pode ser simulada substituindo a coordenada Y para obter uma chave pública diferente e inválida. É importante notar que o exemplo de código é simplificado e não é uma implementação completa do ataque , mas apenas mostra seu princípio.
Um invasor pode explorar a ambiguidade da recuperação da coordenada Y na rede Bitcoin, o que pode levar a erros na recuperação da chave pública. Aqui está um exemplo de como isso pode ser feito usando a operação XOR bit a bit.
Script Python weak_key_recovery.py
!pip install pycryptodome
from hashlib import sha256
from Crypto.PublicKey import ECC
from Crypto.Signature import DSS
from Crypto.Hash import SHA256
import secrets
# Elliptic curve parameters secp256k1
# PyCryptodome does not provide a convenient way to directly specify the parameters of the secp256k1 curve.
# Therefore, we will use the standard ECC curve.
# For production code, be careful when choosing the curve and its parameters.
def hash_to_int(msghash):
return int(sha256(msghash.encode('utf-8')).hexdigest(), 16)
def deterministic_generate_k(msghash, priv_key_int):
k = 0
while k == 0:
v = b'\x01' * 32
k = b'\x00' * 32
k = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest()
v = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest()
k = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest()
v = sha256(v + k + priv_key_int.to_bytes(32, 'big') + msghash.encode('utf-8')).digest()
k = int.from_bytes(sha256(v + k).digest(), 'big') # % N # Removed % N, since N is no longer a defined constant
return k
def ecdsa_raw_sign(msghash, priv_key_int):
z = hash_to_int(msghash)
k = deterministic_generate_k(msghash, priv_key_int)
# Generate private key object
key = ECC.construct(curve='P-256', d=priv_key_int)
# Calculate point R = kG
# PyCryptodome does not provide direct access to the coordinates of point R
# Therefore, the signature will be calculated in a different way, using DSS
# s = pow(k, -1, N) * (z + r * private_key_int) % N # N is no longer defined
# v = 27 + ((y % 2) ^ (0 if s * 2 < N else 1)) # y is not available
return key, z, k # Return the key, hash, and k for further use in signing
def recover_pubkey(msghash, signature, key):
# WARNING: This is a VERY SIMPLIFIED example of public key recovery.
# In real life, ECDSA public key recovery is a complex process.
# This code is intended only to demonstrate the principle.
# PyCryptodome does not have a simple way to recover PublicKey from r and s directly.
# This code does not perform real recovery, but creates a new PublicKey from the private key.
# In a real attack scenario, you need to try to guess the y-coordinate to get a valid PublicKey.
# But this requires a more complex logic to work with the elliptic curve. return key.public_key()def emulate_attack(msghash, priv): # 1. Sign the message priv_key_int = int(priv, 16) key, z, k = ecdsa_raw_sign(msghash, priv_key_int) signer = DSS.new(key, 'fips-186-3') hash_obj = SHA256.new(msghash.encode('utf-8')) signature = signer.sign(hash_obj) # 2. Attempt to recover the public key (incorrectly) Q = recover_pubkey(msghash, signature, key) # 3. Simulate a situation where the Y coordinate is recovered incorrectly # In a real attack scenario, an attacker will try to iterate through different y-coordinates. # In this example, we simply change the x-coordinate slightly tampered_key = ECC.construct(curve='P-256', d=priv_key_int + 1) # EXAMPLE! DO NOT DO THIS IN REAL CODE! Q_tampered = tampered_key.public_key() return Q, Q_tampered # Example usage msghash = "Message example" # Generate a random private key private_key = ECC.generate(curve='P-256') priv = hex(private_key.d) # Store private key as a hex string # Example usage Q, Q_tampered = emulate_attack(msghash, priv) print("Original Public Key:", Q) print("Tampered Public Key:", Q_tampered) print("Are the keys equal?", Q == Q_tampered)
Este script demonstra como a coordenada Y pode ser alterada para produzir uma chave pública inválida.
Observe que este é apenas um exemplo e um ataque real pode ser muito mais complexo.
Além do script acima, aqui estão alguns pontos adicionais a considerar:
APIs de hash legadas na rede Bitcoin, especialmente na ausência de RIPEMD-160, podem ser vulneráveis. Invasores podem identificar e explorar implementações fracas, destacando a importância de usar bibliotecas criptográficas atualizadas e atualizações regulares de segurança.
Um invasor na rede Bitcoin poderia encontrar uma vulnerabilidade na API de hash legada, especialmente se alguns sistemas não tiverem uma implementação de RIPEMD-160. O problema está em uma função bin_ripemd160 que tenta usar hashlib para hashing, mas, se isso falhar, ela passa para sua própria implementação, potencialmente mais fraca.
O script Python fornecido demonstra como um invasor pode testar um nó Bitcoin para tal implementação de API fraca. Se o hashlib não suportar RIPEMD-160, uma implementação simplificada é usada, o que pode levar a colisões de hash e outras vulnerabilidades. O script simula o ataque aplicando hash aos dados e imprimindo um aviso se uma implementação fraca for usada.
Os riscos incluem a possibilidade de falsificação de transações e exploração de vulnerabilidades conhecidas em APIs legadas. Para se proteger, é recomendável usar bibliotecas criptográficas atualizadas e testadas, atualizar regularmente o software Bitcoin e verificar a saída das operações criptográficas.
Um script Python no qual um invasor Bitcoin encontra uma API de hash obsoleta e discute o risco de não implementar RIPEMD-160 em determinados ambientes:
Script Python ripemd160_vulnerability.py
RIPEMD160 simula uma implementação do RIPEMD160. Na realidade, ela deveria implementar o algoritmo de hash RIPEMD160. Para fins de demonstração, ela retorna um hash fictício.bin_ripemd160(string):
check_for_weak_api(data):
bin_ripemd160 para fazer hash dos dados.if __name__ == "__main__":, ele especifica dados de exemplo e chama check_for_weak_api com esses dados.hashlib para hash RIPEMD160. Se isso falhar (porque o hashlib do ambiente específico não suporta RIPEMD160), ele recorre a uma implementação personalizada (que neste exemplo é uma versão simplificada).multiply Sem verificação de um ponto na curva ECCO Bitcoin tem uma vulnerabilidade potencial em sua função multiply devido à validação insuficiente de pontos na curva ECC. Isso poderia permitir que um atacante executasse ataques de curva inválida, embora bibliotecas criptográficas modernas como pycryptodomedificultem essa exploração. O ataque é possível por meio de manipulação da curva jacobiana , o que poderia levar a assinaturas forjadas e manipulação da rede.
Na rede Bitcoin, um atacante pode encontrar uma vulnerabilidade na função multiplyque não possui uma verificação completa se um ponto está em uma curva elíptica (ECC). No código, a verificação é realizada apenas para pontos não nulos, o que abre a possibilidade de ataques usando curvas inválidas (invalid curve attacks).
O código de exemplo do atacante mostra como essa vulnerabilidade pode ser explorada. Ele demonstra uma função multiplyque não possui uma verificação confiável de ponto em uma curva, e uma função invalid_curve_attackque tenta explorar essa fraqueza. O código também usa bibliotecas pycryptodome para operações criptográficas.
Com pycryptodome, é mais difícil realizar tais ataques diretamente devido aos mecanismos de segurança integrados. O código mostra como se pode criar uma curva “incorreta” e tentar realizar uma multiplicação, mas é enfatizado que isso é inseguro e requer um profundo conhecimento de criptografia.
Ao explorar uma vulnerabilidade na função
multiply, um atacante pode realizar um ataque de curva inválida para comprometer chaves privadas na rede Bitcoin. Abaixo está um script Python de exemplo demonstrando esse ataque.
Script Python ecdsa_curve_attack.py
!pip install pycryptodome
from Crypto.Hash import SHA256
from Crypto.Signature import DSS
from Crypto.PublicKey import ECC
from Crypto.Math import *
class Exploit:
def __init__(self):
self.msg = "ATTACK!"
self.hash = hash_msg(self.msg)
def sign_message(self, private_key):
signer = DSS.new(private_key, 'fips-186-3')
signature = signer.sign(self.hash)
return signature
def verify_signature(self, public_key, signature):
verifier = DSS.new(public_key, 'fips-186-3')
try:
verifier.verify(self.hash, signature)
return True
except ValueError:
return False
def hash_msg(msg):
hasher = SHA256.new(msg.encode('utf-8'))
return hasher.digest()
# Elliptic curve parameters (example, must be replaced with the parameters of the curve being used)
# WARNING: IN REAL CODE, YOU MUST USE SECURE CURVES AND THEIR PARAMETERS!
# EXAMPLE FOR DEMONSTRATION, DO NOT USE IN PRODUCTION!
curve = 'secp256r1' # Or another curve
# Vulnerable function (EXAMPLE! PyCryptodome HAS NO DIRECT EQUIVALENT to fast_multiply)
# This function is here to demonstrate the vulnerability, but requires adaptation to specific needs and cryptographic primitives.
def multiply(pubkey, privkey):
# WARNING: THIS IS A VERY SIMPLIFIED EXAMPLE, NOT SAFE!
# IN REAL CODE, YOU NEED TO USE CRYPTOGRAPHICALLY SECURE METHODS!
# Checking if the point is on the curve. In PyCryptodome, this is done automatically.
#Performing multiplication
result = privkey.d * pubkey.pointQ
return result
# Example of invalid curve attack (adapted for pycryptodome)
def invalid_curve_attack(public_key, malformed_curve_parameters):
# Creating a "wrong" curve (example!)
#malformed_curve = ECC.CurveObj(malformed_curve_parameters['name'],
# malformed_curve_parameters['oid'],
# malformed_curve_parameters['field'],
# malformed_curve_parameters['a'],
# malformed_curve_parameters['b'],
# malformed_curve_parameters['generator'],
# malformed_curve_parameters['order'])
# Creating a public key on the "wrong" curve (example!)
#attacker_key = ECC.EccPoint(malformed_curve_parameters['generator'].x, malformed_curve_parameters['generator'].y, malformed_curve)
# Creating a fake private key (example!) #attacker_private_key = ECC.construct(curve=malformed_curve, pointQ=attacker_key) # WARNING: In PyCryptodome, it is more difficult to directly manipulate curves and points # to demonstrate invalid curve attack. This code is left commented out, # because correct operation requires a deep understanding of ECC and unsafe operations. # It is recommended to use standard curves and avoid creating your own. # Performing multiplication using the vulnerable function (EXAMPLE! NOT SAFE!) # result = multiply(attacker_key, attacker_private_key) # return result return None # Returning None to avoid an error # Example of "wrong" curve parameters (NEVER USE IN PRODUCTION!) # This is just an example showing the data structure. Real parameters should be carefully selected. # These parameters are commented out to avoid an error when creating EccPoint with curve=None malformed_curve_parameters = { #'name': "MalformedCurve", #'oid': "1.2.3.4", #'field': 17, #'a': 2, #'b': 3, #'generator': ECC.EccPoint(5, 1), # Removed None because it causes an error #'order': 19 } # Creating a private key (for example) private_key = ECC.generate(curve=curve) public_key = private_key.public_key() # Example of using invalid curve attack attack_result = invalid_curve_attack(public_key, malformed_curve_parameters) print(attack_result)
Explicação do código:
multiply verifica se um ponto está na curva ECC apenas se ele não for um ponto no infinito. Isso permite usar pontos que não estão na curva principal, mas estão na curva twist.invalid_curve_attack: Esta função recebe uma chave pública e parâmetros de uma curva malformada. Ela cria um ponto na curva malformada e usa a função vulnerável multiply para realizar a multiplicação.Como funciona o Ataque de Subgrupo Pequeno:
Q de ordem baixa na curva ou no twist da curva.Q à vítima, fazendo-o passar por sua chave pública.nQ, onde n é a chave secreta da vítima.Q tem ordem pequena, há um pequeno número de valores possíveis para nQ. Um atacante pode fazer força bruta em todos esses valores e verificar qual corresponde aos dados criptografados, calculando n módulo a ordem de Q.Recomendações:
Decodifique uma transação RawTX vulnerável usando a função de serviço SMALL SUBGROUP ATTACK
O resultado é o valor K da chave secreta Nonce em formato HEX
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2Para obter todos os outros valores da transação RawTX vulnerável, usaremos o serviço RSZ Signature Decoder.
Valores resultantes para R, S, Z em formato HEX
R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8Para obter o valor X da chave privada a partir da fórmula: priv_key = ((((S * K) - Z) * modinv(R, N)) % N)usaremos o software Dockeyhunt Private Key Calculator
Como resultado, obtemos o valor X da chave privada em formato HEX
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34Vamos iniciar o BitcoinChatGPT
%run BitcoinChatGPTApply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency
Por fim, o módulo BitcoinChatGPT gera a resposta no arquivo: KEYFOUND.privkey armazenando a chave privada nos dois formatos mais usados 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 o código, instalaremos o pacote Bitcoin . Esta biblioteca permite criar carteiras, interagir com o blockchain, criar e assinar transações e trabalhar com vários formatos de endereço e chaves privadas da criptomoeda Bitcoin.
!pip3 install bitcoinVamos executar o código para verificar a correspondência do Endereço Bitcoin:
__________________________________________________
Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________Isso mesmo! A chave privada corresponde à Carteira Bitcoin.
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
No ambiente digital atual, proteger dispositivos e redes é fundamental. Este artigo analisa diversas vulnerabilidades encontradas em vários componentes, incluindo dispositivos ESP32 e softwares para trabalhar com criptomoedas como o Bitcoin. Examinamos falhas no código de verificação de chaves privadas, métodos de hash de transações, geração de chaves aleatórias, verificação de pontos da curva ECC, recuperação da coordenada Y e APIs de hash legadas. Atenção especial é dada à vulnerabilidade CVE-2025-27840 em microcontroladores ESP32, que permite a atacantes injetar atualizações falsas e obter acesso de baixo nível ao sistema. As implicações potenciais dessas vulnerabilidades são discutidas, incluindo a capacidade de contornar controles de auditoria de código, obter acesso a chaves privadas e realizar ataques à cadeia de suprimentos. O artigo conclui com recomendações para fortalecer a segurança e prevenir possíveis ataques.
Bilhões de dispositivos podem agora estar vulneráveis a falhas ocultas de design em um único componente, identificado como CVE-2025-27840. As vulnerabilidades podem permitir que atacantes falsifiquem endereços MAC, obtenham acesso não autorizado à memória do dispositivo e realizem ataques via Bluetooth.
has_invalid_privkey : A falta de verificação do limite inferior para chaves privadas Bitcoin permite que chaves inválidas (menores ou iguais a 0) sejam usadas, o que pode levar à perda de fundos.electrum_sig_hash : O uso de um método de hash de mensagem não padronizado pelo Electrum o torna vulnerável a ataques de falsificação de assinatura devido à sua incompatibilidade com o BIP-137.random_key(PRNG Fraco na Geração de Chaves) : O uso do módulo de geração de chaves random na rede Bitcoin torna as chaves privadas previsíveis para atacantes, pois esse módulo não é destinado a fins criptográficos.multiply(Falta de Validação de Pontos da Curva ECC) : A validação insuficiente de pontos na curva ECC pode permitir que um atacante realize ataques de curva inválida, o que pode levar a assinaturas forjadas e manipulação da rede.ecdsa_raw_sign : A restauração incorreta da coordenada Y pode levar à substituição de uma chave pública na rede Bitcoin.bin_ripemd160 : APIs de hash legadas, especialmente aquelas sem RIPEMD-160, podem ser vulneráveis a ataques, destacando a importância de usar bibliotecas criptográficas atualizadas e atualizações regulares de segurança.
random_key e ecdsa_raw_signmelhora a segurança geral da rede Bitcoin e previne possíveis ataques a transações e assinaturas.A identificação e análise de vulnerabilidades apresentadas neste artigo destacam a necessidade de monitoramento contínuo e melhoria da segurança de dispositivos e softwares. Abordar essas vulnerabilidades não apenas previne possíveis ataques e perdas financeiras, mas também ajuda a construir a confiança dos usuários e a cumprir os padrões de segurança. A implementação de mecanismos robustos de proteção e atualizações regulares de segurança é fundamental para garantir a operação segura e confiável dos sistemas digitais. A necessidade de melhorar a segurança em dispositivos e redes como o ESP32 está se tornando cada vez mais urgente.
Este material foi criado para o portal CRYPTO DEEP TECH para garantir a segurança de dados financeiros e a criptografia em curvas elípticas secp256k1 contra assinaturas ECDSA fracas na criptomoeda BITCOIN . Os criadores do software não são responsáveis pelo uso dos materiais.
Telegram: https://t.me/cryptodeeptech
Material em vídeo: https://youtu.be/nBeZWm2z5o4
Tutorial em vídeo: https://dzen.ru/video/watch/6784be61b09e46422395c236
Fonte: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
has_invalid_privkeypara verificar privkey.