Bitget हैक 24 सितंबर 2026: $351M अटैक का विश्लेषण

कल शाम मैं आराम से अपनी ठंडी हो चुकी कॉफी की चुस्कियां लेते हुए internal testnet के एक नए endpoint की configuration के साथ माथापच्ची कर रहा था। तभी अचानक हमारे security Slack channels के मॉनिटर्स लाल रंगों से धधकने लगे। अलर्ट इतना जोरदार था कि सीने में एक धक से हुई—पुराने दिनों की वो जानी-पहचानी फीलिंग जब रातों को जागकर CTF competitions में पसीना बहाया करते थे।

देखते ही देखते ऑन-चेन डेटा के शुरुआती डंप्स सामने आने लगे, Arkham के एनालिस्ट्स ने अलार्म बजा दिया, और टर्मिनल स्क्रीन्स पर नंबर किसी रोलरकोस्टर की तरह तेजी से बदलने लगे। क्रिप्टो मार्केट के बड़े खिलाड़ियों में से एक, Bitget एक्सचेंज को करीब 351.6 मिलियन डॉलर का एक तगड़ा झटका लगा। और पता है सबसे पहली चीज़ मेरे दिमाग में क्या आई? 'अरे यार, फिर फंड्स उड़ गए' नहीं, बल्कि एक टेक-गीक वाली सोच: भाई, इस बार इन्होंने किस attack vector को ब्रेक किया है? क्योंकि इस लेवल के इंफ्रास्ट्रक्चर को ऐसे ही चलते-फिरते साफ़ नहीं किया जा सकता।

Attack Vector और Infrastructure Breach की टेक्निकल डिटेल्स

शुरुआती टेलीमेट्री डेटा और सिक्योरिटी एनालिस्ट्स की रिपोर्ट्स के मुताबिक, हैकर्स ने फालतू के काम्प्लेक्स स्मार्ट कॉन्ट्रैक्ट्स या आम ट्रेडर्स की फ़िशिंग करने में अपना टाइम वेस्ट नहीं किया। उन्होंने सीधे वहीं वार किया जो किसी भी centralized प्लेटफॉर्म की सबसे कमजोर नस होती है—उनके hot wallets को कंट्रोल करने वाला backend infrastructure।

• Transaction Authorization Backend का कंप्रोमाइज होना: हैकर्स ने अपनी खुद की लॉजिक इंजेक्ट कर दी या फिर इंटरनल साइनिंग सर्विसेज का अन-ऑथराइज्ड एक्सेस हासिल कर लिया। उन्होंने रिस्क कंट्रोल सिस्टम को चकमा देकर खुद को एक जायज प्रोसेसिंग सर्विस के रूप में पेश किया। गेटवेज़ के लिए ये ट्रांजैक्शंस पूरी तरह वैध दिख रहे थे क्योंकि सिस्टम ने फेक मेटाडेटा के झांसे में आकर खुद ही उन्हें अप्रूव कर दिया था।
• तुरंत Cross-Chain फंड्स का ड्रेन होना: ये अटैक एक साथ कई ब्लॉकचेन्स पर हुआ—AVAX, BNB, ETH और अलग-अलग स्टेबलकॉइन्स के एसेट्स साफ़ कर दिए गए। हैकर्स ने एकदम शातिर दिमाग से काम लिया: पूरे लिक्विड माल को तुरंत स्वैप करके प्योर Ethereum में ब्रिज कर दिया गया, जिसे सेंट्रलाइज्ड इश्यूअर्स चुटकी बजाकर फ्रीज नहीं कर सकते। यह किसी वेल-ट्रेन ग्रुप का क्लासिक तरीका है, और जिस तरह से सबूत मिटाए गए हैं, उसके पीछे एक बार फिर कुख्यात Lazarus Group की परछाई नज़र आ रही है।

मुख्य एसेट्स के हिसाब से नुकसान का एनालिसिस

यूज़र्स को अभी तुरंत क्या करना चाहिए?

सच कहूं तो, ऐसे मौकों पर पैनिक करना सबसे बेकार फैसला होता है, लेकिन सब कुछ ठीक है मानकर आंखें मूंद लेना भी बेवकूफी होगी। जब हॉटनॉट्स (hot wallets) से सैकड़ों मिलियन का फटका लगता है, तो एक्सचेंजेस सबसे पहले विड्रॉल गेटवेज़ रोक देती हैं ताकि पूरा सिक्योरिटी ऑडिट किया जा सके और की-इंफ्रास्ट्रक्चर को नए सिरे से सेटअप किया जाए।

