crytic/echidnaEthereum Smart Contract Fuzzer
# Echidna: Ein schneller Smart-Contract-Fuzzer <a href="https://raw.githubusercontent.com/crytic/echidna/master/echidna.png"><img src="https://assets.kitploit.com/production/public/readmes/2659/763a0b6f546e53fe33e871cd7359ba47272d81be37527f1cceaa827256af0337.png" width="75"/></a>
Echidna ist ein seltsames Wesen, das Bugs frisst und äußerst elektrosensibel ist (mit Entschuldigung an Jacob Stanley)
Im Ernst: Echidna ist ein Haskell-Programm, das für Fuzzing/property-basiertes Testen von Ethereum-Smart-Contracts entwickelt wurde. Es verwendet ausgefeilte grammatikbasierte Fuzzing-Kampagnen auf Basis einer [Contract-ABI](https://docs.soliditylang.org/en/develop/abi-spec.html), um benutzerdefinierte Prädikate oder [Solidity-Assertions](https://docs.soliditylang.org/en/develop/control-structures.html#error-handling-assert-require-revert-and-exceptions) zu widerlegen. Wir haben Echidna mit Blick auf Modularität entworfen, sodass es leicht erweitert werden kann, um neue Mutationen aufzunehmen oder bestimmte Contracts in speziellen Fällen zu testen.
## Funktionen
* Generiert Eingaben, die auf Ihren tatsächlichen Code zugeschnitten sind
* Optionale Corpus-Sammlung, Mutations- und Coverage-Führung, um tiefer liegende Bugs zu finden
* Angetrieben von [Slither](https://github.com/crytic/slither), um nützliche Informationen vor der Fuzzing-Kampagne zu extrahieren
* Quellcode-Integration, um zu identifizieren, welche Zeilen nach der Fuzzing-Kampagne abgedeckt sind
* Interaktive Terminal-UI, reine Text- oder JSON-Ausgabe
* Automatische Minimierung von Testfällen für schnelles Triage
* Nahtlose Integration in den Entwicklungsworkflow
.. und [ein wunderschönes handgefertigtes Logo in hoher Auflösung](https://raw.githubusercontent.com/crytic/echidna/master/echidna.png).
<a href="https://i.imgur.com/saFWti4.png"><img src="https://assets.kitploit.com/production/public/readmes/2659/ec117cf17d5b4eeb75f52a3654df19ba615818f232d5e9238093cf010431fedc.png" width="650"/></a>
## Verwendung
### Ausführen des Test-Runners
Die Kernfunktionalität von Echidna ist eine ausführbare Datei namens `echidna`, die einen Contract und eine Liste
von Invarianten (Eigenschaften, die immer wahr bleiben sollten) als Eingabe erhält. Für jede Invariante generiert sie
zufällige Sequenzen von Aufrufen an den Contract und prüft, ob die Invariante gilt. Wenn sie einen Weg findet,
die Invariante zu widerlegen, gibt sie die Aufrufsequenz aus, die dies bewirkt. Wenn nicht, haben Sie eine gewisse
Sicherheit, dass der Contract sicher ist.
### Schreiben von Invarianten
Invarianten werden als Solidity-Funktionen ausgedrückt, deren Namen mit `echidna_` beginnen, keine Argumente haben und einen Boolean zurückgeben. Wenn Sie beispielsweise eine `balance`-Variable haben, die niemals unter `20` fallen sollte, können Sie eine zusätzliche Funktion wie diese in Ihren Contract schreiben:```solidity
function echidna_check_balance() public returns (bool) {
return(balance >= 20);
}
```
Um diese Invarianten zu überprüfen, führe aus:```sh
$ echidna myContract.sol
```
Ein Beispielvertrag mit Tests ist zu finden unter [tests/solidity/basic/flags.sol](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol). Um ihn auszuführen, sollten Sie Folgendes ausführen:```sh
$ echidna tests/solidity/basic/flags.sol
```
Echidna sollte eine Aufrufsequenz finden, die `echidna_sometimesfalse` falsifiziert, und sollte nicht in der Lage sein, eine falsifizierende Eingabe für `echidna_alwaystrue` zu finden.
### Testmodi
Das obige Beispiel verwendet den Standardmodus **property**, aber Echidna unterstützt mehrere Testmodi, die über `testMode` in der Konfigurationsdatei oder `--test-mode` auf der CLI konfiguriert werden:
* **`property`** (Standard): Testet Funktionen mit dem Präfix `echidna_`, die `bool` zurückgeben.
* **`assertion`**: Erkennt Assertion-Fehler von `assert()` und Foundrys `assertX`-Helfern (`assertTrue`, `assertEq` usw.).
* **`foundry`**: Führt Foundry-Style-Tests aus und folgt dabei dessen Namenskonventionen: Unit- und Fuzz-Tests mit Präfix `test` (bei solchen mit Präfix `testFail` wird ein Revert erwartet) und zustandsbehaftete Invarianten mit Präfix `invariant` oder `statefulFuzz`. Funktionen mit Präfix `check` und `prove` sind symbolische Einstiegspunkte, aber da dieser Modus eine Fuzzing-Kampagne ist, werden sie wie jede andere Testfunktion gefuzzt.
* **`verification`**: Verifiziert symbolisch jede Funktion des Contracts mit einer einzigen Transaktion. Funktionen mit Präfix `check` und `prove` werden immer als Einstiegspunkte verwendet.
* **`overflow`**: Erkennt Integer-Über-/Unterläufe (Solidity >= 0.8.0).
* **`optimization`**: Maximiert den Rückgabewert von Funktionen mit Präfix `echidna_`, die `int256` zurückgeben (verwendet dasselbe konfigurierbare Präfix wie der Property-Modus).
* **`exploration`**: Sammelt Coverage, ohne Eigenschaften zu prüfen.
### Sammeln und Visualisieren von Coverage
Nach Abschluss einer Kampagne kann Echidna ein Coverage-maximierendes **Korpus** in einem speziellen Verzeichnis speichern, das mit der Konfigurationsoption `corpusDir` 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 Klartextdatei namens `covered.txt`, eine Kopie des Quellcodes mit Coverage-Annotationen.
Wenn Sie das Beispiel `tests/solidity/basic/flags.sol` ausführen, speichert Echidna einige Dateien mit serialisierten 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 markiert jeden Ausführungs-Trace im Korpus mit dem folgenden "Zeilenmarker":
* `*`, wenn eine Ausführung mit einem STOP endete
* `r`, wenn eine Ausführung mit einem 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](https://book.getfoundry.sh/), [Hardhat](https://hardhat.org/) und [Truffle](https://archive.trufflesuite.com/), unter Verwendung von [crytic-compile](https://github.com/crytic/crytic-compile). Um Echidna mit dem aktuellen Kompilierungs-Framework aufzurufen, verwenden Sie `echidna .`.
Darüber hinaus unterstützt Echidna zwei Modi zum Testen komplexer Verträge. Erstens kann man [den vorhandenen Netzwerkzustand nutzen](https://secure-contracts.com/program-analysis/echidna/advanced/state-network-forking.html) und diesen als Basis-Zustand für Echidna verwenden. Zweitens kann Echidna jeden Vertrag mit bekannter ABI aufrufen, indem die entsprechende Solidity-Quelle in der CLI übergeben wird. Verwenden Sie `allContracts: true` in Ihrer Konfiguration, um dies zu aktivieren.
### Crashkurs zu Echidna
Unser Repository [Building Secure Smart Contracts](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial) enthält einen Crashkurs zu Echidna, einschließlich Beispielen, Lektionen und Übungen.
### Verwendung von Echidna in einem GitHub-Actions-Workflow
Es gibt eine Echidna-Action, mit der `echidna` als Teil eines GitHub-Actions-Workflows ausgeführt werden kann. Bitte lesen Sie das Repository [crytic/echidna-action](https://github.com/crytic/echidna-action) für Anweisungen zur Verwendung 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 finden Sie unter
[tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/default.yaml).
Weitere detaillierte Informationen zu den verfügbaren Konfigurationsoptionen finden Sie in der [Dokumentation](https://secure-contracts.com/program-analysis/echidna/configuration.html).
Echidna unterstützt drei verschiedene Ausgabetreiber. Es gibt den Standard-`text`-Treiber, einen `json`-Treiber und einen `none`-Treiber, der alle `stdout`-Ausgaben unterdrücken sollte. Der JSON-Treiber meldet die Gesamtkampagne 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 abdeckungserhöhende Aufrufe beschreibt. Diese Schnittstellen
können zu einem späteren Zeitpunkt geändert werden, um etwas benutzerfreundlicher zu sein. `testType`
ist eines von `property`, `assertion`, `optimization`, `exploration` oder `call`,
und `status` nimmt immer einen der Werte `fuzzing`, `shrinking`, `solved`, `passed` oder `error` an.
### Debuggen 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
```
Dadurch wird eine Berichtsdatei (`echidna.prof`) erzeugt, die anzeigt, welche Funktionen die meiste CPU- und Speichernutzung verursachen.
Wenn das grundlegende Profiling nicht hilft, können Sie [fortgeschrittenere 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:
- Kostspielige Funktionen, die in Hot Paths aufgerufen werden
- Lazy-Datenkonstruktoren, die Thunks ansammeln
- Ineffiziente Datenstrukturen, die in Hot Paths verwendet werden
Die Überprüfung auf diese ist ein guter Ausgangspunkt. Wenn Sie vermuten, dass eine Berechnung zu lazy ist und Speicher verliert, 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 sind von [hevm](https://github.com/argotorg/hevm) übernommen, während andere auf Design-/Performance-Entscheidungen oder einfach auf Fehler in unserem Code zurückzuführen sind. Wir listen sie hier auf, einschließlich des entsprechenden Issues und des Status ("wont fix", "on hold", "in review", "fixed"). Issues, die "fixed" sind, werden voraussichtlich in der nächsten Echidna-Version 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
Bevor Sie beginnen, stellen Sie sicher, dass Slither [installiert](https://github.com/crytic/slither) ist (`pip3 install slither-analyzer --user`).
Wenn Sie Echidna schnell unter Linux oder MacOS testen möchten, stellen wir statisch gelinkte Linux-Binärdateien, die auf Ubuntu gebaut wurden, und größtenteils statische MacOS-Binärdateien auf unserer [Releases-Seite](https://github.com/crytic/echidna/releases) bereit. Sie können dieselbe Art von 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) installieren, indem Sie `brew install echidna` ausführen.
Sie können auch den neuesten Code des `master`-Branches kompilieren und installieren, indem Sie `brew install --HEAD echidna` ausführen.
Weitere Informationen finden Sie auf der Seite der [`echidna` Homebrew Formula](https://formulae.brew.sh/formula/echidna). Die Formula 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 vorgefertigten Docker-Container bevorzugen, sehen Sie sich unser [Docker-Paket](https://github.com/orgs/crytic/packages?repo_name=echidna) an, das über GitHub Actions automatisch gebaut wird. Der `echidna`-Container basiert auf `ubuntu:noble` und soll ein kleines, aber dennoch flexibles Image sein, um Echidna zu verwenden. Es bietet eine vorgefertigte 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 gebaut werden. Das Ausführen 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 dem Release `vx.y.z`
| `latest` | Neuestes getaggtes Echidna-Release.
| `edge` | Neuester Commit auf dem Standard-Branch.
| `testing-foo` | Test-Build basierend auf dem Branch `foo`.
Um den Container mit der neuesten Echidna-Version interaktiv auszuführen, können Sie etwas wie den folgenden Befehl verwenden. Er bindet das aktuelle Verzeichnis als `/src` im Container ein 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. Um beispielsweise solc
0.5.7 zu installieren und `tests/solidity/basic/flags.sol` zu prü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 außerdem Foundry-Tools für umfassende Smart-Contract-Entwicklung und -Tests. 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 du es vorziehst, aus dem Quellcode zu erstellen, verwende [Stack](https://docs.haskellstack.org/en/stable/). `stack install` sollte `echidna` in `~/.local/bin` erstellen und kompilieren. Du musst gegen libreadline und libsecp256k1 (mit aktivierter Wiederherstellung erstellt) linken, die mit dem Paketmanager deiner Wahl installiert werden sollten. Du musst außerdem die neueste Version von [libff](https://github.com/scipr-lab/libff) installieren. Orientier dich an unseren [CI-Tests](https://github.com/crytic/echidna/blob/master/.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 Linker-Fehlern fehlschlägt, weil wir das `-static`-Flag verwenden. Verwende in diesem Fall `--flag echidna:-static`, um eine dynamisch gelinkte Binärdatei zu erzeugen.
Wenn du Fehler beim Erstellen im Zusammenhang mit dem Linken erhältst, versuche, mit `--extra-include-dirs` und `--extra-lib-dirs` zu experimentieren.
### Erstellen mit Nix (funktioniert nativ auf Apple-M1-Systemen)
[Nix-Nutzer](https://nixos.org/download/) können die neueste Echidna installieren mit:```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master
```
Mit aktivierten Flakes kannst du Echidna direkt aus diesem Repository 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 Version für Nicht-Nix-macOS-Systeme zu erstellen, wird mit dem Folgenden Echidna in einer größtenteils statischen Binärdatei gebaut. Dies kann auch auf Linux-Systemen verwendet werden, um eine vollständig statische Binärdatei zu erzeugen.```sh
$ nix build .#echidna-redistributable
```
Nix installiert automatisch alle für die Entwicklung erforderlichen Abhängigkeiten,
einschließlich `crytic-compile` und `solc`. Ein schneller Weg, 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
```
### Ausführen der Test-Suites
`cabal run tests` ist die Haskell-Suite und deckt alles ab, was Echidna
im Prozess tut.
Der MCP-Server wird stattdessen außerhalb des Prozesses getestet, indem eine echte Kampagne gestartet und
sie so gesteuert wird, wie es ein Agent-Client tun würde. Diese Suite ist in Python geschrieben und benötigt
ein `echidna` im `$PATH`:```sh
$ pip install -r tests/mcp/requirements-test.txt
$ pytest tests/mcp -v
```
Richte es auf eine Kampagne, die du selbst gestartet hast, mit `ECHIDNA_MCP_URL`, auf einen anderen Port mit `ECHIDNA_MCP_PORT` oder auf eine bestimmte Binärdatei mit `ECHIDNA_BIN`. Ein Beispiel für einen Agenten, der eine Kampagne über dieselbe Schnittstelle steuert, findest du in [examples/](https://github.com/crytic/echidna/blob/master/examples/README.md).
## Öffentliche Nutzung von Echidna
### Property-Testing-Suites
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
Das Folgende zeigt öffentliche Sicherheitsüberprüfungen, bei denen Echidna eingesetzt 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 von Echidna gefunden. Wenn du mit unserem Tool eine Sicherheitslücke gefunden hast, reiche 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 eine Order nicht gefüllt werden kann, kann sie nicht storniert werden | Okt 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Wenn eine Order teilweise mit null gefüllt werden kann, kann sie 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 wird nicht zurückgesetzt, wenn gültige Eingabeparameter verwendet werden | Okt 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Ein Angreifer kann keine Assets 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-Token generieren | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Der Aufruf von joinPool-exitPool führt nicht zu kostenlosen Pool-Token | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Der Aufruf von exitswapExternAmountOut führt nicht zu kostenlosen Assets | Jan 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Das Schließen von Troves erfordert das Halten des vollen Betrags an geprägtem 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) | Die anfängliche Einlösung kann unerwartet zurückgesetzt werden | Dez 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Einlösen ohne Einlösungen könnte dennoch Erfolg zurückgeben | Dez 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Benutzer dürfen mehr Token ü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 das Gesamtangebot | Nov 2020
[Yield Protocol](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf) | Die arithmetische Berechnung für den Kauf und Verkauf von Token ist ungenau | Aug 2020
### Forschung
Wir können Echidna auch verwenden, um Forschungsbeispiele aus Smart-Contract-Fuzzing-Papers zu reproduzieren, um zu zeigen, wie schnell es die Lösung finden kann. All diese können in wenigen Sekunden bis ein oder zwei Minuten auf einem Laptop-Computer 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)
### Akademische Publikationen
| Paper-Titel | Veranstaltung | 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 du Echidna für akademische Arbeit verwendest, ziehe in Betracht, dich für den [Crytic $10k Research Prize](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/) zu bewerben.
## Hilfe erhalten
Komm gerne in unserem #ethereum-Slack-Kanal in [Empire Hacking](https://slack.empirehacking.nyc/) vorbei, um Hilfe bei der Verwendung oder Erweiterung von Echidna zu erhalten.
* Beginne mit der Durchsicht dieser einfachen [Echidna-Invarianten](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol)
* Ziehe in Betracht, 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.