比特币密码分析：ESP32 微控制器中的 CVE-2025-27840 漏洞通过 Wi-Fi 和蓝牙将数十亿 IoT 设备置于风险之中

本文讨论了攻击者如何通过模块更新引入隐藏的漏洞列表，从而导致 ESP32 设备被入侵并获取未授权的私钥访问权限，影响了数十亿使用该微控制器的设备。关键问题之一是在 ESP32 架构中发现的 CVE-2025-27840 漏洞。为确保比特币网络的安全性，我们识别了以下漏洞：由于函数 has_invalid_privkey 中缺少下限检查而可能使用无效私钥的可能性；函数 electrum_sig_hash 中因与 BIP-137 不兼容导致的交易签名伪造漏洞；密钥生成函数 random_key 中的弱 PRNG 问题，使加密货币钱包的个人私钥变得可预测；函数 multiply 中缺少对 ECC 曲线点的验证，可能导致无效曲线攻击；函数 ecdsa_raw_sign 中在恢复 Y 坐标时的漏洞，可能导致公钥替换；以及 bin_ripemd160 中与弃用哈希 API 相关的漏洞。

教程：https://youtu.be/nBeZWm2z5o4
教程：https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
教程：https://dzen.ru/video/watch/6784be61b09e46422395c236
Google Colab：https://colab.research.google.com/drive/15lPDHeTo7FkrPY7v4qS7X6hO4x27qT2Y

2025 年 3 月初，Tarlogic Security 在 ESP32 微控制器中发现了一个漏洞，该微控制器广泛用于通过 WiFi 和蓝牙连接设备。此漏洞编号为 CVE-2025-27840。攻击者可以通过将 ESP32 芯片作为对运行在比特币和以太坊等流行加密货币网络上的设备进行密码学攻击的切入点，来未授权访问比特币钱包数据。此问题影响数百万使用该微控制器的 IoT 设备。利用此漏洞，攻击者可以伪装成合法用户进行攻击，并永久感染易受攻击的设备。这威胁到了基于 ESP32 微控制器的 IoT 设备的安全，并可能导致比特币钱包私钥被盗。

ESP32 是一种广泛用于 IoT 设备的微控制器，用于提供 Wi-Fi 和蓝牙连接。攻击者可以使用各种方法通过 ESP32 获取比特币钱包私钥数据。

与 ESP32 微控制器相关的安全威胁可能导致比特币钱包私钥被盗。主要问题包括后门和漏洞的存在。利用此类漏洞，他们可以操纵内存、伪造 MAC 地址并注入恶意代码，这造成了严重的安全风险。

攻击者可以通过利用蓝牙和 Wi-Fi 连接中的漏洞来攻击带有 ESP32 微控制器的 IoT 设备，这些设备可能成为攻击其他与比特币相关网络设备的工具，并窃取包括比特币钱包私钥在内的机密信息。

https://youtu.be/nBeZWm2z5o4

隐藏的漏洞列表：

攻击者可以更新模块并向代码中引入各种漏洞列表，包括：

函数 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。该代码仅供演示目的。

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L305

此错误允许使用无效的私钥，这可能导致严重问题，包括资金损失。

要修复此问题，您需要添加检查以确保私钥大于 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: 
    """ 
    检查私钥是否无效，基于缺少下限检查。 

    参数： 
        privkey：要检查的私钥。 

    返回： 
        如果私钥无效（<= 0 或 >= N）则返回 True，否则返回 False。 
    """ 
    # 比特币使用的 secp256k1 椭圆曲线的阶 
    N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 

    if privkey >= N: # 仅检查上限 
        raise Exception("Invalid privkey") 

    if privkey <= 0: # 缺少下限检查 
        return True 

    return False 

# 使用示例 
privkey = 0 # 无效私钥 
is_invalid = has_invalid_privkey(privkey) 

if is_invalid: 
    print("无效私钥！") 
else: 
    print("有效私钥。")

代码说明：

