KI-Framework für Smart-Contract-Sicherheitsanalyse und PoC-Generierung

Neuerungen in v5.0

SAGE-Institutionsgedächtnis — Aether lernt jetzt aus jedem Audit, reduziert False Positives und verbessert die Befundqualität im Laufe der Zeit:

• Vortrainierte Wissensbasis — Wird mit 170 institutionellen Erinnerungen ausgeliefert: 75 Exploit-Muster, 63 Checklisten zu Protokoll-Archetypen, 12 Kategorien für Token-Eigenheiten, 20 kuratierte historische Exploits (DAO, Wormhole, Euler, Ronin, Curve und weitere)
• Pipeline-Integration — SAGE ruft historische Befunde und Exploit-Muster in den Deep-Analyse-Passes 3 und 5 ab; speichert Audit-Erkenntnisse nach der Pipeline für den zukünftigen Abruf
• Feedback-Schleife — Bestätigte Befunde werden als Fakten mit hoher Konfidenz gespeichert; abgelehnte Befunde (False Positives) werden gespeichert, damit zukünftige Audits sie vermeiden. Ergebnisse des AccuracyTracker fließen automatisch in SAGE ein
• Validierungspipeline — Neue Stufe -1: Die SAGE-Bekannte-FP-Prüfung filtert Befunde, die zuvor abgelehnten Mustern entsprechen, bevor eine andere Validierung ausgeführt wird
• Detektor-Genauigkeitssynchronisierung — SageFeedbackManager.sync_detector_accuracy() identifiziert Detektoren mit hoher/niedriger Leistung und speichert Dos-and-Don'ts-Reflexionen
• Automatisches Seeding beim Start — Der erste Start mit laufendem SAGE-Docker initialisiert die vortrainierte Wissensbasis automatisch. Versionsbewusst: überspringt das Seeding, wenn bereits durchgeführt
• TUI-Integration — SAGE-ON/OFF-Status mit Speicheranzahl, die in der CostBar angezeigt wird
• Docker-Bereitstellung — docker compose up -d startet SAGE; Konfiguration über sage_enabled/sage_url in ~/.aether/config.yaml
• Sanfte Degradation — Wenn SAGE nicht verfügbar ist, wird die Audit-Funktionalität niemals beeinträchtigt

