mount -tubifs /dev/ubi${UBIDEVNUM}_0 /mnt/filesystem
                    ```
                    1. Identificare i byte per il modulo kernel
                        - Durante l'avvio di solito vengono stampate informazioni sulla NAND, guardarle (passaggi sopra) e cercare `NAND ID`, i byte stampati sono in ordine primo, secondo e quarto byte
                        - Possiamo trovare queste informazioni anche cercando nel datasheet della EEPROM
                        - Possiamo anche usare `writesize, oobsize, erasesize, iowidth` per trovare [qui](http://www.linux-mtd.infradead.org/faq/nand.html#L_nand_nandsim) il comando corretto
                        - Altrimenti, tentativi ed errori
                    2. Analizzare le partizioni della EEPROM stampate all'avvio per trovare le loro dimensioni e nomi, l'ultimo numero nel comando `flash_erase` è la loro dimensione correlata a `erasesize` (uguale a `parts=x,y,z,...`)
                    3. Caricare le partizioni estratte dal dispositivo in quelle appena create
                    4. Creare un mountpoint per il filesystem e allegare
                        - `-O`: specificare l'offset dell'header del volume ID, se sbagliato il sistema dovrebbe comunque dirti il valore giusto; puoi provare valori diversi come `512, 1024, 2048` (tentativi ed errori)
                        - `-m`: numero del dispositivo `mtd` (vedi punto 3)
                        - `-d`: numero del dispositivo UBI (vedi punto 5)
                    5. Montare
    - Modalità utente: come wine, esegue solo un binario e lo "traduce" per la nostra architettura
        - Note
            - Non molto stabile
            - Può dare risultati strani
        - Come fare
            1. Individuare il formato eseguibile di QEMU: `qemu-$PROCESSORE$ARCHITETTURA`
                - Esempio: `qemu-mips64`
            2. Se QEMU lamenta l'assenza dell'interprete, passare il percorso della **CARTELLA CHE CONTIENE** questo interprete con `-L` (o vedere `man`)
                - Per sapere quale interprete viene utilizzato da un eseguibile, usare `readelf -l $ESEGUIBILE`
    - Modalità virtualizzazione: non interessante per noi
- Costruzione del kernel e del filesystem root usando buildroot e docker
    - Il nostro kernel costruito dovrebbe avere (rispetto al kernel originale)
        - Stessa versione del kernel
        - Stessa versione di libc (`uClibc, uClibc-ng, musl, dietlibc...`)
        - Stesse versioni delle librerie (dell'eseguibile che ci interessa)
    1. Cercare la versione di buildroot più vicina alle versioni del nostro dispositivo
        - A volte durante l'avvio/esplorazione della memoria scansionata possiamo trovare la versione di buildroot utilizzata (se il dispositivo è stato costruito con buildroot)
    2. Trovare una versione di linux compatibile con la versione di buildroot trovata e creare un container docker, [qui](https://github.com/digiampietro/hacking-gemtek/blob/master/docker/Dockerfile) un esempio di dockerfile (i pacchetti sono importanti per eseguire buildroot)
    3. Scaricare la versione di buildroot selezionata da [qui](https://buildroot.org/downloads/) e metterla nella cartella condivisa del container docker
    4. Eseguire e passare al container docker
    5. Estrarre buildroot e `make manual` per creare il manuale di buildroot
    6. Usare `make help` per stampare tutti i dispositivi (board) supportati da buildroot; `make $NOMEBOARD` per creare un file di configurazione buildroot della tua board
    7. `make menuconfig` (testuale) o `make xconfig` (GUI) per selezionare i moduli del kernel da aggiungere alla nostra build, useremo `make xconfig`
        - Qui c'è un esempio/linea guida ma dovrai scoprire da solo quali moduli in particolare ti serviranno per eseguire le tue applicazioni
        - Trucco: `Edit->Find` per cercare moduli
        - Opzioni
            - `Target options`
                - Spuntare `Show options and packages that are deprecated or obsolete`
                - Spuntare `Build packages with debugging symbols` con il `debug level` più alto
                - Spuntare `Strip command for binaries on target` a `None`
                - Spuntare `GCC optimization level` a `0`
            - `Toolchain`
                - Spuntare `Toolchain type` a `Buildroot toolchain`
                - Spuntare `Kernel headers` a `Manually specified linux version`
                - Spuntare `Custom kernel headers series` a `$VERSIONEKERNELDISPOSITIVO`
                - Impostare `Linux version` a `$VERSIONEKERNELDISPOSITIVO`
                - Spuntare `C library` a `$LIBRERIACDISPOSITIVO`
                - Spuntare `$LIBRERIACDISPOSITIVO version` a `$LIBRERIACDISPOSITIVO $VERSIONELIBRERIADISPOSITIVO`
                - Spuntare `Enable large files`
                - Spuntare `Enable IPv6`
                - Spuntare `Enable RPC`
                - Spuntare `Enable WCHAR`
                - Spuntare `Thread library implementation` a `linuxthreads`
                - Spuntare `Thread library debugging`
                - Spuntare `Build cross gdb for the host`
                - Spuntare `TUI support`
                - Spuntare `Python support`
                - Spuntare `GDB debugger version` a `$ULTIMAVERSIONEGDB`
            - `System configuration`
                - Spuntare `Passwords encoding` a `MD5`
                - Spuntare `Init system` a `$SISTEMAINITDISPOSITIVO` (o `BusyBox`)
                - Spuntare `/dev management` a `Dynamic using devtmpfs only`
                - Spuntare `/bin/sh` a `Busybox default shell`
                - Spuntare `Install timezone info`
            - `Kernel`
                - Impostare `Kernel version` a `$VERSIONEKERNELDISPOSITIVO`
                - Spuntare `Kernel binary format` a `vmlinux`
            - `Target packages`
                - `Compressors and decompressors`
                    - `bzip2` e `xz-utils`
                - `Debugging profiling and benchmark`
                    - Spuntare `gdb` e `full debugger`
                - `Development tools`
                    - Quello che ti serve
                - `Filesystem and flash utilities`
                    - `mtd, jffs2 and ubi/ubifs tools` (o quello che ti serve)
                - `Libraries`
                    - In generale quello che ti serve (suggerimenti sotto)
                    - `Crypto`
                        - `libsha1`
                        - `libssh2`
                        - `openssl`
                    - `JSON/XML`
                        - `expat`
                        - `json-c`
            - `Networking applications`
                - `rsync` e quello che ti serve
            - `Shell and utilities`
                - `file`
            - `Filesystem images`
                - `ext2`
            - `Host utilities` (non riguarda il dispositivo target, qui parliamo del dispositivo host)
                - `host mtd, jffs2 and ubi/ubifs tools`
                - `host util-linux`
        - Ricordarsi di SALVARE
    8. Per salvare permanentemente la configurazione appena definita usare `make savedconfig`
    9. Configurare il kernel con `make linux-menuconfig` (testuale) o `make linux-xconfig` (GUI), qui useremo la versione CLI
        - Qui c'è un esempio/linea guida ma dovrai scoprire da solo quali moduli in particolare ti serviranno per eseguire le tue applicazioni
        - Opzioni
            - `Kernel type` -> `Preemption model (Preemptible Kernel (Low-Latency Desktop))` -> `Preemptible Kernel (Low-Latency Desktop)`
            - `Kernel type` -> `Device drivers` -> `Memory technology device (MTD) support` -> `NAND device support` -> `Support for NAND flash simulator`
            - `Kernel type` -> `Device drivers` -> `Memory technology device (MTD) support` -> `UBI - Unsorted block images` -> `Enable UBI`
            - `File systems` -> `Miscellaneous filesystem` -> `JFFS2 support`
            - `File systems` -> `Miscellaneous filesystem` -> `UBIFS filesystem support`
        - `Save`
    10. Configurare `uClibc` (o la tua libreria c) usando `uclibc-menuconfig` (come sempre)
        - Abilitare il debugging: `Development/Debugging options` -> `Enable debugging symbols`, se non funziona (errori di compilazione) allora `Development/Debugging options` -> `(Wall) compiler warnings` -> aggiungere `-Wall -ggdb -g3`
            - `-ggdb`: fornisce informazioni di debug per l'uso con GDB
            - `-g3`: fornisce informazioni di debug extra
        - `Save`
        - Abilitare le funzionalità come nel nostro dispositivo (tentativi ed errori, se ottieni errori investiga e poi ricostruisci con le funzionalità necessarie)
    11. `make`, se ci sono problemi tornare indietro
        - Possibili errori di compilazione
            - `Need to use -fPIC`
                - Aggiungere `--enable-shared` nei moduli del kernel (punto 7) sotto `Toolchain` -> `Additional gcc options` o patchare buildroot
    - Salvare i file di configurazione per buildroot con git
        - Struttura dell'albero esterno (tree view dei file da comprendere per buildroot) (`br2`)
            ```
            +-- board/
            |   +-- <company>/ (non sempre usato)
            |       +-- <boardname>/
            |           +-- linux.config
            |           +-- busybox.config
            |           +-- kernel-defconfig (file di configurazione del kernel)
            |           +-- <altri file di configurazione>
            |           +-- post_build.sh (eseguito appena prima di costruire l'immagine, utile per copiare il filesystem root nell'immagine)
            |           +-- post_image.sh
            |           +-- rootfs_overlay/ (tutto qui verrà copiato nell'immagine finale)
            |           |   +-- etc/
            |           |   +-- <qualche file>
            |           +-- patches/
            |               +-- foo/
            |               |   +-- <qualche patch>
            |               +-- libbar/
            |                   +-- <altre patch>
            |
            +-- configs/
            |   +-- <boardname>_defconfig (configurazione buildroot per la nostra board)
            |   +-- uClibc.config (opzionale)
            +-- patches/
            |   +-- (qui patch da applicare)
            |
            +-- Config.in (se si utilizza un albero br2-external)
            +-- external.mk (se si utilizza un albero br2-external)
            +-- external.desc (se si utilizza un albero br2-external)
            ```
        - Per utilizzare un albero esterno, invocare buildroot in questo modo: `make BR2_EXTERNAL=$PERCORSOALBEROESTERNO $COMANDO`
        - Per salvare la configurazione buildroot nel nostro albero esterno: `make BR2_EXTERNAL=$PERCORSOALBEROESTERNO savedefconfig`
        - Per salvare la configurazione del kernel nel nostro albero esterno: `make BR2_EXTERNAL=$PERCORSOALBEROESTERNO linux-update-defconfig`
        - Per salvare la configurazione uClibc nel nostro albero esterno: `make BR2_EXTERNAL=$PERCORSOALBEROESTERNO BR2_UCLIBC_CONFIG=$PERCORSO DOVE SALVARE LA CONFIGURAZIONE UCLIBC uclibc-update-defconfig`

## Fonti, crediti e ringraziamenti

- Grazie a [Valerio Di Giampietro](https://va.ler.io/) ([@valerio](https://twitter.com/valerio)) per il suo incredibile canale youtube [tutorial](https://www.youtube.com/channel/UCoyNuc5bJ-z4X-6OlpNtJUw) sull'hardware hacking, tutto ciò che è scritto qui è al massimo preso da questi video.
- Grazie a [Luca Bongiorni](https://lockpicking.club/) ([@LucaBongiorni](https://twitter.com/LucaBongiorni)) per i suoi preziosi consigli e strumenti hardware.
- Grazie a mightyohm.com per [Soldering comics](https://mightyohm.com/files/soldercomic/FullSolderComic_EN.pdf)
- Grazie alla community di Reddit [hardwarehacking](https://www.reddit.com/r/hardwarehacking) per avermi aiutato
    - [[Noob] Direct PCB soldering (maybe?)](https://www.reddit.com/r/hardwarehacking/comments/lrbtaa/noob_direct_pcb_soldering_maybe/?utm_medium=android_app&utm_source=share)
- Grazie a [Andrew Paul](https://www.youtube.com/channel/UCtfcWatnWeEY_vq_UOL4PDQ) per il tutorial sulla saldatura di vias
- [Manuale di Buildroot](https://buildroot.org/downloads/manual/manual.html)
- [JTAG spiegato](https://blog.senr.io/blog/jtag-explained)
- [OpenOCD - Comandi Flash](http://openocd.org/doc/html/Flash-Commands.html)
- [Informazioni su OpenOCD + JTAG](https://www.allaboutcircuits.com/technical-articles/getting-started-with-openocd-using-ft2232h-adapter-for-swd-debugging/)
- [Hardware hacking cheat sheet - Piccolo PDF](https://github.com/arunmagesh/hw_hacking_cheatsheet/blob/master/cheatsheet_0.1.pdf)
- [OpenOCD](http://openocd.org/)