demining/bluetooth-attacks-cve-2025-27840Bitcoin Cryptanalysis: ESP32 마이크로컨트롤러의 CVE-2025-27840 취약점이 Wi-Fi 및 Bluetooth를 통해 수십억 개의 IoT 기기를 위험에 빠뜨립니다
이 논문은 공격자가 모듈 업데이트를 통해 숨겨진 취약점 목록을 도입할 수 있는 방법을 논의하며, 이는 ESP32 기기 손상 및 개인 키에 대한 무단 액세스로 이어져 이 마이크로컨트롤러를 사용하는 수십억 개의 기기에 영향을 미칠 수 있습니다. 핵심 문제 중 하나는 ESP32 아키텍처에서 발견된 CVE-2025-27840 취약점입니다. 비트코인 네트워크의 보안을 보장하기 위해 우리는 다음과 같은 취약점을 식별했습니다: has_invalid_privkey 함수의 하한 검사 부재로 인해 유효하지 않은 개인 키를 사용할 가능성; BIP-137 비호환성으로 인한 electrum_sig_hash 함수의 트랜잭션 서명 위조 취약점; 키 생성 함수 random_key의 약한 PRNG 문제로 인해 암호화폐 지갑의 개인 키가 예측 가능해지는 문제; multiply 함수에서 ECC 곡선 위 점 검증 부재로 인해 잘못된 곡선 공격(Invalid Curve Attack)이 발생할 수 있는 문제; Y-좌표 복원 시 ecdsa_raw_sign 함수의 취약점으로 인해 공개 키가 대체될 수 있는 문제; 그리고 bin_ripemd160에서 더 이상 사용되지 않는 해싱 API와 관련된 취약점.
2025년 3월 초, Tarlogic Security는 WiFi 및 Bluetooth를 통해 기기를 연결하는 데 널리 사용되는 ESP32 마이크로컨트롤러에서 취약점을 식별했습니다. 이 취약점은 CVE-2025-27840 번호로 등록되었습니다. 공격자는 ESP32 칩을 비트코인 및 이더리움과 같은 인기 있는 암호화폐 네트워크에서 실행되는 기기에 대한 암호화 공격의 지점으로 사용하여 비트코인 지갑 데이터에 무단으로 액세스할 수 있습니다. 이 문제는 이 마이크로컨트롤러를 사용하는 수백만 개의 IoT 기기에 영향을 미칩니다. 이 취약점을 악용하면 공격자는 합법적인 사용자로 위장한 공격을 수행하고 취약한 기기를 영구적으로 감염시킬 수 있습니다. 이는 ESP32 마이크로컨트롤러 기반 IoT 기기의 보안을 위협하고 비트코인 지갑의 개인 키 탈취로 이어질 수 있습니다.
ESP32는 Wi-Fi 및 Bluetooth 연결을 제공하기 위해 IoT 기기에서 널리 사용되는 마이크로컨트롤러입니다. 공격자는 ESP32를 통해 비트코인 지갑의 개인 키 데이터에 액세스하기 위해 다양한 방법을 사용할 수 있습니다.
ESP32 마이크로컨트롤러와 관련된 보안 위협은 비트코인 지갑의 개인 키 탈취로 이어질 수 있습니다. 주요 문제로는 백도어와 취약점의 존재가 있습니다. 이러한 취약점을 이용하면 메모리를 조작하고 MAC 주소를 스푸핑하며 악성 코드를 주입할 수 있어 심각한 보안 위험을 초래합니다.
공격자는 Bluetooth 및 Wi-Fi 연결의 취약점을 이용해 ESP32 마이크로컨트롤러가 장착된 IoT 기기를 공격할 수 있으며, 이는 비트코인 관련 네트워크의 다른 기기를 공격하는 도구가 될 수 있을 뿐만 아니라 비트코인 지갑의 개인 키를 포함한 기밀 정보를 탈취하는 데 사용될 수 있습니다.
공격자는 모듈을 업데이트하여 코드에 다양한 취약점 목록을 도입할 수 있습니다. 여기에는 다음이 포함됩니다:
has_invalid_privkey 함수의 취약점으로 개인 키를 얻는 데 사용될 수 있습니다.electrum_sig_hash 함수의 취약점으로 비트코인 트랜잭션 서명을 위조할 수 있습니다.random_key 함수의 취약점.multiply 함수의 취약점.ecdsa_raw_sign 및 bin_ripemd160 함수의 취약점.이러한 취약점은 ESP32 기기에 가짜 업데이트를 주입하는 데 사용될 수 있으며, 공격자에게 시스템에 대한 낮은 수준의 액세스 권한을 부여합니다. 이를 통해 코드 감사 통제를 우회하고 개인 키에 액세스할 수 있습니다. 현재 수십억 개의 기기가 아키텍처의 단일 구성 요소에 숨겨진 기능으로 인해 취약할 수 있으며, 이는 CVE-2025-27840으로 지정되었습니다.
has_invalid_privkey 함수에서 개인 키를 얻기 위한 취약점이 취약점은 비트코인의 개인 키 검증 코드에서 발견되었으며, 하한 검사 부재로 인해 유효하지 않은 키(0 이하)를 사용할 수 있습니다. 이로 인해 자금 손실이 발생할 수 있습니다. 이를 수정하려면 개인 키가 0보다 큰지 확인하는 검사를 추가해야 합니다. 코드는 데모 목적으로 제공됩니다.
이 버그는 잘못된 개인 키를 사용할 수 있게 하여 돈 손실을 포함한 심각한 문제를 초래할 수 있습니다.
이를 수정하려면 개인 키가 0보다 큰지 확인하는 검사를 추가해야 합니다.
누군가 비트코인 네트워크를 "해킹"하려 한다고 상상해 보세요. 그들은 암호화폐에 액세스하는 데 사용되는 개인 키의 검증에서 약점을 찾습니다.
문제는 코드가 개인 키가 너무 큰지만 검사한다는 것입니다. 키가 매우 크면 거부됩니다. 그러나 코드는 키가 너무 작은지(0 이하) 검사하는 것을 잊습니다.
이 문제가 발생하는 코드 부분:
...
...if privkey >= N: #Checking only the upper boundLower bound is not checked properly
raise Exception("Invalid privkey")
if privkey <= 0: #
return True
...
...
이 버그로 인해 유효하지 않은(매우 작은) 개인 키를 사용할 수 있습니다. 이 취약점은 has_invalid_privkey 함수에 있습니다.
이 모든 것이 작동하려면 ecdsa 라이브러리를 설치해야 합니다(암호화 작업에 필요합니다):
Python 스크립트 secp256k1_privkey_validator.py
!pip install ecdsa
import ecdsa
def has_invalid_privkey(privkey: int) -> bool:
"""
Checks if a private key is invalid, based on the absence of a lower bound check.
Args:
privkey: The private key to check.
Returns:
True if the private key is invalid (<= 0 or >= N), False otherwise.
"""
# Order of the secp256k1 elliptic curve used by Bitcoin
N = 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 <= 0)가 없습니다. 이로 인해 유효하지 않은 개인 키를 사용할 수 있으며, 자금 손실을 포함한 예측할 수 없는 결과를 초래할 수 있습니다.
수정 방법 :
개인 키가 0보다 큰지 확인하기 위해 하한 검사를 추가해야 합니다.
electrum_sig_hashElectrum의 electrum_sig_hash 함수는 비표준 메시지 해싱 방식을 사용하므로 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 모듈은 충분히 무작위한 숫자를 생성하지 않기 때문에 암호화 목적에 적합하지 않으며, 개인 키를 공격자가 예측할 수 있게 만듭니다. 이로 인해 비트코인 네트워크가 취약해집니다.
secrets 또는 os.urandom 대신 random을 사용하여 Bitcoin 네트워크를 취약하게 만들고, 개인 키를 Bitcoin 공격자에게 예측 가능하게 만드는 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 모듈을 사용하는 것보다 훨씬 안전합니다.
Y-좌표를 복원할 때 ecdsa_raw_sign 함수의 취약점은 Bitcoin 네트워크에서 공개 키가 대체되는 결과를 초래할 수 있습니다. 공격자가 타원 곡선 작업 시 Y-좌표 복원의 특성을 악용할 위험이 높습니다. 이러한 모호성은 공개 키가 잘못 복원되는 결과를 초래할 수 있습니다.
라이브러리 pycryptodome을 사용하여 제공된 코드 예제는 Y-좌표를 교체하여 다른 유효하지 않은 공개 키를 얻는 방식으로 이 상황을 시뮬레이션하는 방법을 보여줍니다. 이 코드 예제는 단순화된 것이며 공격의 전체 구현이 아니라 그 원리만 보여준다는 점에 유의해야 합니다.
공격자는 Bitcoin 네트워크에서 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-좌표를 변경하여 유효하지 않은 공개 키를 생성하는 방법을 보여줍니다.
이것은 단지 예시일 뿐이며 실제 공격은 훨씬 더 복잡할 수 있다는 점에 유의하십시오.
위의 스크립트 외에도 고려해야 할 몇 가지 추가 사항은 다음과 같습니다:
Bitcoin 네트워크의 레거시 해싱 API는 특히 RIPEMD-160이 없는 환경에서 취약할 수 있습니다. 공격자는 취약한 구현을 식별하고 악용할 수 있으므로, 최신 암호화 라이브러리를 사용하고 정기적인 보안 업데이트를 수행하는 것이 중요합니다.
Bitcoin 네트워크의 공격자는 특히 일부 시스템에 RIPEMD-160 구현이 없는 경우 레거시 해싱 API에서 취약점을 발견할 수 있습니다. 문제는 해싱에 hashlib을 사용하려 시도하는 bin_ripemd160 함수에 있으며, 이에 실패하면 잠재적으로 더 취약한 자체 구현으로 전환됩니다.
제공된 Python 스크립트는 공격자가 이러한 취약한 API 구현이 있는지 Bitcoin 노드를 테스트하는 방법을 보여줍니다. hashlib이 RIPEMD-160을 지원하지 않으면 단순화된 구현이 사용되며, 이로 인해 해시 충돌 및 기타 취약점이 발생할 수 있습니다. 이 스크립트는 데이터를 해싱하고 취약한 구현이 사용되는 경우 경고를 출력하여 공격을 시뮬레이션합니다.
위험에는 트랜잭션 위조 가능성과 레거시 API의 알려진 취약점 악용이 포함됩니다. 보호를 위해 최신의 검증된 암호화 라이브러리를 사용하고, Bitcoin 소프트웨어를 정기적으로 업데이트하며, 암호화 작업의 출력을 확인하는 것이 좋습니다.
Bitcoin 공격자가 더 이상 사용되지 않는 해싱 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 곡선 위 점 검사 누락비트코인은 ECC 곡선 위 점의 검증 부족으로 인해 함수 multiply에 잠재적 취약점이 있습니다. 이로 인해 공격자가 잘못된 곡선 공격(invalid curve attack)을 수행할 수 있지만, pycryptodome과 같은 최신 암호화 라이브러리는 이러한 악용을 어렵게 만듭니다. 이 공격은 야코비안 곡선 조작을 통해 가능하며, 이는 위조 서명과 네트워크 조작으로 이어질 수 있습니다.
비트코인 네트워크에서 공격자는 점이 타원 곡선(ECC) 위에 있는지에 대한 완전한 검사가 없는 함수 multiply에서 취약점을 찾을 수 있습니다. 코드에서는 0이 아닌 점에 대해서만 검사를 수행하므로 잘못된 곡선 공격(invalid curve attacks)의 가능성이 열립니다.
공격자의 샘플 코드는 이 취약점을 어떻게 악용할 수 있는지 보여줍니다. 이 코드는 곡선 위 점에 대한 신뢰할 수 있는 검사가 없는 함수 multiply와 이러한 약점을 악용하려는 함수 invalid_curve_attack을 보여줍니다. 또한 이 코드는 암호화 작업을 위해 pycryptodome 라이브러리를 사용합니다.
내장된 보안 메커니즘으로 인해 pycryptodome에서는 이러한 공격을 직접 수행하기가 더 어렵습니다. 이 코드는 "잘못된" 곡선을 생성하고 곱셈을 수행하려고 시도하는 방법을 보여주지만, 이는 안전하지 않으며 암호화에 대한 깊은 이해가 필요하다는 점을 강조합니다.
multiply함수의 취약점을 악용하여 공격자는 비트코인 네트워크의 개인 키를 손상시키기 위해 잘못된 곡선 공격(invalid curve attack)을 수행할 수 있습니다. 아래는 이 공격을 시연하는 샘플 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는 점이 무한대 점(point at infinity)이 아닌 경우에만 해당 점이 ECC 곡선 위에 있는지 확인합니다. 이로 인해 기본 곡선이 아닌 트위스트 곡선(twist curve) 위에 있는 점을 사용할 수 있습니다.invalid_curve_attack: 이 함수는 공개 키와 변형된 곡선 매개변수를 받습니다. 변형된 곡선 위에 점을 생성하고 취약한 함수 multiply를 사용하여 곱셈을 수행합니다.소규모 부분군 공격(Small Subgroup Attack)의 작동 방식:
Q 낮은 차수 점을 선택합니다.Q를 자신의 공개 키로 위장하여 피해자에게 보냅니다.nQ를 계산합니다. 여기서 n은 피해자의 비밀 키입니다.Q는 작은 차수를 가지므로 nQ 에 대해 가능한 값의 수가 적습니다. 공격자는 n을 Q의 차수로 모듈로 연산하여 확장함으로써 이 모든 값을 무차별 대입하고, 어떤 값이 암호화된 데이터와 일치하는지 확인할 수 있습니다.권장 사항:
취약한 RawTX 트랜잭션을 SMALL SUBGROUP ATTACK 서비스 함수를 사용하여 디코딩하세요
결과는 K 값, 즉 비밀 키 Nonce의 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 개인 키를 가장 널리 사용되는 두 가지 형식인 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 주소를 스푸핑하고, 장치 메모리에 대한 무단 접근 권한을 얻고, 블루투스를 통한 공격을 수행할 수 있습니다.
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와 같은 장치 및 네트워크의 보안을 개선해야 할 필요성은 점점 더 시급해지고 있습니다.
본 자료는 CRYPTO DEEP TECH 포털을 위해 작성되었으며, 금융 데이터 보안과 타원곡선 secp256k1 암호화를 보장하고, 약한 ECDSA 서명에 대비하여 BITCOIN 암호화폐에서 . 소프트웨어 제작자는 자료의 사용에 대해 책임을 지지 않습니다.
Telegram: https://t.me/cryptodeeptech
영상 자료: https://youtu.be/nBeZWm2z5o4
영상 튜토리얼: https://dzen.ru/video/watch/6784be61b09e46422395c236
출처: https://cryptodeeptech.ru/bitcoin-bluetooth-attacks
privkey