Exploit for MIPS

## https://sploitus.com/exploit?id=KITPLOIT:TOOLS-GITHUB-MERCUL1NINNA-MIPS-CVE-2014-9222
## अस्वीकरण

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

## आवश्यकताएँ

root@kitploit:~
    
    
    $ IDA Pro +7.0 (आप Radar2 का उपयोग कर सकते हैं क्योंकि IDA काफी महंगा है)
    $ राउटर जिसमें Rompager 4.07 चल रहा है : इनकी भारी संख्या है जैसे TP-Link TD-W8951*, ZyXEL P-660R, Billion BiPAC 51**/52**
    $ UART से USB
    

मिस्फॉर्च्यून कुकी भेद्यता कुछ समय से मौजूद है लेकिन फिर भी सार्वजनिक रूप से भेद्यता के तकनीकी विवरणों को दर्शाने वाले विश्लेषण का अभाव है। चेक पॉइंट के अनुसार, प्रभावित सॉफ्टवेयर AllegroSoft का एम्बेडेड वेब सर्वर RomPager है। इंटरनेट-व्यापी स्कैन से पता चलता है कि उपलब्ध एंडपॉइंट्स की संख्या के मामले में RomPager संभवतः दुनिया में सबसे लोकप्रिय वेब सर्वर सॉफ्टवेयर है। RomPager आमतौर पर डिवाइस के साथ जारी फर्मवेयर में एम्बेडेड होता है। यह विशिष्ट भेद्यता 2002 में कोड बेस में पेश की गई थी। इसके अलावा, उजागर किए गए डिवाइस वे हैं जो संस्करण 4.34 से पहले (और विशेष रूप से 4.07) के RomPager सेवाओं का उपयोग करते हैं।

> इस ट्यूटोरियल के लिए मैं ZXHN H108L का उपयोग करूंगा जो Rompager 4.07 का उपयोग करता है

root@kitploit:~
    
    
    HTTP/1.1 401 अनधिकृत
    WWW-Authenticate: Basic realm="ZXHN H108L"
    Content-Type: text/html
    Transfer-Encoding: chunked
    Server: RomPager/4.07 UPnP/1.0
    EXT:
    

अब सीरियल पोर्ट का उपयोग करते हैं, पहले हमें बॉड दर निर्धारित करनी होगी

root@kitploit:~
    
    
    $ sudo stty -F /dev/ttyUSB0
    

> आउटपुट :

root@kitploit:~
    
    
    speed 115200 baud; line = 0;
    -brkint -imaxbel
    

device

मैं **minicom** का उपयोग करता हूं, आप **screen** से लेकर **HyperTerminal** तक कुछ भी उपयोग कर सकते हैं, लेकिन मैं इसकी स्थिरता के कारण इसे पसंद करता हूं ;)

### आपको पहले **हार्डवेयर फ्लो कंट्रोल** को निष्क्रिय करना होगा

root@kitploit:~
    
    
    $ sudo minicom -s
    

root@kitploit:~
    
    
        +-----------------------------------------------------------------------+
        | A -    सीरियल डिवाइस      : /dev/modem                                |
        | B - लॉकफ़ाइल स्थान     : /var/lock                                 |
        | C -   कॉलिन प्रोग्राम      :                                           |
        | D -  कॉलआउट प्रोग्राम      :                                           |
        | E -    Bps/Par/Bits       : 115200 8N1                                |
        | F - हार्डवेयर फ्लो कंट्रोल : नहीं                                        |
        | G - सॉफ्टवेयर फ्लो कंट्रोल : नहीं                                        |
        |                                                                       |
        |    कौन सी सेटिंग बदलनी है?                                              |
        +-----------------------------------------------------------------------+
                | स्क्रीन और कीबोर्ड      |
                | सेटअप को dfl के रूप में सहेजें        |
                | सेटअप को इस नाम से सहेजें..          |
                | बाहर निकलें                     |
                | Minicom से बाहर निकलें        |
                +--------------------------+
    

