Echidna: Ein schneller Smart-Contract-Fuzzer

Echidna ist eine seltsame Kreatur, die sich von Bugs ernährt und hochelektrosensitiv ist (mit Verbeugung vor Jacob Stanley)

Um ernst zu sein: Echidna ist ein Haskell-Programm, das zum Fuzzing/propertybasierten Testen von Ethereum-Smart-Contracts entwickelt wurde. Es nutzt ausgefeilte, grammatikbasierte Fuzzing-Kampagnen auf Grundlage eines Contract-ABI, um benutzerdefinierte Prädikate oder Solidity-Assertions zu falsifizieren. Wir haben Echidna mit Modularität im Hinterkopf entworfen, sodass es leicht erweitert werden kann, um neue Mutationen zu integrieren oder bestimmte Verträge in bestimmten Fällen zu testen.

Funktionen

Generiert Eingaben, die auf Ihren tatsächlichen Code zugeschnitten sind
Optionale Korpus-Sammlung, Mutation und Abdeckungsführung, um tiefere Fehler zu finden
Angetrieben von Slither, um nützliche Informationen vor der Fuzzing-Kampagne zu extrahieren
Quellcode-Integration zur Identifizierung, welche Zeilen nach der Fuzzing-Kampagne abgedeckt sind
Interaktive Terminal-Benutzeroberfläche, reine Text- oder JSON-Ausgabe
Automatische Testfallminimierung für schnelles Triage
Nahtlose Integration in den Entwicklungsablauf

.. und ein wunderschönes, hochauflösendes handgefertigtes Logo.

Verwendung

Ausführen des Test-Runners

Die Kernfunktionalität von Echidna ist eine ausführbare Datei namens echidna, die einen Vertrag und eine Liste von Invarianten (Eigenschaften, die stets wahr bleiben sollten) als Eingabe nimmt. Für jede Invariante generiert es zufällige Sequenzen von Aufrufen an den Vertrag und prüft, ob die Invariante hält. Wenn es einen Weg finden kann, die Invariante zu falsifizieren, gibt es die Aufrufsequenz aus, die dies bewirkt. Wenn es dies nicht kann, haben Sie eine gewisse Sicherheit, dass der Vertrag sicher ist.

Schreiben von Invarianten

Invarianten werden als Solidity-Funktionen mit Namen, die mit echidna_ beginnen, ohne Argumente und mit einem booleschen Rückgabewert ausgedrückt. Wenn Sie beispielsweise eine balance-Variable haben, die niemals unter 20 fallen sollte, können Sie eine zusätzliche Funktion in Ihren Vertrag schreiben, wie diese hier:```solidity function echidna_check_balance() public returns (bool) { return(balance >= 20); }

Um diese Invarianten zu überprüfen, führen Sie aus:```sh
$ echidna myContract.sol

