Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

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

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

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

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

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
Hardware Hacking Cheatsheet — Hardware Hacking Cheatsheet | Kitploit
उपकरण/GitLabGitLab/myasnik/hardware-hacking-cheatsheet
Embedded Systems SecurityIoT SecurityHardware SecurityLearning & EducationCurated ResourcesFirmware Analysis
GitLabmyasnik/hardware-hacking-cheatsheet

Hardware Hacking Cheatsheet

Hardware Hacking Cheatsheet

रिपॉजिटरी देखें
25 साल पहलेअभी तक समीक्षित नहीं

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

सभी देखें →

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

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

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

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

हार्डवेयर हैकिंग चीटशीट

[[TOC]]

अस्वीकरण

  • मैं एक नौसिखिया हूँ जो इस तरह की चीज़ें सीखने की कोशिश कर रहा हूँ, इसलिए शायद कुछ चीज़ें 100% सही न हों
  • खराब अंग्रेज़ी के लिए क्षमा करें

नोट्स

  • सबसे आसान रास्ता पहले अपनाने की पद्धति का पालन करें
  • कभी-कभी आपको सोल्डरिंग करनी पड़ेगी; यहाँ एक त्वरित और सरल गाइड है
    • आपको सीधे PCB vias पर तारों को सोल्डर करना पड़ सकता है (वीडियो)
      1. कटर का उपयोग करके PCB की सतह को तब तक खुरचें जब तक आप सोल्डर मास्क के नीचे की चमक न देख सकें
      2. फाइबरग्लास पेंसिल का उपयोग करके सतह को एक बार फिर खुरचें
      3. सतह को कुछ IPA और कॉटन स्वैब से साफ करें
      4. थोड़ा सा फ्लक्स लगाएँ
      5. तार को टिन करें और सोल्डर करें
    • नोट्स
      • अपने सोल्डरिंग आयरन की नोक को हमेशा टिन करें
      • तापमान: 250-350 C
      • PCB को हाथों से न छुएँ

