Aether v6.0 — Framework zur Sicherheitsanalyse von Smart Contracts

Version 6.0 | Neuerungen in v6.0 | Changelog

Aether ist ein auf Python basierendes Framework zur Analyse von Solidity-Smart-Contracts, zur Erzeugung von Schwachstellenbefunden, zur Erstellung von Foundry-basierten Proof-of-Concept-Tests (PoC) und zur Validierung von Exploits auf Mainnet-Forks. Es vereint Solidity-AST-Parsing, Taint-Analyse, Kontrollflussgraphen-Analyse, Cross-Contract-Analyse, symbolische Ausführung mit Halmos, 180+ musterbasierte statische Detektoren, eine kollaborative Multi-Agent-LLM-Pipeline (GPT/Gemini/Claude) mit gemeinsam genutztem SAGE-Institutionsgedächtnis, 14 Protokoll-Archetypen, eine Wissensbasis mit über 75 Exploits, ML-kalibrierte Erkennung, Erkennung von Token-Eigenheiten, Invariantenextraktion, Auflösung des Kontexts verwandter Verträge und erweitertes kontextbewusstes Filtern zu einer einzigen persistenten Vollbild-TUI.

Neuerungen in v6.0

Kollaborative Agenten-Pipeline — Die Deep-Analyse-Pipeline wandelt sich von 5 unabhängigen Durchläufen zu 5 kollaborativen Agenten, die strukturiertes Wissen über das institutionelle SAGE-Gedächtnis austauschen:

• Gemeinsamer Sitzungsspeicher — Jeder Durchlauf speichert Befunde, Verwerfungen und verifizierte Schutzmaßnahmen in einer SAGE-Sitzung pro Audit. Spätere Durchläufe erhalten "Prior Pass Intelligence" anstelle von flachen Textzusammenfassungen.
• Verwerfungen als erstklassige Datensätze — Wenn Pass 3 ein Bedenken verwirft (z. B. "Reentrancy durch nonReentrant-Modifikator geschützt"), wird Pass 5 es nicht erneut kennzeichnen. Dadurch wird die Quelle Nr. 1 für doppelte Befunde direkt beseitigt.
• Herausforderungsmechanismus — Spätere Durchläufe können frühere Verwerfungen überstimmen, müssen jedoch NEUE Beweise liefern. "Pass 3 hat den Callback-Pfad durch diese andere Funktion nicht gesehen" ist gültig. "Ich bin anderer Meinung" gilt nicht.
• Pass-übergreifende Bestätigung — Wenn mehrere Durchläufe einen Befund unabhängig voneinander bestätigen, erhält die Konfidenz eine Steigerung von 15 %. Pass-übergreifend bestätigte Befunde werden in Berichten priorisiert.
• SAGE erforderlich — Das institutionelle Gedächtnis ist jetzt erforderlich, nicht optional. Kein SAGE = kein Audit. Führen Sie docker compose up -d aus, um zu starten.

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()"

### Wie SAGE Audits verbessert```
Audit 1 → Findings + FPs → Record outcomes in SAGE
                                    ↓
Audit 2 → SAGE recalls FP patterns → Fewer false positives
                                    ↓
Audit 3 → Richer institutional context → Better severity calibration
                                    ↓
Audit N → Institutional expert-level knowledge → Bug-bounty-quality findings

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, PoCs, Reports, Abrufen, Einstellungen, 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)

### 2. Aether starten```bash
python aether.py         # Launches the full-screen Textual TUI

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

## Konfiguration

Der Setup-Assistent (`python setup.py`) übernimmt alles. Sie können auch über `s` (Einstellungen) innerhalb der TUI konfigurieren:

- **API-Schlüssel konfigurieren** — sequenzielle Eingabeaufforderungen für OpenAI-, Gemini-, Anthropic- und Etherscan-Schlüssel mit maskierten aktuellen Werten
- **Modelle konfigurieren** — Modelle pro Anbieter aus den verfügbaren Optionen auswählen
- **Vollständiger Assistent** — fragt zuerst die API-Schlüssel ab, gefolgt von der Modellauswahl
- **Triage-Einstellungen** — Schweregrad-Schwellenwerte, Konfidenzstufen und maximale Befunde anpassen

