EF/CF - il Fuzzer per Contratti (ethereum smart) Estremamente Veloce

EF/CF è un nuovo approccio al fuzzing di smart contract: invece di usare un nuovo fuzzer costruito su misura, riutilizza l'infrastruttura di fuzzing esistente per codice C/C++ applicandola agli smart contract. Attualmente, AFL++ è il fuzzer supportato principalmente, sebbene esista anche un supporto molto rudimentale per libfuzzer e honggfuzz.

Perché usare l'infrastruttura di fuzzing esistente?

• Velocità. Possiamo fare fuzzing più velocemente. Raggiungiamo regolarmente circa 20k esecuzioni/sec/core.
• I fuzzer per codice nativo sono ben progettati e ottimizzati.
• Corretta guida basata sulla copertura, gestione della coda, riproduzione deterministica dei casi di test, ecc.

Quali sono alcuni problemi che incontriamo lungo il percorso?

• Dobbiamo insegnare al fuzzer la struttura: cioè cos'è una transazione e qual è l'ABI dello smart contract. Usiamo un mutatore personalizzato per questo: ./src/ethmutator/
• Per aumentare la velocità e ottenere un feedback di copertura utile, traduciamo il bytecode EVM in C++ usando un transpiler personalizzato ./src/evm2cpp/

Questo repository è il punto di ingresso principale per il progetto EF/CF. Contiene tutto il codice rilevante come sotto-progetti in ./src/ e diversi script di comodità per l'installazione, script per avviare campagne di fuzzing e vari dataset per testare il fuzzer (e confrontarlo con altri strumenti).

• ./src/ - contiene tutto il codice sorgente necessario per compilare ed eseguire EF/CF; per riproducibilità tutte le dipendenze dirette sono aggiunte come sottomoduli git.
• ./data/ - contiene i dataset usati durante la valutazione
• ./scripts - contiene script per eseguire esperimenti, installazione, ecc.
• ./docker - Dockerfile per un flusso di lavoro basato su container
  • Lo standard è Ubuntu, ma puoi anche avere un container basato su Fedora o Arch Linux se preferisci.
  • ./docker/tools/ contiene i dockerfile per gli strumenti con cui abbiamo confrontato EF/CF. Abbiamo fatto del nostro meglio per fissare le versioni che abbiamo valutato nel nostro articolo nei dockerfile.
• ./EXPERIMENTS.md - contiene una guida per riprodurre gli esperimenti del nostro articolo.
• ./examples - contiene output di esempio prodotti da EF/CF

L'Articolo su EF/CF

Descriviamo l'architettura di EF/CF, l'implementazione e riassumiamo i risultati della nostra valutazione nel nostro articolo: preprint su arxiv.org

Citazione in Lavori Accademici

Quando si fa riferimento a EF/CF in lavori accademici, si prega di usare la seguente voce bibtex per la citazione:```bibtex @InProceedings{efcf2023, author = "Michael Rodler and David Paaßen and Wenting Li and Lukas Bernhard and Thorsten Holz and Ghassan Karame and Lucas Davi", title = "EF/CF: High Performance Smart Contract Fuzzing for Exploit Generation", booktitle = "{IEEE} European Symposium on Security and Privacy ({EuroS&P})", publisher = "{IEEE}", year = "2023", }

## Avvio rapido

Il metodo consigliato è eseguire EF/CF come container docker interattivo.

1. Entra nel container con una shell   ```
   docker run --rm -it ghcr.io/uni-due-syssec/efcf-framework

oppure crea il container dal repository clonato ``` make gitmodules # to fetch the git submodules make container-enter

1. Compila e poi fai fuzzing su un contratto solidity finché non viene scoperto il primo
crash/bug:   ```
efcfuzz --until-crash --out ./baby_bank_results/ --source ./data/examples/baby_bank.sol

2. Ispeziona il crash identificato ``` cd /tmp/baby_bank_results/ ./r.sh crashes_min/default_id:000000*

Installazione / Configurazione

Sottomoduli Git

Niente git? se usi una release tarball/docker, ignora questo.

Esegui git submodule update --init per recuperare gli ultimi commit dei sottomoduli su repository già clonati. Assicurati di eseguirlo anche in ./src/eEVM.``` git submodule update --init; cd src/eEVM/; git submodule update --init; cd ../../

*Avvertenza:* Eseguire `git clone --recursive $repo` o passare l'argomento `--recursive` a `git sumbodule (update|init)` farà sì che git entri ricorsivamente nei sottomoduli del repository AFL++, che non sono necessari per questo progetto. Quindi, per risparmiare spazio, è meglio evitare i checkout ricorsivi dei sottomoduli.


### Container

Forniamo i seguenti comodi target make per workflow basati su container:```sh
make container-build  # build default efcf container
make container-enter  # enter default efcf container in current working dir

Se vuoi assicurarti una build pulita, puoi usare il seguente comando```sh make container-build CLEAN_CHECKOUT=1

In alternativa, il container può essere creato con il seguente comando docker:```sh
docker build \
    -f docker/ubuntu.Dockerfile \
    -t efcf:latest \
    .

Nota che esiste anche un Dockerfile basato su Archlinux e Fedora. Dovrebbero funzionare anche loro, ma non sono altrettanto testati.

Per distribuire manualmente un'immagine docker (ad es., se si includono alcune modifiche locali), usa:``` make container-release docker load -i ./efcf*.tar

Consigliamo le seguenti opzioni docker per l'avvio:

* `--security-opt seccomp=unconfined` - prestazioni di fuzzing migliori
* `--net=host` - per un facile accesso a un nodo ethereum locale
* `--tmpfs "/tmp/efcf/":exec,size=6g` - metti i file temporanei di EF/CF su un ramdisk se possibile (minore usura del disco)
* `--privileged` - per eseguire `afl-system-config` o `efcfuzz --configure-system`
* `-v` - per persistere i dati di output di EF/CF


### VM / Bare-Metal

Per flussi di lavoro basati su VM o bare-metal:```sh
make system-install   # install efcf to current system (requires root or sudo rights)

Nota che molti degli script funzionano comunque con il layout di directory relativo, quindi questo installa principalmente dipendenze e alcuni strumenti utili da avere nel tuo PATH. Abbiamo testato l'esecuzione di EF/CF sulle seguenti distribuzioni Linux:

• Ubuntu Jammy (o successiva)
• Fedora ($ > 35 $)
• Archlinux

(La distro non ha molta importanza: abbiamo testato LLVM 13 e 14, con 14 come scelta preferita. LLVM 11 o 12 potrebbero funzionare ancora, ma come sempre - più nuovo è, meglio è. La parte importante è che ci sia un LLVM compatibile con il nostro fork di AFL++.)

Su Mac OS / M1