अब हम जाने के लिए तैयार हैं:

root@kitploit:~
    
    
    $ sudo minicom -D /dev/ttyUSB0 -b 115200
    

root@kitploit:~
    
    
    Bootbase Version: VTC_SPI1.26 |  2012/12/26 16:00:00    
    RAM: आकार = 8192 Kbytes
    SPI फ्लैश 2MiB GD25Q16 0xbfc00000 पर मिला
    SPI फ्लैश क्वाड सक्षम
    क्वाड मोड बंद करें
    
    RAS Version: ZXHN H108LV4.0.0a_ZRQ_MA                                          
    System   ID: $2.12.162.0(G94.BY.2)3.20.19.0| 2014/03/21   20140321_v006  | 2014 
    
    डीबग मोड में प्रवेश करने के लिए 3 सेकंड के भीतर कोई भी कुंजी दबाएं।
    ..........
    

संभावित कमांड दिखाने के लिए:

`$ ATHE`

root@kitploit:~
    
    
    ======= डीबग कमांड सूची =======
    AT          बस OK उत्तर दें
    ATHE          सहायता प्रिंट करें
    ATBAx         बॉडरेट बदलें। 1:38.4k, 2:19.2k, 3:9.6k 4:57.6k 5:115.2k
    ATENx,(y)     BootExtension डीबग फ़्लैग सेट करें (y=पासवर्ड)
    ATSE          पासवर्ड जनरेटर का सीड दिखाएं
    ATTI(h,m,s)   सिस्टम समय को घंटा:मिनट:सेकंड में बदलें या वर्तमान समय दिखाएं
    ATDA(y,m,d)   सिस्टम दिनांक को वर्ष/महीना/दिन में बदलें या वर्तमान दिनांक दिखाएं
    ATDS          RAS स्टैक डंप करें
    ATDT          बूट मॉड्यूल सामान्य क्षेत्र डंप करें
    ATDUx,y       पते x से y लंबाई के लिए मेमोरी सामग्री डंप करें
    ATRBx         पते x का 8-बिट मान प्रदर्शित करें
    ATRWx         पते x का 16-बिट मान प्रदर्शित करें
    ATRLx         पते x का 32-बिट मान प्रदर्शित करें
    ATGO(x)       एड्रेस x पर प्रोग्राम चलाएं या राउटर बूट करें
    ATGR          राउटर बूट करें
    ATGT          हार्डवेयर परीक्षण प्रोग्राम चलाएं
    ATRTw,x,y(,z) RAM परीक्षण स्तर w, पता x से y तक (z पुनरावृत्तियाँ)
    ATSH          ROM में निर्माता संबंधित डेटा डंप करें
    ATDOx,y       पते x से y लंबाई के लिए XMODEM के माध्यम से PC पर डाउनलोड करें
    ATTD          XMODEM के माध्यम से PC पर राउटर कॉन्फ़िगरेशन डाउनलोड करें
    ATUR          फ्लैश ROM पर राउटर फर्मवेयर अपलोड करें
    
    < जारी रखने के लिए कोई भी कुंजी दबाएं >
    

इस फर्मवेयर में छिपे हुए कमांड का एक सेट है जो हमारे गतिशील विश्लेषण के लिए बहुत उपयोगी है, समस्या यह है कि हम रजिस्टर नहीं देख सकते हैं और न ही ब्रेकपॉइंट सेट कर सकते हैं लेकिन उम्मीद है कि इन छिपे हुए कमांड के साथ हमारे पास वे सुविधाएँ होंगी, उन्हें देखने और उपयोग करने के लिए हमें **ATEN** का उपयोग करने की आवश्यकता है। हालाँकि, इस कमांड के लिए एक पासवर्ड आवश्यक है, तो अब हम क्या कर सकते हैं? आइए पासवर्ड जनरेटर के एल्गोरिदम को खोजने के लिए फर्मवेयर को रिवर्स इंजीनियर करें।

(स्थैतिक विश्लेषण) पहले फर्मवेयर फ़ाइल देखते हैं:

