xenokovah/inteltxe-pocIntel Management Engine JTAG Prova di concetto - Istruzioni 2022
Tutte le informazioni sono fornite solo a scopo educativo. Segui queste istruzioni a tuo rischio. Né gli autori né il loro datore di lavoro sono responsabili per danni diretti o consequenziali o perdite derivanti da qualsiasi persona o organizzazione che agisca o non agisca sulla base delle informazioni contenute in questa pagina.
Introduzione
Software richiesto
Generazione del payload
Generazione del token di sblocco
Preparazione dell'immagine SPI Flash
Integrazione dei file nell'immagine del firmware
Disattivazione della firma OEM
Creazione dell'immagine del firmware
BringUP della CPU principale
Scrittura dell'immagine sulla SPI Flash
Preparazione del cavo USB di debug
Applicazione delle patch ai file di configurazione OpenIPC
Decifratura dei file di configurazione OpenIPC
Aggiunta del core LMT alla configurazione
Impostazione della variabile d'ambiente IPC_PATH
Esecuzione di un controllo iniziale del funzionamento del JTAG
Mostra thread CPU ME
Arresto dei core
Debug di ME: Avvio rapido
Lettura di memoria arbitraria
Lettura della ROM
Perché TXE?
Elenco delle piattaforme testate
Autori
Licenza
La vulnerabilità INTEL-SA-00086 consente di attivare il JTAG per il core Intel Management Engine. Abbiamo sviluppato la nostra [PoC JTAG][8] per la piattaforma Gigabyte Brix GP-BPCE-3350C. Sebbene raccomandiamo ai potenziali ricercatori di utilizzare la stessa piattaforma, anche le piattaforme di altri produttori con il chipset Intel Apollo Lake dovrebbero supportare la PoC (per la versione TXE 3.0.1.1107).
Poiché la Gigabyte Brix GP-BPCE-3350C non è più ampiamente disponibile in commercio, queste istruzioni sono state aggiornate per puntare invece alla AAEON UP Squared SKU UPS-APLX7-A20-0864 (Intel Atom® x7-E3950). Se acquisti questa scheda, assicurati di procurarti anche l'alimentatore, l'adattatore seriale e un qualsiasi adattatore USB-to-serial. Inoltre, la UP Squared necessita solo di un cavo USB di debug di base per eseguire il debug DCI. Il cavo USB di debug deve essere collegato alla porta in cui è mostrato il cavo USB giallo qui.
La vulnerabilità INTEL-SA-00086 comporta un buffer overflow nella gestione di un file archiviato su MFS (il [file system interno di ME][6]). Il percorso completo del file è /home/bup/ct. Dovrai integrare una versione di questo file che sfrutti la vulnerabilità nel firmware ME utilizzando Intel Flash Image Tool (FIT), uno degli Intel System Tools forniti da Intel agli OEM di hardware basati su chipset Intel PCH.
Le utility degli Intel System Tools per ME (TXE, SPS) non sono destinate agli utenti finali—quindi non puoi trovarle sul sito ufficiale Intel. Tuttavia, alcuni OEM le pubblicano come parte degli aggiornamenti software insieme ai driver di dispositivo. Quindi, per integrare la nostra PoC hai bisogno di "CSTXE System Tools v3", che puoi trovare qui.
Devi installare Intel System Studio per eseguire il debug JTAG. Nei nostri esperimenti originali abbiamo usato Intel System Studio 2018. Queste istruzioni sono state aggiornate per Intel System Studio 2020, che può essere ottenuto da qui.
La PoC punta alla versione 3.0.1.1107 del firmware Intel TXE. Il repository di immagini "CSTXE 3.0" presso i forum Win-Raid contiene la versione necessaria del firmware TXE.
Tutti i nostri script sono scritti in Python. Consigliamo di usare Python 2.7 Inoltre, gli script richiedono il pacchetto pycrypto. Per installare pycrypto, esegui il seguente comando:``` pip install pycrypto
## Esecuzione del debug x86 di base tramite DCI
Sebbene lo scopo di questa guida sia abilitare il debug JTAG nel ME tramite un exploit, è buona pratica effettuare prima un sanity check e assicurarsi di poter eseguire il debug JTAG normale della scheda UP Squared tramite DCI. AAEON non distribuisce più i propri BIOS con DCI abilitato, come dichiarato sui loro forum, poiché ciò portava a instabilità. (E le versioni del BIOS precedenti alla v5.0 che avevano DCI abilitato non funzioneranno più con l'hardware più recente, a causa di una modifica hardware del fornitore di DRAM.) Pertanto, per abilitare DCI JTAG su UP Squared, è necessario eseguire 3 passaggi:
1) Eseguire la patch binaria descritta da Satoshi Tanda [qui](https://forum.up-community.org/discussion/comment/12877#Comment_12877) (anche se dovrebbe dire di usare UEFITool 0.28, non 2.8).
2) Abilitare DCI tramite il menu di configurazione del BIOS premendo F7 all'avvio, inserendo la password UP predefinita (*upassw0rd*), dal menu principale scendendo fino a "CRB Setup" -> "CSB Chipset" -> "South Cluster Configuration" -> "Miscellaneous Configuration" -> "DCI Enable (HDCIEN)" e impostandola su enabled. Quindi uscire dal menu di setup del BIOS, salvare la modifica della configurazione e riavviare il sistema.
3) Aprire "C:\IntelSWTools\system_studio_2020\system_debugger_2020\target_indicator\bin\TargetIndicator.exe" e verificare che, quando il sistema è collegato alla UP Squared tramite il cavo di debug, venga visualizzato un indicatore blu che segnala che DCI è possibile, come quello qui sotto:
È quindi possibile avviare ":\Program Files (x86)\IntelSWTools\sw_dev_tools\system_debugger_2020\system_debug_legacy\xdb.bat", connettersi al target, interromperne l'esecuzione ed eseguire il single step per confermare di avere capacità di debug di base.
(Potete anche seguire la serie di blog di Alan Sguigna [qui](https://www.asset-intertech.com/resources/blog/2020/05/open-source-firmware-explorations-using-dci-on-the-aaeon-up-squared-board/) su come compilare la build di Debug del codice open source per questa piattaforma, che sarà debuggabile tramite DCI dal reset vector. Tuttavia, notare che a causa di una modifica hardware per la DRAM, questo codice compilato dai sorgenti non si avvierà più completamente sul nuovo hardware - si bloccherà invece all'avvio, come indicato [qui](https://forum.up-community.org/discussion/comment/12877). I manutentori di Intel TianoCore hanno rifiutato di correggere il problema.)
# Generazione del Payload
Eseguire lo script **me_exp_bxtp.py**:```
me_exp_bxtp.py -f <file_name>
Lo script genera i dati necessari e li esporta nel file specificato (indica il percorso completo del file oppure, nella directory corrente, semplicemente un nome, ct.bin di default). Questo file verrà utilizzato in seguito da FIT.
Esegui lo script utock_gen.py:``` utock_gen.py -f <file_name>
Lo script genera i dati necessari e li esporta nel file specificato (indicare il percorso completo oppure, nella directory corrente, semplicemente un nome, *utok.bin* di default). Questo file verrà utilizzato successivamente da *FIT*.
# Preparazione dell'immagine SPI Flash
## Integrazione del payload
Per integrare i file *ct.bin* e *utok.bin*, eseguire l'utility *FIT* (*fit.exe*) ottenuta da *CSTXE System Tools v3*. Prima utilizzarla per aprire l'immagine BIOS UP Squared che è stata abilitata per DCI (ad es. "UPA1AM61_DCI_Enabled.bin")
*FIT* estrae diverse sezioni dell'immagine SPI complessiva (SPI descriptor, firmware UEFI/BIOS, firmware Intel ME e Unlock Token) quando l'immagine viene aperta e le salva nella cartella *"nome_immagine"/Decomp* nella stessa directory locale di FIT.
Dopo aver fatto ciò, salvare il file di configurazione XML (ad es. in "UPA1AM61_DCI_Enabled.xml") e uscire da fit.exe.
Per effettuare il downgrade del firmware Intel TXE alla versione vulnerabile **3.0.1.1107**, è necessario sostituire il file <nome immagine>/Decomp/TXE Region.bin con il file "3.0.1.1107_B_PRD_RGN.bin". Questa operazione va eseguita rinominando il file originale in "TXE Region.bin.orig" e poi rinominando "3.0.1.1107_B_PRD_RGN.bin" in "TXE Region.bin".
Riaprire fit.exe e ricaricare la configurazione dal file XML salvato. Se il file è stato sostituito correttamente nel filesystem, nella voce "Intel(R) TXE Binary File" della scheda Flash Layout si dovrebbe vedere la versione indicata come 3.0.1.1107 invece di quella originale:
# Integrazione dei file exploit nell'immagine firmware
Ora dobbiamo indicare in *FIT* i file generati per */home/bup/ct* (**ct.bin**) e *Unlock Token* (**utok.bin**). Nella scheda *Debug* di *FIT* è possibile specificare il Trace Hub Binary e l'Unlock Token da integrare nel firmware. Dovrebbero essere i file che abbiamo già generato.
# Disabilitazione della firma OEM
Nella scheda Platform Protection è presente un hash della chiave pubblica OEM. Rimuoverlo inserendo 32 zeri:```
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Selezionare Build Settings
Per impostazione predefinita apparirà come segue:
Aggiornare l'impostazione: cambiare outimage.bin con lo stesso nome del file di input. Impostare inoltre "Enable Boot Guard warning message at build time" su No,
e "Verify manifest signing keys against the OEM Key Manifest" su No. Dovrebbe quindi apparire come segue:
Generare l'immagine selezionando Build Image nel menu Build.
Se tutto è stato eseguito correttamente fino a questo punto, il processo di build dovrebbe terminare con successo e FIT produrrà un messaggio di console simile al seguente:
È necessario attivare la modalità HAP affinché questo exploit funzioni. Il bit di indice 0 del byte all'offset +0x102 deve essere impostato manualmente a 1 tramite un editor esadecimale nel file di output generato da fit.exe:
Al termine del processo si dovrebbe ottenere un file simile al file di esempio fornito qui, anche se quest'ultimo è per la versione 5.2 del BIOS UP, mentre le istruzioni precedenti riguardano la versione 6.1.
Per scrivere l'immagine nella flash SPI, consigliamo vivamente di utilizzare un programmatore SPI (come il Dediprog SF600Plus).
Assicurarsi di eseguire il backup del firmware originale per poterlo ripristinare in caso di problemi!
Servirà un cavo di debug USB 3.0 per collegarsi alla piattaforma. È possibile acquistarne uno appositamente realizzato oppure assemblarne uno proprio partendo da un cavo USB 3.0 AM–AM isolando i contatti D+, D- e Vcc.
Intel sviluppa e fornisce agli utenti due pacchetti software che possono essere utilizzati per il debug JTAG delle piattaforme e della CPU principale: DAL (DFx Abstraction Layer) e OpenIPC. Sia DAL che OpenIPC fanno parte di Intel System Studio. Dopo l'installazione di Intel System Studio 2020, OpenIPC compare nella seguente directory:
Windows``` C:\IntelSWTools\system_studio_2020\tools\OpenIPC_1.2035.4868.100
La configurazione di *OpenIPC* è crittografata e non supporta il core TXE. Quindi decripta la configurazione e aggiungi una descrizione TXE.
## Decriptazione dei file di configurazione di OpenIPC
Per decriptare i file di configurazione, estrai la chiave dalla libreria *StructuredData* (*StructuredData_x64.dll*) in *OpenIPC/Bin* usando lo script [IDA Pro](https://www.hex-rays.com/products/ida/support/download_freeware.shtml) *openipc_key_extract.py*. Se lo script non funziona, puoi semplicemente aprire il file in IDA Pro, cercare la stringa "Logging.xml" e poi prendere i 16 byte successivi a essa, dopo il successivo allineamento. (Ci saranno 4 byte extra, e poi 4 zeri dopo i 16 byte che ti interessano.) Passa la chiave (nel nostro caso, *F820AD4F6CC2E9EE050C43DEBF631F59*) allo script *config_decryptor.py* con il percorso della directory OpenIPC.```
config_decryptor.py –k F820AD4F6CC2E9EE050C43DEBF631F59 –p C:\IntelSWTools\system_studio_2020\tools\OpenIPC_1.2035.4868.100
La versione fornita di OpenIPC non contiene le informazioni necessarie sul core TXE. Quindi dobbiamo applicare una patch (patch.diff) ai file di configurazione OpenIPC decifrati. Ecco come fare:``` patch -p2 < patch.diff
# Impostazione della variabile d'ambiente IPC_PATH
Dopo la decrittazione e l'applicazione della patch, imposta la variabile d'ambiente *IPC_PATH* sulla nuova directory *OpenIPC* in modo che *ipccli* utilizzi la versione modificata di *OpenIPC*. Ad esempio:
Windows```
set IPC_PATH=C:\IntelSWTools\system_studio_2020\tools\OpenIPC_1.2035.4868.100\Bin
L'activator blocca il caricamento successivo mantenendo il processo BUP in un ciclo dopo l'attivazione di JTAG. Dopo l'avvio, la piattaforma non mostrerà alcun segno di vita (il monitor non si accende, gli indicatori della tastiera non si illuminano e non viene emesso alcun suono POST del BIOS). Dovrai quindi verificare tramite il debug DCI che la piattaforma sia "bloccata" nel modulo BUP.
Come DAL, la libreria OpenIPC include un'interfaccia a riga di comando (CLI), scritta in Python e fornita come libreria per Python come parte di Intel System Studio, che può essere installata sul sistema con l'aiuto di pip. Il pacchetto di installazione per ipccli si trova al seguente percorso: Windows``` C:\IntelSWTools\system_studio_2020\system_debugger_2020\debugger\ipccli\ipccli-1.2035.1920.100-py2.py3-none-any.whl
Per installare ipccli, esegui il seguente comando console:```
pip install ipccli-1.2035.1920.100-py2.py3-none-any.whl
Una volta installato, ipccli è disponibile nel runtime della corrispondente versione di Python (quella da cui è stato invocato pip).
Per iniziare con OpenIPC, esegui i seguenti comandi nella console Python da un prompt dei comandi con privilegi di amministratore:```
import ipccli
ipc = ipccli.baseaccess()
Il meccanismo per connettersi alla piattaforma target tramite DCI si avvia, generando il seguente output sulla console:
Quando non viene stabilita alcuna connessione—ad esempio, se la piattaforma non è accesa o non è fisicamente collegata tramite DCI—i messaggi saranno simili ai seguenti:
Se la connessione *DCI* è riuscita, assicurati che il registro *PERSONALITY* del dispositivo *DFX_AGGRAGATOR* sia uguale a 3.
Il registro *PERSONALITY* ha un codice *IR* (*Instruction Register*) di *0x54*. Per leggerlo, esegui i seguenti comandi:```
dfx_agg = ipc.devs.mdu_dfx_agg_tap0
ipc.irdrscan(dfx_agg, 0x54, 32)
Ecco come dovrebbe apparire il risultato di quel comando:
Lo strumento ipccli include una documentazione HTML piuttosto dettagliata, che si trova in una cartella del pacchetto Python ipccli:``` \Lib\site-packages\ipccli\html\Index.html
## Mostra thread CPU ME
Se i passaggi precedenti sono stati eseguiti correttamente, quando viene effettuata una connessione alla piattaforma tramite *ipccli*, il core *TXE* è accessibile tramite *CSE Tap* e *ipccli* consente di accedervi applicando il seguente percorso *ipccli*:```
ipc.devs.cse_c0.threads[0]
Ma poiché il PoC blocca il caricamento della piattaforma finché la CPU principale non è inizializzata, i suoi core sono inaccessibili tramite JTAG e il core ME è accessibile tramite il seguente comando:``` ipc.threads[0]
## Arresto dei Core
Per arrestare le istruzioni del processore ME, esegui il seguente comando:```
me = ipc.devs.cse_c0.threads[0]
me.halt()
Per fermare le istruzioni del processore CPU, esegui il seguente comando:``` core = ipc.threads[0] core.halt()
La console mostra l'indirizzo logico dell'istruzione in cui è stato effettuato l'arresto.
## Lettura di Memoria Arbitraria
*OpenIPC* consente di leggere la memoria dopo l'arresto, ad esempio:```
ipc.threads[0].mem("0xf0080004P", 4)
Puoi specificare un indirizzo logico (sel:offset), un indirizzo lineare (modificatore L) o un indirizzo fisico (modificatore P).
L'agent di sistema ME (MISA) consente di ottenere l'indirizzo fisico iniziale della regione ROM, che include il vettore di reset ME. Puoi ottenere l'indirizzo ROM tramite il registro Hunit ROM Memory Base (HROMMB) all'offset 0xe20 MISA MMIO (0xf0000000P):
ROM risiede sempre da ROMBASE a 0xffffffff Per copiare la ROM in un file, esegui il seguente comando:``` ipc.threads[0].memsave("", "0xfffe0000p", 0x20001)
È importante specificare la dimensione come *0x20001*, anziché *0x20000* (altrimenti *OpenIPC* incontra problemi a causa di difficoltà con l'accesso a 64 bit, che non è possibile per il core ME a 32 bit). L'ultimo byte del file può essere scartato, poiché non fa parte della *ROM*.
# Perché TXE?
La piattaforma offre maggiori opportunità di debugging senza un adattatore [Intel CCA-SVT](https://designintools.intel.com/Silicon_View_Technology_Closed_Chassis_Adapter_p/itpxdpsvt.htm) speciale e consente di eseguire il debug delle prime fasi del core TXE tramite un normale *cavo di debug USB*.
## URL correlati:
[Intel ME: La via dell'analisi statica][4]
[Segreti di Intel DCI][5]
[Intel ME: Il file system flash spiegato][6]
[Come hackerare un computer spento o eseguire codice non firmato nell'Intel Management Engine][7]
[Dentro l'Intel Management Engine][8]
[Disabilitare Intel ME 11 tramite modalità non documentata][9]
## Elenco delle piattaforme testate
* Gigabyte Mini-PC Barebone (BRIX) GB-BPCE-3350C (rev:1.1, 1.2)
* Beelink M1
* [MinisForum N33](https://github.com/HackingThings/MinisForum_N33_JTAG) Mini PC - 2021
* UP Squared Intel Atom® x7-E3950 [SKU UPS-APLX7-A20-0864](https://up-shop.org/up-squared-series.html) - 2022
* UP 4000 Intel Atom® x7-E3950 [SKU UP-APL03X7F-A10-0464](https://up-shop.org/up4000series.html) - 2022
# Autori
Mark Ermolov ([@\_markel___][1])
Maxim Goryachy ([@h0t_max][2])
### Aggiornamento del README.md per Intel System Studio 2020 & hardware UP Squared
Xeno Kovah ([@XenoKovah][10])
# Team di ricerca
Mark Ermolov ([@\_markel___][1])
Maxim Goryachy ([@h0t_max][2])
Dmitry Sklyarov ([@_Dmit][3])
# Licenza
Copyright (c) 2018 Mark Ermolov, Maxim Goryachy presso Positive Technologies
Con la presente viene concessa, gratuitamente, a chiunque ottenga una copia di questo software e dei relativi file di documentazione (il "Software"), l'autorizzazione a trattare il Software senza restrizioni, inclusi, senza limitazione, i diritti di utilizzare, copiare, modificare, fondere, pubblicare, distribuire, concedere in sublicenza e/o vendere copie del Software, e a consentire alle persone a cui il Software è fornito di fare altrettanto, alle seguenti condizioni:L'avviso di copyright sopra riportato e il presente avviso di autorizzazione devono essere inclusi in tutte le copie o parti sostanziali del Software.
IL SOFTWARE È FORNITO "COSÌ COM'È", SENZA GARANZIA DI ALCUN TIPO, ESPRESSA O IMPLICITA, INCLUDENDO, SENZA LIMITAZIONE, LE GARANZIE DI COMMERCIABILITÀ, IDONEITÀ A UN PARTICOLARE SCOPO E NON VIOLAZIONE. IN NESSUN CASO GLI AUTORI O I TITOLARI DEL COPYRIGHT SARANNO RESPONSABILI PER QUALSIASI RECLAMO, DANNO O ALTRA RESPONSABILITÀ, SIA IN UN'AZIONE DI CONTRATTO, ILLECITO O ALTRO, DERIVANTE DA, FUORI O IN CONNESSIONE CON IL SOFTWARE O L'USO O ALTRE OPERAZIONI NEL SOFTWARE.
[1]: https://twitter.com/_markel___
[2]: https://twitter.com/h0t_max
[3]: https://twitter.com/_Dmit
[4]: https://www.troopers.de/troopers17/talks/772-intel-me-the-way-of-the-static-analysis/
[5]: http://conference.hitb.org/hitbsecconf2017ams/sessions/commsec-intel-dci-secrets/
[6]: https://www.blackhat.com/docs/eu-17/materials/eu-17-Sklyarov-Intel-ME-Flash-File-System-Explained-wp.pdf
[7]: https://www.blackhat.com/docs/eu-17/materials/eu-17-Goryachy-How-To-Hack-A-Turned-Off-Computer-Or-Running-Unsigned-Code-In-Intel-Management-Engine-wp.pdf
[8]: https://github.com/ptresearch/IntelME-JTAG
[9]: http://blog.ptsecurity.com/2017/08/disabling-intel-me.html
[10]: https://twitter.com/XenoKovah