Oder setzen Sie Umgebungsvariablen direkt:```bash
export OPENAI_API_KEY=sk-...
export GEMINI_API_KEY=...
export ANTHROPIC_API_KEY=...

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

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, , , , , — alle Subklassen von ModalScreen

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

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, , — Spezialisierte Analyzer (Präzisions-Analyzer erweitert um die Erkennung von Share-Inflation, Rundungsrichtung, Divisions-Trunkierung, Dust-Ausnutzung und Akkumulator-Overflows)

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

## Fehlerbehebung

- **Foundry nicht gefunden** — Stellen Sie sicher, dass `forge`/`anvil` installiert und im `PATH` sind (`foundryup` und `export PATH="$PATH:$HOME/.foundry/bin"`)
- **solc nicht gefunden** — Installieren Sie `solc-select` und die erforderlichen Versionen: `solc-select install 0.8.20 latest`
- **LLM-Funktionen funktionieren nicht** — Überprüfen Sie, ob API-Schlüssel gesetzt sind. Einige Modelle sind in Ihrem Konto/Ihrer Region möglicherweise nicht verfügbar; das System greift automatisch auf Alternativen zurück
- **Datenbank nicht gefunden** — Stellen Sie für GitHub-Berichte sicher, dass der Audit-Workflow zuerst ausgeführt wurde
- **Textual wird nicht geladen** — Führen Sie `pip install textual>=1.0.0` aus, falls es fehlt

---

## Changelog

### v4.7 — PoC-Autoausführung, Halmos-Symbolverifikation, CFG-Analyse & ML-Feedback-Schleife
- **PoC-Autoausführung** — generierte Foundry-PoCs werden automatisch kompiliert und über `forge test --json` ausgeführt, mit `PoCTestResult`-Parsing und Fork-Modus-Unterstützung; `POC_TESTING`-Phase zur Live-Verfolgung in der TUI
- **Halmos-symbolische Ausführung** — `HalmosRunner`, `HalmosPropertyGenerator` und `HalmosSymbolicNode`-Pipeline-Knoten (Validierungsstufe 1.95) für die formale Verifikation von Invarianten; automatische Funktionsreduktion, falls Halmos nicht installiert ist
- **Kontrollflussgraphen-Analyse** — `BasicBlock`, `CFGEdge`, `ControlFlowGraph` mit `build_cfg()`, Dominatorbäumen, Schleifenkopf-Erkennung, Assembly-Block-Parsing; CFG-Kontext wird in Pass 2 der Tiefenanalyse eingespeist; verzweigungsbewusste Taint-Ausbreitung
- **ML-Feedback-Schleife** — `AccuracyTracker` erfasst die Ergebnisse der Meldungen mit `get_detector_accuracy()` und `get_detector_weights()` für Statistiken pro Detektor; Anpassung der Konfidenzgewichte in `EnhancedVulnerabilityDetector`; Schweregrad-Kalibrierung in Pass 5 der Tiefenanalyse
- **Kontext verwandter Verträge** — `RelatedContractResolver` ermittelt Eltern-, Interface-, Bibliotheks- und Abhängigkeitsverträge mit einem Budget-System pro Pass (200K/100K/50K Zeichen); Zusammenfassung der Standardbibliothek; Erkennung verwandter Verträge in derselben Datei
- **Bereinigung technischer Schulden** — 8.500 Zeilen toter Code entfernt: `ai_ensemble.py`, `audit_engine.py`, `fork_verifier.py` gelöscht; alle ai_ensemble-Verweise aus CLI, Audit-Runner, TUI-Screens und Berichtsgenerator entfernt
- **2059 Tests** bestehen in 76 Testdateien

### v4.0 — Solidity-AST-Parsing, Taint-Analyse & Datenflussverfolgung
- **Solidity-AST-Parser** — vollständige solc-Integration über py-solc-x für korrekte Vererbungsauflösung, Funktionssichtbarkeit, Speicherlayout und Verfolgung von Zustands-Lese-/Schreibvorgängen; eleganter Regex-Fallback
- **Taint-Analyse-Engine** — verfolgt benutzergesteuerte Eingaben von 8 Quellentypen bis zu 12 gefährlichen Sinks, mit Sanitizer-Erkennung und vertragsübergreifender Verfolgung
- **Pipeline-Integration** — AST-Daten fließen in Pass 1 ein, Taint-Daten in Pass 2, taint-bewusste Validierungsstufe 1.85
- **1839 Tests** bestehen in 67 Testdateien (~23 Sekunden)

### v3.8 — Erweiterte Erkennung & PoC-Generierung
- **Vertragsübergreifende Analyse** — neuer Pass 3.5 mit Analyzer für Beziehungen zwischen Verträgen, Erkennung von Vertrauensgrenzen, Union-Find-Gruppierung
- **Datenbank für Token-Eigenheiten** — 12 Kategorien nicht standardkonformer ERC-20-Verhaltensweisen (fee-on-transfer, Rebasing, ERC-777, usw.)
- **Erweiterte Präzisions-Engine** — Erkennung von Share-Inflation, Analyse der Rundungsrichtung, Verfolgung von Divisionskürzungen, Ausnutzung von Dust-Beträgen, Akkumulator-Überlauf
- **Ausführbare PoC-Generierung** — Mock-Vertragsbibliothek (ERC20, Oracle, WETH, FlashLoan), intelligentes setUp(), maximale Kompilier-Versuche 3→5
- **Few-Shot-Beispiele** in den Tiefenanalyse-Pässen 3, 4, 5 mit echten Schwachstellen- und False-Positive-Beispielen
- **Schweregrad-Kalibrierung** — konkrete Schwellenwerte (Kritisch >1 Mio. $, Hoch >100.000 $, Mittel >10.000 $, Niedrig (theoretisch))
- **Chain-of-Thought-Erzwingung** — verpflichtende 5-Schritte-Schlussfolgerung vor der JSON-Ausgabe
- **KI-Ensemble ausgemustert** — ersetzt durch Multi-Provider-Rotation über die Tiefenanalyse-Pässe hinweg
- **Multi-Provider-Rotation** — Gemini Flash (günstige Pässe), Anthropic Claude (Reasoning), OpenAI GPT (Vielfalt)
- **1682 Tests** bestehen

### v3.7 — Erweiterte Archetypen & Exploit-Muster
- **4 neue Protokoll-Archetypen** — LIQUID_STAKING, PERPETUAL_DEX, CDP_STABLECOIN, YIELD_AGGREGATOR (insgesamt 10→14)
- **25 neue Exploit-Muster** — Kategorien CROSS_CONTRACT, SIGNATURE_AUTH, TOKEN_INTEGRATION, PROXY_UPGRADE, TYPE_SAFETY (insgesamt 50→75)
- **Verbesserter Vertrags-Scanner** — abstrakte Verträge werden jetzt bewertet; Schwellenwerte für die Monorepo-Unterstützung angepasst
- **1528 Tests** bestehen

### v3.5.2 — Reduzierung von False Positives
- **Skript-Erkennung bei der Vertragsermittlung** — Dateien unter `script/`/`scripts/`, `.s.sol`-Dateien und Verträge, die `forge-std/Script.sol` importieren oder `is Script` erben, werden als Deployment-Skripte markiert und von der LLM-Schwachstellenanalyse ausgeschlossen. Damit wird eine ganze Klasse von False Positives eliminiert, die dadurch entstand, dass Foundry-Deployment-Helfer als Produktionscode analysiert wurden
- **Dateikontext-Marker in LLM-Prompts** — der kombinierte Inhalt enthält jetzt `// FILE: <name>`-Marker pro Datei; die Tiefenanalyse-Pässe 1 und 3 erhalten einen `## Project Files`-Header, der jede Datei als `[PRODUCTION]` oder `[DEPLOYMENT SCRIPT]` kennzeichnet, damit sich die LLMs auf den richtigen Code konzentrieren
- **Dynamische Modifier-Erkennung** — `GovernanceDetector` extrahiert jetzt benutzerdefinierte Zugriffskontroll-Modifier, die im Vertrag definiert sind (z. B. `onlyDistributor`, `onlyMinter`, `authorized`), indem nach Modifier-Definitionen mit `only`-Präfix oder `msg.sender`-Prüfungen gescannt wird. Diese werden für `has_access_control()` und `is_governance_function()` mit der hartcodierten Modifier-Liste zusammengeführt
- **Deduplizierung im Funktionsbereich** — `VulnerabilityDeduplicator` gruppiert Befunde jetzt nach `(function_name, vuln_type)`, wenn Vertragscode verfügbar ist, und ersetzt damit den fragilen Abgleich exakter Zeilen, der Duplikate in benachbarten Zeilen derselben Funktion übersah. Fällt auf eine 20-Zeilen-Bucket-Gruppierung zurück, wenn der Funktionskontext nicht verfügbar ist
- **Erweiterte Zeilentoleranz des KI-Ensembles** — die Toleranz von `_findings_match_fuzzy()` wurde von ±5 auf ±15 Zeilen erhöht, um Duplikate innerhalb derselben Funktion über Agenten hinweg zu erkennen
- **False-Positive-Muster bei atomaren Konstruktoren** — `_check_constructor_context()` erkennt jetzt, wenn ein Vertrag im selben Konstruktor deployed (`new`/`Create2`) und initialisiert (`.initialize()`) wird, und markiert Front-Running-Bedenken als False Positives, da die Operationen atomar sind
- **LLM-Validierungsmuster Nr. 18** — „Atomic Deployment + Initialization" zur 18-Muster-False-Positive-Checkliste im LLM-Validierungs-Prompt hinzugefügt
- **1489 Tests** bestehen in 56 Testdateien (~40 Sekunden), gegenüber 1461