जानकारी एकत्र करना और पहला संपर्क

  1. डिवाइस के पीछे लगे लेबल को देखें और पता करें
    • मॉडल नाम
    • सीरियल नंबर
    • वह कंपनी जिसने डिवाइस को ब्रांड किया है (हो सकता है वही न हो जिसने इसे बनाया है)
  2. अभी एकत्र की गई जानकारी का उपयोग करके इंटरनेट पर खोजें
    • जानकारी वाली सर्वश्रेष्ठ वेबसाइटें
      • TechInfoDepot
      • OpenWRT
    • खोजें ..., इससे आमतौर पर बहुत सारी जानकारी मिलती है
      • FCC ID (संदर्भ वेबसाइट)
      • SOC नाम
      • फ्लैश चिप का नाम और मात्रा
      • RAM चिप का नाम और मात्रा
      • अन्य संभावित जानकारी स्रोत
  3. डिवाइस खोलें
    • डिवाइस खोलने के तरीके पर ट्यूटोरियल खोजें
    • कुछ डिवाइस खोलने से रोकने के लिए चिपके हो सकते हैं, धीरे से काम करें
    • कभी-कभी हीटसिंक होते हैं जो सर्किट के कुछ हिस्से को ढकते हैं, यदि संभव हो तो उसे हटा दें
  4. घटकों की पहचान करें
    • सर्किट नामों को अधिक पठनीय बनाने के लिए
      • कॉटन + अल्कोहल का उपयोग करें, जब अल्कोहल सूख जाए तो सर्किट को चॉक से ढक दें, फिर उसे साफ करें; अब सर्किट का नाम पठनीय होना चाहिए
      • आवर्धक कांच का उपयोग करें
    • इन घटकों के बारे में इंटरनेट पर जानकारी और डेटाशीट खोजें; यदि कुछ न मिले तो चीनी खोज इंजन पर प्रयास करें
      • Baidu
      • Sogou
      • Haosou
    • महत्वपूर्ण: ऐसा घटक ढूँढना जिसमें VCC और GND अच्छी तरह से उजागर हों, बहुत उपयोगी है
  5. UART इंटरफ़ेस का पता लगाएँ: लगभग एक TTY
    • इंटरनेट पर खोजें
    • PCB पर GND, IN या RX, OUT या TX और VCC खोजें
    • PCB पर 3/4 पिन खोजें
      1. GND का संदर्भ खोजें
        • पहले खोजे गए घटकों का उपयोग करके
        • आमतौर पर धातु की प्लेटें GND पर होती हैं
      2. VCC का संदर्भ खोजें
        • पहले खोजे गए घटकों का उपयोग करके
        • कैपेसिटर खोजें, उनका एक पिन आमतौर पर VCC पर होता है
      3. नीचे दी गई तालिका भरते हुए UART उम्मीदवार पिनों का परीक्षण करें (बुलेट पॉइंट क्रमशः तालिका के प्रत्येक कॉलम हैं)
        1. GND के सापेक्ष UART पिनों की प्रतिरोधकता का परीक्षण करें (मल्टीमीटर को प्रतिरोध मापन पर रखें, आमतौर पर 200k)
  6. UART के माध्यम से कनेक्ट करें: कंप्यूटर के माध्यम से बोर्ड से कनेक्ट करने के लिए एक सीरियल एडाप्टर (UART -> USB) का उपयोग करें
    • चुना गया सीरियल एडाप्टर: FT232H + Focaccia Board
    1. उपयुक्त वोल्टेज (3.3V या 5V) चुनें, अन्यथा बोर्ड या सीरियल एडाप्टर क्षतिग्रस्त हो जाएगा
    2. बोर्ड RX को एडाप्टर TX से और बोर्ड TX को एडाप्टर RX से कनेक्ट करें
      • नोट: आमतौर पर VCC पिन को कनेक्ट करने की आवश्यकता नहीं होती
    3. एडाप्टर को कंप्यूटर से कनेक्ट करें
      1. एडाप्टर का पता लगाने के लिए sudo lsusb चलाएँ
      2. सभी डिवाइस फ़ाइलों का पता लगाने के लिए ls -lart /dev चलाएँ; हमारी फ़ाइल अंतिम में से एक होनी चाहिए, आमतौर पर ttyUSB0
      3. इस डिवाइस तक पहुँचने के लिए हमें dialout समूह का सदस्य होना चाहिए (या होना चाहिए), अपने समूहों की जाँच करने के लिए चलाएँ
  7. JTAG इंटरफ़ेस का पता लगाएँ
    • JTAG क्या है: JTAG इंटरफ़ेस निर्माताओं को चिप पर पिनों के बीच भौतिक कनेक्शन का परीक्षण करने का एक तरीका देता है। जब इलेक्ट्रिकल इंजीनियर किसी चिप को "डीबग" करने के लिए JTAG का उपयोग करने की बात करते हैं, तो वे पारंपरिक सॉफ़्टवेयर डीबगिंग से बहुत अलग चीज़ की बात कर रहे होते हैं। वे यह सुनिश्चित करने की बात कर रहे हैं कि चिप A पर पिन A, चिप B पर पिन B से भौतिक रूप से जुड़ा है, और वे सभी पिन सही ढंग से काम कर रहे हैं। चूँकि JTAG आपको डिवाइस तक सीधी हार्डवेयर पहुँच देता है, यह सुरक्षा अनुसंधान के लिए भी एक शानदार उपकरण है।
    • JTAG गुण
      • नियंत्रणीयता: आंतरिक बिट्स को 0 या 1 पर सेट करना
      • अवलोकनीयता: आंतरिक बिट्स का मान जाँचना
      • ...इसलिए EEPROM पढ़ें/लिखें
      • इन-सर्किट डीबगिंग: सर्किट पर कोड डीबग करना (उदाहरण के लिए OpenOCD और GDB का उपयोग करके)
    • इंटरनेट पर खोजें
    • PCB पर TCK, TDI, TDO, TMS और TRST (वैकल्पिक) खोजें
      • TCK (टेस्ट क्लॉक): ड्रमर, या मेट्रोनोम जो नियंत्रक की गति निर्धारित करता है। इस पिन पर वोल्टेज बस एक लयबद्ध, स्थिर धड़कन में ऊपर-नीचे होता रहता है। क्लॉक की हर "धड़कन" पर नियंत्रक एक एकल क्रिया करता है।
      • TMS (टेस्ट मोड सिलेक्ट): मोड सिलेक्ट पिन पर वोल्टेज नियंत्रित करते हैं कि JTAG कौन सी क्रिया करे। इस पिन पर वोल्टेज में हेरफेर करके, आप JTAG को बताते हैं कि आप उससे क्या करवाना चाहते हैं।
  8. JTAG के माध्यम से कनेक्ट करें: बोर्ड से कंप्यूटर के माध्यम से कनेक्ट करने के लिए एक "सीरियल एडाप्टर" (JTAG -> USB) का उपयोग करें
    • चुना गया "सीरियल एडाप्टर": FT232H + Focaccia Board
    1. उचित वोल्टेज चुनें (3.3V या 5V), अन्यथा बोर्ड या सीरियल एडाप्टर क्षतिग्रस्त हो जाएगा
    2. पहले प्राप्त JTAG पिनआउट का उपयोग करके सब कुछ एक साथ कनेक्ट करें
    3. डिवाइस के साथ इंटरैक्ट करने और उसके व्यवहार को देखने के लिए UART कनेक्शन खुला रखें (जैसा पहले बताया गया है)
    4. OpenOCD चलाएँ
      • पहली विंडो (OpenOCD "server"): openocd -f $FT232HCONFIGFILE -f $BOARDCONFIGFILE
        • $FT232HCONFIGFILE: Focaccia बोर्ड संदर्भ
        • $BOARDCONFIGFILE: जिस बोर्ड को आप हैक कर रहे हैं उसकी कॉन्फिग फ़ाइल (उपयोगी है लेकिन शायद आपके पास न हो, वैकल्पिक)
          • नोट्स
            • कॉन्फिगरेशन फ़ाइलें /usr/local के अंदर हैं, शायद यहाँ आपको कुछ उपयोगी $BOARDCONFIGFILE मिल सकती है
            • अन्यथा आप इंटरनेट पर खोज सकते हैं
            • अन्यथा आप इसे स्वयं लिख सकते हैं
            • TODO (स्वयं लिखें)
      • दूसरी विंडो (OpenOCD "client"): telnet localhost 4444
  9. फर्मवेयर और फाइलसिस्टम प्राप्त करें
    • संभावनाएँ (फर्मवेयर और फाइलसिस्टम एन्क्रिप्टेड हो सकते हैं)
      • इसे निर्माता की वेबसाइट से डाउनलोड करें
      • यदि केवल डिवाइस ही फर्मवेयर डाउनलोड कर सकता है (अपडेट के माध्यम से) तो जानकारी इकट्ठा करने के लिए wireshark का उपयोग करके नेट को सूँघें
      • फ्लैश चिप प्रोग्रामर और टेस्ट क्लिप का उपयोग करके सीधे EEPROM पढ़ना
      • बूटलोडर डंप कमांड
        1. UART इंटरफ़ेस पर प्रिंट होने वाले बूट लॉग का विश्लेषण करें
          • जानकारी जो प्रिंट हो सकती है और जिसमें हमारी रुचि है (मान उदाहरण हैं लेकिन बताते हैं कि हम क्या खोज रहे हैं)
            • बूटलोडर सामान्य जानकारी
              • बूटलोडर नाम और संस्करण खोजें (जैसे: U-Boot 1.1.3)
            • SOC जानकारी
              • अतिरिक्त बोर्ड जानकारी (wifi, ethernet...), उनका अपना बूटलोडर हो सकता है
              • SOC मॉडल (जैसे: ASIC MT7621A...)
              • CPU आवृत्ति
            • RAM जानकारी
              • mtd->writesize=2048: पेज आकार (बाइट्स)
              • mtd->oobsize=64: त्रुटि सुधार के लिए उपयोग किया जाने वाला डेटा (बाइट्स)
              • devinfo.iowidth=8: प्रति ऑपरेशन लिखा/पढ़ा गया डेटा (बाइट्स)
              • RAM की मात्रा
            • EEPROM जानकारी
              • mtd->erasesize=131072: EEPROM शेष लेखन? (लगभग)
            • OS कर्नेल जानकारी
              • बूटलोडर लोडिंग जानकारी देखें, यहाँ आपको फाइलसिस्टम के बारे में जानकारी मिल सकती है
              • buildroot संस्करण देखें, यह हमें सर्किट का अनुकरण करने और विभिन्न परीक्षण करने में मदद करेगा
            • फाइल सिस्टम जानकारी
              • बूटलोडर लोडिंग जानकारी और OS प्रारंभ प्रक्रिया देखें, यहाँ आपको फाइलसिस्टम के बारे में जानकारी मिल सकती है

TODO SPI डंप

TODO GDB अटैच????