Mitwirkende: Dank an @sashavdv für die Behebung hartcodierter Pfadvariablen (PR #1) und an @pro258b für das Identifizieren der fehlenden Methode validate_anthropic_key() (PR #2).

SAGE-Schnellstart

SAGE ist ein persistentes institutionelles Gedächtnissystem, das auf BFT-Konsens basiert. Die vollständige Dokumentation finden Sie im SAGE-Projekt.```bash

Install SAGE Python SDK

pip install sage-agent-sdk

Start SAGE (Docker required)

docker compose up -d

Run Aether — SAGE auto-seeds on first launch

python aether.py

Regenerate seed fixtures after updating knowledge bases (dev only)

python -c "from core.sage_seeder import SageSeeder; SageSeeder.generate_seed_fixtures()"

Neuerungen in v4.7

Automatische PoC-Ausführung — Generierte Foundry-PoCs werden jetzt automatisch kompiliert und ausgeführt:

• Die forge test --json-Integration führt PoCs unmittelbar nach der Kompilierung aus
• JSON-Ergebnisanalyse mit der PoCTestResult-Dataclass für strukturierte Erfolgs-/Fehler-/Fehlermeldungen
• Fork-Modus-Unterstützung zur Mainnet-Validierung von Exploits gegen den Live-Zustand
• Neue POC_TESTING-Phase im JobManager für die Live-Fortschrittsverfolgung in der TUI

Symbolische Ausführung mit Halmos — Formale Verifikation mittels symbolischer Ausführung:

• HalmosRunner zur Ausführung von Halmos-Symboltests gegen generierte Eigenschaften
• HalmosPropertyGenerator zur automatischen Generierung von Verifikationseigenschaften aus extrahierten Invarianten
• HalmosSymbolicNode-Pipelineknoten integriert in Validierungsstufe 1.95
• Konfigurationsoptionen: enable_symbolic_verification, halmos_timeout
• Fällt elegant zurück, wenn Halmos nicht installiert ist – die symbolische Verifikation wird ohne Fehler übersprungen

Kontrollflussgraphen-Analyse — Kontrollflussverständnis auf Compiler-Ebene:

• BasicBlock-, CFGEdge- und ControlFlowGraph-Dataclasses in solidity_ast.py
• build_cfg(), get_dominators(), get_loop_headers(), format_cfg_for_llm() für die Strukturanalyse
• Assembly-Block-Parsing über parse_assembly_block() zur Unterstützung von Inline-Assembly
• Verzweigungsbewusste Taint-Ausbreitung im Taint-Analyzer für pfadsensitive Analyse
• CFG-Kontext wird zusammen mit Taint-Daten in die Pass-2-Analyse der Tiefenanalyse injiziert

ML-Feedback-Schleife — Kalibrierung auf Basis historischer Ergebnisse:

• AccuracyTracker.record_finding_outcome() zur Verfolgung von Submission-Ergebnissen und Bounty-Einnahmen
• get_detector_accuracy() und get_detector_weights() für detektorspezifische Leistungsstatistiken
• DetectorStats-Dataclass zur Verfolgung von True/False Positives und der historischen Genauigkeit
• Anpassung der Konfidenzgewichte im EnhancedVulnerabilityDetector basierend auf der Erfolgsbilanz des Detektors
• In die Pass-5-Analyse der Tiefenanalyse fließt eine Schweregradkalibrierung aus historischen Daten ein

Kontext verwandter Verträge — Die LLM-Analyse sieht jetzt den vollständigen Quellcode der Abhängigkeiten:

• RelatedContractResolver erkennt automatisch Parent-, Interface-, Bibliotheks- und Abhängigkeitsverträge
• Der Projektmodus nutzt die Analyse von Beziehungen zwischen Verträgen; der Einzeldateimodus parst Import-Anweisungen
• Budgetsystem pro Pass: 200K Zeichen für Gemini-Flash-Pässe, 100K für Claude, 50K für GPT
• Standardbibliotheken (@openzeppelin, solmate, solady) werden zur Budgetersparnis auf reine Interfaces reduziert
• Einzeldatei-Audits erkennen automatisch zugehörige .sol-Dateien als Kontext

Bereinigung technischer Schulden — 8.500 Zeilen toter Code entfernt:

• Gelöscht: ai_ensemble.py, audit_engine.py, fork_verifier.py
• Alle ai_ensemble-Referenzen aus CLI, Audit-Runner, TUI-Bildschirmen und Report-Generator entfernt
• slither_project_cache aus dem Datenbank-Manager entfernt
• Formale-verifikations-Stubs aus der erweiterten Audit-Engine entfernt

Neuerungen in v4.0

Solidity-AST-Parsing — Aether v4.0 fügt compilerbasierte Codeanalyse über py-solc-x hinzu und geht damit über reine Regex-Statikanalyse hinaus:

• Vollständige solc --ast-json-Integration für korrekte Vererbungsauflösung, Funktionssichtbarkeit, Storage-Layout mit Slot-Nummern und Lese-/Schreibverfolgung von Zustandsvariablen pro Funktion
• Graziöser Regex-Fallback, wenn die Kompilierung fehlschlägt (fehlende Imports, falsche Compiler-Version)
• Strukturelle AST-Zusammenfassung wird automatisch in die LLM-Pipeline der Tiefenanalyse eingespeist, um das Protokoll besser zu verstehen

Taint-Analyse-Engine — Verfolgt benutzergesteuerte Eingaben durch Verträge, um gefährliche Datenflüsse zu identifizieren:

• 8 Taint-Quelltypen: Funktionsparameter, msg.sender, msg.value, calldata, Rückgabewerte externer Aufrufe, block.timestamp, block.number, tx.origin
• 12 gefährliche Senkentypen: delegatecall, selfdestruct, externe Aufrufe, ETH-Transfers, Storage-Schreibvorgänge, Array-Indizierung, Division durch null und mehr
• Sanitizer-Erkennung: erkennt require-Grenzprüfungen, Zugriffskontroll-Modifier, bedingte Reverts, Math.min/max-Klemmung, SafeCast
• Cross-Contract-Taint-Tracking über mehrere Dateien hinweg
• In die Validierungspipeline (Stufe 1.85) integriert, für taint-bewusste Bestätigung/Widerlegung von Funden

Cross-Contract-Analyse (Pass 3.5) — Neuer Tiefenanalyse-Pass, der auf Multi-Contract-Schwachstellen abzielt:

• Beziehungsanalysator zwischen Verträgen: erkennt Vererbung, Interface-Aufrufe, delegatecall, staticcall und typisierte Zustandsvariablen-Beziehungen
• Union-Find-Gruppierung verwandter Verträge mit Vertrauensgrenzen-Erkennung
• Eigener LLM-Pass zur Analyse von: Vertrauensgrenzen-Verletzungen, Cross-Contract-Zustandskonsistenz, Cross-Contract-Reentrancy, Interface-Konformität, Upgrade-Interaktionen und Privilegieneskalation
• Cross-Contract-Kontext wird auch in Pass 4 für funktionsübergreifendes Bewusstsein eingespeist

Token-Quirks-Datenbank — 12 Kategorien nicht standardgemäßer ERC-20-Verhaltensweisen, die echte Exploits verursachen:

Integriert in die statische Erkennungspipeline und die Archetyp-Checklisten.

Erweiterte Präzisions-Engine — Fortgeschrittene Erkennung von Rundungs- und Präzisionsschwachstellen:

• Share-Inflation / First-Depositor-Angriff-Erkennung für ERC-4626-Vaults, Kreditpools, Staking
• Rundungsrichtungsanalyse — Einzahlungen sollten abgerundet werden, Auszahlungen aufgerundet
• Verfolgung von Divisionsabbrüchen — erkennt abgeschnittene Ratenvariablen, die später in Multiplikationen verwendet werden
• Dust-Exploitation-Erkennung — Abrunden auf null ermöglicht kostenlose Operationen
• Akkumulator-Überlauf — Risikobewertung für Überläufe des Belohnungsakkumulators

Ausführbare PoC-Generierung — Generierte Foundry-Tests kompilieren und laufen jetzt tatsächlich:

• Mock-Vertragsbibliothek: MockERC20, MockOracle, MockWETH, MockFlashLoanProvider
• Intelligenter setUp()-Generator: extrahiert Konstruktorparameter, deployed Mocks, behandelt upgradebare Verträge, mint Token und setzt Approvals
• Maximale Kompilierungsversuche von 3 auf 5 erhöht
• LLM-Prompts enthalten Mock-API-Dokumentation und empfohlenes setUp

LLM-Pipeline-Verbesserungen:

• Few-Shot-Beispiele in den Pässen 3, 4, 5 — echte Schwachstellen- und False-Positive-Beispiele aus der Exploit-Wissensdatenbank
• Schweregradkalibrierung — konkrete Schwellenwerte, die an die finanzielle Auswirkung gekoppelt sind (Critical >$1M, High >$100K, Medium >$10K)
• Erzwingung von Chain-of-Thought — verpflichtende 5-Schritte-Argumentation vor der JSON-Ausgabe
• Multi-Provider-Rotation — Gemini Flash für günstige Pässe, Anthropic Claude für Reasoning, OpenAI GPT für Diversität
• AI-Ensemble ausgemustert — das 6-Agenten-Ensemble (6-fache Kosten, schlechterer Kontext) wurde durch Provider-Rotation innerhalb der strukturierten Pipeline ersetzt

Neuerungen in v3.5

Tiefenanalyse-Engine — Aether v3.5 verändert die Art und Weise, wie das Tool Schwachstellen findet, grundlegend: von einem One-Shot-„Find Bugs"-LLM-Aufruf hin zu einer strukturierten 6-Pass-Pipeline, die die Arbeitsweise professioneller Auditoren widerspiegelt: erst verstehen, dann systematisch angreifen.

Tiefenanalyse-Engine (6-Pass-LLM-Pipeline)

Statt einen gesamten Vertrag mit einem einzigen Prompt an eine LLM zu senden, führt Aether nun sechs aufeinanderfolgende Analyse-Pässe mit angesammeltem Kontext aus:

Pässe 1-2 werden anhand des Vertragsinhalts-Hashs gecacht, sodass Re-Audits die Verständnisphase überspringen. Jeder nachfolgende Pass erhält den gesamten bisherigen Kontext und baut so ein umfassendes Angriffsmodell auf. Feature-flagged mit AETHER_DEEP_ANALYSIS=1 (Standard: AN); fällt bei Fehlern auf One-Shot zurück.

Protokoll-Archetyp-System

Bevor Aether nach Fehlern sucht, erkennt es, welche Art von Protokoll der Vertrag implementiert, und lädt archetypspezifische Schwachstellen-Checklisten:

Insgesamt 10 Archetypen, jeder mit 3-7 spezifischen Checklistenpunkten, die aus realen Exploits abgeleitet sind.

Exploit-Wissensdatenbank (50+ Muster)

Eine strukturierte Datenbank mit über 50 kategorisierten realen Exploit-Mustern ersetzt die bisherige statische Liste mit 10 Mustern:

Jedes Muster enthält Code-Indikatoren, fehlende Schutzmaßnahmen, den schrittweisen Exploit-Mechanismus und reale Präzedenzfälle (mit Dollar-Beträgen). Die Muster werden nach erkanntem Archetyp und Agenten-Fokusbereich gefiltert.

Invarianten-Engine

Extrahiert automatisch Protokollinvarianten aus drei Quellen:

1. NatSpec-@invariant-Tags in Vertragskommentaren
2. LLM-entdeckte Invarianten aus Pass 1 der Tiefenanalyse
3. Mustererkannte häufige Invarianten (Kontostanderhaltung, AMM-Konstantprodukt, Besicherungsquoten usw.)

Generiert Foundry-invariant_*()-Testsuiten, die als Beweis im Format der formalen Verifikation (lite) dienen – ein fehlschlagender Invariantentest beweist, dass der Fehler real ist.

Pipeline-Korrekturen

• Kontextbewusste Schweregradkalibrierung — stuft division_by_zero, integer_underflow usw. nicht mehr pauschal auf niedrig herab. Prüft nun, ob sich der Fund in einem unchecked{}-Block, in der Nähe von Werttransfers, in Preisberechnungen oder in Oracle-Kontexten befindet, bevor entschieden wird.
• Fix des Validierungsgates — "pending"-Funde werden jetzt an die LLM-Analyse durchgereicht (zuvor wurden nur "validated"-Funde durchgelassen, wodurch viele echte Funde stillschweigend verworfen wurden)
• Spezialistenbewusste Konfidenzstrafe — Einzelagenten-Funde eines Spezialisten in seiner Domäne (z. B. AnthropicReasoningSpecialist, der einen komplexen Logikfehler findet) erhalten nur eine Strafe von -0,05 statt -0,15
• Fix der Zeilen-Bucket-Deduplizierung — die willkürliche (line // 10) * 10-Bucketing wurde entfernt, die Funde, die 2 Zeilen auseinanderlagen, in verschiedene Gruppen aufteilte
• DeFi-Detektor-Integration — DeFiVulnerabilityDetector (zweistufige Präsenz-/Absenz-Analyse) läuft jetzt in der erweiterten Haupt-Audit-Engine, nicht nur in der flow-basierten Pipeline

Neuerungen in v3.0

Vollständig Inline-Textual-TUI — Aether v3.0 ist eine persistente Vollbildanwendung, die niemals auf ein rohes Terminal zurückfällt. Jeder Vorgang — Audits, PoC-Generierung, Report-Generierung, GitHub-Scope-Auswahl, Konfiguration der Einstellungen — läuft vollständig innerhalb der TUI:

• Null app.suspend()-Aufrufe — die TUI verschwindet nie, keine abrupten Terminalwechsel
• Hintergrundjobs für alles — lokale Audits, GitHub-Audits, PoC-Generierung und Report-Generierung laufen alle als Daemon-Threads mit Live-Output-Streaming
• Live-Job-Tabelle — htop-artige Ansicht aller laufenden/abgeschlossenen Jobs mit Echtzeitstatus, Phasenfortschritt, Anzahl der Funde, Kosten und verstrichener Zeit
• Drill-down pro Job — Drücken Sie Enter auf einem beliebigen Job, um den live scrollenden Output, die Phasen-Fortschrittsanzeige und Metadaten zu sehen
• Parallele Vorgänge — mehrere Audits, PoC-Generierungen und Reports gleichzeitig starten; alle sichtbar und nachverfolgbar
• Vertragswahl-Dialog — filterbare, nahezu vollbildgroße Mehrfachauswahl, die den alten curses-basierten Selektor ersetzt. Leertaste zum Umschalten, a/n für alle/keine, Tippen zum Filtern, farbcodierte, bereits geprüfte Verträge
• Inline-GitHub-Audit-Ablauf — klonen, entdecken, Verträge auswählen und Audits starten, ohne die TUI zu verlassen. Scope-Verwaltung (fortsetzen, erneut auditieren, neuer Scope) über native Textual-Dialoge
• Inline-Einstellungen — API-Key-Konfiguration und Modellauswahl über TextInputDialog und SelectDialog, kein externer Setup-Assistent erforderlich
• Sitzungskostenleiste — Echtzeit-LLM-Kostenverfolgung nach Anbieter (OpenAI, Gemini, Anthropic)
• Tastaturgesteuert — n Neues Audit, r Fortsetzen, h Verlauf, p PoCs, o Reports, f Abrufen, s Einstellungen, q Beenden

Vier Arten von Hintergrundjobs: Alle schweren Vorgänge laufen als Hintergrund-Daemon-Threads über AuditRunner, wobei die Ausgabe von ThreadDemuxWriter erfasst und in JobDetailScreen angezeigt wird:

LLM-Unterstützung für drei Anbieter: OpenAI (GPT-5/5.3), Google Gemini (2.5/3.0) und Anthropic Claude (Sonnet 4.5/Opus 4.6) für maximale Flexibilität und Redundanz.

Erweiterte PoC-Generierung: AST-basierte Vertragsanalyse, iterative Kompilierungs-Korrekturen und produktionsreife LLM-Prompts, die Exploits erzeugen, die für Bug-Bounty-Einreichungen geeignet sind.

Erweiterte False-Positive-Filterung: Mehrstufige Validierung reduziert False Positives von 66 % auf ~20-25 % und verbessert die Genauigkeit von 33 % auf 75-80 %:

• Skript-Erkennung — Deploymentskripte (script/, .s.sol, forge-std/Script.sol) werden automatisch von der Schwachstellenanalyse ausgeschlossen
• Dateikontext-Marker — LLM-Prompts enthalten [PRODUCTION]/[DEPLOYMENT SCRIPT]-Kennzeichnungen, damit sich die Modelle auf Produktionscode konzentrieren
• Dynamische Modifier-Erkennung — benutzerdefinierte Zugriffskontroll-Modifier (z. B. onlyDistributor, authorized) werden aus dem Vertragsquellcode extrahiert und neben hartcodierten Mustern erkannt
• Deduplizierung im Funktionsbereich — doppelte Funde in derselben Funktion werden zusammengeführt, anstatt eine fragile Nähe von Zeilennummern zu verwenden
• Erkennung atomarer Konstruktoren — deploy+initialize im selben Konstruktor wird als nicht front-runnable erkannt
• Governance-Erkennung (nur durch onlyOwner/onlyGovernor geschützte Parameter)
• Deployment-Analyse (verifiziert, dass Codepfade tatsächlich in der Produktion verwendet werden)
• Eingebaute Schutzprüfungen (Solidity 0.8+ Auto-Protection, SafeMath)
• Governance-bewusste LLM-Validierung mit 18-Muster-Checkliste
• Genauigkeitsverfolgung mit Submission-Ergebnissen und Bounty-Einnahmen
• Intelligentes Caching für 2x schnellere wiederholte Analysen

Integration der Move-Schwachstellendatenbank: Muster aus 128 Critical/High-Funden über 77 Audits, angepasst für Solidity/EVM:

• Business-Logik, Zustandsverwaltung, Dateninkonsistenz, Zentralisierung, Schleifenprobleme und erweiterte Eingabevalidierung

Schnellstart

1. Einrichtung```bash

python setup.py # Interactive installer (recommended)

Das war's. Die TUI führt dich per Tastenkürzel und modalen Dialogen durch alles.

Voraussetzungen

• Python 3.11+ (getestet mit 3.12.8)
• Node.js 22+ (für Hardhat-/npm-basierte Projekte)
• Foundry (forge/anvil) im PATH für PoC-Generierung und -Validierung
• solc-select für mehrere Solidity-Compiler-Versionen
• py-solc-x (optional) für Solidity-AST-Parsing — greift auf Regex-Analyse zurück, falls nicht verfügbar
• API-Schlüssel für LLM-Funktionen:
  • OPENAI_API_KEY (für GPT-Modelle)
  • GEMINI_API_KEY (für Gemini-Modelle)
  • ANTHROPIC_API_KEY (für Claude-Modelle)
  • ETHERSCAN_API_KEY (optional, zum Abrufen verifizierter Verträge)

Manuelle Einrichtung

Wenn du eine manuelle Installation bevorzugst:```bash

Foundry

curl -L https://foundry.paradigm.xyz | bash && foundryup export PATH="$PATH:$HOME/.foundry/bin"

solc-select

pip install solc-select solc-select install 0.4.26 0.8.0 0.8.19 0.8.20 latest

Python dependencies

python -m venv venv && source venv/bin/activate pip install -r requirements.txt

Die Konfiguration wird in ~/.aether/config.yaml gespeichert.

Speicherorte der Datenbanken:

• Engine-Ergebnisse: ~/.aether/aetheraudit.db
• GitHub-Audit-Workflow: ~/.aether/aether_github_audit.db

TUI-Anleitung

Die gesamte Interaktion erfolgt über Tastaturkürzel vom Hauptbildschirm aus:

n — Neues Audit

Mehrstufiger Assistent mit drei Quelltypen:

Lokale Datei oder Verzeichnis:

1. Pfad über PathDialog auswählen
2. Bei Verzeichnis: Contracts über CheckboxDialog auswählen
3. Funktionen wählen (Enhanced, LLM-Validierung, Foundry-PoC, Enhanced Reports)
4. Ausgabeverzeichnis festlegen
5. Bestätigen und als Hintergrundjob(s) starten

GitHub-URL:

1. Repository-URL eingeben
2. Aether klont das Repository und erkennt Contracts (Fortschritt inline angezeigt)
3. Falls frühere Scopes existieren: fortfahren, erneut auditieren oder neuen Scope erstellen
4. Contracts über ContractSelectorDialog auswählen (filterbar, Leertaste zum Umschalten, a/n für alle/keine)
5. Das Audit startet als Hintergrundjob — sichtbar in der Job-Tabelle

Block-Explorer-URL / Adresse:

1. Adresse oder Explorer-URL eingeben
2. Aether ruft den verifizierten Quellcode ab
3. Durch die Auswahl von Funktionen und Ausgabe fortfahren

r — Audit fortsetzen

Tabelle aller laufenden GitHub-Audits mit Projektname, Scope, Fortschritt (N/M Contracts) und Zeitpunkt der letzten Aktualisierung. Einen Eintrag auswählen, um ausstehende Contracts zu verifizieren und als Hintergrundjob zu starten.

h — Audit-Verlauf

Einheitliche Ansicht aller vergangenen Audits aus beiden Datenbanken (lokal + GitHub). Einen beliebigen Eintrag auswählen, um ein Untermenü zu öffnen:

• Details anzeigen — Scope-Aufschlüsselung mit Fortschritt und Status
• PoCs generieren — Weiterleitung zum PoC-Assistenten mit vorausgewähltem Projekt
• Erneut auditieren — Contracts über ContractSelectorDialog auswählen, als Hintergrundjob starten

p — PoCs generieren

Projekt auswählen, maximale Anzahl, Mindestschweregrad und Nur-Konsens-Filter konfigurieren. Die PoC-Generierung läuft als Hintergrundjob — Fortschritt in der Job-Tabelle beobachten.

o — Berichte

Projekt, Scope und Format auswählen (markdown/json/html/all). Die Berichtserstellung läuft als Hintergrundjob.

f — Contract abrufen

Netzwerk aus 10+ unterstützten Chains wählen, Adresse eingeben oder Explorer-URL einfügen, den verifizierten Quellcode abrufen und optional sofort auditieren.

s — Einstellungen

• Vollständigen Setup-Assistenten ausführen — API-Schlüssel, dann Modellauswahl, alles inline
• Aktuelle Konfiguration anzeigen — formatierte Anzeige aller Einstellungen
• API-Schlüssel neu konfigurieren — TextInputDialog-Eingabeaufforderungen mit maskierten aktuellen Werten
• Modellauswahl neu konfigurieren — SelectDialog pro Anbieter
• Triage-Einstellungen — Schweregrad, Konfidenzschwelle, maximale Befunde
• Daten löschen — lokale Audit-DB, GitHub-Audit-DB, Analyse-Cache oder alles auf einmal löschen (mit Bestätigung)

Enter — Job-Details

Enter auf einer beliebigen Zeile der Job-Tabelle drücken, um Folgendes zu sehen:

• Live scrollende Log-Ausgabe (jede Sekunde aktualisiert)
• Phasen-Fortschrittsbalken
• Job-Metadaten (Typ, Ziel, Status, Kosten, verstrichene Zeit)

q — Beenden

Beendet die TUI. Wenn Jobs laufen, fragt sie nach einer Bestätigung.

Funktionsumfang und Fähigkeiten

• Solidity-AST-Parsing — Compiler-gestützte Codeanalyse über py-solc-x für korrekte Vererbungsauflösung, Funktionssichtbarkeit, Storage-Layout und Lese-/Schreib-Tracking von Zustandsvariablen; sanfter Regex-Fallback
• Kontrollflussgraphen-Analyse — build_cfg() konstruiert Basisblöcke mit Dominatorbäumen und Schleifenkopf-Erkennung; Parsing von Assembly-Blöcken; CFG-Kontext fließt in die Tiefenanalyse und Taint-Propagation ein
• Taint-Analyse-Engine — Verfolgt benutzergesteuerte Eingaben (8 Quelltypen) durch Contracts bis hin zu 12 gefährlichen Sink-Typen mit Sanitizer-Erkennung, Cross-Contract-Tracking und verzweigungsbewusster CFG-Propagation
• Cross-Contract-Analyse — Analyzer für Beziehungen zwischen Contracts mit Vertrauensgrenzen-Erkennung, Union-Find-Gruppierung, dediziertem LLM-Durchlauf (Pass 3.5) für Multi-Contract-Schwachstellen und RelatedContractResolver für den Abhängigkeitskontext
• Tiefenanalyse-Engine — 6-Durchlauf-LLM-Pipeline plus Pass 3.5 (Cross-Contract): verstehen → Angriffsfläche abbilden → Invarianten prüfen → Cross-Contract-Analyse → Cross-Function-Analyse → adversariale Modellierung → Randfälle; Modellstufenauswahl pro Durchlauf, Caching, Few-Shot-Beispiele, Chain-of-Thought-Erzwingung, CFG-Kontext in Pass 2, ML-Schweregradkalibrierung in Pass 5, Kontext verwandter Contracts pro Durchlauf
• Halmos-Symbolische Ausführung — HalmosRunner + HalmosPropertyGenerator für die formale Verifikation von Invarianten; integriert in Validierungsstufe 1.95; sanfte Degradation, wenn Halmos nicht installiert ist
• ML-Feedback-Schleife — AccuracyTracker erfasst Einreichungsergebnisse und erzeugt Konfidenzgewichte pro Detektor; Schweregradkalibrierung aus historischen Daten wird in die Tiefenanalyse eingespeist
• Kontext verwandter Contracts — RelatedContractResolver findet Parent-, Interface-, Library- und Abhängigkeits-Contracts; Budget-System pro Durchlauf mit Zusammenfassung der Standardbibliothek
• Erkennung von Protokoll-Archetypen — Automatische Identifizierung von 14 Protokolltypen (Vault, Lending, DEX, Bridge, Staking, Governance, Oracle, Liquid Staking, Perpetual DEX, CDP-Stablecoin, Yield Aggregator u. v. m.) mit archetyp-spezifischen Schwachstellen-Checklisten
• Exploit-Wissensdatenbank — 75+ kategorisierte reale Exploit-Muster aus 14 Kategorien mit Code-Indikatoren, fehlenden Schutzmaßnahmen und Präzedenzfällen; nach Archetyp und Fokusbereich filterbar
• Token-Quirks-Datenbank — 12 Kategorien nicht standardkonformer ERC-20-Verhaltensweisen (Fee-on-Transfer, Rebasing, ERC-777, Flash-Mintable, Blocklist, Pausable, Low-Decimal usw.), integriert in die Erkennungspipeline
• Invarianten-Engine — Extrahiert Protokoll-Invarianten aus NatSpec, LLM-Analyse und Codemustern; erzeugt Foundry-Invariantentests
• Statische Analyse — 180+ musterbasierte Detektoren (Reentrancy, Zugriffskontrolle, Arithmetik, Oracle-Manipulation, Flash Loans, MEV, Governance, DeFi-spezifisch, Token-Quirks, Präzision/Rundung u. v. m.)
• Erweiterte Präzisions-Engine — Erkennung von Share-Inflation, Analyse der Rundungsrichtung, Tracking von Divisions-Trunkierung, Dust-Ausnutzung, Bewertung von Akkumulator-Overflows
• LLM-Analyse — Strukturierte, validierungsorientierte Analyse mit OpenAI, Gemini und Claude; Multi-Provider-Rotation mit automatischem Fallback; Schweregradkalibrierung gekoppelt an Schwellenwerte der finanziellen Auswirkung
• Kontextbewusste Filterung — Schweregradkalibrierung, die vor einer Herabstufung den Risikokontext prüft (unchecked-Blöcke, Wertoperationen, Oracle-Nutzung); taint-bewusste Validierungsstufe; ausstehende Befunde bleiben für die LLM-Validierung erhalten
• Paralleles Auditing — Gleichzeitige Multi-Contract-Analyse mit Live-Fortschritt in der Job-Tabelle
• GitHub-Audit-Workflow — Repos klonen, Frameworks erkennen, Contracts entdecken, Inline-Scope-Auswahl, dauerhafter Zustand
• Foundry-PoC-Generierung — AST-basierte Analyse, iteratives Kompilierungs-Feedback (bis zu 5 Versuche), Mock-Contract-Bibliothek (ERC20, Oracle, WETH, FlashLoan), intelligente setUp()-Generierung, produktionsreife Exploit-Prompts, automatische Ausführung über forge test --json mit Fork-Mode-Unterstützung
• Multi-Chain-Contract-Abruf — 10+ EVM-Netzwerke + Solana-Unterstützung
• Berichtserstellung — Erzeugung von Markdown-, JSON- und HTML-Berichten aus Audiddaten
• LLM-Nutzungsverfolgung — Token-Verbrauch, Kostenverfolgung und Post-Audit-Zusammenfassung über alle Anbieter
• Persistenz — Zwei SQLite-Datenbanken für Engine-Ergebnisse und GitHub-Audit-Workflow

Ausgabeverzeichnisse

• ./output/ — Allgemeines Ausgabewurzelverzeichnis
• ./output/reports/ — Erzeugte Berichte
• ./output/pocs/ — Erzeugte Foundry-PoC-Suiten
• ./output/exploit_tests/ — Ergebnisse aus Exploit-Tests

Architektur

Einstiegspunkte

• aether.py — Einziger Einstiegspunkt; startet die Textual-TUI
• cli/interactive_menu.py — Dünner Shim, der JobManager + AetherApp erstellt
• cli/tui/app.py — AetherApp(App) — Haupt-Textual-App mit Tastenbelegungen und 1-Sekunden-Aktualisierungstimer

TUI-Ebene (cli/tui/)

• Screens: MainScreen (Job-Tabelle + Kostenleiste), JobDetailScreen (Live-Log + Phase + Metadaten), NewAuditScreen, HistoryScreen, ResumeScreen, PoCScreen, ReportsScreen, FetchScreen, SettingsScreen
• Widgets: JobsTable (DataTable, die den JobManager abfragt), CostBar (Sitzungskosten pro Anbieter), LogViewer (RichLog mit inkrementeller Aktualisierung), PhaseBar (Unicode-Block-Fortschritt)
• Dialoge: ConfirmDialog, TextInputDialog, SelectDialog, CheckboxDialog, PathDialog, ContractSelectorDialog — alle Subklassen von ModalScreen
• Helfer: GitHubAuditHelper — zerlegte GitHub-Audit-Operationen für die TUI-Integration
• Theme: theme.tcss — Textual-CSS mit Cyan-Thema

Hintergrundausführung

• cli/audit_runner.py — Klasse AuditRunner, die Audits, PoCs, Berichte und GitHub-Audits in Daemon-Threads ausführt
• core/job_manager.py — JobManager-Singleton: Sitzungs-Job-Registry (QUEUED/RUNNING/COMPLETED/FAILED/CANCELLED)
• core/audit_progress.py — ContractAuditStatus mit Log-Puffern pro Job, ThreadDemuxWriter zur Erfassung von stdout/stderr
• core/llm_usage_tracker.py — Thread-sicheres Singleton mit snapshot() für Kostendeltas pro Job

Kern-Orchestrierung

• cli/main.py — Klasse AetherCLI (~2600 Zeilen) — interner Audit-Orchestrator, der von AuditRunner verwendet wird
• core/enhanced_audit_engine.py — Haupt-Audit-Engine mit Integration der Tiefenanalyse
• core/post_audit_summary.py — Post-Audit-Panel mit Kostenaufschlüsselung nach Anbieter

Tiefenanalyse-Ebene (v4.7)

• core/deep_analysis_engine.py — 6-Durchlauf-LLM-Pipeline plus Pass 3.5 (Cross-Contract): verstehen → Angriffsfläche → Invarianten → Cross-Contract → Cross-Function → adversarial → Randfälle; Modellstufenauswahl, Caching, Few-Shot-Beispiele, Chain-of-Thought-Erzwingung, CFG-Kontext in Pass 2, ML-Schweregradkalibrierung in Pass 5, Kontext verwandter Contracts pro Durchlauf
• core/protocol_archetypes.py — Erkennung von Protokoll-Archetypen (14 Typen, einschließlich LIQUID_STAKING, PERPETUAL_DEX, CDP_STABLECOIN, YIELD_AGGREGATOR) mit Schwachstellen-Checklisten pro Archetyp
• core/exploit_knowledge_base.py — 75+ kategorisierte reale Exploit-Muster aus 14 Kategorien (einschließlich CROSS_CONTRACT, SIGNATURE_AUTH, TOKEN_INTEGRATION, PROXY_UPGRADE, TYPE_SAFETY)
• core/invariant_engine.py — Invarianten-Extraktion (NatSpec + LLM + Muster) und Erzeugung von Foundry-Invariantentests + Halmos-Eigenschaftsgenerierung
• core/solidity_ast.py — Solidity-AST-Parsing über py-solc-x mit Regex-Fallback für Vererbung, Sichtbarkeit, Storage-Layout, Lese-/Schreib-Tracking von Zustand; Konstruktion des Kontrollflussgraphen (build_cfg(), get_dominators(), get_loop_headers())
• core/taint_analyzer.py — Datenfluss-/Taint-Analyse mit 8 Quelltypen, 12 Sink-Typen, Sanitizer-Erkennung, Cross-Contract-Tracking, verzweigungsbewusster CFG-Propagation
• core/cross_contract_analyzer.py — Analyse der Beziehungen zwischen Contracts mit Vertrauensgrenzen-Erkennung, Union-Find-Gruppierung und RelatedContractResolver für den Abhängigkeitskontext
• core/token_quirks.py — Token-Quirks-Datenbank (12 Kategorien nicht standardkonformer ERC-20-Verhaltensweisen)
• core/halmos_runner.py — Runner für die symbolische Ausführung mit Halmos zur formalen Verifikation
• core/halmos_property_generator.py — Erzeugt automatisch Halmos-Verifikationseigenschaften aus Invarianten
• core/accuracy_tracker.py — ML-Feedback-Schleife: Genauigkeits-Tracking pro Detektor, Anpassung der Konfidenzgewichte, Schweregradkalibrierung

Erkennungsebene

• core/enhanced_vulnerability_detector.py — Primärer Detektor mit 60+ Mustern
• core/business_logic_detector.py, core/state_management_detector.py, core/data_inconsistency_detector.py, core/centralization_detector.py, core/looping_detector.py — Von Move inspirierte Detektoren
• core/defi_vulnerability_detector.py, core/mev_detector.py, core/oracle_manipulation_detector.py — DeFi-spezifische Detektoren (DeFi-Detektor in v3.5 in die erweiterte Engine integriert)
• core/arithmetic_analyzer.py, core/precision_analyzer.py, core/gas_analyzer.py, core/input_validation_detector.py, core/data_decoding_analyzer.py — Spezialisierte Analyzer (Präzisions-Analyzer erweitert um die Erkennung von Share-Inflation, Rundungsrichtung, Divisions-Trunkierung, Dust-Ausnutzung und Akkumulator-Overflows)
• Token-Quirks-Erkennung über core/token_quirks.py in die statische Erkennungspipeline integriert

Validierungsebene

• core/validation_pipeline.py — Mehrstufige Pipeline: Prüfung eingebauter Schutzmechanismen, Governance-Erkennung, taint-bewusste Validierung (Stufe 1.85), symbolische Halmos-Verifikation (Stufe 1.95), Deployment-Verifikation, lokale Validierung
• core/governance_detector.py, core/deployment_analyzer.py, core/llm_false_positive_filter.py
• core/control_flow_guard_detector.py, core/inheritance_verifier.py
• core/nodes/halmos_node.py — Pipeline-Knoten HalmosSymbolicNode für die Validierung durch symbolische Ausführung

LLM- und KI-Ebene

• core/enhanced_llm_analyzer.py — Strukturierte LLM-Analyse (GPT/Gemini/Claude) mit JSON-Ausgabe und Multi-Provider-Rotation
• core/enhanced_prompts.py — Produktions-Prompt-Vorlagen mit dynamischem Laden von Exploit-Mustern aus der Wissensdatenbank, Few-Shot-Beispielen, Schweregradkalibrierung und Chain-of-Thought-Erzwingung

PoC-Generierungsebene

• core/foundry_poc_generator.py (~8000 Zeilen) — AST-basierte Analyse, iteratives Kompilierungs-Feedback (bis zu 5 Versuche), automatische Ausführung über forge test --json mit PoCTestResult-Parsing und Fork-Mode-Unterstützung
• core/llm_foundry_generator.py — LLM-basierte Testgenerierung mit Mock-API-Dokumentation und empfohlenen setUp-Mustern
• core/enhanced_foundry_integration.py — Foundry-Validierung und -Formatierung
• core/poc_templates.py — Mock-Contract-Vorlagen (MockERC20, MockOracle, MockWETH, MockFlashLoanProvider)
• core/poc_setup_generator.py — Intelligente setUp()-Generierung: Extraktion von Konstruktorparametern, Mock-Deployment, Behandlung upgradebarer Contracts, Token-Minting und Genehmigungen

Persistenzebene

• core/database_manager.py — DatabaseManager (lokale Audits) + AetherDatabase (GitHub-Audits)
• core/analysis_cache.py — Intelligentes Caching für 2x schnellere wiederholte Analysen
• core/accuracy_tracker.py — ML-Feedback-Schleife: Einreichungsergebnisse, Bounty-Einnahmen, Genauigkeitsstatistiken pro Detektor, Erzeugung von Konfidenzgewichten

Integrationen

• core/github_auditor.py — Repos klonen, Frameworks erkennen, Contracts entdecken, Analyse koordinieren
• core/etherscan_fetcher.py, core/basescan_fetcher.py — Verifizierte Contracts von Block-Explorern abrufen
• core/exploit_tester.py — Exploits gegen Anvil-Forks validieren

Flussbasierte Ausführung

Audit-Flüsse sind in YAML-Konfigurationen definiert (configs/). Erweiterte Audit-Pipeline: FileReaderNode -> StaticAnalysisNode -> LLMAnalysisNode -> EnhancedExploitabilityNode -> [FixGeneratorNode -> ValidationNode -> HalmosSymbolicNode] -> ReportNode

Tests

2059 Tests in 76 Testdateien, Laufzeit ca. 23 Sekunden:```bash python -m pytest tests/ # All tests (~23s, 2059 tests) python -m pytest tests/test_enhanced_detectors.py -v # Single file python -m pytest tests/test_enhanced_detectors.py::TestArithmeticAnalyzer -v # Single class python -m pytest tests/ -k "governance" -v # Pattern match python -m pytest tests/ --cov=core --cov-report=html # With coverage