From a07a12dee081b2ad57786db1c8362f8c347f0f62 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 18 Aug 2025 20:16:23 +0000 Subject: [PATCH] Translated ['src/todo/hardware-hacking/jtag.md'] to it --- src/todo/hardware-hacking/jtag.md | 112 +++++++++++++++++++++++++++--- 1 file changed, 103 insertions(+), 9 deletions(-) diff --git a/src/todo/hardware-hacking/jtag.md b/src/todo/hardware-hacking/jtag.md index 7edd812e6..60e680e91 100644 --- a/src/todo/hardware-hacking/jtag.md +++ b/src/todo/hardware-hacking/jtag.md @@ -2,25 +2,119 @@ {{#include ../../banners/hacktricks-training.md}} +{{#ref}} +README.md +{{#endref}} + ## JTAGenum -[**JTAGenum** ](https://github.com/cyphunk/JTAGenum)è uno strumento che può essere utilizzato con un Raspberry PI o un Arduino per cercare di identificare i pin JTAG di un chip sconosciuto.\ -Nel **Arduino**, collega i **pin da 2 a 11 a 10 pin che potrebbero appartenere a un JTAG**. Carica il programma nell'Arduino e cercherà di forzare tutti i pin per scoprire se alcuni di essi appartengono a JTAG e quale sia ciascuno.\ -Nel **Raspberry PI** puoi utilizzare solo **pin da 1 a 6** (6 pin, quindi andrà più lentamente testando ciascun potenziale pin JTAG). +[**JTAGenum**](https://github.com/cyphunk/JTAGenum) è uno strumento che puoi caricare su un MCU compatibile con Arduino o (in via sperimentale) su un Raspberry Pi per forzare le pinout JTAG sconosciute e persino enumerare i registri delle istruzioni. -### Arduino +- Arduino: collega i pin digitali D2–D11 a un massimo di 10 pad/testpoint JTAG sospetti, e GND di Arduino a GND di destinazione. Alimenta il target separatamente a meno che tu non sappia che il rail è sicuro. Preferisci la logica a 3.3 V (ad es., Arduino Due) o utilizza un level shifter/resistori in serie quando sondi target a 1.8–3.3 V. +- Raspberry Pi: la build del Pi espone meno GPIO utilizzabili (quindi le scansioni sono più lente); controlla il repo per la mappa dei pin attuale e le limitazioni. -In Arduino, dopo aver collegato i cavi (pin 2 a 11 ai pin JTAG e GND dell'Arduino al GND della scheda madre), **carica il programma JTAGenum nell'Arduino** e nel Monitor Serial invia un **`h`** (comando per aiuto) e dovresti vedere l'aiuto: +Una volta flashato, apri il monitor seriale a 115200 baud e invia `h` per aiuto. Flusso tipico: + +- `l` trova loopback per evitare falsi positivi +- `r` attiva/disattiva pull-up interni se necessario +- `s` scansiona per TCK/TMS/TDI/TDO (e talvolta TRST/SRST) +- `y` forza IR per scoprire opcode non documentati +- `x` snapshot di boundary-scan degli stati dei pin ![](<../../images/image (939).png>) ![](<../../images/image (578).png>) -Configura **"No line ending" e 115200baud**.\ -Invia il comando s per iniziare la scansione: - ![](<../../images/image (774).png>) -Se stai contattando un JTAG, troverai una o più **righe che iniziano con FOUND!** che indicano i pin di JTAG. + + +Se viene trovato un TAP valido vedrai righe che iniziano con `FOUND!` indicando i pin scoperti. + +Suggerimenti +- Condividi sempre il ground e non alimentare mai pin sconosciuti sopra il Vtref del target. In caso di dubbio, aggiungi resistori in serie da 100–470 Ω sui pin candidati. +- Se il dispositivo utilizza SWD/SWJ invece di JTAG a 4 fili, JTAGenum potrebbe non rilevarlo; prova strumenti SWD o un adattatore che supporta SWJ‑DP. + +## Caccia ai pin più sicura e configurazione hardware + +- Identifica prima Vtref e GND con un multimetro. Molti adattatori necessitano di Vtref per impostare la tensione I/O. +- Livellamento: preferisci level shifter bidirezionali progettati per segnali push‑pull (le linee JTAG non sono open‑drain). Evita level shifter I2C a direzione automatica per JTAG. +- Adattatori utili: schede FT2232H/FT232H (ad es., Tigard), CMSIS‑DAP, J‑Link, ST‑LINK (specifici del fornitore), ESP‑USB‑JTAG (su ESP32‑Sx). Collega almeno TCK, TMS, TDI, TDO, GND e Vtref; opzionalmente TRST e SRST. + +## Primo contatto con OpenOCD (scansione e IDCODE) + +OpenOCD è l'OSS de facto per JTAG/SWD. Con un adattatore supportato puoi scansionare la catena e leggere gli IDCODE: + +- Esempio generico con un J‑Link: +``` +openocd -f interface/jlink.cfg -c "transport select jtag; adapter speed 1000" \ +-c "init; scan_chain; shutdown" +``` +- ESP32‑S3 USB‑JTAG integrato (nessun probe esterno richiesto): +``` +openocd -f board/esp32s3-builtin.cfg -c "init; scan_chain; shutdown" +``` +Note +- Se ottieni un IDCODE "tutti uno/zero", controlla il cablaggio, l'alimentazione, Vtref e che la porta non sia bloccata da fusibili/opzioni. +- Vedi OpenOCD low‑level `irscan`/`drscan` per interazione manuale TAP quando si attivano catene sconosciute. + +## Fermare la CPU e scaricare la memoria/flash + +Una volta che il TAP è riconosciuto e uno script di destinazione è scelto, puoi fermare il core e scaricare le regioni di memoria o la flash interna. Esempi (regola destinazione, indirizzi base e dimensioni): + +- Destinazione generica dopo l'inizializzazione: +``` +openocd -f interface/jlink.cfg -f target/stm32f1x.cfg \ +-c "init; reset halt; mdw 0x08000000 4; dump_image flash.bin 0x08000000 0x00100000; shutdown" +``` +- RISC‑V SoC (preferisci SBA quando disponibile): +``` +openocd -f interface/ftdi/ft232h.cfg -f target/riscv.cfg \ +-c "init; riscv set_prefer_sba on; halt; dump_image sram.bin 0x80000000 0x20000; shutdown" +``` +- ESP32‑S3, programma o leggi tramite l'aiuto di OpenOCD: +``` +openocd -f board/esp32s3-builtin.cfg \ +-c "program_esp app.bin 0x10000 verify exit" +``` +Tips +- Usa `mdw/mdh/mdb` per controllare la memoria prima di dump lunghi. +- Per catene multi-dispositivo, imposta BYPASS su non-target o usa un file di scheda che definisce tutti i TAP. + +## Trucchi di boundary-scan (EXTEST/SAMPLE) + +Anche quando l'accesso al debug della CPU è bloccato, il boundary-scan potrebbe essere ancora esposto. Con UrJTAG/OpenOCD puoi: +- SAMPLE per acquisire gli stati dei pin mentre il sistema è in esecuzione (trovare attività del bus, confermare il mapping dei pin). +- EXTEST per pilotare i pin (ad esempio, bit-bangare le linee SPI flash esterne tramite l'MCU per leggerle offline se il cablaggio della scheda lo consente). + +Flusso minimo di UrJTAG con un adattatore FT2232x: +``` +jtag> cable ft2232 vid=0x0403 pid=0x6010 interface=1 +jtag> frequency 100000 +jtag> detect +jtag> bsdl path /path/to/bsdl/files +jtag> instruction EXTEST +jtag> shift ir +jtag> dr +``` +Hai bisogno del BSDL del dispositivo per conoscere l'ordinamento dei bit del registro di confine. Fai attenzione che alcuni fornitori bloccano le celle di scansione del confine in produzione. + +## Obiettivi moderni e note + +- ESP32‑S3/C3 include un ponte USB‑JTAG nativo; OpenOCD può comunicare direttamente tramite USB senza una sonda esterna. Molto conveniente per la triage e i dump. +- Il debug RISC‑V (v0.13+) è ampiamente supportato da OpenOCD; preferisci SBA per l'accesso alla memoria quando il core non può essere arrestato in modo sicuro. +- Molti MCU implementano l'autenticazione del debug e stati del ciclo di vita. Se JTAG sembra morto ma l'alimentazione è corretta, il dispositivo potrebbe essere fuso in uno stato chiuso o richiedere una sonda autenticata. + +## Difese e indurimento (cosa aspettarsi su dispositivi reali) + +- Disabilita o blocca permanentemente JTAG/SWD in produzione (ad es., STM32 RDP livello 2, ESP eFuses che disabilitano PAD JTAG, NXP/Nordic APPROTECT/DPAP). +- Richiedi debug autenticato (ARMv8.2‑A ADIv6 Debug Authentication, sfida-risposta gestita da OEM) mantenendo l'accesso alla produzione. +- Non instradare pad di test facili; seppellire via di test, rimuovere/popolare resistori per isolare TAP, utilizzare connettori con chiavi o fixture a pogo-pin. +- Blocco del debug all'accensione: controlla il TAP dietro ROM iniziali che impongono l'avvio sicuro. + +## Riferimenti + +- OpenOCD User’s Guide – JTAG Commands and configuration. https://openocd.org/doc-release/html/JTAG-Commands.html +- Espressif ESP32‑S3 JTAG debugging (USB‑JTAG, OpenOCD usage). https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-guides/jtag-debugging/ {{#include ../../banners/hacktricks-training.md}}