Ein Beispielvertrag mit Tests befindet sich unter tests/solidity/basic/flags.sol. Um ihn auszuführen, führen Sie folgenden Befehl aus:```sh $ echidna tests/solidity/basic/flags.sol

Echidna sollte eine Aufrufsequenz finden, die `echidna_sometimesfalse` falsifiziert, und sollte keinen falsifizierenden Input für `echidna_alwaystrue` finden können.

### Testmodi

Das obige Beispiel verwendet den Standard-**Property**-Modus, aber Echidna unterstützt mehrere Testmodi, die über `testMode` in der Konfigurationsdatei oder `--test-mode` auf der CLI konfiguriert werden:

* **`property`** (Standard): Testet `echidna_`-präfixierte Funktionen, die `bool` zurückgeben.
* **`assertion`**: Erkennt Assertionsfehler von `assert()` und Foundrys `assertX`-Helfern (`assertTrue`, `assertEq`, usw.).
* **`foundry`**: Führt Foundry-artige `test`-präfixierte Unit-Tests und `invariant_`-präfixierte zustandsbehaftete Invarianten aus.
* **`overflow`**: Erkennt Integer-Über-/Unterläufe (Solidity >= 0.8.0).
* **`optimization`**: Maximiert den Rückgabewert von `echidna_`-präfixierten Funktionen, die `int256` zurückgeben (verwendet dasselbe konfigurierbare Präfix wie der Property-Modus).
* **`exploration`**: Sammelt Coverage ohne Überprüfung von Properties.

### Sammeln und Visualisieren der Coverage

Nach Abschluss einer Kampagne kann Echidna ein coverage-maximierendes **Corpus** in einem speziellen Verzeichnis speichern, das mit der `corpusDir`-Konfigurationsoption angegeben wird. Dieses Verzeichnis enthält zwei Einträge: (1) ein Verzeichnis namens `coverage` mit JSON-Dateien, die von Echidna wiedergegeben werden können, und (2) eine Textdatei namens `covered.txt`, eine Kopie des Quellcodes mit Coverage-Anmerkungen.

Wenn Sie das Beispiel `tests/solidity/basic/flags.sol` ausführen, speichert Echidna einige Dateien serialisierte Transaktionen im Verzeichnis `coverage` und eine Datei `covered.$(date +%s).txt` mit den folgenden Zeilen:```text
*r  |  function set0(int val) public returns (bool){
*   |    if (val % 100 == 0)
*   |      flag0 = false;
  }

*r  |  function set1(int val) public returns (bool){
*   |    if (val % 10 == 0 && !flag0)
*   |      flag1 = false;
  }

Unser Tool kennzeichnet jede Ausführungs-Spur im Korpus mit dem folgenden „Zeilenmarker“:

* wenn eine Ausführung mit STOP endete
r wenn eine Ausführung mit REVERT endete
o wenn eine Ausführung mit einem Out-of-Gas-Fehler endete
e wenn eine Ausführung mit einem anderen Fehler endete (Division durch Null, Assertion-Fehler usw.)

Unterstützung für Smart-Contract-Build-Systeme

Echidna kann Verträge testen, die mit verschiedenen Smart-Contract-Build-Systemen kompiliert wurden, darunter Foundry, Hardhat und Truffle, unter Verwendung von crytic-compile. Um Echidna mit dem aktuellen Kompilierungsframework aufzurufen, verwenden Sie echidna ..

Darüber hinaus unterstützt Echidna zwei Modi zum Testen komplexer Verträge. Erstens kann man den vorhandenen Netzwerkzustand nutzen und diesen als Basiszustand für Echidna verwenden. Zweitens kann Echidna jeden Vertrag mit einem bekannten ABI aufrufen, indem der entsprechende Solidity-Quellcode in der CLI übergeben wird. Verwenden Sie allContracts: true in Ihrer Konfiguration, um dies zu aktivieren.

Schnellkurs zu Echidna

Unser Repository Building Secure Smart Contracts enthält einen Schnellkurs zu Echidna, einschließlich Beispielen, Lektionen und Übungen.

Verwendung von Echidna in einem GitHub Actions-Workflow

Es gibt eine Echidna-Aktion, mit der echidna als Teil eines GitHub Actions-Workflows ausgeführt werden kann. Bitte lesen Sie das Repository crytic/echidna-action für Anwendungsanweisungen und Beispiele.

Konfigurationsoptionen

Die CLI von Echidna kann verwendet werden, um den zu testenden Vertrag auszuwählen und eine Konfigurationsdatei zu laden.```sh $ echidna contract.sol --contract TEST --config config.yaml

Die Konfigurationsdatei ermöglicht es Benutzern, EVM- und Testgenerierungsparameter auszuwählen. Ein Beispiel für eine vollständige und kommentierte Konfigurationsdatei mit den Standardoptionen findet sich unter [tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/default.yaml). Siehe die [Dokumentation](https://secure-contracts.com/program-analysis/echidna/configuration.html) für detailliertere Informationen zu den verfügbaren Konfigurationsoptionen.

Echidna unterstützt drei verschiedene Ausgabetreiber. Es gibt den Standard-`text`-Treiber, einen `json`-Treiber und einen `none`-Treiber, der die gesamte `stdout`-Ausgabe unterdrücken sollte. Der JSON-Treiber meldet die gesamte Kampagne wie folgt.```
Campaign = {
  "success"      : bool,
  "error"        : string?,
  "tests"        : [Test],
  "seed"         : number,
  "coverage"     : Coverage
}
Test = {
  "contract"     : string,
  "name"         : string,
  "status"       : string,
  "error"        : string?,
  "testType"     : string,
  "transactions" : [Transaction]?
}
Transaction = {
  "contract"     : string,
  "function"     : string,
  "arguments"    : [string]?,
  "gas"          : number,
  "gasprice"     : number
}