### v3.5 — Tiefenanalyse-Engine
- **Tiefenanalyse-Pipeline mit 6 Pässen** — ersetzt einmalige LLM-Aufrufe durch strukturiertes Multi-Pass-Schlussfolgern: Protokollverständnis → Angriffsflächen-Kartierung → Invarianten-Verletzungsanalyse → Funktionsübergreifende Interaktion → Adversarial-Modellierung → Grenz- und Randfälle. Jeder Pass erhält den akkumulierten Kontext der vorherigen Pässe. Die Pässe 1-2 werden anhand des Inhalts-Hashs gecacht, um Re-Audits zu beschleunigen
- **Erkennung von Protokoll-Archetypen** — identifiziert automatisch den Protokolltyp (ERC-4626-Vault, Lending-Pool, DEX/AMM, Bridge, Staking, Governance, Oracle, NFT-Marktplatz, Token, Orderbuch) mit Schwachstellen-Checklisten pro Archetyp, die aus realen Exploits abgeleitet sind
- **Exploit-Wissensdatenbank** — 50+ kategorisierte Exploit-Muster in 9 Kategorien (Inflation/Share, Reentrancy, Oracle, Governance, Bridge, Präzision/Rundung, Zugriffskontrolle, Wirtschaftlich/DeFi, Logik), die die statische Liste mit 10 Mustern ersetzt. Jedes Muster enthält Code-Indikatoren, fehlende Schutzmaßnahmen, den schrittweisen Exploit-Mechanismus, reale Präzedenzfälle mit Dollar-Beträgen und die Anwendbarkeit auf Archetypen
- **Invarianten-Engine** — extrahiert Protokoll-Invarianten aus NatSpec-`@invariant`-Tags, LLM-Analyse und 6 Detektoren für häufige Muster (Vault-Erhaltung, Kontostandsverfolgung, Bilanzierung des Angebots, AMM-Konstantprodukt, Kreditbesicherung, Staking-Belohnungen). Generiert Foundry-`invariant_*()`-Testsuiten als leichtgewichtige Nachweise formaler Verifikation
- **Kontextbewusste Schweregrad-Kalibrierung** — ersetzt pauschale Schweregrad-Herabstufungen durch Prüfungen des Risikokontexts. Befunde in `unchecked{}`-Blöcken, in der Nähe von Wertübertragungen (`call{value:}`, `_mint`, `safeTransfer`), bei Preisberechnungen oder in Oracle-Kontexten behalten ihren ursprünglichen Schweregrad
- **Korrektur des Validierungs-Gates** — `"pending"`-Befunde gelangen jetzt mit dem `needs_llm_validation`-Flag zur LLM-Analyse. Nur explizite `"false_positive"`-Befunde werden verworfen (zuvor wurden alle nicht-`"validated"`-Befunde stillschweigend herausgefiltert)
- **Spezialistenbewusste Konfidenzstrafe** — Ein-Agenten-Befunde, die der Spezialisierung des Agenten entsprechen (z. B. AnthropicReasoningSpecialist + wirtschaftliche Angriffe), erhalten eine Strafe von -0.05; Nicht-Spezialisten-Befunde behalten -0.15
- **Korrektur der Zeilen-Bucket-Deduplizierung** — das Bucketing `(line // 10) * 10`, das willkürliche Grenzprobleme verursachte (Zeilen 9 und 11 in verschiedenen Buckets), wurde entfernt. Die Deduplizierung verwendet jetzt nur noch den normalisierten Schwachstellentyp; `_findings_match_fuzzy()` übernimmt die Zeilennähe
- **Integration des DeFi-Detektors** — `DeFiVulnerabilityDetector` (zweistufige semantische Präsenz-/Absenz-Analyse) läuft jetzt in der erweiterten Audit-Engine neben `EnhancedVulnerabilityDetector`
- **Dynamische Exploit-Muster in Prompts** — `enhanced_prompts.py` lädt Muster jetzt aus der ExploitKnowledgeBase, gefiltert nach Fokusbereich, mit Fallback auf statische Muster
- **1461 Tests** bestehen in 55 Testdateien (~50 Sekunden)