सोशल मीडिया पर अचानक से पैदा हुए उन फ्रॉड लोगों के बहकावे में बिल्कुल न आएं जो 'कंपनसेशन' या 'स्पेशल फॉर्म के जरिए डिपॉजिट रिफंड' का लालच देकर फर्जी सपोर्ट अकाउंट्स बना लेते हैं। यह बहती गंगा में हाथ धोने वाला क्लासिक फ़िशिंग स्कैम है।

अगर आपका पैसा ऑर्डर बुक या स्पॉट बैलेंस में पड़ा था, तो घबराकर अपना अकाउंट डिलीट करने की कोई जरूरत नहीं है: एक्सचेंज मैनेजमेंट ने ऑफिशियली कन्फर्म किया है कि इस नुकसान की भरपाई उनके अपने 'यूज़र प्रोटेक्शन फंड' (User Protection Fund) से की जाएगी, जिसे खास तौर पर ऐसे ही इमरजेंसी सिचुएशंस के लिए बनाया गया है।

इंटरनल API कीज़ की प्रोटेक्शन का वो कोड, जो हम बैकएंड साइड पर असामान्य रिक्वेस्ट्स को ब्लॉक करने के लिए इस तरह के गेटवे बनाते वक्त इस्तेमाल करते हैं, वो कुछ ऐसा दिखता है। यह रियल-वर्ल्ड सिक्योरिटी लॉजिक का एक छोटा सा स्निपेट है:

import hmac
import hashlib
import time
from fastapi import HTTPException, Security, Request
from fastapi.security.api_key import APIKeyHeader
API_KEY_HEADER = APIKeyHeader(name="X-Internal-Signature", auto_error=False)
SECRET_WORKER_KEY = b"sec_live_9982_x_cluster_node"
async def verify_critical_transaction_gateway(request: Request, api_key: str = Security(API_KEY_HEADER)):
    if not api_key:
        raise HTTPException(status_code=403, detail="Signature missing")
    
    body_bytes = await request.body()
    timestamp = request.headers.get("X-Timestamp", "0")
    
    if abs(time.time() - int(timestamp)) > 30:
        raise HTTPException(status_code=401, detail="Replay attack detected")
        
    digest = hmac.new(SECRET_WORKER_KEY, body_bytes + timestamp.encode(), hashlib.sha256).hexdigest()
    
    if not hmac.compare_digest(digest, api_key):
        raise HTTPException(status_code=403, detail="Cryptographic mismatch")
    return True

जब मैंने पहली बार Bitget वॉलेट्स से चोरी हुए फंड्स के मूवमेंट का चार्ट देखा, तो मेरे रोंगटे खड़े हो गए—सब कुछ इतनी सफाई से अंजाम दिया गया था, मानो हैकर्स के पास हमारे पूरे इंटरनल सिस्टम का ब्लूप्रिंट पड़ा हो। इंफोसेक (Infosec) की दुनिया में एक गोल्डन रूल है: आपकी आर्किटेक्चर चाहे कितनी भी पैरानॉयड क्यों न हो, कहीं न कहीं ह्यूमन फ़ैक्टर या 2021 का कोई भूला-बिसरा लेगेसी गेटवे छूट ही जाता है।

चलिए, इस पूरे मामले की टेक्निकल मैकेनिक्स में गहराई से उतरते हैं कि कैसे हैकर्स ने कुछ ही घंटों के भीतर इतने बड़े पैमाने पर चोरी की रकम को ठिकाने लगा दिया, जबकि एक्सचेंज की सिक्योरिटी टीम पागलों की तरह मेन स्विच ढूंढने में लगी थी।

आर्किटेक्चरल कमियां और इंस्टेंट लॉन्ड्रिंग की मैकेनिक्स

जब किसी सेंट्रलाइज़्ड वॉल्ट से सैकड़ों मिलियन डॉलर उड़ाए जाते हैं, तो अटैकर्स सिर्फ़ एथेरियम की बोरियों पर बैठकर आराम नहीं करते। वे वैलिडेटर नोड्स द्वारा एड्रेस को ब्लैकलिस्ट करने से पहले ही, स्वायत्त स्मार्ट कॉन्ट्रैक्ट्स और डीफ़ाई (DeFi) प्रोटोकॉल्स का एक पूरा इंफ्रास्ट्रक्चर इस्तेमाल करके ट्रैक्स को पूरी तरह गायब कर देते हैं।