root@kitploit:~
    
    
    $ binwalk ras
    

binwalk1

root@kitploit:~
    
    
    $ dd if=ras of=rom1.lzma bs=1 skip=85043 count=66696
    $ dd if=ras of=rom2.lzma bs=1 skip=350259 count=3350556
    $ lzma -d <rom1.lzma> rom1
    $ lzma -d <rom2.lzma> rom2
    

अब निकाली गई फ़ाइलों में हस्ताक्षर देखते हैं:

root@kitploit:~
    
    
    $ binwalk -Y rom1
    

root@kitploit:~
    
    
    DECIMAL       HEXADECIMAL     DESCRIPTION
    --------------------------------------------------------------------------------
    0             0x0             MIPS निष्पादन योग्य कोड, 32/64-बिट, बिग एंडियन, कम से कम 1250 मान्य निर्देश
    

**स्ट्रिंग** एक बेहतरीन उपकरण है जो यह अंदाजा लगाने में मदद करता है कि बाइनरी फ़ाइल क्या है या उसमें क्या है, आइए देखें कि क्या हम पासवर्ड एल्गोरिदम पा सकते हैं:

root@kitploit:~
    
    
    $ strings rom1 | grep -i aten
    $ strings rom2 | grep -i aten
    

जाहिर है, हम इसे नहीं देख सकते क्योंकि फर्मवेयर अभी भी संपीड़ित है, जिसका अर्थ है कि हमें इसे डीबगिंग मोड का उपयोग करके राउटर से डंप करना होगा:

root@kitploit:~
    
    
    $ ATDO bfc00000, 1f0000
    

xmodem

सबसे पहले जो बात दिमाग में आती है वह है डिस्पैच टेबल की तलाश शुरू करना। क्यों? बस अंतर्ज्ञान, एकमात्र विकल्प if-elif है लेकिन यह उनका एक लंबा सेट होगा, उपयोगकर्ता द्वारा प्रदान किए गए पासवर्ड की वैधता की जांच करने के लिए, और यहाँ मुझे क्या मिला:

root@kitploit:~
    
    
    ROM:800158A0 CmdTable:       .word unk_80015C20       # DATA XREF: sub_8000E3D8+4Co
    ROM:800158A0                                          # sub_8000E3D8+90o ...
    ROM:800158A4                 .word sub_8000E6D0
    ROM:800158A8                 .byte    0
    ROM:800158A9                 .byte    0
    ROM:800158AA                 .byte    0
    ROM:800158AB                 .byte    0
    ROM:800158AC                 .word aJustAnswerOk      # "          बस OK उत्तर दें"
    ROM:800158B0                 .word aAthe              # "ATHE"
    ROM:800158B4                 .word CMD_SHOW_HELP_ATHE
    ROM:800158B8                 .byte    0
    ROM:800158B9                 .byte    0
    ROM:800158BA                 .byte    0
    ROM:800158BB                 .byte    0
    ROM:800158BC                 .word aPrintHelp         # "          सहायता प्रिंट करें"
    ROM:800158C0                 .word aAtba              # "ATBA"
    ROM:800158C4                 .word CMD_ATBA
    ...
    ROM:800158D0                 .word aAten              # "ATEN"
    ROM:800158D4                 .word CMD_ATEN
    

ध्यान रखें कि MIPS शब्द 4 बाइट्स का होता है, अब **CMD_ATEN** देखते हैं:

root@kitploit:~
    
    
    ROM:8000FF84                 lw      $a0, 8($s0)
    ROM:8000FF88                 jal     sub_80013654
    ROM:8000FF8C                 li      $a1, 0
    ROM:8000FF90                 jal     passwd_generator
    

और अब: **passwd_generator**

