demining/bluetooth-attacks-cve-2025-27840Bitcoin-Kryptanalyse: CVE-2025-27840 Sicherheitslücke in ESP32-Mikrocontrollern setzt Milliarden von IoT-Geräten über Wi-Fi & Bluetooth einem Risiko aus
In diesem Artikel wird erörtert, wie ein Angreifer über Modul-Updates eine versteckte Liste von Schwachstellen einschleusen kann, die zu einer Kompromittierung von ESP32-Geräten und einem unbefugten Zugriff auf private Schlüssel führen können, was Milliarden von Geräten betrifft, die diesen Mikrocontroller verwenden. Eines der Hauptprobleme ist die CVE-2025-27840-Schwachstelle, die in der ESP32-Architektur entdeckt wurde. Um die Sicherheit des Bitcoin-Netzwerks zu gewährleisten, haben wir die folgenden Schwachstellen identifiziert: die Möglichkeit der Verwendung ungültiger privater Schlüssel aufgrund des Fehlens einer Untergrenzenprüfung in der Funktion has_invalid_privkey; eine Schwachstelle bei der Fälschung von Transaktionssignaturen in der Funktion electrum_sig_hash aufgrund fehlender Kompatibilität mit BIP-137; ein Problem mit einem schwachen PRNG in der Schlüsselerzeugungsfunktion random_key, das persönliche private Schlüssel für Kryptowährungs-Wallets vorhersagbar macht; fehlende Überprüfung von Punkten auf der ECC-Kurve in der Funktion multiply, was zu Angriffen mit ungültigen Kurven führen kann; eine Schwachstelle in der Funktion ecdsa_raw_sign bei der Wiederherstellung der Y-Koordinate, die möglicherweise zu einer Substitution des öffentlichen Schlüssels führt; sowie Schwachstellen im Zusammenhang mit veralteten Hashing-APIs in bin_ripemd160.
Anfang März 2025 identifizierte Tarlogic Security eine Schwachstelle im Mikrocontroller ESP32, der häufig zur Verbindung von Geräten über WLAN und Bluetooth verwendet wird. Diese Schwachstelle wurde unter der Nummer CVE-2025-27840 erfasst. Angreifer können unbefugt auf Bitcoin-Wallet-Daten zugreifen, indem sie den ESP32-Chip als Angriffspunkt für kryptografische Angriffe auf Geräte nutzen, die in Netzwerken populärer Kryptowährungen wie Bitcoin und Ethereum laufen. Dieses Problem betrifft Millionen von IoT-Geräten, die diesen Mikrocontroller verwenden. Die Ausnutzung dieser Schwachstelle ermöglicht es Angreifern, sich als legitime Benutzer auszugeben und verwundbare Geräte dauerhaft zu infizieren. Dies bedroht die Sicherheit von IoT-Geräten auf Basis des ESP32-Mikrocontrollers und kann zum Diebstahl privater Bitcoin-Wallet-Schlüssel führen.
ESP32 ist ein Mikrocontroller, der in IoT-Geräten weit verbreitet ist, um WLAN- und Bluetooth-Konnektivität bereitzustellen. Angreifer können verschiedene Methoden nutzen, um über den ESP32 Zugriff auf die Daten privater Bitcoin-Wallet-Schlüssel zu erhalten.
Sicherheitsbedrohungen im Zusammenhang mit dem ESP32-Mikrocontroller können zum Diebstahl privater Bitcoin-Wallet-Schlüssel führen. Zu den Hauptproblemen gehören das Vorhandensein von Hintertüren und Schwachstellen. Durch die Nutzung solcher Schwachstellen können sie den Speicher manipulieren, MAC-Adressen fälschen und bösartigen Code einschleusen, was ernsthafte Sicherheitsrisiken schafft.
Angreifer können IoT-Geräte mit einem ESP32-Mikrocontroller über Bluetooth- und WLAN-Verbindungen angreifen, was zu einem Werkzeug für Angriffe auf andere Geräte im Bitcoin-bezogenen Netzwerk sowie zum Diebstahl vertraulicher Informationen, einschließlich privater Bitcoin-Wallet-Schlüssel, werden kann.
Ein Angreifer kann Module aktualisieren und eine Liste verschiedener Schwachstellen in den Code einschleusen, darunter:
has_invalid_privkey, die verwendet werden kann, um den privaten Schlüssel zu erhalten.electrum_sig_hash, die das Fälschen von Bitcoin-Transaktionssignaturen ermöglicht.random_key im Zusammenhang mit einem schwachen Pseudo-Zufallszahlengenerator (nicht-deterministischer PRNG).multiply, bei der keine Überprüfung eines Punktes auf der ECC-Kurve erfolgt.ecdsa_raw_sign und bin_ripemd160.Diese Schwachstellen können verwendet werden, um gefälschte Updates in ESP32-Geräte einzuschleusen, was Angreifern Low-Level-Zugriff auf das System ermöglicht. Dadurch können sie Code-Audit-Kontrollen umgehen und Zugriff auf private Schlüssel erhalten. Derzeit könnten Milliarden von Geräten aufgrund versteckter Funktionen einer einzelnen Komponente in ihrer Architektur, die als CVE-2025-27840 bezeichnet wird, angreifbar sein.
has_invalid_privkeyDiese Schwachstelle wurde im Bitcoin-Private-Key-Überprüfungscode gefunden und ermöglicht die Verwendung ungültiger Schlüssel (kleiner oder gleich 0) aufgrund des Fehlens einer Untergrenzenprüfung. Dies kann zu Geldverlust führen. Um dies zu beheben, muss eine Prüfung hinzugefügt werden, die sicherstellt, dass der private Schlüssel größer als 0 ist. Der Code dient Demonstrationszwecken.
Dieser Fehler erlaubt die Verwendung ungültiger privater Schlüssel, was zu ernsthaften Problemen, einschließlich Geldverlust, führen kann.
Um dies zu beheben, muss eine Prüfung hinzugefügt werden, die sicherstellt, dass der private Schlüssel größer als 0 ist.
Stellen Sie sich vor, jemand versucht, das Bitcoin-Netzwerk zu „hacken“. Er findet eine Schwachstelle in der Überprüfung privater Schlüssel, die zum Zugriff auf die Kryptowährung verwendet werden.
Das Problem ist, dass der Code nur prüft, ob der private Schlüssel zu groß ist. Wenn der Schlüssel sehr groß ist, wird er abgelehnt. Der Code vergisst jedoch zu prüfen, ob der Schlüssel zu klein ist (kleiner oder gleich Null).
Der Codeabschnitt, in dem dies geschieht:
...
...if privkey >= N: #Nur die obere Grenze wird geprüftDie untere Grenze wird nicht richtig geprüft
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
Aufgrund dieses Fehlers ist es möglich, ungültige (sehr kleine) private Schlüssel zu verwenden. Diese Schwachstelle befindet sich in der Funktion has_invalid_privkey.
Damit das alles funktioniert, muss die Bibliothek ecdsa installiert werden (wird für die Arbeit mit Kryptografie benötigt):
Python-Skript 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.")
Erklärung des Codes:
ecdsa: Obwohl sie in diesem Beispiel nicht direkt verwendet wird, kann diese Bibliothek in realen Szenarien mit Bitcoin und ECDSA (Elliptic Curve Digital Signature Algorithm) für kryptografische Operationen benötigt werden.has_invalid_privkey(privkey: int) -> bool:
privkey akzeptiert einen privaten Schlüssel als Ganzzahl.N, die die Ordnung der in Bitcoin verwendeten elliptischen Kurve secp256k1 darstellt.privkey größer oder gleich N ist. Falls ja, wird eine Ausnahme ausgelöst, die angibt, dass der private Schlüssel ungültig ist.privkey kleiner oder gleich 0 ist. Falls ja, wird True zurückgegeben, was anzeigt, dass der private Schlüssel aufgrund der fehlenden Untergrenzenprüfung ungültig ist.False zurückgegeben.privkey = 0, was ein ungültiger privater Schlüssel ist.Schwachstelle:
Der Code enthält eine Schwachstelle aufgrund unzureichender Überprüfung des privaten Schlüssels. Insbesondere fehlt eine Untergrenzenprüfung (privkey <= 0). Dies ermöglicht die Verwendung ungültiger privater Schlüssel, was zu unvorhersehbaren Konsequenzen, einschließlich Geldverlust, führen kann.
Wie man es behebt:
Es muss eine Untergrenzenprüfung des privaten Schlüssels hinzugefügt werden, um sicherzustellen, dass er größer als 0 ist.
electrum_sig_hashDie Funktion electrum_sig_hash in Electrum verwendet eine nicht standardmäßige Methode zum Hashen von Nachrichten, was sie aufgrund ihrer Inkompatibilität mit BIP-137 anfällig für Signaturfälschungsangriffe macht.
Ein Angreifer, der auf das Bitcoin-Netzwerk abzielt, kann die nicht standardmäßige Methode zum Hashen von Nachrichten, die von Electrum über electrum_sig_hash verwendet wird, entdecken. Diese Funktion erstellt einen Nachrichten-Hash auf eine Weise, die aufgrund der BIP-137-Inkompatibilität zu Signaturfälschungsangriffen führen kann. Das bereitgestellte Python-Skript demonstriert, wie ein Angreifer den von Electrum verwendeten Nachrichten-Hash generieren kann, um die Schwachstelle der BIP-137-Inkompatibilität auszunutzen. Die Funktion electrum_sig_hash bereitet die Nachricht vor, indem sie ein Präfix hinzufügt und ihre Länge kodiert, bevor sie mit SHA256 doppelt gehasht wird.
Ein Python-Skript, das demonstriert, wie ein Angreifer einen nicht standardmäßigen Nachrichten-Hash finden kann, der von Electrum verwendet wird, um aufgrund der BIP-137-Inkompatibilität Signaturfälschungsangriffe durchzuführen.
Python-Skript bitcoin_sign_hash.py
!pip install ecdsa
import hashlib
def num_to_var_int(i):
if i < 0xfd:
return i.to_bytes(1, 'little')
elif i <= 0xffff:
return b'\xfd' + i.to_bytes(2, 'little')
elif i <= 0xffffffff:
return b'\xfe' + i.to_bytes(4, 'little')
else:
return b'\xff' + i.to_bytes(8, 'little')
def from_string_to_bytes(s):
return s.encode('utf-8')
def bin_dbl_sha256(s):
hash1 = hashlib.sha256(s).digest()
hash2 = hashlib.sha256(hash1).digest()
return hash2
def electrum_sig_hash(message):
padded = b"\x18Bitcoin Signed Message:\n" + num_to_var_int(len(message)) + from_string_to_bytes(message)
return bin_dbl_sha256(padded)
# Usage example
message = "Example message for signing"
message_hash = electrum_sig_hash(message)
print(f"Electrum message hash: {message_hash.hex()}")
In diesem Skript:
num_to_var_int(i): konvertiert eine Ganzzahl in das in Bitcoin verwendete variable Längenformat.from_string_to_bytes(s): kodiert eine Zeichenfolge in Bytes unter Verwendung der UTF-8-Kodierung.bin_dbl_sha256(s): führt eine doppelte SHA256-Hash-Funktion auf der Eingabe aus.electrum_sig_hash(message): simuliert Electrums nicht standardmäßige Methode zum Hashen von Nachrichten, die der BIP-137-Inkompatibilität unterliegt.random_key-Funktion mit schwachem PRNG bei der Schlüsselerzeugung (nicht-deterministischer PRNG)Das Problem tritt auf, wenn Bitcoin eine Funktion random_key verwendet, die zur Erstellung von Schlüsseln auf den Modul random angewiesen ist. Der Modul random ist nicht für kryptografische Zwecke vorgesehen, da er keine ausreichend zufälligen Zahlen generiert, was private Schlüssel für Angreifer vorhersagbar macht. Dies macht das Bitcoin-Netzwerk anfällig.
Ein Python-Skript, das das Bitcoin-Netzwerk angreifbar macht, indem es random anstelle von secrets oder os.urandom verwendet, wodurch die privaten Schlüssel für einen Bitcoin-Angreifer vorhersagbar werden:
Python-Skript 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():
# Muss sicher sein nach dem java.SecureRandom-Desaster...
entropy = random_string(32) \
+ str(random.randrange(2**256)) \
+ str(int(time.time() * 1000000))
return sha256(entropy.encode('utf-8')).hexdigest()
# Beispielverwendung: Generieren eines privaten Schlüssels
private_key = random_key()
print("Generated Private Key:", private_key)Dieses Skript verwendet das Modul random zur Schlüsselgenerierung, was es angreifbar macht. Die Verwendung des Moduls random ist für kryptografische Zwecke nicht geeignet, da es keine ausreichend zufälligen Zahlen erzeugt.
Um einen sichereren Schlüssel zu erstellen, können Sie das Modul secrets oder os.urandom verwenden. Hier ist ein Beispiel für die Verwendung des Moduls secrets:
import secrets
import hashlib
def secure_random_key():
# Generiere eine Zufallszahl mit ausreichender Entropie
random_bytes = secrets.token_bytes(32) # 32 Bytes = 256 Bits
# Hashe die zufälligen Bytes, um einen privaten Schlüssel zu erstellen
private_key = hashlib.sha256(random_bytes).hexdigest()
return private_key
# Beispielverwendung: Generieren eines sicheren privaten Schlüssels
secure_private_key = secure_random_key()
print("Generated Secure Private Key:", secure_private_key)In diesem Beispiel wird das Modul secrets verwendet, um eine Zufallszahl mit ausreichender Entropie zu generieren. Die Zufallszahl wird dann gehasht, um einen persönlichen privaten Schlüssel zu erstellen. Diese Methode ist viel sicherer als die Verwendung des Moduls random.
Eine Sicherheitslücke in der ecdsa_raw_sign-Funktion bei der Wiederherstellung der Y-Koordinate kann zur Substitution eines öffentlichen Schlüssels im Bitcoin-Netzwerk führen. Es besteht ein hohes Risiko, dass ein Angreifer die Besonderheit der Y-Koordinaten-Wiederherstellung bei der Arbeit mit einer elliptischen Kurve ausnutzt. Diese Mehrdeutigkeit kann dazu führen, dass der öffentliche Schlüssel falsch wiederhergestellt wird .
Das Codebeispiel, das mit der Bibliothek pycryptodome erstellt wurde, zeigt, wie diese Situation simuliert werden kann, indem die Y-Koordinate ersetzt wird, um einen anderen, ungültigen öffentlichen Schlüssel zu erhalten. Es ist wichtig zu beachten, dass das Codebeispiel vereinfacht ist und keine vollständige Implementierung des Angriffs darstellt, sondern nur das Prinzip zeigt.
Ein Angreifer kann die Mehrdeutigkeit der Y-Koordinaten-Wiederherstellung im Bitcoin-Netzwerk ausnutzen, was zu Fehlern bei der Wiederherstellung des öffentlichen Schlüssels führen kann. Hier ist ein Beispiel, wie dies mit der bitweisen XOR-Operation durchgeführt werden kann.
Python-Skript 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
# Elliptische Kurvenparameter secp256k1
# PyCryptodome bietet keine bequeme Möglichkeit, die Parameter der secp256k1-Kurve direkt anzugeben.
# Daher verwenden wir die Standard-ECC-Kurve.
# Achten Sie bei Produktionscode auf die Wahl der Kurve und ihrer Parameter.
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 entfernt, da N keine definierte Konstante mehr ist
return k
def ecdsa_raw_sign(msghash, priv_key_int):
z = hash_to_int(msghash)
k = deterministic_generate_k(msghash, priv_key_int)
# Erstellen eines privaten Schlüsselobjekts
key = ECC.construct(curve='P-256', d=priv_key_int)
# Berechnen des Punktes R = kG
# PyCryptodome bietet keinen direkten Zugriff auf die Koordinaten von Punkt R
# Daher wird die Signatur auf andere Weise mit DSS berechnet
# s = pow(k, -1, N) * (z + r * private_key_int) % N # N ist nicht mehr definiert
# v = 27 + ((y % 2) ^ (0 if s * 2 < N else 1)) # y ist nicht verfügbar
return key, z, k # Gib den Schlüssel, Hash und k zur weiteren Verwendung bei der Signatur zurück
def recover_pubkey(msghash, signature, key):
# WARNUNG: Dies ist ein SEHR VEREINFACHTES Beispiel der Wiederherstellung des öffentlichen Schlüssels.
# Im realen Leben ist die Wiederherstellung des öffentlichen ECDSA-Schlüssels ein komplexer Prozess.
# Dieser Code dient nur zur Demonstration des Prinzips.
# PyCryptodome hat keine einfache Möglichkeit, PublicKey direkt aus r und s wiederherzustellen.
# Dieser Code führt keine echte Wiederherstellung durch, sondern erstellt einen neuen PublicKey aus dem privaten Schlüssel.
# In einem realen Angriffsszenario müssen Sie versuchen, die y-Koordinate zu erraten, um einen gültigen PublicKey zu erhalten. # Dies erfordert jedoch eine komplexere Logik für die Arbeit mit der elliptischen Kurve. return key.public_key()def emulate_attack(msghash, priv): # 1. Signiere die Nachricht 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. Versuch, den öffentlichen Schlüssel (falsch) wiederherzustellen Q = recover_pubkey(msghash, signature, key) # 3. Simuliere eine Situation, in der die Y-Koordinate falsch wiederhergestellt wird # In einem realen Angriffsszenario wird ein Angreifer versuchen, verschiedene y-Koordinaten zu durchlaufen. # In diesem Beispiel ändern wir einfach die x-Koordinate geringfügig tampered_key = ECC.construct(curve='P-256', d=priv_key_int + 1) # BEISPIEL! NICHT IN ECHTEM CODE TUN! Q_tampered = tampered_key.public_key() return Q, Q_tampered # Beispielverwendung msghash = "Message example" # Generiere einen zufälligen privaten Schlüssel private_key = ECC.generate(curve='P-256') priv = hex(private_key.d) # Speichere den privaten Schlüssel als Hex-String # Beispielverwendung 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)
Dieses Skript zeigt, wie die Y-Koordinate geändert werden kann, um einen ungültigen öffentlichen Schlüssel zu erzeugen.
Bitte beachten Sie, dass dies nur ein Beispiel ist und ein echter Angriff viel komplexer sein kann.
Zusätzlich zum obigen Skript sind hier einige zusätzliche Punkte zu beachten:
Legacy-Hashing-APIs im Bitcoin-Netzwerk können, insbesondere ohne RIPEMD-160, angreifbar sein. Angreifer können schwache Implementierungen identifizieren und ausnutzen, was die Bedeutung der Verwendung aktueller kryptografischer Bibliotheken und regelmäßiger Sicherheitsupdates unterstreicht.
Ein Angreifer im Bitcoin-Netzwerk könnte eine Sicherheitslücke in der Legacy-Hashing-API finden, insbesondere wenn einige Systeme keine RIPEMD-160-Implementierung haben. Das Problem liegt in einer Funktion bin_ripemd160, die versucht, hashlib zum Hashing zu verwenden, aber falls dies fehlschlägt, wechselt sie zu einer eigenen, potenziell schwächeren Implementierung.
Das bereitgestellte Python-Skript zeigt, wie ein Angreifer einen Bitcoin-Knoten auf eine solche schwache API-Implementierung testen kann. Wenn hashlib RIPEMD-160 nicht unterstützt, wird eine vereinfachte Implementierung verwendet, was zu Hash-Kollisionen und anderen Sicherheitslücken führen kann. Das Skript simuliert den Angriff, indem es die Daten hasht und eine Warnung ausgibt, falls eine schwache Implementierung verwendet wird.
Zu den Risiken gehören die Möglichkeit von Transaktionsfälschungen und die Ausnutzung bekannter Schwachstellen in Legacy-APIs. Zum Schutz wird empfohlen, aktuelle und getestete kryptografische Bibliotheken zu verwenden, Bitcoin-Software regelmäßig zu aktualisieren und die Ausgabe kryptografischer Operationen zu überprüfen.
Ein Python-Skript, in dem ein Bitcoin-Angreifer eine veraltete Hashing-API findet und das Risiko der Nichtimplementierung von RIPEMD-160 in bestimmten Umgebungen diskutiert:
Python-Skript ripemd160_vulnerability.py
RIPEMD160 simuliert eine Implementierung von RIPEMD160. In der Realität sollte sie den RIPEMD160-Hashing-Algorithmus implementieren. Zu Demonstrationszwecken gibt sie einen Dummy-Hash zurück.bin_ripemd160(string):
check_for_weak_api(data):
bin_ripemd160zum Hashen der Daten auf.if __name__ == "__main__": werden Beispieldaten angegeben und check_for_weak_apimit diesen Daten aufgerufen.hashlib für RIPEMD160-Hashing zu verwenden. Wenn dies fehlschlägt (weil hashlib in der jeweiligen Umgebung RIPEMD160 nicht unterstützt), wird auf eine benutzerdefinierte Implementierung zurückgegriffen (die in diesem Beispiel eine vereinfachte Version ist).multiply Keine Überprüfung eines Punktes auf der ECC-KurveBitcoin hat eine potenzielle Sicherheitslücke in seiner Funktion multiply aufgrund unzureichender Validierung von Punkten auf der ECC-Kurve. Dies könnte einem Angreifer ermöglichen, Invalid-Curve-Angriffe durchzuführen, obwohl moderne kryptografische Bibliotheken wie pycryptodome eine solche Ausnutzung erschweren. Der Angriff ist möglich durch Manipulation der Jacobi-Kurve , was zu gefälschten Signaturen und Manipulation des Netzwerks führen könnte.
Im Bitcoin-Netzwerk kann ein Angreifer eine Sicherheitslücke in der Funktion multiply finden, der eine vollständige Überprüfung fehlt, ob ein Punkt auf einer elliptischen Kurve (ECC) liegt. Im Code wird die Prüfung nur für Nicht-Null-Punkte durchgeführt, was die Möglichkeit von Angriffen mit ungültigen Kurven (Invalid-Curve-Angriffe) eröffnet.
Der Beispielcode des Angreifers zeigt, wie diese Sicherheitslücke ausgenutzt werden kann. Er demonstriert eine Funktion multiply, der eine zuverlässige Überprüfung eines Punktes auf einer Kurve fehlt, und eine Funktion invalid_curve_attack, die versucht, diese Schwachstelle auszunutzen. Der Code verwendet auch die Bibliotheken pycryptodome für kryptografische Operationen.
Mit pycryptodome ist es schwieriger, solche Angriffe direkt durchzuführen, aufgrund der integrierten Sicherheitsmechanismen. Der Code zeigt, wie man eine „falsche“ Kurve erstellt und eine Multiplikation versucht, aber es wird betont, dass dies unsicher ist und ein tiefes Verständnis der Kryptographie erfordert.
Durch Ausnutzen einer Sicherheitslücke in der Funktion
multiplykann ein Angreifer einen Invalid-Curve-Angriff durchführen, um private Schlüssel im Bitcoin-Netzwerk zu kompromittieren. Nachfolgend finden Sie ein Beispiel-Python-Skript, das diesen Angriff demonstriert.
Python script 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)
Code-Erklärung:
multiply prüft nur dann, ob ein Punkt auf der ECC-Kurve liegt, wenn es sich nicht um den Punkt im Unendlichen handelt. Dadurch können Punkte verwendet werden, die nicht auf der Hauptkurve, sondern auf der Twist-Kurve liegen.invalid_curve_attack: Diese Funktion nimmt einen öffentlichen Schlüssel und Parameter einer fehlerhaften Kurve entgegen. Sie erstellt einen Punkt auf der fehlerhaften Kurve und verwendet die anfällige Funktion multiply zur Durchführung der Multiplikation.Wie der Small Subgroup Attack funktioniert:
Q-Punkt niedriger Ordnung auf der Kurve oder auf der Twist-Kurve aus.Q an das Opfer und gibt ihn als seinen öffentlichen Schlüssel aus.nQ, wobei n der geheime Schlüssel des Opfers ist.Q eine kleine Ordnung hat, gibt es eine kleine Anzahl möglicher Werte für nQ . Ein Angreifer kann alle diese Werte durch Brute-Force ermitteln und prüfen, welcher den verschlüsselten Daten entspricht, indem er n modulo der Ordnung von Q erweitert.Empfehlungen:
Dekodieren Sie eine anfällige RawTX-Transaktion mithilfe der SMALL SUBGROUP ATTACK Servicefunktion
Das Ergebnis ist der Wert K des geheimen Schlüssels Nonce im HEX-Format
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2Um alle anderen Werte aus der anfälligen RawTX-Transaktion zu erhalten, verwenden wir den RSZ Signature Decoder Service.
Ergebniswerte für R, S, Z im HEX-Format
R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8Um den Wert X des privaten Schlüssels aus der Formel: priv_key = ((((S * K) - Z) * modinv(R, N)) % N)zu erhalten, verwenden wir die Software Dockeyhunt Private Key Calculator
Als Ergebnis erhalten wir den Wert des privaten Schlüssels X im HEX-Format
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34Starten wir BitcoinChatGPT
%run BitcoinChatGPTApply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency
Schließlich gibt das Modul BitcoinChatGPT die Antwort in die Datei aus: KEYFOUND.privkey, die den privaten Schlüssel in den beiden am häufigsten verwendeten Formaten HEX & WIF speichert
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 =============================Zur Implementierung des Codes installieren wir das Paket Bitcoin. Diese Bibliothek ermöglicht das Erstellen von Wallets, die Interaktion mit der Blockchain, das Erstellen und Signieren von Transaktionen sowie die Arbeit mit verschiedenen Adressformaten und privaten Schlüsseln der Kryptowährung Bitcoin.
!pip3 install bitcoinFühren wir den Code aus, um die Übereinstimmung der Bitcoin-Adresse zu überprüfen:
__________________________________________________
Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________Das ist richtig! Der private Schlüssel entspricht der Bitcoin-Wallet.
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
In der heutigen digitalen Umgebung ist die Sicherung von Geräten und Netzwerken von entscheidender Bedeutung. Dieses Papier analysiert eine Reihe von Schwachstellen, die in verschiedenen Komponenten gefunden wurden, darunter ESP32-Geräte und Software für die Arbeit mit Kryptowährungen wie Bitcoin. Wir untersuchen Fehler im Code zur Überprüfung privater Schlüssel, Methoden zum Hashen von Transaktionen, zur Generierung zufälliger Schlüssel, zur Überprüfung von ECC-Kurvenpunkten, zur Wiederherstellung der Y-Koordinate und veraltete Hashing-APIs. Besondere Aufmerksamkeit gilt der Sicherheitslücke CVE-2025-27840 in ESP32-Mikrocontrollern, die es Angreifern ermöglicht, gefälschte Updates einzuschleusen und Low-Level-Zugriff auf das System zu erhalten. Die potenziellen Auswirkungen dieser Schwachstellen werden diskutiert, einschließlich der Möglichkeit, Code-Audit-Kontrollen zu umgehen, Zugang zu privaten Schlüsseln zu erhalten und Lieferkettenangriffe durchzuführen. Das Papier schließt mit Empfehlungen zur Stärkung der Sicherheit und zur Verhinderung potenzieller Angriffe.
Milliarden von Geräten könnten nun durch versteckte Designfehler in einer einzigen Komponente verwundbar sein, identifiziert als CVE-2025-27840. Die Schwachstellen könnten es Angreifern ermöglichen, MAC-Adressen zu fälschen, unbefugten Zugriff auf den Gerätespeicher zu erlangen und Angriffe über Bluetooth durchzuführen.
has_invalid_privkey: Das Fehlen einer Untergrenzenprüfung für private Bitcoin-Schlüssel erlaubt die Verwendung ungültiger Schlüssel (kleiner oder gleich 0), was zu einem Verlust von Geldern führen kann.electrum_sig_hash: Die Verwendung einer nicht standardmäßigen Methode zum Hashen von Nachrichten durch Electrum macht es aufgrund seiner Inkompatibilität mit BIP-137 anfällig für Signaturfälschungsangriffe.random_key (Schwacher PRNG bei der Schlüsselgenerierung): Die Verwendung des random-Moduls zur Schlüsselgenerierung im Bitcoin-Netzwerk macht private Schlüssel für Angreifer vorhersagbar, da dieses Modul nicht für kryptografische Zwecke vorgesehen ist.multiply (Fehlende Validierung von ECC-Kurvenpunkten): Eine unzureichende Validierung von Punkten auf der ECC-Kurve kann es einem Angreifer ermöglichen, Angriffe mit ungültigen Kurven durchzuführen, was zu gefälschten Signaturen und Netzwerkmanipulation führen kann.ecdsa_raw_sign: Eine falsche Wiederherstellung der Y-Koordinate kann zur Substitution des öffentlichen Schlüssels im Bitcoin-Netzwerk führen.bin_ripemd160: Veraltete Hashing-APIs, insbesondere solche ohne RIPEMD-160, können anfällig für Angriffe sein, was die Bedeutung der Verwendung aktueller kryptografischer Bibliotheken und regelmäßiger Sicherheitsupdates unterstreicht.
random_key und ecdsa_raw_sign verbessert die allgemeine Sicherheit des Bitcoin-Netzwerks und verhindert potenzielle Angriffe auf Transaktionen und Signaturen.Die in diesem Papier vorgestellte Identifizierung und Analyse von Schwachstellen unterstreicht die Notwendigkeit einer kontinuierlichen Überwachung und Verbesserung der Sicherheit von Geräten und Software. Die Behebung dieser Schwachstellen verhindert nicht nur potenzielle Angriffe und finanzielle Verluste, sondern trägt auch zum Aufbau von Benutzervertrauen und zur Einhaltung von Sicherheitsstandards bei. Die Implementierung robuster Schutzmechanismen und regelmäßiger Sicherheitsupdates sind der Schlüssel für einen sicheren und zuverlässigen Betrieb digitaler Systeme. Die Notwendigkeit, die Sicherheit in Geräten und Netzwerken wie dem ESP32 zu verbessern, wird immer dringlicher.
Dieses Material wurde für das CRYPTO DEEP TECH Portal erstellt, um die finanzielle Datensicherheit und Kryptographie auf elliptischen Kurven secp256k1 gegen schwache ECDSA Signaturen in der BITCOIN Kryptowährung zu gewährleisten. Die Ersteller der Software übernehmen keine Verantwortung für die Nutzung der Materialien.
Angriff auf kleine Untergruppen
Telegram: https://t.me/cryptodeeptech
Videomaterial: https://youtu.be/nBeZWm2z5o4
Video-Tutorial: https://dzen.ru/video/watch/6784be61b09e46422395c236
Quelle: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
has_invalid_privkey auf, um privkey zu überprüfen.