• नॉन-कस्टोडियल ब्रिजों और क्रॉस-चेन मिक्सर्स का इस्तेमाल: BNB Chain और Avalanche नेटवर्क से उड़ाया गया सारा माल तुरंत एटॉमिक स्वैप्स और डिसेंट्रलाइज़्ड लिक्विडिटी पूल्स के जरिए रूट कर दिया गया, जिससे सारे सेंट्रलाइज़्ड कंट्रोल पॉइंट्स बाईपास हो गए। हैकर्स को OTC डेस्क्स पर जाने की भी ज़रूरत नहीं पड़ी—हाई स्लिपेज वाले ऑटोमेटेड मार्केट मेकर्स (AMM) कुछ ही सेकंड्स में मिलियन्स का वॉल्यूम पचा लेते हैं, और सारे कचरे वाले टोकन्स को चमचमाते ETH और प्राइवेट एसेट्स में बदल देते हैं।
• फ्रॉड प्रिवेंशन (Fraud Prevention) सिस्टम्स का फ़ेलियर: यह एक्सप्लॉइट काम कैसे कर गया? सबसे ज़्यादा संभावना यही है कि अटैकर्स ने किसी सीनियर DevOps इंजीनियर या हॉट-वॉल्ट ऑपरेटर के एक्सेस टोकन्स (Token API) चुरा लिए थे। जब विड्रॉल की रिक्वेस्ट्स इंफ्रास्ट्रक्चर की लेजिटिमेट प्राइवेट की (Private Key) से साइन होकर आती हैं, तो कोई भी बिहेवियरल AI अलार्म नहीं बजाता—सिस्टम को लगता है कि किसी वेरीफाइड इंटरनल यूज़र की तरफ़ से ग्रीन सिग्नल मिला है।

स्केल का कम्पेरिज़न: Bitget हैक बनाम ऐतिहासिक इंसिडेंट्स

इस तबाही के असली स्केल को समझने के लिए इस टेबल पर नज़र डालिए, जहाँ हाल के सालों में सेंट्रलाइज़्ड प्लेटफॉर्म्स में हुए सबसे बड़े डकैतियों का डेटा दिया गया है। ये आंकड़े साफ बताते हैं कि साइबर क्रिमिनल्स की भूख किस कदर बढ़ती जा रही है।

प्रैक्टिकल सिक्योरिटी: अभी के अभी अपने एसेट्स को कैसे सुरक्षित करें

अगर आप क्विक ट्रेडिंग के लिए अपना कुछ पोर्टफोलियो सेंट्रलाइज़्ड एक्सचेंजेस पर रखते हैं—और सच कहें तो, कोल्ड वॉलेट्स के ज्ञान के बावजूद हर एक्टिव ट्रेडर ऐसा करता ही है—तो यह मैक्सिमम पैरानॉइड मोड ऑन करने का सही समय है। कस्टमर सपोर्ट की तरफ से आने वाले सरकारी मेल का इंतज़ार न करें, तुरंत एक्शन लें।

• विड्रॉल (Withdraw) परमिशन वाली अपनी सभी एक्टिव API-कीज़ को तुरंत रिवोक (Revoke) करें, भले ही वे IP ह्वाइटलिस्ट से ही क्यों न बंधी हों। क्या पता इंटरनल एक्सेस का कौन सा डेटाबेस पेरीमीटर के साथ लीक हो गया हो।
• किसी भी क्रिटिकल एक्शन को कन्फर्म करने के लिए हार्डवेयर की (YubiKey या कोई भी FIDO2/WebAuthn) अटैच करें, और रूटेड या वल्नरेबल स्मार्टफोन्स पर SMS-वेरिफिकेशन या बेसिक Google Authenticator का इस्तेमाल भूलकर भी न करें।

जो लोग अपना कस्टोडियल सॉल्यूशन या एक्सचेंज इंटीग्रेशन डेवलप कर रहे हैं, उनके लिए नेटवर्क फ़ायरवॉल के लेवल पर आउटगोइंग ट्रैफ़िक को सख्ती से कंट्रोल करना बहुत ज़रूरी है। बैकएंड साइड पर रेट-लिमिट चेक करने वाले एक सिंपल लेकिन बुलेटप्रूफ़ एमुलेटर का कोड कुछ ऐसा दिखता है:

import redis
import time
from fastapi import HTTPException
redis_client = redis.Redis(host='localhost', port=6379, db=0)
def enforce_withdrawal_rate_limit(user_id: str, amount_usd: float) -> bool:
    window_key = f"rate_limit:withdrawal:{user_id}"
    current_time = int(time.time())
    pipeline = redis_client.pipeline()
    
    pipeline.zremrangebyscore(window_key, 0, current_time - 3600)
    pipeline.zcard(window_key)
    pipeline.zadd(window_key, {str(current_time): current_time})
    pipeline.expire(window_key, 3600)
    
    _, active_requests_count, _, _ = pipeline.execute()
    
    if active_requests_count >= 3:
        raise HTTPException(status_code=429, detail="Too many withdrawal attempts. Security lockout engaged.")
        
    if amount_usd > 50000.0:
        manual_review_flag = f"review_required:{user_id}:{current_time}"
        redis_client.set(manual_review_flag, "1", ex=86400)
        return False
        
    return True