root@kitploit:~
    
    
    ROM:80010A2C passwd_generator:                         # CODE XREF: CMD_ATEN+50p
    ROM:80010A2C                 lui     $t9, 0xA11F
    ROM:80010A30                 lw      $v1, ptrDO_GTABLE
    ROM:80010A34                 lw      $t8, dword_80017050
    ROM:80010A38                 lw      $v1, 0x18($v1)   # ATSE कमांड द्वारा उत्पन्न सीड भाग लें
    ROM:80010A3C                 lbu     $t8, 0x6D($t8)   # MAC पते का अंतिम बाइट लें
    ROM:80010A40                 sll     $v1, 8     # $v1 = v1 << 8
    ROM:80010A44                 andi    $t7, $t8, 7    # $t7 = t8 & 0x7
    ROM:80010A48                 li      $t8, 0     # $t8 = 0
    ROM:80010A4C                 srl     $v1, 8     # $v1 = v1 >> 8 
    ROM:80010A50                 li      $t9, 0xA11F5AC6    # $t9 = MAGIC
    ROM:80010A54                 j       loc_80010A68
    ROM:80010A58                 addu    $t9, $v1, $t9    # $t9 = $v1 + $t9
    ROM:80010A5C  # ---------------------------------------------------------------------------
    ROM:80010A5C
    ROM:80010A5C loc_80010A5C:                              # CODE XREF: passwd_generator+40j
    ROM:80010A5C                 sll     $t9, 31      # $t9 = $t9 << 31
    ROM:80010A60                 or      $t9, $t6, $t9    # $t9 = $t6 | $t9
    ROM:80010A64                 addiu   $t8, 1       # $t8 = $t8 + 1
    ROM:80010A68
    ROM:80010A68 loc_80010A68:                # CODE XREF: passwd_generator+28j
    ROM:80010A68                 sltu    $t6, $t8, $t7    # $t6 = (t8 < t7? 1:0)
    ROM:80010A6C                 bnez    $t6, loc_80010A5C    # यदि $t6 != 0 तो कूदें
    ROM:80010A70                 srl     $t6, $t9, 1    # $t6 = $t9 >> 1
    ROM:80010A74                 jr      $ra      # सब कुछ हो गया, बाहर निकलें
    ROM:80010A78                 xor     $v0, $t9, $v1    # $v0 = $t9 ^ $v1
    

हम क्या निष्कर्ष निकाल सकते हैं:

  * $v1 सीड मान है (ATSE कमांड द्वारा उत्पन्न, यदि ATSE का उपयोग नहीं किया गया तो शून्य)
  * $t8 में शुरू में MAC पते का अंतिम बाइट (अंतिम ऑक्टेट) होता है
  * 0xA11F5AC6 वह जादुई मान है जिसकी हम तलाश कर रहे थे!
  * वे दो निर्देश: "$v1 = v1 << 8" और "$v1 = v1 >> 8" "seed = seed & 0x00FFFFFF" के बराबर हैं
  * (sll-or-srl) के साथ लूप ROR निर्देश (MIPS पर ROR निर्देश एक छद्म निर्देश है जिसका अर्थ है कि इसे आमतौर पर sll-or-srl अनुक्रम का उपयोग करके अनुकरण किया जाता है) के अलावा कुछ नहीं है
  * $v0 परिणाम है



अब एक C प्रोग्राम बनाते हैं जो वही काम करता है और इसे संकलित करते हैं:

root@kitploit:~
    
    
    U32 passwd_generator(U32 seed, U8 last_mac_octet)
    {
          U32 b = seed & 0x00FFFFFF;
          U32 r = ROR(b + 0xA11F5AC6, last_mac_octet & 7);
          return r^b;
    }
    

अब सीड प्राप्त करने के लिए **ATSE** चलाएं और इसका उपयोग करें (उदाहरण के लिए: मुझे 088521A78838 मिला):

root@kitploit:~
    
    
    $ ./gen_pass 088521A78838
    

आइए वह जादुई कमांड चलाएं जिसे हमने अभी हैक किया है :p

root@kitploit:~
    
    
    $ ATEN1, A12F5AC6
    