### v3.2 — Job-Statistiken & UI-Korrekturen
- **Behoben: Job-Befunde/Kosten/LLM-Statistiken zeigten immer Null an** — der Audit-Worker erfasst jetzt das Ergebnis-Dict von `run_audit()`, um die Anzahl der Befunde zu extrahieren; `LLMUsageTracker.reset()`, das Singleton-Referenzen verwaist zurückließ, wurde entfernt; alle 4 Worker-Typen berechnen die Pro-Job-Statistiken aus den Snapshot-Deltas
- **Behoben: UI-Neuzeichnungs-Artefakt beim Fensterwechsel** — scrollbare Container in JobDetailScreen durch einfaches `Container` + `overflow: hidden` ersetzt, um veraltete Compositor-Frames zu verhindern
- **„Job Details" zu border_title verschoben** für eine sauberere Darstellung des Metadaten-Panels
- `CLAUDE.md` aus der Git-Verfolgung entfernt

### v3.0 — Vollständig Inline-Textual-TUI
- **Null `app.suspend()`-Aufrufe** — die TUI wechselt nie in ein Raw-Terminal; jede Operation läuft inline
- **PoC-Generierung im Hintergrund** — läuft als Daemon-Thread über `AuditRunner.start_poc_generation()` mit Live-Ausgabe in JobDetailScreen
- **Berichtsgenerierung im Hintergrund** — läuft als Daemon-Thread über `AuditRunner.start_report_generation()` mit Live-Ausgabe
- **GitHub-Audits im Hintergrund** — Scope-Auswahl über Textual-Dialoge; der Audit läuft als Daemon-Thread über `AuditRunner.start_github_audit()`
- **ContractSelectorDialog** — nahezu bildschirmfüllendes, filterbares Multi-Select-Modal, das den auf curses basierenden `ScopeManager.interactive_select()` ersetzt. Leertaste zum Umschalten, `a`/`n` für alle/keine, Tippen zum Filtern, farbcodierte, bereits geprüfte Verträge
- **GitHubAuditHelper** — zerlegter Wrapper um `GitHubAuditor`/`AetherDatabase`, der atomare Operationen (`clone_and_discover`, `get_scope_state`, `save_new_scope`, `get_pending_contracts`, `handle_reaudit`) bereitstellt, die von Textual-Screens aus aufgerufen werden können
- **Inline-Einstellungen** — API-Schlüssel- und Modellkonfiguration über native TextInputDialog/SelectDialog; kein externer Setup-Assistent erforderlich
- **Inline-Verwaltung des GitHub-Scopes** — Fortsetzen, erneut prüfen oder neuen Scope über SelectDialog erstellen; Vertragsauswahl über ContractSelectorDialog
- **6 Screens neu geschrieben** — PoCScreen, ReportsScreen, SettingsScreen, NewAuditScreen, HistoryScreen, ResumeScreen — alle vollständig inline
- **770 Tests** bestehen in 50 Testdateien

