Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
8cryptdo — 8BitDo फर्मवेयर एन्क्रिप्शन विधियों के लिए रिवर्स-इंजीनियर किए गए दस्तावेज़ और टूल | Kitploit
उपकरण/GitHubGitHub/aeromodes/8cryptdo
एम्बेडेड सिस्टम सुरक्षाएन्क्रिप्शन/डिक्रिप्शन उपकरणIoT सुरक्षारिवर्स इंजीनियरिंगक्रिप्टोग्राफीहार्डवेयर और IoT सुरक्षाबाइनरी विश्लेषणपेपर और शोधफर्मवेयर विश्लेषण
GitHubaeromodes/8cryptdo

8cryptdo

5151361 महीना पहलेKitploit द्वारा समीक्षित
साझा करें

8BitDo फर्मवेयर एन्क्रिप्शन विधियों के लिए रिवर्स-इंजीनियर किए गए दस्तावेज़ और टूल

रिपॉजिटरी देखें

8CryptDo

8BitDo द्वारा कई उत्पादों के लिए उपयोग की जाने वाली फ़र्मवेयर एन्क्रिप्शन विधियों के लिए रिवर्स-इंजीनियर किया गया दस्तावेज़ीकरण और टूलिंग।

इस दस्तावेज़ में वर्णित एल्गोरिदम को लागू करने वाले डिक्रिप्शन और पुनः-एन्क्रिप्शन टूल के लिए cryptdo8.py देखें।

यह टूल संभावित रूप से अनुकूलित फ़र्मवेयर बनाना संभव बनाता है। हालाँकि, इस रिपॉज़िटरी में आधिकारिक फ़र्मवेयर डेटा में से कोई भी शामिल नहीं है। नवीनतम फ़र्मवेयर फ़ाइलों को डाउनलोड करने के लिए एक स्क्रिप्ट fwupd/8bitdo-firmware रिपॉज़िटरी में पाई जा सकती है, जिसमें कुछ पुराने फ़र्मवेयर बाइनरी संग्रहीत हैं।

हेडर

सतह पर एक फ़र्मवेयर .dat फ़ाइल को देखने पर, एक 28-बाइट प्लेनटेक्स्ट हेडर मौजूद होता है।

import struct

raw = open("sn30.dat", "rb").read()
version, addr, payload_len, pid = struct.unpack("<IIII", raw[:16])
# version     = 207        -> firmware == v2.07
# addr        = 0x08003400 -> destination (probably)
# payload_len = 99328      -> section payload length in bytes
# pid         = 0x0000     -> (optional, usually 0) USB PID

हेडर का बाकी हिस्सा शून्य है। फ़ाइल के भीतर पेलोड लंबाई को सीक करने के बाद, एक और हेडर और अधिक फ़र्मवेयर डेटा मौजूद हो सकता है। हम इन्हें फ़र्मवेयर "सेक्शन" के रूप में संदर्भित कर सकते हैं। अभी के लिए, हम केवल पहले सेक्शन पर ध्यान केंद्रित करेंगे।

कीलेस चेनिंग लेयर

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

def rotr(x, r):
    return ((x >> r) | (x << (32 - r))) & 0xFFFFFFFF

dechained = [words[0]]
for i in range(1, len(words)):
    dechained.append(words[i] ^ rotr(words[i - 1], 3))

यह चेनिंग हर 128-शब्द ब्लॉक सीमा पर रीसेट होती है। किसी ब्लॉक के पहले शब्द (pos = 0) का कोई पूर्ववर्ती पद नहीं होता, और pos = 1..127 अपने पहले के शब्द से चेन होते हैं।

बिना कुंजी वाली परत कोई सुरक्षा नहीं जोड़ती। उसे हटाने पर एक साफ़ मध्यवर्ती रूप (dechained) सामने आता है, जहाँ plaintext को छिपाने वाली एकमात्र चीज़ keystream रह जाती है।

P[i] = dechained[i] ^ keystream[i]

कीस्ट्रीम फैक्टरिंग

fwupd/8bitdo-firmware रिपॉज़िटरी में पुराने फ़र्मवेयर की एक सूची है। इन सभी फ़र्मवेयर में चेनिंग लेयर मौजूद प्रतीत होती थी।

चेनिंग लेयर हटाने के बाद उनमें से कुछ को XOR करने पर शून्यों की लंबी श्रृंखलाएँ और पठनीय संरचना उजागर होती है।

plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]

यदि वही कीस्ट्रीम दोनों में उपयोग की जाती है...

a = dechained_a[i] ^ dechained_b[i]
b = (P_a[i] ^ keystream[i]) ^ (P_b[i] ^ keystream[i])
c = P_a[i] ^ P_b[i]
assert a == b == c

कीस्ट्रीम रद्द हो जाती है।

यह एक क्लासिक मेनी-टाइम पैड है। ऐसी कीस्ट्रीम केवल तभी सुरक्षित होती है जब उसे एक बार उपयोग किया जाए। किसी कारणवश, 8BitDo ने न केवल प्रति-उत्पाद कीस्ट्रीम का उपयोग करने का निर्णय लिया, बल्कि कई उत्पादों में एक ही कीस्ट्रीम का उपयोग किया। इसने उनके सिफर की सुरक्षा को काफी कमजोर कर दिया और यहाँ के शेष विश्लेषण को संभव बनाया।

कीस्ट्रीम को पढ़ना

एक बार जब आप जान जाते हैं कि दो प्लेनटेक्स्ट XOR-किए गए हैं, तो आप एक के भाग का अनुमान लगा सकते हैं और दूसरे को पढ़ने के लिए अपने अनुमान को XOR कर सकते हैं। इससे उस स्थान पर कीस्ट्रीम पुनः प्राप्त हो जाती है।

keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
    P[fw][i] = dechained[fw][i] ^ keystream[i]

यह स्ट्रिंग्स के साथ सबसे आसान होता, लेकिन यहाँ सबसे उपयोगी तरकीब ARM निर्देशों का क्रॉस-वर्ज़न पुनर्स्थापन था। एक फ़ंक्शन दो फ़र्मवेयर वर्ज़न में स्थानांतरित स्थितियों पर प्रकट हो सकता है। जहाँ एक वर्ज़न में कीस्ट्रीम ज्ञात है, वहाँ आप साझा कोड को दूसरे में संरेखित कर सकते हैं और नए कीस्ट्रीम मान एकत्र कर सकते हैं।

इसका शोषण करने से ज्ञात कीस्ट्रीम शब्द ~1,500 से कई हज़ार तक बढ़ गए, जिससे लगभग 18% फ़र्मवेयर पठनीय हो गया।

कीस्ट्रीम नियम

कीस्ट्रीम के बड़े नमूने के साथ, पैटर्न दिखाई देने लगे: 16 शब्दों के अंतराल पर स्थितियाँ जो लगभग स्थिर मात्रा में बढ़ती थीं, और बाइट्स जो एक पूर्वानुमेय आकार से आगे बढ़ते थे।

परीक्षण और त्रुटि के माध्यम से, यह पता चला कि एक ब्लॉक में प्रत्येक कीस्ट्रीम शब्द एक सूत्र का पालन करता है:

STEP  = 0x92A753FA
A_MUL = 0x80000301
ROT   = 18
UINT32_MAX = 0xFFFFFFFF

def rotr(x, r):
    r &= 31
    return ((x >> r) | (x << (32 - r))) & UINT32_MAX if r else x

def block_base(block):
    return (block * A_MUL + block // 2) & UINT32_MAX

def keystream(block, pos, block_key):
    counter = (block_base(block) + pos * STEP) & UINT32_MAX
    mask = rotr(block_key, ROT * pos)
    return counter ^ mask

पूरा 128-शब्द ब्लॉक एक 32-बिट संख्या से निर्धारित होता है: उसका "block key।" एक ब्लॉक के भीतर, एक सरल काउंटर (block_base(block) + pos * STEP) पर चलें, और इसे एक मास्क के साथ XOR करें जो block key से शुरू होता है और हर चरण में 18 बिट घूमता है।

इसलिए, एक ज्ञात शब्द पूरे ब्लॉक को अनलॉक कर देता है। सूत्र को पुनर्व्यवस्थित करने पर किसी भी ज्ञात keystream शब्द से block key प्राप्त होती है:

def block_key_from_known(block, pos, known_keystream):
    counter = (block_base(block) + pos * STEP) & UINT32_MAX
    return rotr(known_keystream ^ counter, -ROT * pos & 31)

सीड तालिका

प्रत्येक ब्लॉक की कुंजी कहाँ से आई? यह दो 16-बिट हिस्सों में विभाजित होती है जो 256-प्रविष्टि वाली सीड तालिका से निकाले जाते हैं:

def block_key_of(block, seed_table):
    hi = seed_table[block]
    lo = seed_table[block ^ 0xF9]
    return (hi << 16) | lo

सीड तालिका में स्वयं कोई विशिष्ट सूत्र नहीं दिखता; यह संभवतः प्रत्येक डिवाइस के बूटलोडर में कहीं संग्रहीत 512 स्थिर बाइट्स है। हालाँकि, 0xF9 के साथ XOR एक सुंदर साइड इफ़ेक्ट प्रदान करता है: एक मिरर लॉ। एक ब्लॉक और उसका साथी block ^ 0xF9 समान दो तालिका प्रविष्टियों को अदला-बदली करके बनाए जाते हैं।

mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)