root@kitploit:~
    
    
    ATEN1, A12F5AC6
    OK
    ATHE
    ======= डीबग कमांड सूची =======
    AT          बस OK उत्तर दें
    ATHE          सहायता प्रिंट करें
    ATBAx         बॉडरेट बदलें। 1:38.4k, 2:19.2k, 3:9.6k 4:57.6k 5:115.2k
    ATENx,(y)     BootExtension डीबग फ़्लैग सेट करें (y=पासवर्ड)
    ATSE          पासवर्ड जनरेटर का सीड दिखाएं
    ATTI(h,m,s)   सिस्टम समय को घंटा:मिनट:सेकंड में बदलें या वर्तमान समय दिखाएं
    ATDA(y,m,d)   सिस्टम दिनांक को वर्ष/महीना/दिन में बदलें या वर्तमान दिनांक दिखाएं
    ATDS          RAS स्टैक डंप करें
    ATDT          बूट मॉड्यूल सामान्य क्षेत्र डंप करें
    ATDUx,y       पते x से y लंबाई के लिए मेमोरी सामग्री डंप करें
    ATWBx,y       पते x को 8-बिट मान y से लिखें
    ATWWx,y       पते x को 16-बिट मान y से लिखें
    ATWLx,y       पते x को 32-बिट मान y से लिखें
    ATRBx         पते x का 8-बिट मान प्रदर्शित करें
    ATRWx         पते x का 16-बिट मान प्रदर्शित करें
    ATRLx         पते x का 32-बिट मान प्रदर्शित करें
    ATGO(x)       एड्रेस x पर प्रोग्राम चलाएं या राउटर बूट करें
    ATGR          राउटर बूट करें
    ATGT          हार्डवेयर परीक्षण प्रोग्राम चलाएं
    AT%Tx         बूट अप पर हार्डवेयर परीक्षण प्रोग्राम सक्षम करें
    ATBTx         ब्लॉक0 लिखना सक्षम करें (1=सक्षम, अन्य=अक्षम)
    
    < जारी रखने के लिए कोई भी कुंजी दबाएं >
    ATRTw,x,y(,z) RAM परीक्षण स्तर w, पता x से y तक (z पुनरावृत्तियाँ)
    ATWEa(,b,c,d) MAC addr, देश कोड, EngDbgFlag, FeatureBit को फ्लैश ROM पर लिखें
    ATCUx         देश कोड फ्लैश ROM पर लिखें
    ATCB          फ्लैश ROM से वर्किंग बफर पर कॉपी करें
    ATCL          वर्किंग बफर साफ़ करें
    ATSB          वर्किंग बफर को फ्लैश ROM में सहेजें
    ATBU          वर्किंग बफर में निर्माता संबंधित डेटा डंप करें
    ATSH          ROM में निर्माता संबंधित डेटा डंप करें
    ATWMx         वर्किंग बफर में MAC पते के निचले 6 अंक सेट करें
    ATMHx         वर्किंग बफर में MAC पते के उच्च 6 अंक सेट करें
    ATBS          पासवर्ड जनरेटर का bootbase सीड दिखाएं
    ATLBx         xmodem अपलोड bootbase, x पासवर्ड है
    ATSMx         वर्किंग बफर में MAC पते के 6 अंक सेट करें
    ATCOx         वर्किंग बफर में देश कोड सेट करें
    ATFLx         वर्किंग बफर में EngDebugFlag सेट करें
    ATSTx         वर्किंग बफर में ROMRAS पता सेट करें
    ATSYx         वर्किंग बफर में सिस्टम प्रकार सेट करें
    ATVDx         वर्किंग बफर में विक्रेता नाम सेट करें
    ATPNx         वर्किंग बफर में उत्पाद नाम सेट करें
    ATFEx,y,...   वर्किंग बफर में सुविधा बिट्स सेट करें
    ATMP          memMapTab की जांच करें और डंप करें
    ATDOx,y       पते x से y लंबाई के लिए XMODEM के माध्यम से PC पर डाउनलोड करें
    
    < जारी रखने के लिए कोई भी कुंजी दबाएं >
    ATTD          XMODEM के माध्यम से PC पर राउटर कॉन्फ़िगरेशन डाउनलोड करें
    ATUPx,y       पते x से y लंबाई के लिए XMODEM के माध्यम से PC से RAM पर अपलोड करें
    ATUR          फ्लैश ROM पर राउटर फर्मवेयर अपलोड करें
    ATDC          फर्मवेयर अपलोड करने के दौरान हार्डवेयर संस्करण जांच अक्षम करें
    ATLC          फ्लैश ROM पर राउटर कॉन्फ़िगरेशन फ़ाइल अपलोड करें
    ATUXx(,y)     फ्लैश ब्लॉक x से y तक xmodem अपलोड
    ATERx,y       फ्लैश ROM को ब्लॉक x से y तक मिटाएं
    ATWFx,y,z     पते x से फ्लैश पते y पर डेटा कॉपी करें, लंबाई z
    ATXSx         xmodem चयन: x=0: CRC मोड (डिफ़ॉल्ट); x=1: चेकसम मोड
    ATLD          कॉन्फ़िगरेशन फ़ाइल और डिफ़ॉल्ट ROM फ़ाइल फ्लैश पर अपलोड करें
    ATBR              डिफ़ॉल्ट Romfile पर रीसेट करें
    ATCD          चल रही ROM फ़ाइल को फ्लैश में डिफ़ॉल्ट ROM फ़ाइल में कन्वर्ट करें
    
    OK
    

अंत में, हमें कमांड का एक पूरा नया सेट मिलता है जो हमें मेमोरी डंप करने की अनुमति देता है

root@kitploit:~
    
    
    $ ATMP
    

root@kitploit:~
    
    
    ROMIO इमेज bfc30000 पर शुरू होती है
    कोड संस्करण: 
    कोड प्रारंभ: 80008000
    कोड लंबाई: 1A5D4E
    memMapTab: 18 प्रविष्टियाँ, प्रारंभ = bfc44000, चेकसम = 9770
    $RAM अनुभाग:
      0: BootExt(RAMBOOT), प्रारंभ=80030000, लंबाई=18000
      1: HTPCode(RAMCODE), प्रारंभ=80048000, लंबाई=E0000
      2: RasCode(RAMCODE), प्रारंभ=80048000, लंबाई=420000
    $ROM अनुभाग:
      3: BootBas(ROMIMG), प्रारंभ=bfc28000, लंबाई=4000
      4: DbgArea(ROMIMG), प्रारंभ=bfc2c000, लंबाई=2000
      5: RomDir2(ROMDIR), प्रारंभ=bfc2e000, लंबाई=2000
      6: BootExt(ROMIMG), प्रारंभ=bfc30030, लंबाई=13FD0
      7: MemMapT(ROMMAP), प्रारंभ=bfc44000, लंबाई=C00
      8: HTPCode(ROMBIN), प्रारंभ=bfc44c00, लंबाई=8000
         (संपीड़ित)
         संस्करण: HTP_TC V 0.05, प्रारंभ: bfc44c30
         लंबाई: 10488, चेकसम: CB32
         संपीड़ित लंबाई: 41CF, चेकसम: D5A5
      9: termcap(ROMIMG), प्रारंभ=bfc4cc00, लंबाई=400
     10: RomDefa(ROMIMG), प्रारंभ=bfc4d000, लंबाई=2000
     11: LedDefi(ROMIMG), प्रारंभ=bfc4f000, लंबाई=400
     12: LogoImg(ROMIMG), प्रारंभ=bfc4f400, लंबाई=2000
     13: LogoImg2(ROMIMG), प्रारंभ=bfc51400, लंबाई=2000
     14: StrImag(ROMIMG), प्रारंभ=bfc53400, लंबाई=32000
     15: StrImag2(ROMIMG), प्रारंभ=bfc85400, लंबाई=32000
     16: Rt11nE2p(ROMIMG), प्रारंभ=bfcb7400, लंबाई=400
     17: RasCode(ROMBIN), प्रारंभ=bfcb7800, लंबाई=246C00
         (संपीड़ित)
         संस्करण: ADSL ATU-R, प्रारंभ: bfcb7830
         लंबाई: 321D2C, चेकसम: 582D
         संपीड़ित लंबाई: 11E54B, चेकसम: B30B
    $USER अनुभाग:
    Msecs   128
    Heap0   16   300 16
    Heap1   32   64  4
    Heap2   64   64  4
    Heap3   128  160 4
    Heap4   192  256 4
    Heap5   256  80  4
    Heap6   320  20   4
    Heap7   384  4   2
    Heap8   448  20  2
    Heap9   512  34  2
    Heap10  1024 52  4
    Heap11  2048 20  2
    Heap12  3172 4   2
    Heap13  4096 2   2
    Heap14  0 0
    ...
    