### v2.2 — Textual-TUI-Dashboard
- Vollbild-Textual-TUI mit persistenter App, Tastenkürzeln und 1-Sekunden-Aktualisierungstimer
- MainScreen mit Live-Job-Tabelle und Sitzungskosten-Leiste
- JobDetailScreen mit Live-Log-Viewer, Phasen-Fortschrittsbalken und Metadaten
- Modale Dialoge (Bestätigung, Texteingabe, Auswahl, Kontrollkästchen, Pfadauswahl), die questionary-Prompts ersetzen
- Audit-Ausführung im Hintergrund über AuditRunner mit Ausgabeerfassung durch ThreadDemuxWriter
- JobManager-Singleton für die Job-Registrierung der Sitzung
- Kostenverfolgung pro Job über LLMUsageTracker-Snapshots

### v2.1 — Parallele Audits, Slither-Entfernung & Testbereinigung
- Parallele Audit-Engine — mehrere Verträge gleichzeitig mit `ThreadPoolExecutor` ausführen, konfigurierbar auf bis zu 8 parallele Worker
- Thread-sichere Fortschrittsverfolgung — `ContractAuditStatus` mit Locking, `ThreadDemuxWriter` für das Stdout-Multiplexing
- Zusammenfassung nach dem Audit — konsolidierte Ergebnisansicht nach Abschluss der parallelen Audits
- LLM-Nutzungsverfolgung — Token-Verbrauch, Kosten und API-Aufrufe über alle drei Anbieter hinweg verfolgen
- Slither vollständig entfernt — alle Abhängigkeiten, Integrationscode und Tests gelöscht (~1200 Zeilen); musterbasierte Detektoren + Foundry-ABI + Regex sind die einzigen Analysetools
- Testsuite-Bereinigung — mehr als 40 alte/langsame/Integrationstestdateien entfernt