Coverage ist ein Dict, das bestimmte coverage-erhöhende Aufrufe beschreibt. Diese Schnittstellen können sich in Zukunft ändern, um etwas benutzerfreundlicher zu werden. testType wird entweder property, assertion, optimization, exploration oder call sein, und status nimmt immer entweder fuzzing, shrinking, solved, passed oder error an.

Debugging von Leistungsproblemen

Eine Möglichkeit, Leistungsprobleme von Echidna zu diagnostizieren, besteht darin, echidna mit aktiviertem Profiling auszuführen. Um Echidna mit grundlegendem Profiling auszuführen, fügen Sie +RTS -p -s zu Ihrem ursprünglichen echidna-Befehl hinzu:```sh $ nix develop # alternatively nix-shell $ cabal --enable-profiling run echidna -- ... +RTS -p -s $ less echidna.prof

Dies erzeugt eine Berichtsdatei (`echidna.prof`), die anzeigt, welche Funktionen die meiste CPU- und Speichernutzung verursachen.

Wenn die grundlegende Profilerstellung nicht hilft, können Sie erweiterte [Profiling-Techniken](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html) verwenden.

Häufige Ursachen für Leistungsprobleme, die wir beobachtet haben:

- Teure Funktionen, die in heißen Pfaden aufgerufen werden
- Faule Datenkonstruktoren, die Thunks ansammeln
- Ineffiziente Datenstrukturen, die in heißen Pfaden verwendet werden

Dies zu überprüfen ist ein guter Ausgangspunkt. Wenn Sie vermuten, dass eine Berechnung zu faul ist und
Speicher leckt, können Sie `force` aus `Control.DeepSeq` verwenden, um sicherzustellen, dass sie ausgewertet wird.

## Einschränkungen und bekannte Probleme

EVM-Emulation und -Tests sind schwierig. Echidna hat in der neuesten Version einige Einschränkungen. Einige
davon werden von [hevm](https://github.com/argotorg/hevm) geerbt, während andere aus
Design-/Leistungsentscheidungen oder einfach Fehlern in unserem Code resultieren. Wir listen sie hier zusammen mit dem
entsprechenden Issue und dem Status auf ("wont fix", "on hold", "in review", "fixed"). Probleme, die
"fixed" sind, werden voraussichtlich im nächsten Echidna-Release enthalten sein.

| Beschreibung | Issue | Status |
| :---        | :---: | :---:  |
| Vyper-Unterstützung ist eingeschränkt | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Eingeschränkte Bibliotheksunterstützung für Tests | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |

## Installation

### Vorkompilierte Binärdateien

Stellen Sie vor dem Start sicher, dass Slither [installiert](https://github.com/crytic/slither) ist (`pip3 install slither-analyzer --user`).
Wenn Sie Echidna unter Linux oder macOS schnell testen möchten, bieten wir statisch gelinkte Linux-Binärdateien (erstellt auf Ubuntu) und größtenteils statische macOS-Binärdateien auf unserer [Releases-Seite](https://github.com/crytic/echidna/releases) an. Sie können dieselben Binärdateien auch aus unserer [CI-Pipeline](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush) beziehen – klicken Sie einfach auf den Commit, um Binärdateien für Linux oder macOS zu finden.

### Homebrew (macOS / Linux)

Wenn Sie Homebrew auf Ihrem Mac oder Linux-Rechner installiert haben, können Sie Echidna und alle seine Abhängigkeiten (Slither, crytic-compile) mit dem Befehl `brew install echidna` installieren.

Sie können auch den neuesten `master`-Branch-Code kompilieren und installieren, indem Sie `brew install --HEAD echidna` ausführen.

Weitere Informationen finden Sie auf der Seite der [`echidna` Homebrew-Formel](https://formulae.brew.sh/formula/echidna). Die Formel selbst wird als Teil des [homebrew-core-Repository](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/echidna.rb) gepflegt.

### Docker-Container

Wenn Sie einen vorgebauten Docker-Container bevorzugen, schauen Sie sich unser [Docker-Paket](https://github.com/orgs/crytic/packages?repo_name=echidna) an, das
automatisch über GitHub Actions erstellt wird. Der `echidna`-Container basiert auf
`ubuntu:noble` und ist als kleines, aber dennoch flexibles Image konzipiert, um
Echidna zu verwenden. Es enthält eine vorgebaute Version von `echidna` sowie
`slither`, `crytic-compile`, `solc-select`, `nvm` und `foundry` (einschließlich
`forge`, `cast`, `anvil` und `chisel`) unter 200 MB.

Beachten Sie, dass die Container-Images derzeit nur auf x86-Systemen erstellt werden. Die Ausführung
auf ARM-Geräten wie Mac M1-Systemen wird aufgrund des
Leistungsverlusts durch die CPU-Emulation nicht empfohlen.

Für das Docker-Container-Image sind verschiedene Tags verfügbar:

| Tag           | Build im Tag
|---------------|-------------
| `vx.y.z`      | Build entsprechend Release `vx.y.z`
| `latest`      | Neuestes getaggtes Echidna-Release.
| `edge`        | Neuester Commit auf dem Standard-Branch.
| `testing-foo` | Test-Build basierend auf Branch `foo`.

Um den Container mit der neuesten Echidna-Version interaktiv auszuführen, können Sie
etwa den folgenden Befehl verwenden. Er bildet das aktuelle Verzeichnis als
`/src` im Container ab und gibt Ihnen eine Shell, in der Sie `echidna` verwenden können:```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna

Andernfalls, wenn Sie die neueste Version von Echidna lokal erstellen möchten, empfehlen wir die Verwendung von Docker. Führen Sie innerhalb eines Klons dieses Repositorys den folgenden Befehl aus, um das Docker-Container-Image zu erstellen:```sh $ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .

Dann können Sie das `echidna`-Image lokal ausführen. Zum Beispiel, um solc
0.5.7 zu installieren und `tests/solidity/basic/flags.sol` zu überprüfen, können Sie Folgendes ausführen:```sh
$ docker run -it -v "$(pwd)":/src echidna bash -c "solc-select install 0.5.7 && solc-select use 0.5.7 && echidna /src/tests/solidity/basic/flags.sol"

Das Docker-Image enthält auch Foundry-Tools für die umfassende Entwicklung und das Testen von Smart Contracts. Sie können forge, cast, anvil und chisel direkt im Container verwenden:```sh

Run an interactive shell with Foundry tools available

$ docker run -it -v "$(pwd)":/src echidna bash

Inside the container, you can use Foundry commands:

$ forge --version $ cast --version $ anvil --version $ chisel --version

Example: Initialize a new Foundry project

$ forge init my-project $ cd my-project $ forge build $ forge test

### Erstellen mit Stack

Wenn Sie es vorziehen, aus dem Quellcode zu erstellen, verwenden Sie [Stack](https://docs.haskellstack.org/en/stable/). `stack install` sollte `echidna` in `~/.local/bin` erstellen und kompilieren. Sie müssen gegen libreadline und libsecp256k1 (mit aktivierter Wiederherstellung erstellt) linken, die mit dem von Ihnen gewählten Paketmanager installiert werden sollten. Sie müssen auch die neueste Version von [libff](https://github.com/scipr-lab/libff) installieren. Beachten Sie dazu unsere [CI-Tests](https://github.com/crytic/echidna/blob/HEAD/.github/scripts/install-libff.sh).

Einige Linux-Distributionen liefern keine statischen Bibliotheken für bestimmte Dinge, die Haskell benötigt, z.B. Arch Linux, was dazu führt, dass `stack build` mit Linkfehlern fehlschlägt, weil wir das `-static` Flag verwenden. Verwenden Sie in diesem Fall `--flag echidna:-static`, um eine dynamisch gelinkte Binärdatei zu erzeugen.

Wenn Sie Fehler beim Erstellen im Zusammenhang mit dem Linken erhalten, versuchen Sie, mit `--extra-include-dirs` und `--extra-lib-dirs` herumzuspielen.

### Erstellen mit Nix (funktioniert nativ auf Apple M1 Systemen)

[Nix-Benutzer](https://nixos.org/download/) können die neueste Echidna mit installieren:```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master