导入库 ecdsa：虽然在此示例中未直接使用，但在涉及比特币和 ECDSA（椭圆曲线数字签名算法）的实际场景中，可能需要此库来执行密码学操作。
函数 has_invalid_privkey(privkey: int) -> bool：
- 接收一个整数类型的私钥作为输入。
- 定义一个常量 N，代表比特币中使用的 secp256k1 椭圆曲线的阶。
- 检查 privkey 是否大于或等于 N。如果是，则引发异常，指示私钥无效。
- 检查 privkey 是否小于或等于 0。如果是，则返回 True，指示由于缺少下限检查，私钥无效。
- 如果两项检查均通过，则返回 False。
使用示例：
- 将 privkey = 0 设置为值，这是一个无效的私钥。
- 调用函数 has_invalid_privkey 来检查 privkey。
- 根据结果，显示指示私钥是否有效的消息。

漏洞：

代码包含一个与私钥验证不足相关的漏洞。具体来说，缺少下限检查（privkey <= 0）。这允许使用无效的私钥，可能导致不可预测的后果，包括资金损失。

修复方法：

需要添加私钥的下限检查，以确保它大于 0。

函数 `electrum_sig_hash` 中的比特币交易签名伪造漏洞

Electrum 中的函数 electrum_sig_hash 使用了一种非标准的消息哈希方法，由于与 BIP-137 不兼容，这使得它容易受到签名伪造攻击。

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L425

针对比特币网络的攻击者可以通过 electrum_sig_hash 发现 Electrum 使用的非标准消息哈希方法。此函数创建消息哈希的方式可能导致签名伪造攻击，因为它与 BIP-137 不兼容。提供的 Python 脚本演示了攻击者如何生成 Electrum 使用的消息哈希，以利用 BIP-137 不兼容漏洞。函数 electrum_sig_hash 通过为消息添加前缀、编码其长度，然后使用 SHA256 进行双重哈希来准备消息。

一个 Python 脚本，演示攻击者如何找到 Electrum 用于执行签名伪造攻击的非标准消息哈希（由于 BIP-137 不兼容）。

Python 脚本 bitcoin_sign_hash.py

!pip install ecdsa 
import hashlib 

def num_to_var_int(i): 
    if i < 0xfd: 
        return i.to_bytes(1, 'little') 
    elif i <= 0xffff: 
        return b'\xfd' + i.to_bytes(2, 'little') 
    elif i <= 0xffffffff: 
        return b'\xfe' + i.to_bytes(4, 'little') 
    else: 
        return b'\xff' + i.to_bytes(8, 'little') 

def from_string_to_bytes(s): 
    return s.encode('utf-8') 

def bin_dbl_sha256(s): 
    hash1 = hashlib.sha256(s).digest() 
    hash2 = hashlib.sha256(hash1).digest() 
    return hash2 

def electrum_sig_hash(message): 
    padded = b"\x18Bitcoin Signed Message:\n" + num_to_var_int(len(message)) + from_string_to_bytes(message) 
    return bin_dbl_sha256(padded) 

# 使用示例 
message = "用于签名的示例消息" 
message_hash = electrum_sig_hash(message) 
print(f"Electrum 消息哈希：{message_hash.hex()}")

在此脚本中：

num_to_var_int(i)：将整数转换为比特币中使用的可变长度格式。
from_string_to_bytes(s)：使用 UTF-8 编码将字符串编码为字节。
bin_dbl_sha256(s)：对输入执行双重 SHA256 哈希运算。
electrum_sig_hash(message)：模拟 Electrum 的非标准消息哈希方式，该方式存在 BIP-137 不兼容问题。

密钥生成中 `random_key` 弱 PRNG 函数的漏洞（非确定性 PRNG）

当比特币使用依赖于 random 模数的函数 random_key 来创建密钥时，问题就出现了。random 模数并非用于密码学目的，因为它无法生成足够随机的数字，使得私钥对攻击者而言可预测。这使得比特币网络易受攻击。

比特币密码分析：ESP32 微控制器中的 CVE-2025-27840 漏洞通过 Wi-Fi 蓝牙将数十亿物联网设备置于风险之中

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L432

一个 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 坐标恢复的特性。这种歧义可能导致公钥被错误恢复。

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L543

