EF/CF - le Fuzzer de Contrats (Ethereum smart) Extrêmement Rapide

EF/CF est une nouvelle approche du fuzzing de contrats intelligents : au lieu d'utiliser un nouveau fuzzer développé sur mesure, il réutilise l'infrastructure de fuzzing existante pour le code C/C++ et l'applique aux contrats intelligents. Actuellement, AFL++ est le fuzzer principalement pris en charge, bien qu'il existe également un support très rudimentaire pour libfuzzer et honggfuzz.

Pourquoi utiliser l'infrastructure de fuzzing existante ?

• Vitesse. Nous pouvons fuzzer plus rapidement. Nous atteignons régulièrement environ 20 000 exécutions/s/cœur.
• Les fuzzers de code natif sont bien conçus et optimisés.
• Guidage par couverture adéquat, gestion de file d'attente, relecture déterministe de cas de test, etc.

Quels sont les problèmes que nous rencontrons en cours de route ?

• Nous devons enseigner au fuzzer la structure : à savoir ce qu'est une transaction et ce qu'est l'ABI du contrat intelligent. Nous utilisons un mutateur personnalisé pour cela : ./src/ethmutator/
• Pour augmenter la vitesse et obtenir un retour de couverture utile, nous traduisons le bytecode EVM en C++ à l'aide d'un transpileur personnalisé ./src/evm2cpp/

Ce dépôt est le point d'entrée principal du projet EF/CF. Il contient tout le code pertinent sous forme de sous-projets dans ./src/ et plusieurs scripts pratiques pour l'installation, des scripts pour lancer des campagnes de fuzzing et divers ensembles de données pour tester le fuzzer (et le comparer à d'autres outils).

• ./src/ - contient tout le code source nécessaire pour construire et exécuter EF/CF ; pour la reproductibilité, toutes les dépendances directes sont ajoutées en tant que sous-modules git.
• ./data/ - contient les ensembles de données utilisés lors de l'évaluation
• ./scripts - contient des scripts pour exécuter les expériences, l'installation, etc.
• ./docker - Dockerfile pour un flux de travail basé sur des conteneurs
  • La norme est Ubuntu, mais vous pouvez également avoir un conteneur basé sur Fedora ou Arch Linux si vous le souhaitez.
  • ./docker/tools/ contient des dockerfiles pour les outils auxquels nous avons comparé EF/CF. Nous avons fait de notre mieux pour fixer dans les dockerfiles les versions que nous avons évaluées dans notre article.
• ./EXPERIMENTS.md - contient un guide pour reproduire les expériences de notre article.
• ./examples - contient des exemples de sorties produites par EF/CF

L'article EF/CF

Nous décrivons l'architecture et l'implémentation d'EF/CF, et résumons les résultats de notre évaluation dans notre article : preprint arxiv.org

Citation dans les travaux académiques

Lorsque vous référencez EF/CF dans des travaux académiques, veuillez utiliser l'entrée bibtex suivante pour la citation :```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", }

## Démarrage rapide

La méthode recommandée est d'exécuter EF/CF dans un conteneur docker interactif.

1. Entrez dans le conteneur avec un shell   ```
   docker run --rm -it ghcr.io/uni-due-syssec/efcf-framework

ou construire le conteneur à partir du dépôt cloné ``` make gitmodules # to fetch the git submodules make container-enter

1. Compilez puis fuzz un contrat Solidity jusqu'à ce que le premier crash/bug soit
découvert :   ```
efcfuzz --until-crash --out ./baby_bank_results/ --source ./data/examples/baby_bank.sol

2. Inspectez le crash identifié ``` cd /tmp/baby_bank_results/ ./r.sh crashes_min/default_id:000000*

Installation / Configuration

Sous-modules Git

Pas de git ? si vous utilisez une version tarball/docker, ignorez ceci.

Exécutez git submodule update --init pour récupérer les derniers commits des sous-modules sur les dépôts déjà clonés. Assurez-vous d'exécuter ceci aussi dans ./src/eEVM.``` git submodule update --init; cd src/eEVM/; git submodule update --init; cd ../../

*Attention :* Exécuter `git clone --recursive $repo` ou passer l'argument `--recursive` à `git sumbodule (update|init)` fera récurser git dans les sous-modules du dépôt AFL++, qui ne sont pas nécessaires pour ce projet. Ainsi, pour économiser de l'espace, il est préférable d'éviter les vérifications récursives des sous-modules.


### Conteneur

Nous fournissons les cibles make pratiques suivantes pour les flux de travail basés sur des conteneurs :```sh
make container-build  # build default efcf container
make container-enter  # enter default efcf container in current working dir

Si vous souhaitez garantir une compilation propre, vous pouvez utiliser la commande suivante```sh make container-build CLEAN_CHECKOUT=1

Alternativement, le conteneur peut être construit avec la commande docker suivante :```sh
docker build \
    -f docker/ubuntu.Dockerfile \
    -t efcf:latest \
    .

Notez qu'il existe également des Dockerfiles basés sur Archlinux et Fedora. Ils devraient fonctionner, mais ne sont pas aussi bien testés.

Pour distribuer manuellement une image docker (p. ex., si vous incluez des modifications locales), utilisez :``` make container-release docker load -i ./efcf*.tar

Nous recommandons les options Docker suivantes pour le lancement :

* `--security-opt seccomp=unconfined` - meilleures performances de fuzzing
* `--net=host` - pour un accès facile à un nœud Ethereum local
* `--tmpfs "/tmp/efcf/":exec,size=6g` - placer les fichiers temporaires d'EF/CF sur un ramdisk si possible (moins d'usure du disque)
* `--privileged` - pour exécuter `afl-system-config` ou `efcfuzz --configure-system`
* `-v` - pour conserver les données de sortie d'EF/CF


### VM / Bare-Metal

Pour les workflows basés sur une VM ou sur du bare-metal :```sh
make system-install   # install efcf to current system (requires root or sudo rights)

Notez que beaucoup de scripts fonctionnent de toute façon avec la structure de répertoires relative, donc cela installe principalement des dépendances et quelques outils pratiques à avoir dans votre PATH. Nous avons testé l'exécution d'EF/CF sur les distributions Linux suivantes :

• Ubuntu Jammy (ou ultérieure)
• Fedora ($ > 35 $)
• Archlinux

(La distribution n'a pas beaucoup d'importance, nous avons testé LLVM 13 et 14, 14 étant le choix préféré. LLVM 11 ou 12 pourrait également encore fonctionner, mais comme toujours - plus c'est récent, mieux c'est. L'important est qu'il y ait un LLVM compatible avec notre fork d'AFL++.)

Sur Mac OS / M1