Mit aktivierten Flakes können Sie Echidna direkt von diesem Repository aus ausführen:```sh $ nix run github:crytic/echidna # master $ nix run github:crytic/echidna/v2.1.1 # specific ref (tag/branch/commit)

Um eine eigenständige Veröffentlichung für Nicht-Nix-macOS-Systeme zu erstellen, wird das Folgende Echidna in einem größtenteils statischen Binärprogramm bauen. Dies kann auch auf Linux-Systemen verwendet werden, um ein vollständig statisches Binärprogramm zu erzeugen.```sh
$ nix build .#echidna-redistributable

Nix installiert automatisch alle für die Entwicklung erforderlichen Abhängigkeiten, einschließlich crytic-compile und solc. Eine schnelle Möglichkeit, mit der Entwicklung von Echidna zu beginnen:```sh $ git clone https://github.com/crytic/echidna $ cd echidna $ nix develop # alternatively nix-shell [nix-shell]$ cabal run echidna [nix-shell]$ cabal run tests [nix-shell]$ cabal new-repl

## Öffentliche Nutzung von Echidna

### Eigenschafts-Testsuiten

Dies ist eine unvollständige Liste von Smart-Contract-Projekten, die Echidna zum Testen verwenden:

* [Curvance](https://github.com/curvance/Curvance-CantinaCompetition/tree/CodeFAQAndAdjustments/tests/fuzzing)
* [Primitive](https://github.com/primitivefinance/rmm-core/tree/main/contracts/crytic)
* [Uniswap-v3](https://github.com/search?q=org%3AUniswap+echidna&type=commits)
* [Balancer](https://github.com/balancer/balancer-core/tree/master/echidna)
* [MakerDAO vest](https://github.com/makerdao/dss-vest/pull/16)
* [Optimism DAI Bridge](https://github.com/makerdao/optimism-dai-bridge/blob/master/contracts/test/DaiEchidnaTest.sol)
* [WETH10](https://github.com/WETH10/WETH10/tree/main/contracts/fuzzing)
* [Yield](https://github.com/yieldprotocol/fyDai/pull/312)
* [Convexity Protocol](https://github.com/opynfinance/ConvexityProtocol/tree/dev/contracts/echidna)
* [Aragon Staking](https://github.com/aragon/staking/blob/82bf54a3e11ec4e50d470d66048a2dd3154f940b/packages/protocol/contracts/test/lib/EchidnaStaking.sol)
* [Centre Token](https://github.com/circlefin/stablecoin-evm/tree/release-2024-03-15T223309/echidna_tests)
* [Tokencard](https://github.com/tokencard/contracts/tree/master/tools/echidna)
* [Minimalist USD Stablecoin](https://github.com/usmfum/USM/pull/41)

### Sicherheitsüberprüfungen

Die folgende Liste zeigt öffentliche Sicherheitsüberprüfungen, bei denen Echidna verwendet wurde, um Schwachstellen aufzudecken:

- [Advanced Blockchain](https://github.com/trailofbits/publications/blob/master/reviews/AdvancedBlockchain.pdf)
- [Amp](https://github.com/trailofbits/publications/blob/master/reviews/amp.pdf)
- [Ampleforth](https://github.com/trailofbits/publications/blob/master/reviews/ampleforth.pdf)
- [Atlendis](https://github.com/trailofbits/publications/blob/master/reviews/2023-03-atlendis-atlendissmartcontracts-securityreview.pdf)
- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/2021-04-balancer-balancerv2-securityreview.pdf)
- [Basis](https://github.com/trailofbits/publications/blob/master/reviews/basis.pdf)
- [Dai](https://github.com/trailofbits/publications/blob/master/reviews/mc-dai.pdf)
- [Frax](https://github.com/trailofbits/publications/blob/master/reviews/FraxQ22022.pdf)
- [Liquity](https://github.com/trailofbits/publications/blob/master/reviews/LiquityProtocolandStabilityPoolFinalReport.pdf)
- [LooksRare](https://github.com/trailofbits/publications/blob/master/reviews/LooksRare.pdf)
- [Maple](https://github.com/trailofbits/publications/blob/master/reviews/2022-03-maplefinance-securityreview.pdf)
- [Optimism](https://github.com/trailofbits/publications/blob/master/reviews/2022-11-optimism-securityreview.pdf)
- [Opyn](https://github.com/trailofbits/publications/blob/master/reviews/Opyn.pdf)
- [Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf)
- [Origin](https://github.com/trailofbits/publications/blob/master/reviews/origin.pdf)
- [Paxos](https://github.com/trailofbits/publications/blob/master/reviews/paxos.pdf)
- [Primitive](https://github.com/trailofbits/publications/blob/master/reviews/Primitive.pdf)
- [RocketPool](https://github.com/trailofbits/publications/blob/master/reviews/RocketPool.pdf)
- [Seaport](https://github.com/trailofbits/publications/blob/master/reviews/SeaportProtocol.pdf)
- [Set Protocol](https://github.com/trailofbits/publications/blob/master/reviews/setprotocol.pdf)
- [Shell protocol](https://github.com/trailofbits/publications/blob/master/reviews/ShellProtocolv2.pdf)
- [Sherlock](https://github.com/trailofbits/publications/blob/master/reviews/Sherlockv2.pdf)
- [Pegasys Pantheon](https://github.com/trailofbits/publications/blob/master/reviews/pantheon.pdf)
- [TokenCard](https://github.com/trailofbits/publications/blob/master/reviews/TokenCard.pdf)
- [Uniswap](https://github.com/trailofbits/publications/blob/master/reviews/UniswapV3Core.pdf)
- [Yearn](https://github.com/trailofbits/publications/blob/master/reviews/YearnV2Vaults.pdf)
- [Yield](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf)
- [88mph](https://github.com/trailofbits/publications/blob/master/reviews/88mph.pdf)
- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf)

### Trophäen

Die folgenden Sicherheitslücken wurden mit Echidna gefunden. Falls Sie mit unserem Tool eine Sicherheitslücke gefunden haben, reichen Sie bitte einen PR mit den relevanten Informationen ein.

| Projekt | Schwachstelle | Datum |
|--|--|--|
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Wenn ein Auftrag nicht ausgeführt werden kann, kann er auch nicht storniert werden | Okt. 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Wenn ein Auftrag teilweise mit Null gefüllt werden kann, kann er auch teilweise mit einem Token gefüllt werden | Okt. 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Die cobbdouglas-Funktion macht keinen Rückgängig (revert), wenn gültige Eingabeparameter verwendet werden | Okt. 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Ein Angreifer kann keine Vermögenswerte aus einem öffentlichen Pool stehlen | Jan. 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Ein Angreifer kann mit joinPool keine kostenlosen Pool-Tokens generieren | Jan. 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Das Aufrufen von joinPool-exitPool führt nicht zu kostenlosen Pool-Tokens | Jan. 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Das Aufrufen von exitswapExternAmountOut führt nicht zu kostenlosen Vermögenswerten | Jan. 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Das Schließen von Troves erfordert den vollständigen Betrag der geprägten LUSD](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dez. 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Troves können unsachgemäß entfernt werden](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dez. 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Der erste Rückkauf (redeem) kann unerwartet einen Fehler auslösen | Dez. 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Ein Rückkauf ohne tatsächliche Einlösungen könnte trotzdem Erfolg zurückmelden | Dez. 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Benutzern ist es erlaubt, mehr Token zu übertragen, als sie besitzen | Nov. 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Benutzerguthaben können größer sein als der Gesamtvorrat | Nov. 2020
[Yield Protocol](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf) | Die arithmetische Berechnung beim Kauf und Verkauf von Token ist ungenau | Aug. 2020

### Forschung

Wir können Echidna auch verwenden, um Forschungsbeispiele aus Smart-Contract-Fuzzing-Papieren zu reproduzieren und zu zeigen, wie schnell es die Lösung finden kann. Alle diese Beispiele können in wenigen Sekunden bis zu einer oder zwei Minuten auf einem Laptop gelöst werden.

| Quelle | Code
|--|--
[Using automatic analysis tools with MakerDAO contracts](https://forum.openzeppelin.com/t/using-automatic-analysis-tools-with-makerdao-contracts/1021) | [SimpleDSChief](https://github.com/crytic/echidna/blob/master/tests/solidity/research/vera_dschief.sol)
[Integer precision bug in Sigma Prime](https://github.com/muellerberndt/sabre#example-2-integer-precision-bug) | [VerifyFunWithNumbers](https://github.com/crytic/echidna/blob/master/tests/solidity/research/solcfuzz_funwithnumbers.sol)
[Learning to Fuzz from Symbolic Execution with Application to Smart Contracts](https://files.sri.inf.ethz.ch/website/papers/ccs19-ilf.pdf) | [Crowdsale](https://github.com/crytic/echidna/blob/master/tests/solidity/research/ilf_crowdsale.sol)
[Harvey: A Greybox Fuzzer for Smart Contracts](https://arxiv.org/abs/1905.06944) | [Foo](https://github.com/crytic/echidna/blob/master/tests/solidity/research/harvey_foo.sol), [Baz](https://github.com/crytic/echidna/blob/master/tests/solidity/research/harvey_baz.sol)

### Wissenschaftliche Publikationen

| Titel des Papiers | Veranstaltungsort | Veröffentlichungsdatum |
| --- | --- | --- |
| [echidna-parade: Diverse multicore smart contract fuzzing](https://agroce.github.io/issta21.pdf) | [ISSTA 2021](https://conf.researchr.org/home/issta-2021) | Juli 2021 |
| [Echidna: Effective, usable, and fast fuzzing for smart contracts](https://agroce.github.io/issta20.pdf) | [ISSTA 2020](https://conf.researchr.org/home/issta-2020) | Juli 2020 |
| [Echidna: A Practical Smart Contract Fuzzer](https://github.com/trailofbits/publications/blob/master/papers/echidna_fc_poster.pdf) | [FC 2020](https://fc20.ifca.ai/program.html) | Feb. 2020 |

Wenn Sie Echidna für akademische Arbeiten verwenden, sollten Sie eine Bewerbung für den [Crytic 10.000 $ Forschungspreis](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/) in Betracht ziehen.

## Hilfe erhalten

Besuchen Sie gerne unseren #ethereum-Slack-Kanal bei [Empire Hacking](https://slack.empirehacking.nyc/), um Hilfe bei der Nutzung oder Erweiterung von Echidna zu erhalten.

* Beginnen Sie mit der Überprüfung dieser einfachen [Echidna-Invarianten](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/flags.sol)

* Erwägen Sie, das Echidna-Entwicklungsteam direkt per [E-Mail](mailto:[email protected]) für detailliertere Fragen zu kontaktieren

## Lizenz

Echidna ist unter der [AGPLv3-Lizenz](https://github.com/crytic/echidna/blob/master/LICENSE) lizenziert und wird unter dieser vertrieben.

echidna

Beliebteste