रिवर्स इंजीनियरिंग

  1. Init प्रक्रिया प्रकार और कॉन्फ़िगरेशन फ़ाइलें
    • प्रकार
      • BSD शैली
        • स्क्रिप्ट निष्पादित करना प्रारंभ करें
          • /etc/rc
          • /etc/rc.local
        • अधिक हालिया
          • जानकारी के लिए /etc/rc.conf देखें
          • /etc/rc.d/ निष्पादित करें
      • System V (सबसे लोकप्रिय)
        • BusyBox प्रारंभ किया जाता है
        • कॉन्फ़िगरेशन फ़ाइलें /etc/inittab में हैं
          • runlevel
            • 1: एकल उपयोगकर्ता मोड, रूट शेल, कोई पासवर्ड नहीं, कोई डेमॉन नहीं चल रहा
            • 3: टेक्स्ट आधारित मल्टीयूज़र मोड, लॉगिन प्रॉम्प्ट
            • 5: ग्राफिकल लॉगिन
          • फिर init पर की गई क्रियाओं की एक सूची होती है
        • /etc/init.d/ निष्पादित करें
      • Systemd (एम्बेडेड में उपयोग नहीं किया जाता)
    • कैसे पहचानें
      • बूट पर प्रिंट होता है
      • प्रकारों की पहचान करने वाली जानकारी (ऊपर) के लिए का विश्लेषण करें

एमुलेशन वातावरण

  • आवश्यकताएँ
    • बाइनरी फ़ाइल CPU आर्किटेक्चर जानें
      • file कमांड का उपयोग करके आसान
    • QEMU को इस आर्किटेक्चर का समर्थन करना चाहिए
  • QEMU एमुलेशन (मोड)
    • सिस्टम मोड: पूरे सिस्टम का अनुकरण करें
      • कैसे करें

        1. QEMU निष्पादन योग्य प्रारूप ढूंढें: qemu-system-$PROCESSOR$ARCHITECTURE

          • उदाहरण: qemu-system-mipsel

        2. यदि आप प्रोसेसर परिवार जानते हैं तो आप इसे QEMU को बेहतर वातावरण का अनुकरण करने में मदद करने के लिए निर्दिष्ट कर सकते हैं

          • समर्थित परिवारों की सूची प्राप्त करने के लिए: $QEMUBIN -cpu help
          • हमेशा सामान्य परिवार CPU से शुरू करना बेहतर होता है, फिर यदि कुछ काम नहीं करता है तो गहराई में जाकर विशिष्ट CPU परिवारों का उपयोग करें

        3. हमें कर्नेल और रूट फाइलसिस्टम की आवश्यकता है

          • नोट्स
            • डिवाइस कर्नेल लापता ड्राइवरों के लिए अच्छा नहीं है
            • IOT दुनिया में कोई मानकीकरण नहीं है
              • कर्नेल डिवाइस ट्री का उपयोग करें: बोर्ड ड्राइवरों को परिभाषित करने वाली टेक्स्ट फ़ाइल
                • कर्नेल बूट होने पर इस फ़ाइल को लोड करेगा और सामान्य ड्राइवरों को उपयोग में आने वाले बोर्ड के अनुकूल बनाएगा
                • अधिक उपयोग नहीं किया जाता
            • तो.. कर्नेल और फाइलसिस्टम का पुनर्निर्माण करें

          1. कर्नेल संस्करण, libc संस्करण और हमारी रुचि के निष्पादन योग्य द्वारा उपयोग की जाने वाली लाइब्रेरी की सूची खोजें (readelf -d $EXECUTABLE)

            • लाइब्रेरी संस्करण प्रारूप: ( संस्करण है)
