ghidra_kernelcache: un framework Ghidra per kernelcache iOS per il reverse engineering

Questo framework è il prodotto finale della mia esperienza nel reverse engineering dei kernelcache. Di solito cerco vulnerabilità controllando manualmente il kernel e le sue estensioni e ho automatizzato la maggior parte delle cose che volevo vedere in Ghidra per velocizzare il processo di reverse engineering, e questo si è dimostrato efficace e fa risparmiare molto tempo. Il framework funziona su iOS 12/13/14/15 e su macOS 11/12 (sia kernelcache che singolo KEXT) ed è stato reso pubblico con l'intenzione di aiutare le persone a iniziare a fare ricerca sul kernel iOS senza la fatica di preparare il proprio ambiente. Secondo me, questo framework (incluso il set di strumenti che fornisce e con una conoscenza di base di IOKit) è sufficiente per iniziare a fare hacking nel Kernelcache.

Il framework è interamente scritto in Python e può essere esteso per costruire altri strumenti; fornisce alcune API di base che puoi usare in quasi tutti i progetti e risparmiare tempo leggendo il manuale verboso. Sei invitato a leggere le funzionalità principali nella directory utils/.

Ghidra è bravo nell'analisi dei kernelcache, ma come altri strumenti di reverse engineering richiede un po' di lavoro manuale. ghidra_kernelcache fornisce un buon punto di partenza per sistemare le cose all'inizio e anche durante il reverse engineering, fornendo quindi un output del decompilatore di bell'aspetto.

Esiste un progetto simile realizzato da @_bazad in IDAPro chiamato ida_kernelcache che fornisce un buon punto di partenza per i ricercatori che vogliono lavorare con l'immagine del kernel in IDA. Il mio framework assomiglia un po' al lavoro di Brandon e va oltre fornendo molte più funzionalità per rendere meno doloroso il processo di lavoro con il kernelcache.

Caratteristiche :

• Simbolizzazione del kernelcache *OS.
• Ricostruzione della gerarchia delle classi C++ e delle tabelle virtuali.
• Riferimenti a chiamate di metodi virtuali.
• Correzione automatica della tabella di dispatch dei metodi esterni sia per ::externalMethod() che per ::getTargetAndMethodForIndex().
• Applicazione di namespace ai metodi di classe.
• Propagazione di nomi di simboli e tipi sugli argomenti delle funzioni.
• Applicazione di firme di funzioni per funzioni note del kernel.
• Importazione di strutture e classi vecchie da un progetto vecchio a un progetto nuovo.

Queste caratteristiche sono realizzate come strumenti separati che possono essere eseguiti tramite scorciatoie da tastiera o facendo clic sulle loro icone nella barra degli strumenti.

Installazione

Clona il repository :```sh git clone https://github.com/0x36/ghidra_kernelcache.git

**Nota importante**: Il progetto è stato testato su Ghidra 10.1_PUBLIC e 10.2_DEV e non è retrocompatibile.

Vai su *`Windows → Script Manager`,*  clicca su  *`script Directory` ,* quindi aggiungi *`ghidra_kernelcache`* all'elenco dei percorsi delle directory.
Vai su *`Windows → Script Manager`,* nell'elenco degli *scripts*, vai alla categoria *`iOS→kernel`* e seleziona i plugin che vedi lì; appariranno nella barra degli strumenti di GHIDRA .

nella directory [logos/](https://github.com/0x36/ghidra_kernelcache/tree/master/logos), puoi inserire i tuoi loghi per ogni strumento.

## Simbolizzazione del kernelcache iOS

`ghidra_kernelcache` richiede nella prima fase [iometa](https://github.com/Siguza/iometa/) (realizzato da [@s1guza](https://twitter.com/s1guza)), un potente strumento che fornisce informazioni sulle classi C++ nel binario del kernel. La cosa grandiosa è che funziona come binario autonomo, quindi l'output può essere importato nel tuo framework di reverse engineering preferito semplicemente analizzandolo. Il mio framework prende l'output di iometa e lo analizza per simbolizzare e correggere le tabelle virtuali.

### Utilizzo

Dopo aver decompresso il kernel, esegui i seguenti comandi :```sh
$ iometa -n -A /tmp/kernel A10-legacy.txt > /tmp/kernel.txt
# if you want also to symbolicate using jtool2
$ jtool2 --analyze /tmp/kernel