इसने पहले अज्ञात क्षेत्रों को क्रैक कर दिया। पूर्ण ब्लॉक कुंजी को अंधाधुंध अनुमान लगाने के बजाय, आप दो 16-बिट हिस्सों का अनुमान लगा सकते हैं और यह स्कोर कर सकते हैं कि कौन सा विकल्प दोनों ब्लॉकों को विश्वसनीय स्ट्रिंग्स या ARM निर्देशों में बदल देता है।

इसके साथ, इस विशिष्ट सिफर का उपयोग करते हुए सभी फर्मवेयर डेटा का 100% कवरेज प्राप्त किया गया।

Yichip सिफर

उपरोक्त सिफर 8BitDo के अधिकांश GD32 उपकरणों पर मौजूद प्रतीत होता है, इसलिए मैंने इसे "GD32 सिफर" का नाम दिया है।

8BitDo द्वारा लगातार उपयोग किया जाने वाला एक नया सिफर है। इस सिफर का उपयोग करने वाले उत्पादों में Ultimate/Pro श्रृंखला के अधिकांश, M30, और Zero 2 शामिल हैं, कुछ का नाम लेने के लिए। बाद वाले दो के फर्मवेयर फ़ाइलों में कई सेक्शन प्रतीत होते हैं: पहला पुराने GD32 सिफर से एन्कोड किया गया है, और दूसरा इस नए सिफर से।

बहुत सारे प्रयोगों के बाद, मैंने पाया कि यह सिफर पूरी तरह से नया नहीं है। यह वास्तव में संशोधित मापदंडों के साथ मौजूदा GD32 सिफर का एक प्रकार है:

CHAIN_ROT = 18          # GD32: 3
STEP      = 0xEE97FAFA  # GD32: 0x92A753FA
A_MUL     = 0x01200210  # GD32: 0x80000301
ROT       = 16          # GD32: 18

def block_base(block):
    return (block * A_MUL + (block >> 8)) & UINT32_MAX

विशेष रूप से, ब्लॉक कुंजी अभी भी एक इंडेक्स और उसके 0xF9 साथी से बनाई जाती है, लेकिन प्रत्येक को पहले एक छोटी तालिका से एक मान के साथ XOR करके एक सीड तालिका इंडेक्स में बदल दिया जाता है। यहाँ, e 256-प्रविष्टि वाले कुंजी शेड्यूल में ब्लॉक की स्थिति है:

INDEX_XOR = ((0x00, 0x82, 0x83, 0x81, 0x03, 0x81, 0x83, 0x81),
             (0x86, 0x83, 0x81, 0x82, 0x03, 0x05, 0x82, 0x82))

def seed_index(e):
    return e ^ INDEX_XOR[e >> 7][e & 7]

def block_key_of(block, seed_table):
    e = (block + (block >> 8)) & 0xFF
    hi = seed_table[seed_index(e)]
    lo = seed_table[seed_index(e ^ 0xF9)]
    return (hi << 16) | lo

डिक्रिप्ट की गई छवियाँ अधिकतर Yichip-आधारित प्रतीत होती हैं, जिसका अनुमान SDK के अवशेषों से लगता है। वास्तव में, हाल ही के Zero 2 डिवाइस के टियरडाउन से पता चला कि यह विशेष रूप से YC3121 का उपयोग करता है। इसलिए, मैं इसे "Yichip cipher" का नाम दूँगा।

टूल डाउनलोड करें

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    795
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    520
  • 3

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    439
  • 4

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    267
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    264

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →