donfanning/mips-cve-2014-9222Lass uns Spaß haben, indem wir in die Firmware eines Zyxel-Routers und die MIPS-Architektur eintauchen.
Tutorials dienen ausschließlich Informations- und Bildungszwecken. Ich bin der Meinung, dass ethisches Hacken, Informationssicherheit und Cybersicherheit vertraute Themen für jeden sein sollten, der digitale Informationen und Computer nutzt. Ich bin der Meinung, dass es unmöglich ist, sich vor Hackern zu schützen, ohne zu wissen, wie Hacker vorgehen.
$ IDA Pro +7.0 (Sie können Radar2 verwenden, da IDA recht teuer ist)
$ Router mit Rompager 4.07 : Es gibt eine immense Anzahl davon, z. B. TP-Link TD-W8951*, ZyXEL P-660R, Billion BiPAC 51**/52**
$ UART auf USB
Die Misfortune-Cookie-Sicherheitslücke existiert schon eine Weile, aber es fehlt immer noch eine öffentlich zugängliche Analyse, die die technischen Details der Schwachstelle darstellt. Laut Check Point ist die betroffene Software der eingebettete Webserver RomPager von AllegroSoft. Internetweite Scans deuten darauf hin, dass RomPager gemessen an der Anzahl der verfügbaren Endpunkte wahrscheinlich die am weitesten verbreitete Webserver-Software der Welt ist. RomPager ist typischerweise in der Firmware eingebettet, die mit dem Gerät ausgeliefert wird. Diese spezifische Schwachstelle wurde im Jahr 2002 in den Code eingeführt. Darüber hinaus sind die Geräte betroffen, die RomPager-Dienste mit Versionen vor 4.34 (und insbesondere 4.07) verwenden.
Für dieses Tutorial verwende ich einen ZXHN H108L, der Rompager 4.07 verwendet.
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic realm="ZXHN H108L"
Content-Type: text/html
Transfer-Encoding: chunked
Server: RomPager/4.07 UPnP/1.0
EXT:
Jetzt nutzen wir die serielle Schnittstelle. Zuerst müssen wir die Baudrate ermitteln.
$ sudo stty -F /dev/ttyUSB0
AUSGABE:
speed 115200 baud; line = 0;
-brkint -imaxbel
Gerät
Ich verwende minicom, du kannst alles von screen bis HyperTerminal verwenden, aber ich bevorzuge dieses wegen seiner Stabilität ;)
$ sudo minicom -s
+-----------------------------------------------------------------------+
| A - Serielles Gerät : /dev/modem |
| B - Lockfile-Speicherort : /var/lock |
| C - Anrufprogramm : |
| D - Anrufausgabeprogramm : |
| E - Bps/Par/Bits : 115200 8N1 |
| F - Hardware-Flusskontrolle : Nein |
| G - Software-Flusskontrolle : Nein |
| |
| Welche Einstellung ändern? |
+-----------------------------------------------------------------------+
| Bildschirm und Tastatur |
| Setup als dfl speichern |
| Setup als... speichern |
| Beenden |
| Minicom beenden |
+------------------------------+
Jetzt kann es losgehen:
$ sudo minicom -D /dev/ttyUSB0 -b 115200
Bootbase Version: VTC_SPI1.26 | 2012/12/26 16:00:00
RAM: Größe = 8192 Kbytes
SPI Flash 2MiB GD25Q16 bei 0xbfc00000 gefunden
SPI Flash Quad Enable
Quad-Modus ausschalten
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
Drücke innerhalb von 3 Sekunden eine beliebige Taste, um den Debug-Modus zu aktivieren.
..........
Um mögliche Befehle anzuzeigen:
$ ATHE
======= Debug-Befehlsliste =======
AT einfach OK antworten
ATHE Hilfe anzeigen
ATBAx Baudrate ändern. 1:38.4k, 2:19.2k, 3:9.6k 4:57.6k 5:115.2k
ATENx,(y) BootExtension Debug-Flag setzen (y=Passwort)
ATSE den Seed des Passwortgenerators anzeigen
ATTI(h,m,s) Systemzeit auf Stunde:Minute:Sekunde ändern oder aktuelle Zeit anzeigen
ATDA(y,m,d) Systemdatum auf Jahr/Monat/Tag ändern oder aktuelles Datum anzeigen
ATDS RAS-Stack ausgeben
ATDT Boot Module Common Area ausgeben
ATDUx,y Speicherinhalt ab Adresse x mit Länge y ausgeben
ATRBx 8-Bit-Wert von Adresse x anzeigen
ATRWx 16-Bit-Wert von Adresse x anzeigen
ATRLx 32-Bit-Wert von Adresse x anzeigen
ATGO(x) Programm bei Adresse x ausführen oder Router booten
ATGR Router booten
ATGT Hardware-Testprogramm ausführen
ATRTw,x,y(,z) RAM-Teststufe w, von Adresse x bis y (z Iterationen)
ATSH Herstellerbezogene Daten im ROM ausgeben
ATDOx,y Download von Adresse x mit Länge y zum PC via XMODEM
ATTD Routerkonfiguration zum PC via XMODEM herunterladen
ATUR Router-Firmware in Flash-ROM hochladen
< Drücke eine beliebige Taste zum Fortfahren >
Diese Firmware verfügt über eine Reihe versteckter Befehle, die für unsere dynamische Analyse sehr nützlich sind. Das Problem ist, dass wir die Register nicht sehen und keine Breakpoints setzen können, aber hoffentlich werden wir diese Funktionen mit diesen versteckten Befehlen haben. Um sie zu sehen und zu nutzen, müssen wir ATEN verwenden. Dieser Befehl erfordert jedoch ein Passwort. Was können wir also jetzt tun? Lassen Sie uns die Firmware reverse engineeren, um den Algorithmus des Passwortgenerators zu finden.
(Statische Analyse) Schauen wir uns zuerst die Firmware-Datei an:
$ binwalk ras
binwalk1
$ 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
Schauen wir uns nun die Signatur in den extrahierten Dateien an:
$ binwalk -Y rom1
DECIMAL HEXADECIMAL BESCHREIBUNG
--------------------------------------------------------------------------------
0 0x0 MIPS ausführbarer Code, 32/64-Bit, Big Endian, mindestens 1250 gültige Anweisungen
string ist ein großartiges Werkzeug, um eine Vorstellung davon zu bekommen, was eine Binärdatei ist oder was sie enthält. Mal sehen, ob wir den Passwortalgorithmus finden können:
$ strings rom1 | grep -i aten
$ strings rom2 | grep -i aten
Anscheinend können wir ihn nicht sehen, da die Firmware noch komprimiert ist. Das bedeutet, dass wir sie mit dem Debug-Modus aus dem Router auslesen müssen:
$ ATDO bfc00000, 1f0000
xmodem
Das erste, was mir in den Sinn kommt, ist, nach einer Dispatch-Tabelle zu suchen. Warum? Nur Intuition, die einzige Alternative ist if-elif, aber das wäre eine lange Liste davon, um die Gültigkeit des vom Benutzer bereitgestellten Passworts zu überprüfen. Und hier ist, was ich gefunden habe:
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 # " just answer 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 # " print help"
ROM:800158C0 .word aAtba # "ATBA"
ROM:800158C4 .word CMD_ATBA
...
ROM:800158D0 .word aAten # "ATEN"
ROM:800158D4 .word CMD_ATEN
Beachten Sie, dass ein MIPS-Wort 4 Bytes groß ist. Schauen wir uns nun CMD_ATEN an:
ROM:8000FF84 lw $a0, 8($s0)
ROM:8000FF88 jal sub_80013654
ROM:8000FF8C li $a1, 0
ROM:8000FF90 jal passwd_generator
und jetzt: passwd_generator
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) # nimm den Seed-Teil, generiert durch den ATSE-Befehl
ROM:80010A3C lbu $t8, 0x6D($t8) # nimm das letzte Byte der MAC-Adresse
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 # springe, wenn $t6 != 0
ROM:80010A70 srl $t6, $t9, 1 # $t6 = $t9 >> 1
ROM:80010A74 jr $ra # alles erledigt, aussteigen
ROM:80010A78 xor $v0, $t9, $v1 # $v0 = $t9 ^ $v1
Was wir daraus schließen können:
Jetzt erstellen wir ein C-Programm, das dasselbe tut, und kompilieren es:
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;
}
Jetzt führen wir ATSE aus, um den Seed zu erhalten, und verwenden ihn (zum Beispiel: ich habe 088521A78838 erhalten):
$ ./gen_pass 088521A78838
Lassen Sie uns den magischen Befehl ausführen, den wir gerade geknackt haben :p
$ ATEN1, A12F5AC6
ATEN1, A12F5AC6
OK
ATHE
======= Debug-Befehlsliste =======
AT einfach OK antworten
ATHE Hilfe anzeigen
ATBAx Baudrate ändern. 1:38.4k, 2:19.2k, 3:9.6k 4:57.6k 5:115.2k
ATENx,(y) BootExtension Debug-Flag setzen (y=Passwort)
ATSE den Seed des Passwortgenerators anzeigen
ATTI(h,m,s) Systemzeit auf Stunde:Minute:Sekunde ändern oder aktuelle Zeit anzeigen
ATDA(y,m,d) Systemdatum auf Jahr/Monat/Tag ändern oder aktuelles Datum anzeigen
ATDS RAS-Stack ausgeben
ATDT Boot Module Common Area ausgeben
ATDUx,y Speicherinhalt ab Adresse x mit Länge y ausgeben
ATWBx,y Adresse x mit 8-Bit-Wert y beschreiben
ATWWx,y Adresse x mit 16-Bit-Wert y beschreiben
ATWLx,y Adresse x mit 32-Bit-Wert y beschreiben
ATRBx 8-Bit-Wert von Adresse x anzeigen
ATRWx 16-Bit-Wert von Adresse x anzeigen
ATRLx 32-Bit-Wert von Adresse x anzeigen
ATGO(x) Programm bei Adresse x ausführen oder Router booten
ATGR Router booten
ATGT Hardware-Testprogramm ausführen
AT%Tx Hardware-Testprogramm beim Booten aktivieren
ATBTx Block0-Schreibaktivierung (1=aktivieren, andere=deaktivieren)
< Drücke eine beliebige Taste zum Fortfahren >
ATRTw,x,y(,z) RAM-Teststufe w, von Adresse x bis y (z Iterationen)
ATWEa(,b,c,d) MAC-Adresse, Ländercode, EngDbgFlag, FeatureBit in Flash-ROM schreiben
ATCUx Ländercode in Flash-ROM schreiben
ATCB von FLASH-ROM in Arbeitspuffer kopieren
ATCL Arbeitspuffer löschen
ATSB Arbeitspuffer in FLASH-ROM speichern
ATBU Herstellerbezogene Daten im Arbeitspuffer ausgeben
ATSH Herstellerbezogene Daten im ROM ausgeben
ATWMx Niedrige 6 Ziffern der MAC-Adresse im Arbeitspuffer setzen
ATMHx Hohe 6 Ziffern der MAC-Adresse im Arbeitspuffer setzen
ATBS Bootbase-Seed des Passwortgenerators anzeigen
ATLBx Xmodem-Upload auf Bootbase, x ist Passwort
ATSMx 6 Ziffern der MAC-Adresse im Arbeitspuffer setzen
ATCOx Ländercode im Arbeitspuffer setzen
ATFLx EngDebugFlag im Arbeitspuffer setzen
ATSTx ROMRAS-Adresse im Arbeitspuffer setzen
ATSYx Systemtyp im Arbeitspuffer setzen
ATVDx Herstellername im Arbeitspuffer setzen
ATPNx Produktname im Arbeitspuffer setzen
ATFEx,y,... Feature-Bits im Arbeitspuffer setzen
ATMP memMapTab überprüfen und ausgeben
ATDOx,y Download von Adresse x mit Länge y zum PC via XMODEM
< Drücke eine beliebige Taste zum Fortfahren >
ATTD Routerkonfiguration zum PC via XMODEM herunterladen
ATUPx,y Upload zu RAM-Adresse x mit Länge y vom PC via XMODEM
ATUR Router-Firmware in Flash-ROM hochladen
ATDC Hardware-Versionsprüfung während des Firmware-Uploads deaktivieren
ATLC Router-Konfigurationsdatei in Flash-ROM hochladen
ATUXx(,y) Xmodem-Upload von Flash-Block x nach y
ATERx,y Flash-ROM von Block x bis y löschen
ATWFx,y,z Daten von Adresse x zu Flash-Adresse y mit Länge z kopieren
ATXSx Xmodem-Auswahl: x=0: CRC-Modus (Standard); x=1: Prüfsummenmodus
ATLD Konfigurationsdatei und Standard-ROM-Datei in Flash hochladen
ATBR Auf Standard-ROM-Datei zurücksetzen
ATCD Laufende ROM-Datei in Standard-ROM-Datei im Flash konvertieren
OK
Endlich erhalten wir einen völlig neuen Befehlssatz, der es uns ermöglicht, den Speicher auszulesen.
$ ATMP
ROMIO-Image startet bei bfc30000
Code-Version:
Code-Start: 80008000
Code-Länge: 1A5D4E
memMapTab: 18 Einträge, Start = bfc44000, Prüfsumme = 9770
$RAM-Abschnitt:
0: BootExt(RAMBOOT), Start=80030000, Länge=18000
1: HTPCode(RAMCODE), Start=80048000, Länge=E0000
2: RasCode(RAMCODE), Start=80048000, Länge=420000
$ROM-Abschnitt:
3: BootBas(ROMIMG), Start=bfc28000, Länge=4000
4: DbgArea(ROMIMG), Start=bfc2c000, Länge=2000
5: RomDir2(ROMDIR), Start=bfc2e000, Länge=2000
6: BootExt(ROMIMG), Start=bfc30030, Länge=13FD0
7: MemMapT(ROMMAP), Start=bfc44000, Länge=C00
8: HTPCode(ROMBIN), Start=bfc44c00, Länge=8000
(Komprimiert)
Version: HTP_TC V 0.05, Start: bfc44c30
Länge: 10488, Prüfsumme: CB32
Komprimierte Länge: 41CF, Prüfsumme: D5A5
9: termcap(ROMIMG), Start=bfc4cc00, Länge=400
10: RomDefa(ROMIMG), Start=bfc4d000, Länge=2000
11: LedDefi(ROMIMG), Start=bfc4f000, Länge=400
12: LogoImg(ROMIMG), Start=bfc4f400, Länge=2000
13: LogoImg2(ROMIMG), Start=bfc51400, Länge=2000
14: StrImag(ROMIMG), Start=bfc53400, Länge=32000
15: StrImag2(ROMIMG), Start=bfc85400, Länge=32000
16: Rt11nE2p(ROMIMG), Start=bfcb7400, Länge=400
17: RasCode(ROMBIN), Start=bfcb7800, Länge=246C00
(Komprimiert)
Version: ADSL ATU-R, Start: bfcb7830
Länge: 321D2C, Prüfsumme: 582D
Komprimierte Länge: 11E54B, Prüfsumme: B30B
$USER-Abschnitt:
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
...
Was wir gerade gelernt haben, wird uns helfen, die ROM-Dateien zu analysieren, die wir zuvor extrahiert haben.
Code-Start: 80008000
Code-Länge: 1A5D4E
Jetzt können wir die ROM-Startadresse und die Ladeadresse auf 0x80008000 setzen, nachdem wir eine neue ROM-Datei mit folgendem Befehl ausgelesen haben:
$ ATDO 80008000, 1A5D4E
Wir wissen, dass ATGR den Router bootet. Was wir also tun könnten, ist, es zu verfolgen, um die Anweisungen zu finden, die die Ausführung an den zweiten Teil der Firmware übergeben.
atgr1
ROM:80011E8C loc_80011E8C: # CODE XREF: LoadAndRunImage+D8j
ROM:80011E8C jal sub_80009B24
ROM:80011E90 li $a0, 0x1F4
ROM:80011E94
ROM:80011E94 execute_image: # Bild ausführen
ROM:80011E94 jalr $s0 # springe und verlinke zur Adresse in $s0
ROM:80011E98 nop
Jetzt müssen wir fragen, welche Adresse in $s0 gespeichert ist? Offensichtlich können wir immer noch keinen Breakpoint setzen, wir können die Register nicht einsehen, also müssen wir sie mit einem Trick preisgeben. Glücklicherweise können wir Speicher lesen und schreiben. Schauen Sie sich den folgenden Befehl an:
ATWL 80011E94, ae30001c
ATGR
Wie es scheint, patcht dieser Befehl die Anweisung bei 0x80011E94 mit ae30001c (der Byte-Darstellung der MIPS-Anweisung sw $s0, 0x1C($s1)). Durch das Überschreiben des ursprünglichen jalr $s0 mit sw $s0, 0x1C($s1) haben wir das Programm gezwungen, den Inhalt des Registers $s0 an der Speicheradresse 0x8001FF1C zu speichern. Jetzt wird die Firmware der zweiten Stufe nicht ausgeführt, stattdessen wird die "ERROR"-Meldung angezeigt, und wir haben immer noch Zugriff auf die Konsole der ersten Stufe. Hurra! Schauen wir uns also an, was bei 0x8001FF1C gespeichert wurde.
ATRL 8001FF1C
8001FF1C: 80020000
Erwischt! ... Mit 0x80020000 können wir den zweiten Teil der Firmware auslesen und richtig analysieren.
Wird fortgesetzt ...