In Action

_{Live-Scan · Apache 2.4.54 · 11 Funde · 44,17 s · Scan #518 · sicherer Modus}

HTML-Bericht – Schweregradeinteilung, OWASP-Zuordnung, Filterleiste

Ergebnistabelle – CVE/CWE-Badges, erweiterbare Nachweise, Konfigurationsausschnitte

🎯 Was ist Hephaestus?

Hephaestus ist ein produktionsreifer Server-Sicherheitsauditor, der Ethik an erste Stelle setzt. Entwickelt für Systemadministratoren, DevOps-Ingenieure und Penetrationstester, scannt es Webserver-Konfigurationen (Apache, Nginx, IIS), um kritische Fehlkonfigurationen zu identifizieren, bevor Angreifer sie ausnutzen.

Warum Hephaestus?

• 🔒 Ethisch durch Design: Ein Zustimmungs-Token-System verhindert unbefugte Scans
• 🤖 KI-gestützt: GPT-4, Claude oder lokales Ollama für intelligente Härtungsleitfäden
• 📊 Professionelle Berichte: Ansprechendes HTML + maschinenlesbares JSON
• 🚀 Schnell & effizient: Paralleles Scannen mit intelligentem Ratenlimit
• 💾 Dauerhafte Nachverfolgung: SQLite-Datenbank mit der Argos-Suite geteilt (~/.argos/argos.db)
• 🐳 Docker-bereit: Containerisiertes Scannen + verwundbare Testumgebungen (Apache & Nginx)
• 🎯 Null Fehlalarme: Umfassend getestet mit über 55 Validierungstests

Was es scannt

✨ Funktionen

🛡️ Kern-Sicherheitsaudit```bash

One command, comprehensive server analysis

python -m heph --target https://example.com --html

- **Multi-Server-Unterstützung**: Erkennung und Härtung von Apache, Nginx, IIS
- **Gleichzeitiges Scannen**: Thread-Pool + Ratenbegrenzung für schnelle, respektvolle Scans
- **Beweissammlung**: HTTP-Antworten, Header, Dateiinhalte werden bewahrt
- **Fehlertoleranz**: Timeouts, DNS-Fehler, Verbindungsablehnungen werden robust behandelt

### 🤖 KI-gestützte Härtungsleitfäden

Wählen Sie Ihren KI-Anbieter basierend auf Ihren Anforderungen:

| Provider             | Am besten geeignet für | Geschwindigkeit | Kosten         | Datenschutz      |
| -------------------- | ---------------------- | --------------- | -------------- | ---------------- |
| **OpenAI GPT-4**     | Produktionsqualität    | ⚡ Schnell (35s) | 💰 $0.25/Scan | 🔒 Standard      |
| **Anthropic Claude** | Datenschutzorientiert  | ⚡ Schnell (45s) | 💰 $0.30/Scan | 🔒 Erweitert     |
| **Ollama (Local)**   | Vollständige Privatsphäre | 🐢 Langsam (28min) | 💰 Kostenlos  | 🔐 100% Offline |

**Zwei Analysemodi:**

- **Technisch**: Apache/Nginx-Konfigurationssnippets, CLI-Befehle, schrittweise Härtung
- **Führungskräfte**: Risikobewertung in einfacher Sprache für Stakeholder und Management

### 📊 Professionelle Berichterstellung

**JSON-Berichte** (maschinenlesbar)```json
{
  "tool": "hephaestus",
  "version": "0.2.0",
  "target": "https://example.com",
  "mode": "safe",
  "summary": {
    "critical": 3,
    "high": 2,
    "medium": 5,
    "low": 3,
    "info": 0
  },
  "findings": [...],
  "diff": {...}
}

HTML-Berichte (benutzerfreundlich)

• 🎨 Schmiede-Theme mit Orange/Rot-Verläufen (⚒️ Schmiedeästhetik)
• 🏷️ Farbcodierte Schweregrad-Abzeichen
• 📝 Erweiterbare Beweisabschnitte
• 🤖 KI-Härtungsleitfäden schön formatiert
• 📱 Mobil-responsive Design

🔐 Einwilligungs-Token-System

Aggressives Scannen und KI-Analyse erfordern Eigentumsnachweis:```bash

1. Generate token

python -m heph --gen-consent example.com

2. Place token on your server

echo "verify-abc123..." > .well-known/verify-abc123.txt

3. Verify ownership

python -m heph --verify-consent http --domain example.com --token verify-abc123

4. Now you can use aggressive mode

python -m heph --target https://example.com --aggressive --use-ai

### 💾 Datenbank-Persistenz

SQLite-Datenbank **GEMEINSAM mit der Argos-Suite** (`~/.argos/argos.db`):

- **Scan-Verlauf**: Datum, Dauer, Anzahl der Funde, Aufschlüsselung nach Schweregrad
- **Fund-Repository**: Durchsuchbare Schwachstellendatenbank (1159+ gespeicherte Funde)
- **Verifizierte Domains**: Nachverfolgung von Einwilligungstokens mit Ablauf
- **Toolübergreifende Integration**: Funktioniert nahtlos mit Argus, Pythia und zukünftigen Tools```bash
# Query recent scans
sqlite3 ~/.argos/argos.db "SELECT * FROM scans WHERE tool='hephaestus' ORDER BY scan_id DESC LIMIT 10"

# Find critical issues
sqlite3 ~/.argos/argos.db "SELECT * FROM findings WHERE severity='critical' AND tool='hephaestus'"

✅ Validierung & Test

Hephaestus v0.2.0 wurde empirisch validiert mittels kontrollierter Docker-basierter anfälliger Labore (Apache & Nginx).

Validierungszusammenfassung (Mai 2026)

Testabdeckung (13 Phasen):

• ✅ Phase 1: Grundlegendes CLI (Exit-Codes, Fehlerbehandlung)
• ✅ Phase 2: Einwilligungs-Tokens (HTTP-Verifikation, aggressiver Modus)
• ✅ Phase 3: KI-Integration (OpenAI, Anthropic, Ollama)
• ✅ Phase 4: Berichterstellung (JSON, HTML, KI-Analyse)
• ✅ Phase 5: Fortgeschrittene Optionen (Ratenbegrenzung, Threads, Timeouts)
• ✅ Phase 6: Prüfmodule (70+ validierte Fundcodes)
• ✅ Phase 7: Protokollierung (Text, JSON, Ausführlichkeitsstufen)
• ✅ Phase 8: Datenbank (Schema, Integrität, Fremdschlüssel)
• ✅ Phase 9: Fehlerbehandlung (Grenzfälle, Berechtigungen)
• ✅ Phase 10: Integration (Argos Suite Kompatibilität)
• ✅ Phase 11: CORS, Robots.txt, WAF-Erkennung
• ✅ Phase 12: API-Erkennung, Cookie-Sicherheit, phpinfo-Analyse
• ✅ Phase 13: Konfigurationsdatei-Parser, Diff-Berichte, KI-Kostenverfolgung

Wichtigste Erkenntnisse:

• ✅ Alle kritischen Schwachstellen erkannt (.env, .git, server-status, phpinfo)
• ✅ Alle Serverversionen identifiziert (Apache 2.4.54, Nginx 1.18.0)
• ✅ Alle Sicherheitsheader korrekt analysiert (6 Header überprüft)
• ✅ Alle Directory-Listing-Probleme identifiziert
• ✅ CORS-, WAF-, API-, Cookie-, phpinfo-Module voll funktionsfähig
• ✅ Diff-Berichte (--diff last) funktionieren über Scan-Verlauf hinweg
• ✅ Robuste Fehlerbehandlung (Timeouts, DNS-Fehler, Verbindung abgelehnt)

Urteil: Hephaestus ist produktionsbereit für Server-Sicherheitsbewertungen.

🚀 Schnellstart

Voraussetzungen

• Python 3.11+ (3.12 empfohlen)
• pip (Python-Paketmanager)
• Docker (optional, für anfällige Labore)

Installation

1. Repository klonen```bash git clone https://github.com/rodhnin/hephaestus-server-forger.git cd hephaestus-server-forger

**2. (Optional) Installiere `venv`, falls noch nicht verfügbar**```bash
# Debian/Ubuntu
sudo apt update && sudo apt install -y python3-venv

# Fedora/RHEL
sudo dnf install python3-virtualenv

# macOS (via Homebrew)
brew install [email protected]

3. Erstellen und Aktivieren einer virtuellen Umgebung```bash python3 -m venv .venv source .venv/bin/activate

You should see (.venv) in your terminal prompt

**4. Pip aktualisieren**```bash
python -m pip install --upgrade pip

5. Abhängigkeiten installieren```bash python -m pip install -r requirements.txt

**6. API-Schlüssel konfigurieren (bei Verwendung von Cloud-KI)**```bash
# OpenAI
export OPENAI_API_KEY="sk-..."

# Anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

7. Installation überprüfen```bash python -m heph --version

Output: heph 0.2.0

### Ihr erster Scan```bash
# Basic scan (safe mode, no consent required)
python -m heph --target https://example.com

# With HTML report
python -m heph --target https://example.com --html

# With AI hardening guide (requires consent)
python -m heph --target https://example.com --use-ai --html

🐳 Schnellstart mit Docker

cd docker && ./deploy.sh

Wählen Sie Option 3 zum Testen (Beide)

docker compose exec hephaestus python -m heph --target http://vulnerable-apache

🎉 Erfolg! Überprüfen Sie ~/.hephaestus/reports/ auf Ihre Berichte.

📘 Nutzungsanleitung

Grundlegendes Scannen```bash

Safe mode (default) - Non-intrusive checks

python -m heph --target https://example.com

Generate HTML report

python -m heph --target https://example.com --html

Increase verbosity for debugging

python -m heph --target https://example.com -vv

Quiet mode (errors only)

python -m heph --target https://example.com -q

### Erweitertes Scannen```bash
# Control scan speed (1-20 req/s)
python -m heph --target https://example.com --rate 10

# Control concurrency (1-20 threads)
python -m heph --target https://example.com --threads 8

# Custom timeout (useful for slow servers)
python -m heph --target https://example.com --timeout 60

# Custom output directory
python -m heph --target https://example.com --report-dir ./my-reports

# Custom User-Agent
python -m heph --target https://example.com --user-agent "MyBot/1.0"

# Disable SSL verification (testing only)
python -m heph --target https://self-signed.badssl.com --no-verify-ssl

KI-gestützte Härtungsanleitungen

Schritt 1: Konfigurieren Sie Ihren Anbieter

Edit config/defaults.yaml:```yaml ai: langchain: provider: "openai" # Options: openai, anthropic, ollama model: "gpt-4o-mini-2024-07-18" temperature: 0.3

**Schritt 2: Testen Sie Ihre Einrichtung**```bash
# Verify AI provider works
python -m heph.core.ai openai

Schritt 3: KI-gestützten Scan ausführen```bash

Technical hardening guide (for sysadmins)

python -m heph --target https://example.com
--use-ai
--ai-tone technical
--html

Executive risk summary (for management)

python -m heph --target https://example.com
--use-ai
--ai-tone non_technical
--html

Both analyses in one report

python -m heph --target https://example.com
--use-ai
--ai-tone both
--html

Stream AI output token-by-token

python -m heph --target https://example.com
--use-ai
--ai-stream
--html

Compare two AI providers in parallel

python -m heph --target https://example.com
--use-ai
--ai-compare openai,anthropic
--html

Agent mode with live NVD CVE lookup

python -m heph --target https://example.com
--use-ai
--ai-agent
--html

Set a cost budget cap (USD)

python -m heph --target https://example.com
--use-ai
--ai-budget 0.50
--html

### Aggressiver Modus (erfordert Zustimmung)```bash
# Step 1: Generate consent token
python -m heph --gen-consent example.com
# Output: Token: verify-a3f9b2c1d8e4...

# Step 2: Place token on your server
# Create: https://example.com/.well-known/verify-a3f9b2c1d8e4.txt
# Content: verify-a3f9b2c1d8e4

# Step 3: Verify consent
python -m heph --verify-consent http \
  --domain example.com \
  --token verify-a3f9b2c1d8e4

# Step 4: Run aggressive scan (deeper checks, higher rate limit)
python -m heph --target https://example.com --aggressive

🤖 KI-gestützte Analyse

Hephaestus verwendet LangChain 1.0.0 mit Unterstützung für mehrere KI-Anbieter.

Unterstützte Anbieter

OpenAI GPT-4 Turbo

Am besten geeignet für: Produktionseinsatz

• ⭐ Qualität: Hervorragend (5/5)
• ⚡ Geschwindigkeit: ~35 Sekunden
• 💰 Kosten: ~0,25 $ pro Scan
• 🔒 Datenschutz: Standard (Daten werden während der Übertragung verschlüsselt)```bash export OPENAI_API_KEY="sk-..." python -m pip install langchain-openai==1.0.0

#### Anthropic Claude

**Am besten für: Erweiterte Privatsphäre**

- ⭐ Qualität: Hervorragend (5/5)
- ⚡ Geschwindigkeit: ~45 Sekunden
- 💰 Kosten: ~$0,30 pro Scan
- 🔒 Datenschutz: Erweitert (Anthropic's datenschutzorientierter Ansatz)```bash
export ANTHROPIC_API_KEY="sk-ant-..."
python -m pip install langchain-anthropic==1.0.0

Ollama (Lokale Modelle)

Am besten für: Vollständige Privatsphäre

• ⭐ Qualität: Gut (3/5)
• 🐢 Geschwindigkeit: ~28 Minuten (CPU) oder ~75 Sekunden (GPU)
• 💰 Kosten: Kostenlos
• 🔐 Privatsphäre: 100 % offline (Daten verlassen niemals Ihren Rechner)```bash

Install Ollama: https://ollama.ai

ollama pull llama3.2 python -m pip install "langchain-ollama>=0.3.0,<0.4.0"

### Datenschutz & Sicherheit

**Automatische Bereinigung**

Vor dem Senden an KI-Anbieter entfernt Hephaestus automatisch:

- ✅ Einwilligungstoken
- ✅ API-Schlüssel und Anmeldedaten
- ✅ Private Schlüssel und Zertifikate
- ✅ Interne IP-Adressen
- ✅ Datenbank-Anmeldedaten

**Nur mit Opt-In**

- KI-Analyse erfordert explizites Flag `--use-ai`
- Aggressives Scannen erfordert verifizierten Einwilligungstoken
- Sie entscheiden, welcher Anbieter Ihre Daten sieht

**Für maximale Privatsphäre**: Verwenden Sie Ollama lokal.

---

## 🧪 Sichere Testlabore

**⚠️ Scannen Sie NIEMALS Produktionsseiten ohne schriftliche Genehmigung!**

Nutzen Sie unsere Docker-Labore zum sicheren Üben:

### Testumgebung einrichten

### Option 1: Interaktives Skript (empfohlen)```bash
# Run the interactive deployment script
cd docker && ./deploy.sh

Das Skript bietet 5 Optionen:

1. Produktion → Hephaestus-Scanner-Dienst bereitstellen
2. Testlabor → Verwundbare Webserver bereitstellen (Apache + Nginx)
3. Beide → Beide Umgebungen bereitstellen
4. Alle stoppen → Alle laufenden Dienste stoppen
5. Alle entfernen → Container, Volumes und Daten entfernen (Bestätigung erforderlich)

Option 2: Manuelle Docker Compose

Nur Testlabor:```bash

Start vulnerable servers (Apache + Nginx)

docker compose -f docker/compose.testing.yml up -d

Wait for initialization (~15 seconds)

sleep 15

Verify services

docker compose -f docker/compose.testing.yml ps curl -I http://localhost:8080 # Apache curl -I http://localhost:8081 # Nginx

**Produktionsscanner:**```bash
# Start Hephaestus scanner service
docker compose -f docker/compose.yml up -d

# Run a scan
docker compose -f docker/compose.yml exec hephaestus heph --target https://example.com

# View reports
ls -lh docker/reports/

Beide Umgebungen:```bash

Start both production and testing

docker compose -f docker/compose.yml up -d docker compose -f docker/compose.testing.yml up -d

Scan the testing labs from host

python -m heph --target http://localhost:8080 --html python -m heph --target http://localhost:8081 --html

### Scanne die Labs```bash
# Scan Apache lab (from host)
python -m heph --target http://localhost:8080 --html

# Scan Nginx lab (from host)
python -m heph --target http://localhost:8081 --html

# AI-powered analysis (requires OPENAI_API_KEY)
python -m heph --target http://localhost:8080 --use-ai --html

# OR from inside production container (using container name)
docker compose -f docker/compose.yml exec hephaestus python -m heph --target http://hephaestus-vulnerable-apache --html

Erwartete Ergebnisse

Apache Lab (localhost:8080):

• 42 Funde insgesamt (in allen 13 Scan-Phasen)
• Enthält CORS, WAF, API, Cookie, phpinfo, OWASP-mapped Funde

Nginx Lab (localhost:8081):

• 25 Funde insgesamt (in allen 13 Scan-Phasen)
• Enthält CORS, WAF, API, Cookie, OWASP-mapped Funde

Bereinigung

Dienste stoppen:```bash

Using script

cd docker && ./deploy.sh # Choose option 4 (Stop All)

OR manually

docker compose -f docker/compose.yml down docker compose -f docker/compose.testing.yml down

**Alles entfernen (WARNUNG: löscht Daten und Berichte):**```bash
# Using script (with confirmation)
cd docker && ./deploy.sh  # Choose option 5 (Remove All)

# OR manually
docker compose -f docker/compose.yml down -v
docker compose -f docker/compose.testing.yml down -v
rm -rf docker/data docker/reports

🐳 Docker-Bereitstellung

Hephaestus bietet zwei Docker-Bereitstellungsoptionen:

Option 1: Docker Compose (Empfohlen)

Produktions-Scanner-Dienst:```bash

Start long-running scanner service

docker compose -f docker/compose.yml up -d

Run scans

docker compose -f docker/compose.yml exec hephaestus heph --target https://example.com --html

View reports

ls -lh docker/reports/

Stop service

docker compose -f docker/compose.yml down

**Testlabor (Verwundbare Server):**```bash
# Start Apache + Nginx vulnerable servers
docker compose -f docker/compose.testing.yml up -d

# Scan from host
python -m heph --target http://localhost:8080 --html

# Stop lab
docker compose -f docker/compose.testing.yml down

Interaktives Bereitstellungsskript:```bash

Use the interactive menu

cd docker && ./deploy.sh

### Option 2: Direkter Docker Run

**Image erstellen:**```bash
docker build -f docker/Dockerfile -t hephaestus:0.2.0 .

Einmaligen Scan ausführen:```bash docker run --rm
-v $(pwd)/docker/reports:/reports
-v $(pwd)/docker/data:/data
hephaestus:0.2.0
--target https://example.com
--html

**Mit KI-Analyse:**```bash
docker run --rm \
  -v $(pwd)/docker/reports:/reports \
  -e OPENAI_API_KEY="$OPENAI_API_KEY" \
  hephaestus:0.2.0 \
  --target https://example.com \
  --use-ai \
  --ai-tone both \
  --html

Lokales Testlabor scannen:```bash

Start testing lab first

docker compose -f docker/compose.testing.yml up -d

Scan from container (join the testing lab network)

docker run --rm
--network hephaestus-lab
hephaestus:0.2.0
--target http://hephaestus-vulnerable-apache

## 📊 Berichte verstehen

### Berichtsstruktur```
~/.hephaestus/
├── reports/
│   ├── hephaestus_report_example_20251021_143022.json
│   └── hephaestus_report_example_20251021_143022.html
└── (shared with Argos)
    ~/.argos/
    ├── argos.db          # Shared database
    └── logs/
        └── hephaestus.log

IDs finden (Muster, 70+ insgesamt)```

HEPH-SRV-001: Server version disclosed (Apache/Nginx/IIS) HEPH-SRV-004: Server disclosed in error page HEPH-SRV-016: PHP version disclosed in Server header HEPH-SRV-017: OpenSSL version disclosed in Server header HEPH-FILE-001: Environment file exposed (.env) HEPH-FILE-002: Git repository exposed HEPH-FILE-003: PHP information page exposed HEPH-FILE-004: Apache server-status exposed HEPH-HTTP-003: Unsafe HTTP method in OPTIONS (TRACE) HEPH-HTTP-008: TRACE method enabled (XST vulnerability) HEPH-HDR-001: Missing security header: HSTS HEPH-HDR-002: Missing security header: CSP HEPH-HDR-003: Missing security header: X-Frame-Options HEPH-HDR-004: Missing security header: X-Content-Type-Options HEPH-HDR-005: Missing security header: Referrer-Policy HEPH-HDR-006: Missing security header: Permissions-Policy HEPH-CFG-001: Directory listing enabled HEPH-TLS-000: TLS not enabled HEPH-TLS-001: Weak TLS protocol (SSLv3, TLS 1.0) HEPH-TLS-002: Weak cipher suite enabled COR-001 to COR-006: CORS misconfiguration findings ROB-001/002/003: Robots.txt intelligence findings WAF-001/002: WAF detection findings API-001 to API-005: API discovery findings COO-001 to COO-005: Cookie security findings PHP-001 to PHP-009: phpinfo() dangerous settings

### Schweregrad-Zuordnung

- **KRITISCH**: .env offengelegt, .git zugänglich, phpinfo, server-status, SQL-Dumps
- **HOCH**: Serverversion preisgegeben, schwaches TLS, TLS fehlt, unsichere HTTP-Methoden
- **MITTEL**: Fehlende wichtige Header (HSTS, CSP, X-Frame-Options), Verzeichnisauflistung, Fehlerseiten-Offenlegung
- **NIEDRIG**: Geringfügige Header (X-Content-Type-Options, Referrer-Policy, Permissions-Policy)
- **INFO**: Informative Funde (Server erkannt, TLS 1.2 OK)

---

## 📁 Projektstruktur```
hephaestus-server-forger/
│
├── heph/                       # Main application package
│   ├── checks/                 # Security check modules (13 phases)
│   │   ├── __init__.py
│   │   ├── api_discovery.py    # Phase 11: Swagger/OpenAPI/GraphQL exposure
│   │   ├── config.py           # Phase 5: Directory listing detection
│   │   ├── config_file.py      # Phase 14: Offline httpd.conf/nginx.conf parser
│   │   ├── cookies.py          # Phase 12: HttpOnly/Secure/SameSite analysis
│   │   ├── cors.py             # Phase 8: CORS wildcard & reflection probes
│   │   ├── files.py            # Phase 2: 70+ sensitive file paths
│   │   ├── headers.py          # Phase 4: Security headers analysis
│   │   ├── http_methods.py     # Phase 3: Unsafe HTTP methods (PUT/DELETE/TRACE)
│   │   ├── phpinfo.py          # Phase 13: phpinfo() dangerous settings
│   │   ├── ports.py            # Phase 7: 37-port scanner with banner grabbing
│   │   ├── robots.py           # Phase 9: robots.txt disallowed path analysis
│   │   ├── server_info.py      # Phase 1: Apache/Nginx/IIS fingerprinting
│   │   ├── tls.py              # Phase 6: Deep TLS/SSL + CVE correlation
│   │   └── waf.py              # Phase 10: 13 WAF signatures detection
│   │
│   ├── core/                   # Core infrastructure
│   │   ├── __init__.py
│   │   ├── ai.py               # LangChain AI (GPT-4/Claude/Ollama) + cost tracking
│   │   ├── config.py           # Configuration loader
│   │   ├── consent.py          # Consent token system (HTTP + DNS)
│   │   ├── cve_lookup.py       # NVD CVE API integration
│   │   ├── db.py               # SQLite — shared with Argos suite (~/.argos/argos.db)
│   │   ├── diff.py             # Scan diff engine (--diff last / --diff <id>)
│   │   ├── http_client.py      # Token-bucket rate-limited HTTP client
│   │   ├── logging.py          # Structured logging
│   │   ├── owasp.py            # HEPH-* code → OWASP Top 10 2021 mapper
│   │   └── report.py           # JSON + HTML report generation
│   │
│   ├── __init__.py             # Package metadata
│   ├── __main__.py             # Entry point
│   ├── cli.py                  # CLI (30+ flags incl. --use-ai, --diff, --config-file)
│   └── scanner.py              # Orchestrator — 13 parallel phases
│
├── assets/
│   └── ascii.txt               # Hephaestus braille ASCII art
│
├── config/                     # Configuration files
│   ├── defaults.yaml           # Default settings
│   └── prompts/                # AI prompt templates
│       ├── technical.txt       # Technical hardening prompt
│       └── non_technical.txt   # Executive summary prompt
│
├── db/
│   └── migrate.sql             # Shared database schema (Argos suite)
│
├── docker/                     # Docker deployment
│   ├── vulnerable-apache/      # Vulnerable Apache lab (port 8080/8443)
│   │   └── docker-entrypoint.sh
│   ├── vulnerable-nginx/       # Vulnerable Nginx lab (port 8081/8444)
│   │   └── docker-entrypoint.sh
│   ├── compose.yml             # Production stack
│   ├── compose.testing.yml     # Vulnerable lab stack
│   ├── deploy.sh               # Interactive deployment script
│   └── Dockerfile              # Production image
│
├── docs/                       # Documentation
│   ├── media/                  # README visual assets
│   │   ├── hephaestus-banner.webp  # Banner 1280×400
│   │   ├── hephaestus-hero.webp    # Hero 1600×640
│   │   ├── console.webp            # Terminal scan output
│   │   ├── report_html.webp        # HTML report header
│   │   └── report_findings.webp    # Findings table with CVE badges
│   ├── AI_INTEGRATION.md       # AI providers setup guide
│   ├── CONSENT.md              # Consent system details
│   ├── DATABASE_GUIDE.md       # Shared database reference
│   ├── ETHICS.md               # Ethical use guidelines
│   ├── REPORT_FORMAT.md        # JSON/HTML report specification
│   ├── ROADMAP.md              # v0.3.0 tickets and priorities
│   └── TESTING_GUIDE.md        # Safe testing practices
│
├── schema/
│   └── report.schema.json      # JSON report schema (OWASP + CVE fields)
│
├── scripts/
│   └── cli-examples.md         # CLI usage examples
│
├── templates/
│   └── report.html.j2          # HTML report template — forge theme
│
├── CHANGELOG.md                # Version history
├── CODE_OF_CONDUCT.md          # Community guidelines
├── CONTRIBUTING.md             # Contribution guide
├── LICENSE                     # MIT License
├── README.md                   # This file
├── requirements.txt            # Python dependencies
└── setup.py                    # Package installer

🗺️ Fahrplan

v0.1.0 — Erste Veröffentlichung ✅ (Januar 2026)

Status: 🎉 Veröffentlicht (ersetzt durch v0.2.0)

• ✅ 6 Sicherheitsprüfmodule (Server, Dateien, Methoden, Header, TLS, Konfiguration)
• ✅ KI-gestützte Härtungsleitfäden (OpenAI, Anthropic, Ollama)
• ✅ Einwilligungs-Token-System (HTTP + DNS-Verifizierung)
• ✅ Professionelle Berichterstattung (JSON + HTML mit KI-Analyse)
• ✅ SQLite-Persistenz (GEMEINSAM mit Argos-Suite: ~/.argos/argos.db)
• ✅ Docker-Unterstützung mit verletzlichen Laboren (Apache & Nginx)
• ✅ Umfassende Fehlerbehandlung und Ausfallsicherheit
• ✅ 55+ Validierungstests (10 Phasen, 100 % bestanden)

v0.2.0 — Erweiterte Erkennung ✅ (Mai 2026)

Status: 🎉 Veröffentlicht

• ✅ 13 Scan-Phasen (7 neue Phasen gegenüber v0.1.0)
• ✅ Tiefgehende TLS-Analyse: SSLyze-Integration, Cipher Suites, CVE-Korrelation, A+/F-Bewertung
• ✅ Framework- und Modulerkennung: Laravel, Django, Rails, mod_security, WAF-Erkennung
• ✅ Apache/Nginx-Konfigurationsparser (--config-file): Offline-Analyse von httpd.conf/nginx.conf
• ✅ CORS-Erkennung: Wildcard, Null-Origin, Reflexionssonden (COR-001 bis COR-006)
• ✅ Robots.txt-Intelligenz: Analyse gesperrter Pfade, Live-Zugänglichkeitsprüfungen (ROB-001/002/003)
• ✅ WAF-Erkennung: 13 Signaturen einschließlich Cloudflare, Sucuri, ModSecurity, AWS WAF (WAF-001/002)
• ✅ API-Erkennung: Swagger/OpenAPI, GraphQL-Introspection, nicht authentifizierte Endpunkte (API-001 bis API-005)
• ✅ Cookie-Sicherheit: Analyse pro Cookie von HttpOnly/Secure/SameSite (COO-001 bis COO-005)
• ✅ Tiefgehende phpinfo()-Analyse: 9 gefährliche PHP-Einstellungen (PHP-001 bis PHP-009)
• ✅ OWASP Top 10 2021-Zuordnung für jeden Befund
• ✅ Live-CVE-Suche über NVD-API v2 (Apache, Nginx, PHP, OpenSSL)
• ✅ Portscanner: 37 Ports mit Banner-Grabbing
• ✅ KI-Kostenverfolgung (--ai-budget): Budgetgrenzen, costs.json, ai_costs-Tabelle
• ✅ KI-Streaming (--ai-stream): Echtzeit-Token-für-Token-Ausgabe
• ✅ KI-Vergleich (--ai-compare): Zwei Anbieter parallel ausführen
• ✅ KI-Agent (--ai-agent): LangChain-Agent mit NVD-CVE-Suche
• ✅ ( / ): neue/behobene/bestehende Befunde

v0.3.0 — Enterprise-Funktionen (Q3 2026)

Schwerpunkt: Benutzerfreundlichkeit, Skalierbarkeit, interaktive KI

• 🔜 Interaktives Konfigurationsmanagement: Metasploit-ähnliche Oberfläche (heph --show-options, heph --set)
• 🔜 Datenbank-CLI: Kein SQL erforderlich (heph db scans list, heph db findings search)
• 🔜 Multi-Site-Scanning: Stapelverarbeitung aus einer Datei
• 🔜 KI-Chat-Oberfläche: Konversationelle Härtungsanleitung
• 🔜 CI/CD-Integration: GitHub Actions, Jenkins, GitLab-Vorlagen
• 🔜 REST-API-Server: FastAPI-basierte API für Automatisierung
• 🔜 Nmap-Integration: Portscanning für umfassende Bewertung

v0.4.0 — Intelligenz & Automatisierung (Q4 2026)

Schwerpunkt: ML, Automatisierung, erweiterte KI

• 🔜 Automatisierte Behebung: Ansible/Puppet-Playbooks zur automatischen Korrektur
• 🔜 ML-basierte Erkennung: Anomalieerkennung, Reduzierung falsch positiver Ergebnisse
• 🔜 Verteiltes Scannen: Worker-Knoten für groß angelegte Operationen
• 🔜 Fortgeschrittene KI-Agenten: Autonome Scan-Planung, Exploit-Erstellung

Pro Track (Q1 2027)

Kommerzielles Produkt für Unternehmen

IN BEARBEITUNG

Ausführliche Funktionsbeschreibungen finden Sie unter ROADMAP.md

🔒 Ethik & Rechtliches

Die goldene Regel

Scannen Sie nur Systeme, die Ihnen gehören oder für deren Tests Sie eine ausdrückliche schriftliche Genehmigung haben.

Einwilligungsdurchsetzung

Hephaestus implementiert technische Kontrollen, um Missbrauch zu verhindern:

Rechtlicher Rahmen

Unbefugter Zugriff auf Computersysteme ist in den meisten Rechtsordnungen illegal:

• 🇺🇸 USA: Computer Fraud and Abuse Act (CFAA)
• 🇬🇧 UK: Computer Misuse Act 1990
• 🇪🇺 EU: Richtlinie 2013/40/EU
• 🌍 International: Verschiedene Cyberstrafgesetze

Best Practices

1. ✅ Holen Sie sich eine schriftliche Genehmigung vor dem Scannen
2. ✅ Definieren Sie den Umfang klar (welche Domains/IPs)
3. ✅ Dokumentieren Sie alles (Einwilligung, Befunde, Behebung)
4. ✅ Verwenden Sie zuerst den sicheren Modus, um eine Basislinie zu erstellen
5. ✅ Melden Sie Befunde verantwortungsvoll (koordinierte Offenlegung)
6. ❌ Nutzen Sie niemals Schwachstellen aus ohne ausdrückliche Genehmigung
7. ❌ Scannen Sie niemals Websites Dritter (z. B. apache.org, nginx.com)

Vollständige ethische Richtlinien finden Sie unter docs/ETHICS.md

🤝 Mitwirken

Wir begrüßen Beiträge! Ob es sich um:

• 🐛 Fehlerberichte
• 💡 Funktionsanfragen
• 📝 Dokumentationsverbesserungen
• 🔧 Codebeiträge

handelt.

So können Sie beitragen

1. Forken Sie das Repository
2. Erstellen Sie einen Feature-Branch (git checkout -b feature/amazing-feature)
3. Nehmen Sie Ihre Änderungen vor
4. Schreiben/aktualisieren Sie Tests (wenn zutreffend)
5. Comitten Sie Ihre Änderungen (git commit -m 'Add amazing feature')
6. Pushen Sie in den Branch (git push origin feature/amazing-feature)
7. Öffnen Sie einen Pull Request

Entwicklungseinrichtung```bash

Clone your fork

git clone https://github.com/YOUR-USERNAME/hephaestus-server-forger.git cd hephaestus-server-forger

Install development dependencies

python -m pip install -r requirements.txt python -m pip install pytest black flake8 mypy

Run code formatting

black heph/

Run linting

flake8 heph/ mypy heph/

Run tests (when available)

pytest tests/

### Probleme melden

Einen Fehler gefunden? Eine Funktion gewünscht?

**Ein Issue eröffnen**: https://github.com/rodhnin/hephaestus-server-forger/issues

Bitte füge Folgendes ein:

- Hephaestus-Version (`python -m heph --version`)
- Python-Version (`python --version`)
- Betriebssystem
- Schritte zur Reproduktion (bei Fehlern)
- Erwartetes vs. tatsächliches Verhalten

---

## 📚 Dokumentation

Umfassende Dokumentation im Verzeichnis `docs/` verfügbar:

| Dokument                                    | Beschreibung                                      |
| ------------------------------------------- | ------------------------------------------------- |
| [AI_INTEGRATION.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/AI_INTEGRATION.md) | Vollständige KI-Einrichtungsanleitung (alle 3 Anbieter) |
| [CONSENT.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/CONSENT.md)               | Technische Details zum Einwilligungs-Token-System |
| [DATABASE_GUIDE.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/DATABASE_GUIDE.md) | SQLite-Schema, Abfragen, Verwaltung               |
| [ETHICS.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/ETHICS.md)                 | Rechtlicher Rahmen und ethische Richtlinien       |
| [REPORT_FORMAT.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/REPORT_FORMAT.md)   | JSON-Schema und HTML-Spezifikationen              |
| [TESTING_GUIDE.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/TESTING_GUIDE.md)   | Sicheres Testen mit Docker-Labs                   |
| [ROADMAP.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/ROADMAP.md)               | Zukünftige Funktionen und Entwicklungspläne       |

### Schnelllinks

- **Changelog**: [CHANGELOG.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/CHANGELOG.md)
- **Lizenz**: [LICENSE](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/LICENSE)
- **CLI-Beispiele**: [scripts/cli-examples.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/scripts/cli-examples.md)

---

## ⚖️ Lizenz

Dieses Projekt ist unter der **MIT-Lizenz** lizenziert – siehe die Datei [LICENSE](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/LICENSE) für Details.```
MIT License

Copyright (c) 2026 Rodney Dhavid Jimenez Chacin

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

⚠️ Haftungsausschluss

WICHTIG: Dieses Tool ist ausschließlich für autorisierte Sicherheitstests bestimmt.

Rechtlicher Hinweis

Durch die Nutzung von Hephaestus erklären Sie sich damit einverstanden, dass:

1. ✅ Sie ausschließlich Systeme scannen, die Ihnen gehören oder für die Sie eine ausdrückliche schriftliche Genehmigung zum Testen haben
2. ✅ Sie alle geltenden Gesetze und Vorschriften einhalten
3. ✅ Sie verstehen, dass unautorisierter Zugriff illegal ist (CFAA, Computer Misuse Act usw.)
4. ✅ Der Autor und die Mitwirkenden übernehmen keine Haftung für Missbrauch
5. ✅ Diese Software wird „wie besehen“ ohne jegliche Gewährleistung zur Verfügung gestellt

Verantwortungsvolle Offenlegung

Wenn Sie mit Hephaestus Schwachstellen entdecken:

• 📧 Kontaktieren Sie zuerst privat den Seitenbetreiber
• ⏰ Geben Sie angemessene Zeit zur Behebung (in der Regel 90 Tage)
• 🤝 Koordinieren Sie den Zeitplan der Offenlegung
• 📝 Dokumentieren Sie Ihre Ergebnisse professionell

Im Zweifelsfall

Scannen Sie nicht. Wenn Sie sich nicht sicher sind, ob Sie die Erlaubnis haben, haben Sie sie wahrscheinlich nicht.

🙏 Danksagungen

Hephaestus steht auf den Schultern von Giganten:

• Apache & Nginx — Dokumentation und Härtungsleitfäden
• OWASP — Sicherheitsstandards (Top 10, Testing Guide, Secure Headers Project)
• CIS Benchmarks — Best Practices zur Serverhärtung
• LangChain — KI-Framework für intelligente Analyse
• Anthropic & OpenAI — KI-Modelle zur Schwachstellenanalyse
• Ollama — Lokale KI-Inferenz für datenschutzorientiertes Scannen
• Python-Community — Hervorragende Bibliotheken und Werkzeuge

Besonderer Dank gilt allen Sicherheitsforschern, die ethisches Hacken praktizieren und fördern.

👤 Autor

Rodney Dhavid Jimenez Chacin (rodhnin)

• 🌐 Website & Kontakt: rodhnin.com
• 💼 GitHub: @rodhnin
• 🔗 Projekt: hephaestus-server-forger

Bei Fragen, Feedback oder Kooperationsanfragen besuchen Sie bitte rodhnin.com, um mich zu kontaktieren.

💬 Community

• Diskussionen: GitHub Discussions
• Issues: GitHub Issues
• Versionen: GitHub Releases