### v2.0 — Interaktive Menü-TUI
- Interaktive, menügesteuerte TUI als primäre Schnittstelle
- Geführter Audit-Assistent mit Quellenauswahl, Funktions-Kontrollkästchen und Bestätigung
- Möglichkeit, laufende GitHub-Audits fortzusetzen
- Einheitlicher Browser für die Audit-Historie über lokale und GitHub-Datenbanken
- Integrierte PoC-Generierungs- und Berichts-Workflows aus dem Menü
- Abruf von Verträgen über mehrere Chains mit optionalem sofortigem Audit
- Einstellungsverwaltung über das Menü
- Konsolenstart/-rückkehr über das Menü

### v1.5 — Drei-Anbieter-LLM-Unterstützung & erweiterte Analyse
- Anthropic-Claude-Integration (Sonnet 4.5, Opus 4.6, Haiku 4.5) als dritter LLM-Anbieter
- KI-Ensemble mit 6 Agenten: 2 OpenAI + 2 Gemini + 2 Anthropic-Spezialagenten
- Automatischer anbieterübergreifender Fallback für maximale Verfügbarkeit
- Aktualisierte OpenAI-Modelle (GPT-5.3) und Google-Gemini-Modelle (3.0 Flash/Pro)
- Setup-Assistent um Anthropic-API-Schlüsselkonfiguration und Modellauswahl erweitert
- Defekten generate-foundry-CLI-Befehl behoben

---

## Lizenz

Aether wird unter der **MIT-Lizenz** vertrieben. Details finden Sie in der Datei [LICENSE](https://github.com/l33tdawg/aether/blob/HEAD/LICENSE).

## Autor

**Dhillon Andrew Kannabhiran** (@l33tdawg)
- E-Mail: [email protected]
- Twitter: [@l33tdawg](https://twitter.com/l33tdawg)
- GitHub: [@l33tdawg](https://github.com/l33tdawg)

## Mitwirken

Beiträge sind willkommen! Sie können gerne Issues einreichen, das Repository forken und Pull-Requests erstellen.