
8BitDo फर्मवेयर एन्क्रिप्शन विधियों के लिए रिवर्स-इंजीनियर किए गए दस्तावेज़ और टूल
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% कवरेज प्राप्त किया गया।
उपरोक्त सिफर 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" का नाम दूँगा।