使用 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 坐标以生成无效的公钥。

请注意，这只是一个示例，实际攻击可能复杂得多。

除了上述脚本之外，还需要考虑以下几点：

Frey-Rück 攻击：此攻击利用 ECDSA 签名中的漏洞来提取私钥“K”（nonce），最终可能导致恢复比特币钱包。
按位操作：XOR 是数据加密的宝贵工具，可以与其他操作结合使用以提高安全性。
51% 攻击：虽然与 Y 坐标恢复没有直接关系，但重要的是要理解，控制超过 50% 网络计算能力的攻击者有可能操纵区块链。
雅可比曲线坐标操纵：攻击者可以利用雅可比坐标的数学属性来创建虚假的数字签名。
软件更新：始终保持软件更新并使用受信任的设备至关重要，以防止因严重漏洞而可能丢失 BTC 币。

bin_ripemd160 函数中的漏洞

比特币网络上的传统哈希 API，特别是在缺少 RIPEMD-160 的情况下，可能容易受到攻击。攻击者可以发现并利用弱实现，这凸显了使用现代加密库和定期安全更新的重要性。

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L378

比特币网络上的攻击者可能会在传统哈希 API 中发现漏洞，尤其是当某些系统缺少 RIPEMD-160 实现时。问题出在 bin_ripemd160 函数中，它尝试使用 hashlib 进行哈希，但如果失败，则会切换到可能较弱的自定义实现。

提供的 Python 脚本演示了攻击者如何测试比特币节点是否存在此类弱 API 实现。如果 hashlib 不支持 RIPEMD-160，则使用简化的实现，这可能导致哈希冲突和其他漏洞。该脚本通过对数据进行哈希并打印警告来模拟攻击，提示使用了弱实现。

风险包括伪造交易的可能性以及利用传统 API 中已知漏洞的可能性。为了保护自己，建议使用经过测试的现代加密库，定期更新比特币软件，并检查加密操作的输出。

一个 Python 脚本，其中比特币攻击者发现了一个弃用的哈希 API，并讨论了在某些环境中未实现 RIPEMD-160 的风险：

Python 脚本 ripemd160_vulnerability.py

详细说明：

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 传递该数据。

工作原理：

模拟攻击：
- 脚本模拟攻击者试图识别比特币网络中使用过时或弱 RIPEMD160 哈希 API 的节点。
RIPEMD160 实现检查：
- 尝试使用标准库 hashlib 进行 RIPEMD160 哈希。如果失败（因为该特定环境中的 hashlib 不支持 RIPEMD160），则回退到自定义实现（本例中为简化版本）。
识别弱点：
- 自定义实现（本例中）被故意弱化。如果节点使用此实现，攻击者可利用此弱点。
可能的风险：
- 哈希碰撞： 弱 RIPEMD160 哈希实现可能易受哈希碰撞攻击。攻击者可利用此篡改交易或数据。
- 安全漏洞： 废弃的 API 可能包含已知漏洞，攻击者可加以利用。

缓解措施：

使用当前库：
- 确保使用最新且经过测试的加密操作库。
- 如果需要 RIPEMD160，使用可靠且最新的实现。
定期更新：
- 保持比特币软件最新，以受益于安全修复和改进。
验证：

函数 `multiply` 的漏洞：缺少 ECC 曲线点检查

比特币的 multiply 函数存在潜在漏洞，因为对 ECC 曲线上的点验证不足。这可能允许攻击者执行无效曲线攻击，尽管现代加密库（如 pycryptodome）使得此类利用变得困难。该攻击可通过雅可比曲线操作实现，可能导致签名伪造和网络操纵。

比特币密码分析：CVE-2025-27840 ESP32微控制器漏洞使数十亿物联网设备面临Wi-Fi和蓝牙风险

https://github.com/primal100/pybitcointools/blob/e7c96bfe1f4be08a9f3c540e598a73dc20ca2462/cryptos/main.py#L275

在比特币网络中，攻击者可能发现 multiply 函数的漏洞：该函数缺少对点是否在椭圆曲线（ECC）上的完整检查。代码中仅对非零点进行了检查，这为使用无效曲线攻击（invalid curve attacks）提供了可能性。

攻击者的示例代码展示了如何利用此漏洞。它演示了一个 multiply 函数，该函数缺乏对曲线点的可靠检查，以及一个 invalid_curve_attack 函数，试图利用此弱点。代码还使用了 pycryptodome 库进行加密操作。

由于 pycryptodome 内置的安全机制，直接执行此类攻击更加困难。代码展示了如何创建“错误”曲线并尝试执行乘法，但强调这是不安全的，需要深入了解密码学。

通过利用 multiply 函数中的漏洞，攻击者可以执行无效曲线攻击以泄露比特币网络上的私钥。以下是一个 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 执行乘法。

小子群攻击的工作原理：

选择低阶点： 攻击者选择曲线或扭曲线上一个低阶点 Q。
发送点： 攻击者将此点 Q 发送给受害者，冒充其公钥。
计算共享密钥： 受害者计算 nQ，其中 n 是受害者的私钥。
暴力破解： 由于 Q 的阶很小，因此 nQ 的可能值很少。攻击者可以暴力破解所有这些值，并通过扩展 n 模 Q 的阶来检查哪一个对应于加密数据。

建议：

始终检查输入点是否确实在 ECC 曲线上。
使用提供稳健曲线检查并防御无效曲线攻击的库。

小子群攻击

使用 SMALL SUBGROUP ATTACK 服务函数 解码易受攻击的 RawTX 交易

结果是 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

比特币密码分析：CVE-2025-27840 ESP32微控制器漏洞使数十亿物联网设备面临Wi-Fi & 蓝牙风险

因此，我们得到了 X 的私钥，格式为 HEX 格式

X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34

使用机器学习验证获取的私钥结果

启动 BitcoinChatGPT

%run BitcoinChatGPT

Apply 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 中的缺陷。特别关注了 ESP32 微控制器中的 CVE-2025-27840 漏洞，该漏洞允许攻击者注入虚假更新并获得对系统的低级访问权限。讨论了这些漏洞的潜在影响，包括绕过代码审计控制、获取私钥以及进行供应链攻击的能力。本文最后提出了加强安全性和防范潜在攻击的建议。

漏洞及其分析

has_invalid_privkey 中的私钥推导漏洞：比特币私钥缺少下限检查，允许使用无效密钥（小于或等于 0），这可能导致资金损失。
electrum_sig_hash 函数中的比特币交易签名伪造漏洞：Electrum 使用非标准的消息哈希方法，由于其与 BIP-137 不兼容，使得其容易受到签名伪造攻击。
random_key 函数漏洞（密钥生成中的弱 PRNG）：在比特币网络中使用 random 密钥生成模块使得私钥对攻击者来说可预测，因为该模块并非用于加密目的。
multiply 函数漏洞（缺少 ECC 曲线点验证）：对 ECC 曲线中点的验证不足可能允许攻击者进行无效曲线攻击，这可能导致签名伪造和网络操纵。
ecdsa_raw_sign 函数漏洞：Y 坐标恢复不正确可能导致比特币网络中的公钥替换。
bin_ripemd160 函数漏洞：遗留哈希 API，尤其是那些缺少 RIPEMD-160 的 API，可能容易受到攻击，这凸显了使用最新加密库和定期安全更新的重要性。

识别和修复漏洞的好处

防止财务损失：修复与私钥和签名伪造相关的漏洞有助于防止加密货币用户损失资金。
保护机密数据：修复 ESP32 设备中的漏洞可防止未经授权的内存访问和 MAC 地址欺骗，从而保护用户的机密数据。
提高网络安全：修复诸如 random_key 和 ecdsa_raw_sign 等加密函数中的漏洞可提高比特币网络的整体安全性，并防止对交易和签名的潜在攻击。
建立用户信任：及时识别和修复漏洞有助于建立用户对设备和软件的信任，这在加密货币和物联网领域尤为重要。
维护安全标准：保持加密库和 API 的更新并遵循现代安全标准有助于防止使用过时和易受攻击的组件。