Carica il kernelcache in Ghidra, NON USARE l'importazione BATCH, caricalo come immagine Mach-O. Dopo che il kernelcache è stato caricato e analizzato automaticamente, fai clic sull'icona mostrata nella barra degli strumenti o premi Meta-Shift-K, quindi inserisci il percorso completo dell'output di iometa che, nel nostro caso, è /tmp/kernel.txt.

Se vuoi utilizzare i simboli di jtool2, puoi usare anche jsymbol.py situato nella categoria iOS→kernel.

API del kernelcache iOS

Esempi completi dell'API sono in ghidra_kernelcache/kc.py

→ Ecco alcuni esempi di manipolazione di oggetti classe:```py from utils.helpers import * from utils.class import * from utils.iometa import ParseIOMeta

ff = "/Users/mg/ghidra_ios/kernel.txt" iom = ParseIOMeta(ff) Obj = iom.getObjects() kc = kernelCache(Obj)

symbolicate the kernel

kc.process_all_classes()

symbolicate the classes under com.apple.iokit.IOSurface bundle

kc.process_classes_for_bundle("com.apple.iokit.IOSurface")

symbolicate the classes under kernel bundle

kc.process_classes_for_bundle("kernel")

Process one class (including its parents)

kc.process_class("IOGraphicsAccelerator2")

Clears the content of the class structures (vtables are excluded)

kc.clear_class_structures()

Overwrite the old vtable structure definition and resymbolicate it again

kc.update_classes_vtable()

Reconstructing function call trees by enumerating all pac references and find their corresponding virtual method call

kc.explore_pac()

Come puoi vedere, puoi simbolizzare completamente o parzialmente il kernelcache; se viene scelta la simbolizzazione parziale, `ghidra_kernelcache` costruirà automaticamente tutte le dipendenze delle classi prima di procedere.
Se esegui lo script sull'intero kernelcache (simbolizzazione completa), `ghidra_kernelcache` impiegherà diversi minuti per analizzare l'immagine del kernel.

Una volta terminato, Ghidra fornirà quanto segue:

→ Una nuova categoria è stata aggiunta in Bookmark Filter chiamata "iOS":

<img src="https://raw.githubusercontent.com/0x36/ghidra_kernelcache/master/screenshots/image1.png" alt="image1" width="200"/>
                    
                    
→ Le tabelle virtuali delle classi IOKit vengono aggiunte al segnalibro 'iOS' per una ricerca delle tabelle virtuali più rapida e semplice; puoi semplicemente cercare un kext o una classe inserendo lettere, parole o il bundle del kext nella barra di ricerca.

<img src="https://raw.githubusercontent.com/0x36/ghidra_kernelcache/master/screenshots/image2.png" alt="image2"/>


→ Correzione della tabella virtuale: disassembla/compila codice sconosciuto, corregge i namespace, risimbolizza i metodi della classe e applica la definizione di funzione a ciascun metodo:

<img src="https://raw.githubusercontent.com/0x36/ghidra_kernelcache/master/screenshots/image3.png" alt="image3"/>

→ Creazione dei namespace delle classi e inserimento di ciascun metodo nel proprio namespace corrispondente:

<img src="https://raw.githubusercontent.com/0x36/ghidra_kernelcache/master/screenshots/image4.png" alt="image4"/>

→ Creazione della struttura della classe rispettando la gerarchia delle classi:

<img src="https://raw.githubusercontent.com/0x36/ghidra_kernelcache/master/screenshots/image5.png" alt="image5"/>

→ Creazione delle vtable delle classi, e ciascun metodo ha la propria definizione di metodo per un miglior output di decompilazione:

<img src="https://raw.githubusercontent.com/0x36/ghidra_kernelcache/master/screenshots/image6.png" alt="image6"/>

L'implementazione completa si trova in [`utils/class.py.`](https://github.com/0x36/ghidra_kernelcache/blob/master/utils/class.py)