root@kitploit:~
                    mount -tubifs /dev/ubi${UBIDEVNUM}_0 /mnt/filesystem
                    ```
                    1. कर्नेल मॉड्यूल के लिए बाइट्स पहचानें
                        - बूट के दौरान आमतौर पर NAND की जानकारी प्रिंट होती है, इसे देखें (ऊपर दिए गए चरण) और `NAND ID` खोजें, बाइट्स पहले, दूसरे और चौथे बाइट के क्रम में प्रिंट होते हैं
                        - हम यह जानकारी EEPROM की डेटाशीट खोजकर भी पा सकते हैं
                        - हम सही कमांड खोजने के लिए [यहाँ](http://www.linux-mtd.infradead.org/faq/nand.html#L_nand_nandsim) पर `writesize, oobsize, erasesize, iowidth` का भी उपयोग कर सकते हैं
                        - अन्यथा, परीक्षण और त्रुटि (trial and error)
                    2. बूट पर प्रिंट होने वाले EEPROM विभाजनों का विश्लेषण करें ताकि उनके आकार और नाम मिल सकें, `flash_erase` कमांड में अंतिम संख्या उनका आकार है जो `erasesize` से संबंधित है (जैसे `parts=x,y,z,...`)
                    3. डिवाइस से डंप किए गए विभाजनों को अभी बनाए गए विभाजनों में लोड करें
                    4. फाइलसिस्टम के लिए माउंटपॉइंट बनाएं और अटैच करें
                        - `-O`: वॉल्यूम आईडी हेडर ऑफसेट निर्दिष्ट करें, गलत होने पर भी सिस्टम आपको सही मान बता देगा, आप `512, 1024, 2048` जैसे अलग-अलग मान आज़मा सकते हैं (परीक्षण और त्रुटि)
                        - `-m`: `mtd` डिवाइस नंबर (बिंदु 3 देखें)
                        - `-d`: UBI डिवाइस नंबर (बिंदु 5 देखें)
                    5. माउंट करें
    - यूज़र मोड: wine की तरह, केवल एक बाइनरी निष्पादित करें और उसे हमारे आर्किटेक्चर में "अनुवादित" करें
        - नोट्स
            - बहुत स्थिर नहीं है
            - अजीब परिणाम दे सकता है
        - कैसे करें
            1. QEMU निष्पादन योग्य प्रारूप खोजें: `qemu-$PROCESSOR$ARCHITECTURE`
                - उदाहरण: `qemu-mips64`
            2. यदि QEMU लापता इंटरप्रेटर की शिकायत करता है तो इस इंटरप्रेटर को समाहित करने वाले **फ़ोल्डर का पथ** `-L` के साथ पास करें (या `man` देखें)
                - यह जानने के लिए कि किसी निष्पादन योग्य द्वारा कौन सा इंटरप्रेटर उपयोग किया जाता है, `readelf -l $EXECUTABLE` का उपयोग करें
    - वर्चुअलाइज़ेशन मोड: हमारे लिए दिलचस्प नहीं है
- buildroot और docker का उपयोग करके कर्नेल और रूट फाइलसिस्टम बनाना
    - हमारे बनाए गए कर्नेल में (मूल कर्नेल की तुलना में) होना चाहिए
        - समान कर्नेल संस्करण
        - समान libc संस्करण (`uClibc, uClibc-ng, musl, dietlibc...`)
        - समान लाइब्रेरी संस्करण (जिस निष्पादन योग्य में हमारी रुचि है)
    1. buildroot का वह संस्करण खोजें जो हमारे डिवाइस के संस्करणों के सबसे निकट हो
        - कभी-कभी बूट के दौरान/डंप की गई मेमोरी की खोज करते समय हम उपयोग किए गए buildroot का संस्करण पा सकते हैं (यदि डिवाइस buildroot का उपयोग करके बनाया गया था)
    2. मिले buildroot संस्करण के साथ संगत linux संस्करण खोजें और एक docker कंटेनर बनाएं, [यहाँ](https://github.com/digiampietro/hacking-gemtek/blob/master/docker/Dockerfile) एक नमूना dockerfile है (buildroot चलाने के लिए पैकेज महत्वपूर्ण हैं)
    3. चयनित buildroot संस्करण को [यहाँ](https://buildroot.org/downloads/) से डाउनलोड करें और उसे docker कंटेनर साझा फ़ोल्डर के अंदर रखें
    4. docker कंटेनर चलाएं और उस पर स्विच करें
    5. buildroot निकालें और buildroot का मैनुअल बनाने के लिए `make manual` चलाएं
    6. `make help` का उपयोग करके buildroot सभी समर्थित डिवाइसों (बोर्ड) को प्रिंट करता है; अपने बोर्ड की buildroot कॉन्फ़िगरेशन फ़ाइल बनाने के लिए `make $YOURBOARDNAME` चलाएँ
    7. हमारे बिल्ड में जोड़ने के लिए कर्नेल मॉड्यूल चुनने हेतु `make menuconfig` (टेक्स्ट आधारित) या `make xconfig` (GUI) चलाएँ, हम `make xconfig` का उपयोग करेंगे
        - यहाँ एक उदाहरण/दिशानिर्देश है, लेकिन आपको स्वयं खोजना होगा कि आपके अनुप्रयोगों को चलाने के लिए विशेष रूप से कौन से मॉड्यूल चाहिए
        - शॉर्टकट: मॉड्यूल खोजने के लिए `Edit->Find`
        - विकल्प
            - `Target options`
                - `Show options and packages that are deprecated or obsolete` चुनें
                - `Build packages with debugging symbols` को उच्चतम `debug level` के साथ चुनें
                - `Strip command for binaries on target` को `None` पर सेट करें
                - `GCC optimization level` को `0` पर सेट करें
            - `Toolchain`
                - `Toolchain type` को `Buildroot toolchain` पर सेट करें
                - `Kernel headers` को `Manually specified linux version` पर सेट करें
                - `Custom kernel headers series` को `$DEVICEKERNELVERSION` पर सेट करें
                - `Linux version` को `$DEVICEKERNELVERSION` पर सेट करें
                - `C library` को `$DEVICECLIBRARY` पर सेट करें
                - `$DEVICECLIBRARY version` को `$DEVICECLIBRARY $DEVICELIBRARYVERSION` पर सेट करें
                - `Enable large files` चुनें
                - `Enable IPv6` चुनें
                - `Enable RPC` चुनें
                - `Enable WCHAR` चुनें
                - `Thread library implementation` को `linuxthreads` पर सेट करें
                - `Thread library debugging` चुनें
                - `Build cross gdb for the host` चुनें
                - `TUI support` चुनें
                - `Python support` चुनें
                - `GDB debugger version` को `$LATESTGDBVERSION` पर सेट करें
            - `System configuration`
                - `Passwords encoding` को `MD5` पर सेट करें
                - `Init system` को `$DEVICEINITSYSTEM` (या `BusyBox`) पर सेट करें
                - `/dev management` को `Dynamic using devtmpfs only` पर सेट करें
                - `/bin/sh` को `Busybox default shell` पर सेट करें
                - `Install timezone info` चुनें
            - `Kernel`
                - `Kernel version` को `$DEVICEKERNELVERSION` पर सेट करें
                - `Kernel binary format` को `vmlinux` पर सेट करें
            - `Target packages`
                - `Compressors and decompressors`
                    - `bzip2` और `xz-utils`
                - `Debugging profiling and benchmark`
                    - `gdb` और `full debugger` चुनें
                - `Development tools`
                    - आपको जो भी चाहिए
                - `Filesystem and flash utilities`
                    - `mtd, jffs2 and ubi/ubifs tools` (या आपको जो भी चाहिए)
                - `Libraries`
                    - सामान्य तौर पर आपको जो चाहिए (नीचे सुझाव)
                    - `Crypto`
                        - `libsha1`
                        - `libssh2`
                        - `openssl`
                    - `JSON/XML`
                        - `expat`
                        - `json-c`
            - `Networking applications`
                - `rsync` और आपको जो चाहिए
            - `Shell and utilities`
                - `file`
            - `Filesystem images`
                - `ext2`
            - `Host utilities` (यहाँ लक्ष्य डिवाइस के बारे में नहीं, बल्कि होस्ट डिवाइस की बात हो रही है)
                - `host mtd, jffs2 and ubi/ubifs tools`
                - `host util-linux`
        - SAVE करना न भूलें
    8. अभी परिभाषित कॉन्फ़िगरेशन को स्थायी रूप से सहेजने के लिए `make savedconfig` का उपयोग करें
    9. `make linux-menuconfig` (टेक्स्ट आधारित) या `make linux-xconfig` (GUI) के साथ कर्नेल कॉन्फ़िगर करें, यहाँ हम CLI संस्करण का उपयोग करेंगे
        - यहाँ एक उदाहरण/दिशानिर्देश है, लेकिन आपको स्वयं खोजना होगा कि आपके अनुप्रयोगों को चलाने के लिए विशेष रूप से कौन से मॉड्यूल चाहिए
        - विकल्प
            - `Kernel type` -> `Preemption model (Preemptible Kernel (Low-Latency Desktop))` -> `Preemptible Kernel (Low-Latency Desktop)`
            - `Kernel type` -> `Device drivers` -> `Memory technology device (MTD) support` -> `NAND device support` -> `Support for NAND flash simulator`
            - `Kernel type` -> `Device drivers` -> `Memory technology device (MTD) support` -> `UBI - Unsorted block images` -> `Enable UBI`
            - `File systems` -> `Miscellaneous filesystem` -> `JFFS2 support`
            - `File systems` -> `Miscellaneous filesystem` -> `UBIFS filesystem support`
        - `Save`
    10. `uClibc` (या आपकी c लाइब्रेरी) को `uclibc-menuconfig` का उपयोग करके कॉन्फ़िगर करें (हमेशा की तरह)
        - डिबगिंग सक्षम करें: `Development/Debugging options` -> `Enable debugging symbols`, यदि यह काम नहीं करता है (संकलन त्रुटियाँ) तो `Development/Debugging options` -> `(Wall) compiler warnings` -> `-Wall -ggdb -g3` जोड़ें
            - `-ggdb`: GDB के साथ उपयोग के लिए डिबगिंग जानकारी प्रदान करता है
            - `-g3`: अतिरिक्त डिबगिंग जानकारी प्रदान करता है 
        - `Save`
        - हमारे डिवाइस के अनुसार फीचर सक्षम करें (परीक्षण और त्रुटि, यदि त्रुटियाँ आती हैं तो जाँच करें और फिर आवश्यक फीचर के साथ पुनर्निर्माण करें)
    11. `make` चलाएँ, यदि समस्याएँ आएँ तो वापस जाकर दोहराएँ
        - संभावित संकलन त्रुटियाँ
            - `Need to use -fPIC`
                - `Toolchain` -> `Additional gcc options` के अंतर्गत कर्नेल मॉड्यूल (बिंदु 7) में `--enable-shared` जोड़ें या buildroot को पैच करें
    - buildroot के कॉन्फ़िगरेशन फ़ाइलों को git के साथ सहेजना
        - बाहरी ट्री कॉन्फ़िगरेशन (buildroot द्वारा समझे जाने वाले फ़ाइलों का ट्री दृश्य) (`br2`)
            ```
            +-- board/
            |   +-- <company>/ (not always used)
            |       +-- <boardname>/
            |           +-- linux.config
            |           +-- busybox.config
            |           +-- kernel-defconfig (kernel config file)
            |           +-- <other configuration files>
            |           +-- post_build.sh (executed just before building the image, useful to copy root filesystem into the image)
            |           +-- post_image.sh
            |           +-- rootfs_overlay/ (everythin here will be copied in the final image)
            |           |   +-- etc/
            |           |   +-- <some file>
            |           +-- patches/
            |               +-- foo/
            |               |   +-- <some patch>
            |               +-- libbar/
            |                   +-- <some other patches>
            |
            +-- configs/
            |   +-- <boardname>_defconfig (buildroot config for our board)
            |   +-- uClibc.config (optional)
            +-- patches/
            |   +-- (here patches to be applied)
            |
            +-- Config.in (if using a br2-external tree)
            +-- external.mk (if using a br2-external tree)
            +-- external.desc (if using a br2-external tree)
            ```
        - बाहरी ट्री का उपयोग करने के लिए buildroot को इस प्रकार चलाएँ: `make BR2_EXTERNAL=$PATHTOEXTTREE $COMMAND`
        - buildroot कॉन्फ़िग को हमारे बाहरी ट्री में सहेजने के लिए: `make BR2_EXTERNAL=$PATHTOEXTTREE savedefconfig`
        - कर्नेल कॉन्फ़िग को हमारे बाहरी ट्री में सहेजने के लिए: `make BR2_EXTERNAL=$PATHTOEXTTREE linux-update-defconfig`
        - uClibc कॉन्फ़िग को हमारे बाहरी ट्री में सहेजने के लिए: `make BR2_EXTERNAL=$PATHTOEXTTREE BR2_UCLIBC_CONFIG=$PATHWHERETOSAVEUCLIBCCONFIG uclibc-update-defconfig`

## स्रोत, श्रेय और धन्यवाद

- [Valerio Di Giampietro](https://va.ler.io/) ([@valerio](https://twitter.com/valerio)) का धन्यवाद, हार्डवेयर हैकिंग पर उनके अद्भुत youtube ट्यूटोरियल [चैनल](https://www.youtube.com/channel/UCoyNuc5bJ-z4X-6OlpNtJUw) के लिए, यहाँ जो कुछ भी लिखा गया है वह अधिकतर इन वीडियो से लिया गया है।
- [Luca Bongiorni](https://lockpicking.club/) ([@LucaBongiorni](https://twitter.com/LucaBongiorni)) का धन्यवाद, उनकी बहुमूल्य सलाह और हार्डवेयर उपकरणों के लिए।
- [सोल्डरिंग कॉमिक्स](https://mightyohm.com/files/soldercomic/FullSolderComic_EN.pdf) के लिए mightyohm.com का धन्यवाद
- मेरी मदद करने के लिए Reddit [hardwarehacking](https://www.reddit.com/r/hardwarehacking) समुदाय का धन्यवाद
    - [[Noob] डायरेक्ट PCB सोल्डरिंग (शायद?)](https://www.reddit.com/r/hardwarehacking/comments/lrbtaa/noob_direct_pcb_soldering_maybe/?utm_medium=android_app&utm_source=share)
- वाया सोल्डरिंग ट्यूटोरियल के लिए [Andrew Paul](https://www.youtube.com/channel/UCtfcWatnWeEY_vq_UOL4PDQ) का धन्यवाद
- [Buildroot मैनुअल](https://buildroot.org/downloads/manual/manual.html)
- [JTAG समझाया गया](https://blog.senr.io/blog/jtag-explained)
- [OpenOCD - फ्लैश कमांड](http://openocd.org/doc/html/Flash-Commands.html)
- [OpenOCD + JTAG जानकारी](https://www.allaboutcircuits.com/technical-articles/getting-started-with-openocd-using-ft2232h-adapter-for-swd-debugging/)
- [हार्डवेयर हैकिंग चीटशीट - लघु PDF](https://github.com/arunmagesh/hw_hacking_cheatsheet/blob/master/cheatsheet_0.1.pdf)
- [OpenOCD](http://openocd.org/)
टूल डाउनलोड करें
  • VCC के सापेक्ष UART पिनों की प्रतिरोधकता का परीक्षण करें (मल्टीमीटर को प्रतिरोध मापन पर रखें, आमतौर पर 200kOhm)
  • डिवाइस को चालू करें और GND के सापेक्ष UART पिनों का वोल्टेज परीक्षण करें (मल्टीमीटर को वोल्टेज मापन पर रखें, आमतौर पर 20V)
  • डिवाइस को चालू करें और बूट के दौरान संदिग्ध TX UART पिन का वोल्टेज GND के सापेक्ष परीक्षण करें (मल्टीमीटर को वोल्टेज मापन पर रखें, आमतौर पर 20V); यदि वोल्टेज दोलन कर रहा है तो यह पिन शायद TX है (क्योंकि यह डेटा भेज रहा है)
  • डिवाइस को चालू करें और बूट के दौरान संदिग्ध RX UART पिन का वोल्टेज GND के सापेक्ष परीक्षण करें (मल्टीमीटर को वोल्टेज मापन पर रखें, आमतौर पर 20V); यदि वोल्टेज 0 पर अटका है तो यह पिन शायद RX है (क्योंकि यह डेटा प्राप्त करने की प्रतीक्षा कर रहा है)

    • तालिका

      PINGND प्रतिरोधVCC प्रतिरोधVनोट्स
      1
      2
      3
      4

      • उदाहरण

  • Jtagulator का उपयोग करें
    1. इसे कंप्यूटर से कनेक्ट करें (बॉड दर: 115200)
    2. महत्वपूर्ण: H प्रिंट हेल्प फ़ंक्शन है, इसका उपयोग हर जगह करें
    3. बोर्ड GND को Jtagulator GND से, बोर्ड पिन 1,2,3 को Jtagulator चैनल 1,2,3 से कनेक्ट करें
    4. V: कार्यशील वोल्टेज सेट करें
    5. U: UART पहचान मेनू में प्रवेश करें
    6. U: पहचान शुरू करें
    7. Text string to output: डिफ़ॉल्ट
    8. Starting channel: वह चैनल जहाँ हमने बोर्ड का पिन 1 लगाया है
    9. Ending channel: वह चैनल जहाँ हमने बोर्ड का पिन 3 लगाया है
    10. Ignore non-printable characters: हाँ
    11. हो गया!
  • TODO: - BurtleinaBoard + Busside का उपयोग करें
    • root
    groups $USER
  • TTY से जुड़ने के लिए screen /dev/ttyUSB0 $BAUDRATE चलाएँ
    • $BAUDRATE यहाँ बताई गई बॉड दरों में से एक हो सकता है
    • सबसे सामान्य $BAUDRATE
      • 115200
      • 9600
      • 57600
      • 38400
      • 19200
    • महत्वपूर्ण: यदि हम $BAUDRATE गड़बड़ करते हैं तो हमें बकवास दिख सकती है या कुछ भी नहीं
    • ctrl + a -> k -> y: स्क्रीन बंद करें
    • यदि RX पिन काम नहीं करता दिख रहा है (आप टाइप करते हैं और एंटर दबाते हैं लेकिन कुछ नहीं होता) तो हो सकता है कि "return" मान गलत हो: \r\n या \n?
      • इसे हल करने के लिए pyserial का उपयोग करें, सीरियल संचार के लिए पायथन की लाइब्रेरी, उदाहरण:
        root@kitploit:~
        #!/usr/bin/env python3

import serial

ser = serial.Serial('/dev/ttyUSB0', 115200, tmieout = 0.1)
ser.write(b"HELLO\r\n")
ser.write(b"HELLO\n")
      • यदि समस्या बनी रहती है तो लॉजिक एनालाइज़र का उपयोग करें (यहाँ एक सस्ता विकल्प)
  • TDI (टेस्ट डेटा-इन): वह पिन जो चिप में डेटा भेजता है। JTAG मानक इस पिन पर संचार के लिए प्रोटोकॉल परिभाषित नहीं करता। यह निर्माता पर छोड़ दिया गया है। जहाँ तक JTAG का सवाल है, यह पिन चिप में 1s और 0s के प्रवेश का एक माध्यम मात्र है। चिप उनके साथ क्या करती है, यह JTAG के लिए अप्रासंगिक है।
  • TDO (टेस्ट डेटा-आउट): चिप से बाहर आने वाले डेटा के लिए पिन। डेटा-इन पिन की तरह, संचार प्रोटोकॉल JTAG द्वारा परिभाषित नहीं हैं।
  • TRST (टेस्ट रीसेट, वैकल्पिक): इस सिग्नल का उपयोग JTAG को ज्ञात अच्छी स्थिति में रीसेट करने के लिए किया जाता है।
  • PCB पर 5/6 पिनों की एक पंक्ति या 10, 12, 14, 20 पिनों की दोहरी पंक्ति खोजें
    1. GND का संदर्भ खोजें
      • पहले खोजे गए घटकों का उपयोग करके
      • आमतौर पर धातु की प्लेटें GND पर होती हैं
    2. VCC का संदर्भ खोजें
      • पहले खोजे गए घटकों का उपयोग करके
      • कैपेसिटर खोजें, उनका एक पिन आमतौर पर VCC पर होता है
    3. नीचे दी गई तालिका भरते हुए JTAG उम्मीदवार पिनों का परीक्षण करें (बुलेट पॉइंट क्रमशः तालिका के प्रत्येक कॉलम हैं)
      1. GND के सापेक्ष JTAG पिनों की प्रतिरोधकता का परीक्षण करें (मल्टीमीटर को प्रतिरोध मापन पर रखें, आमतौर पर 200k)
      2. VCC के सापेक्ष JTAG पिनों की प्रतिरोधकता का परीक्षण करें (मल्टीमीटर को प्रतिरोध मापन पर रखें, आमतौर पर 200kOhm)
      3. डिवाइस को चालू करें और GND के सापेक्ष JTAG पिनों का वोल्टेज परीक्षण करें (मल्टीमीटर को वोल्टेज मापन पर रखें, आमतौर पर 20V)

      • तालिका

    4. पाए गए मानों की तुलना अधिकतर उपयोग होने वाले JTAG पिनआउट से करें, jtagtest पर उपलब्ध
  • Jtagulator का उपयोग करें
    1. इसे कंप्यूटर से कनेक्ट करें (बॉड दर: 115200)
    2. महत्वपूर्ण: H प्रिंट हेल्प फ़ंक्शन है, इसका उपयोग हर जगह करें
    3. बोर्ड GND को Jtagulator GND से, बोर्ड पिन 1,2,3... को Jtagulator चैनल 1,2,3... से कनेक्ट करें
    4. V: कार्यशील वोल्टेज सेट करें
    5. J: JTAG पहचान मेनू में प्रवेश करें
    6. वहाँ हमारे पास दो विकल्प हैं
      • I: IDCODE स्कैन से पहचान करें, TDI नहीं मिलेगा (तेज़), बेहतर यदि मेरे पास पहचानने के लिए बहुत सारे पिन हों
      • B: BYPASS स्कैन से पहचान करें, TDI मिलेगा (धीमा), बेहतर यदि मेरे पास पहचानने के लिए कम पिन हों
    7. Starting channel: वह चैनल जहाँ हम बोर्ड का पिन 1 लगाते हैं
    8. Ending channel: वह चैनल जहाँ हम बोर्ड का पिन n लगाते हैं
    9. Already known pins: नहीं, लेकिन यदि हम पहले से कुछ पिन जानते हैं तो यह प्रक्रिया को तेज़ कर सकता है
    10. प्रारंभ करें और प्रतीक्षा करें.. हो गया!
  • TODO: - BurtleinaBoard + Busside का उपयोग करें
  • महत्वपूर्ण
    • JTAG अक्षम किया गया हो सकता है (हार्डवेयर, रेसिस्टर हटाकर) इसलिए संभव है कि मल्टीमीटर और Jtagulator से जो मिले वह संगत न हो; हम इसे इस पिन और VCC के बीच लगभग 300Ohm या 1kOhm का रेसिस्टर लगाकर हल कर सकते हैं
    • JTAG अक्षम किया गया हो सकता है (हार्डवेयर, रेसिस्टर हटाकर); इस समस्या को रेसिस्टर वापस लगाकर या रेसिस्टर पैड को शॉर्ट-सर्किट करते हुए सीधा कनेक्शन बनाकर हल किया जा सकता है
    • JTAG अक्षम किया गया हो सकता है (सॉफ्टवेयर, कुछ मान सेट करके)
    • JTAG अक्षम किया गया हो सकता है (हार्डवेयर, फ्यूज उड़ाकर... इस स्थिति में कोई उम्मीद नहीं है)
    • उपयोगी कमांड
      • halt: CPU को रोकें (फ्रीज़ करने जैसा)
        • हर डीबगिंग ऑपरेशन से पहले किया जाना चाहिए
      • reset: CPU रीसेट करें
      • reg: CPU रजिस्टर पढ़ें
      • flash info bank $BANKID या flash info $BANKID: फ्लैश मेमोरी बैंक $BANKID के बारे में जानकारी प्रिंट करता है (मुझे लगता है कि बैंक = मेमोरी का खंड)
      • flash list: प्रत्येक डिवाइस के लिए एसोसिएटिव ऐरे की सूची प्राप्त करता है जिसे flash bank ( $BOARDCONFIGFILE में) का उपयोग करके घोषित किया गया था, शून्य से क्रमांकित
      • flash banks: प्रत्येक डिवाइस की एक-पंक्ति सारांश प्रिंट करता है जिसे flash bank ($BOARDCONFIGFILE में) का उपयोग करके घोषित किया गया था, शून्य से क्रमांकित
      • flash write_image erase "$BINTOWRITE" $ADDRTOSTART: फ्लैश मेमोरी
        • $BINTOWRITE: bin (बाइनरी), ihex (Intel hex), elf (ELF फ़ाइल), s19 (Motorola s19), mem... हो सकता है
        • $ADDRTOSTART: वह पता जहाँ से लिखना शुरू करना है (मुझे लगता है कि डिफ़ॉल्ट 0 है)
      • flash dump_image $OUTFILE $ADDRTOSTART $SIZETODUMP: मेमोरी डंप करें
        • $OUTFILE: बाइनरी फ़ाइल जहाँ डंप सहेजना है
        • $ADDRTOSTART: वह पता जहाँ से पढ़ना शुरू करना है (मुझे लगता है कि डिफ़ॉल्ट 0 है)
        • $SIZETODUMP: डंप करने के लिए बाइट्स की संख्या
    • और अधिक यहाँ:
      • OpenOCD PDF
      • OpenOCD HTML
    • TODO
  • EEPROM पार्टीशन
    • OS प्रारंभ प्रक्रिया देखें, यहाँ आपको EEPROM के पार्टीशन, उनके नाम, माउंट पॉइंट और RAM में लंबाई के बारे में जानकारी मिल सकती है
    • यदि आप पार्टीशन को डुप्लिकेट देखते हैं तो संभवतः यह फर्मवेयर अपग्रेड के लिए है, आप अनुमान लगा सकते हैं क्यों
  • Init प्रक्रिया जानकारी
    • init started या ऐसा कुछ खोजें, यह संभवतः BusyBox स्ट्रिंग या इसी तरह की किसी चीज़ के पास होगा
  • क्या बूटलोडर में CLI है?
    • बूटलोडर मेनू खोजें, यहाँ संभवतः हमें इस प्रश्न का उत्तर मिल सकता है
  • बूटलोडर शेल प्राप्त करने का प्रयास करें (स्वचालित रूप से या UART के माध्यम से मेनू प्रिंट द्वारा)
  • बूटलोडर शेल का अन्वेषण करें
    • help कमांड आपका मित्र है
    • मेमोरी की सामग्री को डंप करने का तरीका खोजने का प्रयास करें, python आपका मित्र है
    • OOB डेटा (त्रुटि कोड सुधार) डंप करने के लिए इतना उपयोगी नहीं है
  • डंप किए गए डेटा का विश्लेषण
    • जाँचने के लिए binwalk, file और hexdump -C का उपयोग करें कि डंप की गई फ़ाइल ठीक है या नहीं और क्या यह संपीड़ित या एन्क्रिप्टेड है
      • binwalk -E के साथ हम फ़ाइल की एन्ट्रॉपी का विश्लेषण करते हैं
        • एन्ट्रॉपी 1 के निकट: यादृच्छिक, संपीड़ित या एन्क्रिप्टेड फ़ाइल
        • एन्ट्रॉपी 1 से नीचे: सामान्य निष्पादन योग्य या फ़ाइल
    • फ़ाइल के पहचानने योग्य खंड निकालने के लिए binwalk -e का उपयोग करें
  • यदि binwalk डंप की गई छवि को पूरी तरह से नहीं समझता है तो हम EEPROM पार्टीशन तालिका (यदि पहले मिली हो) का उपयोग करके डंप की गई छवि को मैन्युअल रूप से कई उपयोगी छवियों में विभाजित कर सकते हैं
    • dd if=$IN_DUMPED_IMAGE of=$OUT_FILE bs=1024 skip=$BYTES_TO_SKIP_FROM_THE_START count=$HOW_MANY_BYTES_TO_WRITE
    • छवियों की तुलना करने के लिए sha1sum, md5sum या binwalk -W -i का उपयोग करें (यदि उदाहरण के लिए हमें लगता है कि वे समान छवि हो सकती हैं)
  • अंतिम ऑपरेशन को डंप की गई छवि की सामग्री के आधार पर कई बार निष्पादित किया जा सकता है; यदि उदाहरण के लिए हमारे पास कर्नेल छवि है तो हम रूट फाइलसिस्टम पढ़ने के लिए binwalk (या dd यदि हम ऑनलाइन पा सकते हैं कि हमारी विशिष्ट कर्नेल छवि कैसे संरचित है) के साथ इसके घटकों को फिर से निकाल सकते हैं
  • फाइलसिस्टम निकालें
    • उदाहरण कमांड (फाइलसिस्टम प्रकार के आधार पर): fakeroot -s fakeroot.dat usquashfs -d squashfs-root u04-sqfs.dat
      • fakeroot: नकली रूट वातावरण बनाएं, फ़ाइल अनुमतियों, डिवाइस फ़ाइलों का अनुकरण करने के लिए उपयोगी...
        • -s fakeroot.dat: कमांड fakeroot -i fakeroot.dat bash के साथ आगे पुनर्स्थापित करने के लिए नकली रूट वातावरण सहेजें
      • usquashfs: squashfs फाइलसिस्टम निकालें (आपके मामले में भिन्न हो सकता है)
        • -d squashfs-root: गंतव्य फ़ोल्डर
        • u04-sqfs.dat: निकालने के लिए फाइलसिस्टम छवि
    • /sbin/init
  • दिलचस्प बाइनरी और स्क्रिप्ट
    • init प्रक्रिया द्वारा प्रारंभ की गई दिलचस्प फ़ाइलें देखें और सामान्य तौर पर नामों पर न रुकें, गहराई से देखें कि कौन सा बाइनरी निष्पादित किया जा रहा है और उनका विश्लेषण करें; सबसे दिलचस्प गैर-मानक हैं
    • factory mode स्ट्रिंग देखें; यदि हम डिवाइस को फैक्ट्री मोड में डालने में सफल हो जाते हैं (यदि यह मौजूद है) तो इसे हैक करना बहुत आसान है
    • उपयोगी कमांड
      • टेक्स्ट एडिटर
      • grep
      • find
      • xargs
      • strings
    • libfoo.X.Y.Z
    X.Y.Z
    • X असंगत ABI
    • Y पिछड़ा संगत ABI
    • Z कोई ABI परिवर्तन नहीं
  • इसलिए हमें मूल लाइब्रेरी के बराबर X.Y चाहिए
    • स्वीकार्य: समान X, उच्च Y

  • बिल्ड सिस्टम का उपयोग करके बनाएं (सुविधाओं का चयन करें और निर्भरताओं को स्वचालित रूप से ट्रैक करें)

    • सर्वोत्तम बिल्ड सिस्टम विकल्प
      • Yocto project
      • Buildroot (सर्वोत्तम)
      • OpenWRT बिल्ड सिस्टम

  • एमुलेट करना शुरू करें

    • QEMU एमुलेशन स्क्रिप्ट
      root@kitploit:~
      #!/bin/bash
# This script will build an environment without password for the user root
export QEMU_AUDIO_DRV="none" # ignore audio drivers

qemu-system-${PROCESSOR}${ARCHITECTURE} -M $CPUFAMILY \ # See point 2
                                        -m $RAMSIZE \
                                        -kernel $KERNELPATH \
                                        -nographic \ # No GUI
                                        -hda $FILESYSTEM \
                                        -net nic,model=$NETCARDMODEL \ # Model of net card, driver must be included in kernel
                                        -net user, hostfw=tcp::2222-:22, hostfw=tcp::9000-:9000 \ # 2222 as ssh and 9000 for GDB server
                                        -no-reboot \ # Terminate the machine when is halted
                                        -append "root=/dev/hda console=uart0" # Set root filesystem and console
      • यदि किसी बाइनरी को निष्पादित करते समय लापता लाइब्रेरी के बारे में त्रुटि प्रिंट होती है तो LD_LIBRARY_PATH को इस प्रकार सेट करें (मशीन के अंदर): export LD_LIBRARY_PATH=/lib:/usr/lib:$PATHTOORIGINALFILESYSTEMLIBFOLDER
    • हम NAND EEPROM का भी अनुकरण कर सकते हैं
      root@kitploit:~
      #!/bin/bash

# Part 1: Identify bytes for kernel module
modprobe nandsim first_id_byte=$FIRSTBYTE \
                    second_id_byte=$SECONDBYTE \
                    third_id_byte=$THIRDBYTE \
                    fourth_id_byte=$FOURTHBYTE \
                    cache_file=/root/nandsim.bin \
                    parts=x,y,z,... # Define partitons size in number of erase blocks; the number of partitions depends on your device, partitions are usually print on boot

# Part 2: Erase partitions created (analyze EEPROM partitions)
flash_erase /dev/mtd0 0 8 
flash_erase /dev/mtd1 0 20
# ...

# Part 3: Load partitions dumped from device in the ones just created
nandwrite /dev/mtd0 part0.bin
nandwrite /dev/mtd1 part1.bin
# ...

# Part 4: Create mountpoint for filesystem and attach (if UBIFS)
mkdir /mnt/filesystem
ubiattach -O $N -m $MTDDVENUM -d $UBIDEVNUM
    • PINGND प्रतिरोधVCC प्रतिरोधVनोट्स
    130kOhm0Ohm3.3VVCC
    24.7kOhm34kOhm3.3V1.6-3.3V बूट पर - TX
    3INFOhm (मल्टीमीटर 1)INFOhm (मल्टीमीटर 1)3.3V0V बूट पर - RX
    40Ohm30kOhm0VGND
    PINGND प्रतिरोधVCC प्रतिरोधVनोट्स
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    ...

    • उदाहरण

      PINGND प्रतिरोधVCC प्रतिरोधVनोट्स
      11kOhm1kOhm0V
      20Ohm90Ohm0VGND
      3INFOhm (मल्टीमीटर 1)INFOhm (मल्टीमीटर 1)2.1Vउच्च प्रतिबाधा, TDO?
      490Ohm0Ohm3.3VVCC
      54.7kOhm4.7kOhm3.3V
      6INFOhm (मल्टीमीटर 1)INFOhm (मल्टीमीटर 1)0Vकनेक्टेड नहीं?
      75.7kOhm5.7kOhm3.3V
      8INFOhm (मल्टीमीटर 1)INFOhm (मल्टीमीटर 1)0Vकनेक्टेड नहीं?
      94.7kOhm4.7kOhm3.3V
      100Ohm90Ohm0VGND
      • संगत JTAG टेस्ट साइट पिनआउट मिला: Altera Byteblaster