हमने अभी जो सीखा वह हमें पहले निकाली गई रॉम फ़ाइलों का विश्लेषण करने में मदद करेगा

root@kitploit:~
    
    
    कोड प्रारंभ: 80008000
    कोड लंबाई: 1A5D4E
    

अब हम निम्न का उपयोग करके एक नई रॉम फ़ाइल डंप करने के बाद **ROM प्रारंभ पता** और **लोडिंग पता** को **0x80008000** पर सेट कर सकते हैं:

root@kitploit:~
    
    
    $ ATDO 80008000, 1A5D4E
    

हम जानते हैं कि **ATGR** राउटर को बूट करता है, इसलिए हम फर्मवेयर के दूसरे भाग में नियंत्रण पास करने वाले निर्देशों को खोजने के लिए इसका अनुरेखण कर सकते हैं।

atgr1

root@kitploit:~
    
    
    ROM:80011E8C loc_80011E8C:            # CODE XREF: LoadAndRunImage+D8j
    ROM:80011E8C                 jal     sub_80009B24
    ROM:80011E90                 li      $a0, 0x1F4
    ROM:80011E94
    ROM:80011E94 execute_image:           # इमेज निष्पादित करें
    ROM:80011E94                 jalr    $s0        # $s0 में पते पर कूदें और लिंक करें
    ROM:80011E98                 nop
    

अब हमें पूछना होगा कि $s0 पर संग्रहीत पता क्या है? जाहिर है कि हम अभी भी ब्रेकपॉइंट सेट नहीं कर सकते हैं, हम रजिस्टर नहीं देख सकते हैं, इसलिए हमें किसी तरकीब का उपयोग करके इसे लीक करने की आवश्यकता है। सौभाग्य से, हम मेमोरी पढ़ और लिख सकते हैं, निम्नलिखित कमांड पर एक नज़र डालें:

root@kitploit:~
    
    
    ATWL 80011E94, ae30001c
    ATGR
    

यह कैसा दिखता है, यह कमांड **0x80011E94** पर निर्देश को **ae30001c** (MIPS **sw $s0, 0x1C($s1)** निर्देश का बाइट प्रतिनिधित्व) से पैच करता है। मूल **jalr $s0** को **sw $s0, 0x1C($s1)** से ओवरराइट करके हमने प्रोग्राम को **$s0** रजिस्टर की सामग्री को **0x8001FF1C** मेमोरी पते पर संग्रहीत करने के लिए मजबूर किया है। तो अब दूसरे चरण का फर्मवेयर निष्पादित नहीं होगा, इसके बजाय "ERROR" संदेश प्रस्तुत किया जाएगा और हमारे पास अभी भी पहले चरण के कंसोल तक पहुंच होगी, वाह! तो आइए देखें कि **0x8001FF1C** पर क्या संग्रहीत किया गया था।

root@kitploit:~
    
    
    ATRL 8001FF1C
    8001FF1C: 80020000
    

पकड़ लिया! ... **0x80020000** का उपयोग करके हम फर्मवेयर के दूसरे भाग को डंप कर सकते हैं और ठीक से विश्लेषण कर सकते हैं

जारी रहेगा ...