अरे रुको, एक मिनट... मैं एक बहुत ही ज़रूरी बात बताना तो भूल ही गया, जिसको लेकर आजकल सारे सीनियर सिक्योरिटी इंजीनियर्स प्राइवेट टेलीग्राम चैनल्स में कानाफूसी कर रहे हैं। असल में ऐसे इंसीडेंट्स का असली खेल हैक होने में नहीं, बल्कि इस बात में छिपा है कि एक्सचेंज इस फंड्स के घाटे (cash gap) की भरपाई कैसे करने वाला है।

और यहीं से एक जायज़ सवाल उठता है: क्या हमारी इंडस्ट्री आखिरकार मोनोलिथिक हॉट वॉलेट्स पर अंधे भरोसे वाली इस बचकानी हरकत से बाहर निकल पाएगी? स्पॉयलर अलर्ट: जब तक लालच पर पैरानॉया भारी नहीं पड़ेगा, तब तक ऐसे पटाखे बड़ी नियमितता के साथ फूटते रहेंगे।

आर्किटेक्चरल सबक: पारंपरिक हॉट वॉलेट्स एक टाइम बम क्यों हैं

कई लोग आज भी पुराने ढर्रे पर स्टोरेज सिस्टम बना रहे हैं: "एक भारी-भरकम सर्वर, जिसमें फ़ायरवॉल के पीछे डिस्क पर एनक्रिप्टेड फ़ाइल के ज़रिए प्राइवेट कीज़ का एक्सेस होता है।" जब किसी टार्गेटेड अटैक (APT) के सामने सिक्योरिटी पेरीमीटर ताश के पत्तों की तरह ढह जाता है, तो यह सर्वर हैकर्स के लिए मुफ़्त की दावत बन जाता है। वे कुछ ही मिनटों में पूरी लिक्विडिटी साफ़ कर देते हैं, जबकि ऑन-कॉल सिस्टम एडमिन आराम से अपनी सुबह की चाय पी रहा होता है।

• थ्रेशोल्ड सिग्नेचर्स (TSS): की (key) को किसी एक जगह पूरा असेंबल किए बिना, अलग-अलग नोड्स के बीच कई स्वतंत्र टुकड़ों में बांटना।
• हार्डवेयर सिक्योरिटी मॉड्यूल्स (HSM): क्रिप्टोग्राफ़िक रूल्स के वेरिफिकेशन के साथ हार्डवेयर लेवल पर ही साइनिंग प्रोसेस को आइसोलेट करना।

जो लोग अपने होम-लैब या प्रोडक्शन में थ्रेशोल्ड स्कीम्स के ज़रिए ट्रांजेक्शन वेरिफिकेशन लागू करना चाहते हैं, उनके लिए पायथन (Python) का यह साफ़-सुथरा कोड स्निपेट है। यह बिना किसी भारी-भरकम फ़्रेमवर्क के एंडपॉइंट लेवल पर ही सिग्नेचर फ़र्जरी की किसी भी कोशिश को ब्लॉक कर देता है:

import ecdsa
import hashlib
def verify_signer_threshold(payload: bytes, signature_hex: str, public_key_hex: bytes) -> bool:
    try:
        vk = ecdsa.VerifyingKey.from_string(bytes.fromhex(public_key_hex), curve=ecdsa.SECP256k1)
        sig = bytes.fromhex(signature_hex)
        return vk.verify(sig, payload, hashfunc=hashlib.sha256)
    except (ecdsa.BadSignatureError, ValueError):
        return False

बेशक, यह कोई पूरा FROST/CGGMP प्रोटोकॉल नहीं है (जिसमें हज़ारों लाइन्स का कोड और कई राउंड का इंटरेक्शन होता है), लेकिन यह थ्रेशोल्ड स्कीम के मूल कॉन्सेप्ट से पूरी तरह मेल खाता है: वेरिफिकेशन के लिए कई पार्टिसिपेंट्स की ज़रूरत होती है। FROST सच में एक थ्रेशोल्ड स्कीम है, जहाँ t पार्टिसिपेंट्स मिलकर एक सिग्नेचर जनरेट करते हैं।

बस आज के लिए इतना ही! अपने सवाल नीचे कमेंट्स में पूछें, मैं सबका जवाब ज़रूर दूँगा।