En action

_{Scan en direct · Apache 2.4.54 · 11 constats · 44,17 s · scan n° 518 · mode sûr}

Rapport HTML — répartition par sévérité, correspondance OWASP, barre de filtres

Tableau des constats — badges CVE/CWE, preuves dépliables, extraits de configuration

🎯 Qu'est-ce que Hephaestus ?

Hephaestus est un auditeur de sécurité de serveurs prêt pour la production qui place l'éthique en premier. Conçu pour les administrateurs système, les ingénieurs DevOps et les testeurs d'intrusion, il analyse les configurations de serveurs web (Apache, Nginx, IIS) afin d'identifier les mauvaises configurations critiques avant que des attaquants ne les exploitent.

Pourquoi Hephaestus ?

• 🔒 Éthique par conception : le système de jeton de consentement empêche les scans non autorisés
• 🤖 Propulsé par l'IA : GPT-4, Claude ou Ollama local pour des guides de durcissement intelligents
• 📊 Rapports professionnels : HTML élégant + JSON lisible par machine
• 🚀 Rapide et efficace : scan concurrent avec limitation de débit intelligente
• 💾 Suivi persistant : base de données SQLite PARTAGÉE avec la suite Argos (~/.argos/argos.db)
• 🐳 Prêt pour Docker : scan conteneurisé + laboratoires de test vulnérables (Apache et Nginx)
• 🎯 Zéro faux positif : testé en profondeur avec plus de 55 tests de validation

Ce qu'il scanne

✨ Fonctionnalités

🛡️ Audit de sécurité principal```bash

One command, comprehensive server analysis

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

- **Prise en charge multi-serveurs** : détection et durcissement d'Apache, Nginx, IIS
- **Analyse concurrente** : pool de threads + limitation de débit pour des analyses rapides et respectueuses
- **Collecte de preuves** : réponses HTTP, en-têtes, contenus de fichiers préservés
- **Gestion élégante des erreurs** : délais d'expiration, échecs DNS, connexions refusées gérés de manière robuste

### 🤖 Guides de durcissement assistés par IA

Choisissez votre fournisseur d'IA en fonction de vos besoins :

| Fournisseur         | Idéal pour          | Vitesse          | Coût           | Confidentialité |
| -------------------- | ------------------ | --------------- | ------------- | --------------- |
| **OpenAI GPT-4**     | Qualité production | ⚡ Rapide (35s)  | 💰 $0.25/scan | 🔒 Standard     |
| **Anthropic Claude** | Orienté confidentialité | ⚡ Rapide (45s)  | 💰 $0.30/scan | 🔒 Améliorée    |
| **Ollama (Local)**   | Confidentialité totale | 🐢 Lent (28min) | 💰 Gratuit    | 🔐 100 % hors ligne |

**Deux modes d'analyse :**

- **Technique** : extraits de configuration Apache/Nginx, commandes CLI, durcissement pas à pas
- **Exécutif** : évaluation des risques en langage clair pour les parties prenantes et la direction

### 📊 Rapports professionnels

**Rapports JSON** (lisibles par machine)```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": {...}
}

Rapports HTML (conviviaux)

• 🎨 Thème Forge avec dégradés orange/rouge (⚒️ esthétique forgeron)
• 🏷️ Badges de sévérité codés par couleur
• 📝 Sections de preuves extensibles
• 🤖 Guides de durcissement IA joliment formatés
• 📱 Design adapté aux mobiles

🔐 Système de jeton de consentement

L'analyse agressive et l'analyse IA nécessitent une preuve de propriété :```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

### 💾 Persistance de la base de données

Base de données SQLite **partagée avec la suite Argos** (`~/.argos/argos.db`) :

- **Historique des scans** : date, durée, nombre de résultats, répartition par sévérité
- **Référentiel de résultats** : base de données de vulnérabilités consultable (1159+ résultats stockés)
- **Domaines vérifiés** : suivi des jetons de consentement avec expiration
- **Intégration multi-outils** : fonctionne de manière transparente avec Argus, Pythia et les futurs outils```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'"

✅ Validation et tests

Hephaestus v0.2.0 a été validé empiriquement à l'aide de laboratoires vulnérables contrôlés basés sur Docker (Apache et Nginx).

Résumé de la validation (mai 2026)

Couverture des tests (13 phases) :

• ✅ Phase 1 : CLI de base (codes de sortie, gestion des erreurs)
• ✅ Phase 2 : Jetons de consentement (vérification HTTP, mode agressif)
• ✅ Phase 3 : Intégration IA (OpenAI, Anthropic, Ollama)
• ✅ Phase 4 : Génération de rapports (JSON, HTML, analyse IA)
• ✅ Phase 5 : Options avancées (limitation de débit, threads, délais d'attente)
• ✅ Phase 6 : Modules de vérification (plus de 70 codes de résultats validés)
• ✅ Phase 7 : Journalisation (texte, JSON, niveaux de verbosité)
• ✅ Phase 8 : Base de données (schéma, intégrité, clés étrangères)
• ✅ Phase 9 : Gestion des erreurs (cas limites, permissions)
• ✅ Phase 10 : Intégration (compatibilité avec la suite Argos)
• ✅ Phase 11 : Détection CORS, Robots.txt, WAF
• ✅ Phase 12 : Découverte d'API, sécurité des cookies, analyse phpinfo
• ✅ Phase 13 : Analyseur de fichiers de configuration, rapports de différences, suivi des coûts IA

Résultats clés :

• ✅ Toutes les vulnérabilités critiques détectées (.env, .git, server-status, phpinfo)
• ✅ Toutes les versions de serveurs identifiées (Apache 2.4.54, Nginx 1.18.0)
• ✅ Tous les en-têtes de sécurité analysés correctement (6 en-têtes vérifiés)
• ✅ Tous les problèmes de listage de répertoire identifiés
• ✅ Modules CORS, WAF, API, Cookie et phpinfo entièrement opérationnels
• ✅ Rapports de différences (--diff last) fonctionnels sur tout l'historique des scans
• ✅ Gestion des erreurs résiliente (délais d'attente, échecs DNS, connexion refusée)

Verdict : Hephaestus est prêt pour la production pour les évaluations de sécurité des serveurs.

🚀 Démarrage rapide

Prérequis

• Python 3.11+ (3.12 recommandé)
• pip (gestionnaire de paquets Python)
• Docker (optionnel, pour les laboratoires vulnérables)

Installation

1. Clonez le dépôt```bash git clone https://github.com/rodhnin/hephaestus-server-forger.git cd hephaestus-server-forger

**2. (Facultatif) Installer `venv` s'il n'est pas déjà disponible**```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. Créer et activer l'environnement virtuel```bash python3 -m venv .venv source .venv/bin/activate

You should see (.venv) in your terminal prompt

**4. Mettre à niveau pip**```bash
python -m pip install --upgrade pip

5. Installer les dépendances```bash python -m pip install -r requirements.txt

**6. Configurer les clés API (si vous utilisez l'IA cloud)**```bash
# OpenAI
export OPENAI_API_KEY="sk-..."

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

7. Vérifier l'installation```bash python -m heph --version

Output: heph 0.2.0

### Votre premier 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

🐳 Démarrage rapide avec Docker

cd docker && ./deploy.sh

Sélectionnez l'option 3 pour tester (les deux)

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

🎉 Succès! Vérifiez ~/.hephaestus/reports/ pour vos rapports.

📘 Guide d'utilisation

Analyse de base```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

### Analyse avancée```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

Guides de renforcement alimentés par l'IA

Étape 1 : Configurez votre fournisseur

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

**Étape 2: Testez votre configuration**```bash
# Verify AI provider works
python -m heph.core.ai openai

Étape 3 : Lancer l'analyse propulsée par l'IA```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

### Mode agressif (Nécessite un consentement)```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

🤖 Analyse propulsée par l'IA

Hephaestus utilise LangChain 1.0.0 avec la prise en charge de plusieurs fournisseurs d'IA.

Fournisseurs pris en charge

OpenAI GPT-4 Turbo

Idéal pour : Usage en production

• ⭐ Qualité : Excellente (5/5)
• ⚡ Vitesse : ~35 secondes
• 💰 Coût : ~0,25 $ par analyse
• 🔒 Confidentialité : Standard (données chiffrées en transit)```bash export OPENAI_API_KEY="sk-..." python -m pip install langchain-openai==1.0.0

#### Anthropic Claude

**Idéal pour: Confidentialité renforcée**

- ⭐ Qualité: Excellente (5/5)
- ⚡ Vitesse: ~45 secondes
- 💰 Coût: ~$0.30 par scan
- 🔒 Confidentialité: Renforcée (l'approche d'Anthropic axée sur la confidentialité)```bash
export ANTHROPIC_API_KEY="sk-ant-..."
python -m pip install langchain-anthropic==1.0.0

Ollama (Modèles locaux)

Idéal pour : Confidentialité totale

• ⭐ Qualité : Bonne (3/5)
• 🐢 Vitesse : ~28 minutes (CPU) ou ~75 secondes (GPU)
• 💰 Coût : Gratuit
• 🔐 Confidentialité : 100 % hors ligne (les données ne quittent jamais votre machine)```bash

Install Ollama: https://ollama.ai

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

### Confidentialité et sécurité

**Assainissement automatique**

Avant l'envoi aux fournisseurs d'IA, Hephaestus supprime automatiquement :

- ✅ Jetons de consentement
- ✅ Clés API et identifiants
- ✅ Clés privées et certificats
- ✅ Adresses IP internes
- ✅ Identifiants de base de données

**Opt-In Uniquement**

- L'analyse IA nécessite l'option explicite `--use-ai`
- L'analyse agressive nécessite un jeton de consentement vérifié
- Vous contrôlez quel fournisseur voit vos données

**Pour une confidentialité maximale** : utilisez Ollama localement.

---

## 🧪 Laboratoires de test sécurisés

**⚠️ NE SCANNEZ JAMAIS des sites de production sans autorisation écrite !**

Utilisez nos laboratoires Docker pour vous entraîner en toute sécurité :

### Configurer l'environnement de test

### Option 1 : Script interactif (recommandé)```bash
# Run the interactive deployment script
cd docker && ./deploy.sh

Le script propose 5 options :

1. Production → Déployer le service de scan Hephaestus
2. Testing Lab → Déployer des serveurs web vulnérables (Apache + Nginx)
3. Both → Déployer les deux environnements
4. Stop All → Arrêter tous les services en cours d'exécution
5. Remove All → Supprimer les conteneurs, volumes et données (nécessite une confirmation)

Option 2 : Docker Compose manuel

Testing Lab uniquement :```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

**Scanner de production:**```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/

Les deux environnements :```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

### Scannez les laboratoires```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

Résultats attendus

Apache Lab (localhost:8080):

• 42 constatations au total (sur l'ensemble des 13 phases de scan)
• Inclut les constatations CORS, WAF, API, Cookie, phpinfo, mappées OWASP

Nginx Lab (localhost:8081):

• 25 constatations au total (sur l'ensemble des 13 phases de scan)
• Inclut les constatations CORS, WAF, API, Cookie, mappées OWASP

Nettoyage

Arrêter les services :```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

**Tout supprimer (AVERTISSEMENT : supprime les données et les rapports) :**```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

🐳 Déploiement Docker

Hephaestus propose deux options de déploiement Docker :

Option 1 : Docker Compose (Recommandé)

Service de scanner de production :```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

**Laboratoire de test (Serveurs vulnérables) :**```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

Script de déploiement interactif:```bash

Use the interactive menu

cd docker && ./deploy.sh

### Option 2 : Exécution Docker directe

**Construire l'image :**```bash
docker build -f docker/Dockerfile -t hephaestus:0.2.0 .

Lancer une analyse ponctuelle :```bash docker run --rm
-v $(pwd)/docker/reports:/reports
-v $(pwd)/docker/data:/data
hephaestus:0.2.0
--target https://example.com
--html

**Avec analyse IA :**```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

Scanner le laboratoire de test local :```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

---

## 📊 Comprendre les rapports

### Structure des rapports```
~/.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

Identifiants des constatations (Modèle, 70+ au total)```

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

### Cartographie des sévérités

- **CRITICAL** : .env exposé, .git accessible, phpinfo, server-status, dumps SQL
- **HIGH** : Version du serveur divulguée, TLS faible, TLS absent, méthodes HTTP non sécurisées
- **MEDIUM** : En-têtes importants manquants (HSTS, CSP, X-Frame-Options), listage de répertoire, divulgation de page d'erreur
- **LOW** : En-têtes mineurs (X-Content-Type-Options, Referrer-Policy, Permissions-Policy)
- **INFO** : Constats informatifs (serveur détecté, TLS 1.2 OK)

---

## 📁 Structure du projet```
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

🗺️ Feuille de route

v0.1.0 — Version initiale ✅ (janvier 2026)

Statut : 🎉 Publiée (remplacée par v0.2.0)

• ✅ 6 modules de vérification de sécurité (serveur, fichiers, méthodes, en-têtes, TLS, config)
• ✅ Guides de durcissement propulsés par l'IA (OpenAI, Anthropic, Ollama)
• ✅ Système de jeton de consentement (vérification HTTP + DNS)
• ✅ Rapports professionnels (JSON + HTML avec analyse IA)
• ✅ Persistance SQLite (PARTAGÉE avec la suite Argos : ~/.argos/argos.db)
• ✅ Prise en charge Docker avec laboratoires vulnérables (Apache et Nginx)
• ✅ Gestion complète des erreurs et résilience
• ✅ 55+ tests de validation (10 phases, 100 % de réussite)

v0.2.0 — Détection améliorée ✅ (mai 2026)

Statut : 🎉 Publiée

• ✅ 13 phases d'analyse (7 nouvelles phases ajoutées par rapport à v0.1.0)
• ✅ Analyse TLS approfondie : intégration SSLyze, suites de chiffrement, corrélation CVE, notation A+/F
• ✅ Détection de framework et de module : Laravel, Django, Rails, mod_security, détection WAF
• ✅ Analyseur de configuration Apache/Nginx (--config-file) : analyse hors ligne de httpd.conf/nginx.conf
• ✅ Détection CORS : caractère générique, origine nulle, sondes de réflexion (COR-001 à COR-006)
• ✅ Analyse Robots.txt : analyse des chemins interdits, sondes d'accessibilité en direct (ROB-001/002/003)
• ✅ Détection WAF : 13 signatures dont Cloudflare, Sucuri, ModSecurity, AWS WAF (WAF-001/002)
• ✅ Découverte d'API : Swagger/OpenAPI, introspection GraphQL, points de terminaison non authentifiés (API-001 à API-005)
• ✅ Sécurité des cookies : analyse par cookie de HttpOnly/Secure/SameSite (COO-001 à COO-005)
• ✅ Analyse approfondie de phpinfo() : 9 paramètres PHP dangereux (PHP-001 à PHP-009)
• ✅ Correspondance OWASP Top 10 2021 sur chaque constatation
• ✅ Recherche en direct de CVE via l'API NVD v2 (Apache, Nginx, PHP, OpenSSL)
• ✅ Scanner de ports : 37 ports avec collecte de bannières
• ✅ Suivi des coûts IA (--ai-budget) : limites de budget, costs.json, table ai_costs
• ✅ Streaming IA (--ai-stream) : sortie en temps réel, jeton par jeton
• ✅ Comparaison IA (--ai-compare) : exécuter deux fournisseurs en parallèle
• ✅ Agent IA (--ai-agent) : agent LangChain avec recherche de CVE via NVD

v0.3.0 — Fonctionnalités d'entreprise (T3 2026)

Objectif : ergonomie, évolutivité, IA interactive

• 🔜 Gestion interactive de la configuration : interface de style Metasploit (heph --show-options, heph --set)
• 🔜 CLI de base de données : aucune requête SQL nécessaire (heph db scans list, heph db findings search)
• 🔜 Analyse multi-sites : traitement par lots à partir d'un fichier
• 🔜 Interface de chat IA : conseils de durcissement conversationnels
• 🔜 Intégration CI/CD : modèles GitHub Actions, Jenkins, GitLab
• 🔜 Serveur d'API REST : API basée sur FastAPI pour l'automatisation
• 🔜 Intégration Nmap : analyse de ports pour une évaluation complète

v0.4.0 — Intelligence et automatisation (T4 2026)

Objectif : ML, automatisation, IA avancée

• 🔜 Correction automatisée : playbooks Ansible/Puppet pour l'auto-correction
• 🔜 Détection basée sur le ML : détection d'anomalies, réduction des faux positifs
• 🔜 Analyse distribuée : nœuds de travail pour des opérations à grande échelle
• 🔜 Agents IA avancés : planification d'analyse autonome, génération d'exploits

Parcours Pro (T1 2027)

Produit commercial pour les entreprises

EN COURS

Pour des descriptions détaillées des fonctionnalités, consultez ROADMAP.md

🔒 Éthique et aspects juridiques

La règle d'or

Analysez uniquement les systèmes que vous possédez ou pour lesquels vous disposez d'une autorisation écrite explicite de tester.

Application du consentement

Hephaestus implémente des contrôles techniques pour prévenir toute utilisation abusive :

Cadre juridique

L'accès non autorisé à des systèmes informatiques est illégal dans la plupart des juridictions :

• 🇺🇸 États-Unis : Computer Fraud and Abuse Act (CFAA)
• 🇬🇧 Royaume-Uni : Computer Misuse Act 1990
• 🇪🇺 UE : Directive 2013/40/UE
• 🌍 International : diverses lois sur la cybercriminalité

Bonnes pratiques

1. ✅ Obtenez une autorisation écrite avant l'analyse
2. ✅ Définissez clairement le périmètre (quels domaines/IP)
3. ✅ Documentez tout (consentement, constatations, correction)
4. ✅ Utilisez d'abord le mode sécurisé pour établir une base de référence
5. ✅ Signalez les constatations de manière responsable (divulgation coordonnée)
6. ❌ N'exploitez jamais les vulnérabilités sans autorisation explicite
7. ❌ N'analysez jamais de sites tiers (par exemple, apache.org, nginx.com)

Pour des directives éthiques complètes, consultez docs/ETHICS.md

🤝 Contribuer

Nous accueillons les contributions ! Que ce soit :

• 🐛 Signalements de bogues
• 💡 Demandes de fonctionnalités
• 📝 Améliorations de la documentation
• 🔧 Contributions de code

Comment contribuer

1. Forkez le dépôt
2. Créez une branche de fonctionnalité (git checkout -b feature/amazing-feature)
3. Effectuez vos modifications
4. Rédigez/mettez à jour les tests (le cas échéant)
5. Validez vos modifications (git commit -m 'Add amazing feature')
6. Poussez vers la branche (git push origin feature/amazing-feature)
7. Ouvrez une Pull Request

Configuration de développement```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/

### Signaler des problèmes

Vous avez trouvé un bug ? Une demande de fonctionnalité ?

**Ouvrez une issue** : https://github.com/rodhnin/hephaestus-server-forger/issues

Veuillez inclure :

- Version de Hephaestus (`python -m heph --version`)
- Version de Python (`python --version`)
- Système d'exploitation
- Étapes pour reproduire (pour les bugs)
- Comportement attendu vs réel

---

## 📚 Documentation

Documentation complète disponible dans le répertoire `docs/` :

| Document                                    | Description                               |
| ------------------------------------------- | ----------------------------------------- |
| [AI_INTEGRATION.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/AI_INTEGRATION.md) | Guide complet de configuration IA (les 3 fournisseurs) |
| [CONSENT.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/CONSENT.md)               | Détails techniques du système de jetons de consentement |
| [DATABASE_GUIDE.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/DATABASE_GUIDE.md) | Schéma SQLite, requêtes, gestion        |
| [ETHICS.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/ETHICS.md)                 | Cadre juridique et directives éthiques    |
| [REPORT_FORMAT.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/REPORT_FORMAT.md)   | Schéma JSON et spécifications HTML       |
| [TESTING_GUIDE.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/TESTING_GUIDE.md)   | Tests sécurisés avec les laboratoires Docker             |
| [ROADMAP.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/docs/ROADMAP.md)               | Fonctionnalités futures et plans de développement     |

### Liens rapides

- **Journal des modifications** : [CHANGELOG.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/CHANGELOG.md)
- **Licence** : [LICENSE](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/LICENSE)
- **Exemples CLI** : [scripts/cli-examples.md](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/scripts/cli-examples.md)

---

## ⚖️ Licence

Ce projet est sous licence **MIT** - voir le fichier [LICENSE](https://github.com/rodhnin/hephaestus-server-forger/blob/HEAD/LICENSE) pour plus de détails.```
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.

⚠️ Avertissement

IMPORTANT : Cet outil est réservé aux tests de sécurité autorisés uniquement.

Avis juridique

En utilisant Hephaestus, vous reconnaissez et acceptez que :

1. ✅ Vous scannerez uniquement des systèmes qui vous appartiennent ou pour lesquels vous avez une autorisation écrite explicite de tester
2. ✅ Vous respecterez toutes les lois et réglementations applicables
3. ✅ Vous comprenez que l'accès non autorisé est illégal (CFAA, Computer Misuse Act, etc.)
4. ✅ L'auteur et les contributeurs déclinent toute responsabilité en cas d'utilisation abusive
5. ✅ Ce logiciel est fourni « tel quel », sans garantie d'aucune sorte

Divulgation responsable

Si vous découvrez des vulnérabilités avec Hephaestus :

• 📧 Contactez d'abord le propriétaire du site en privé
• ⏰ Accordez un délai raisonnable pour corriger (généralement 90 jours)
• 🤝 Coordonnez le calendrier de divulgation
• 📝 Documentez vos résultats de manière professionnelle

En cas de doute

Ne scannez pas. Si vous n'êtes pas sûr d'avoir l'autorisation, c'est probablement que vous ne l'avez pas.

🙏 Remerciements

Hephaestus se tient sur les épaules de géants :

• Apache & Nginx — Guides de documentation et de durcissement
• OWASP — Normes de sécurité (Top 10, Testing Guide, Secure Headers Project)
• CIS Benchmarks — Bonnes pratiques de durcissement des serveurs
• LangChain — Framework IA pour l'analyse intelligente
• Anthropic & OpenAI — Modèles d'IA pour l'analyse des vulnérabilités
• Ollama — Inférence IA locale pour des scans respectueux de la vie privée
• Python Community — Bibliothèques et outils incroyables

Un merci tout particulier aux chercheurs en sécurité qui pratiquent et promeuvent le piratage éthique.

👤 Auteur

Rodney Dhavid Jimenez Chacin (rodhnin)

• 🌐 Site Web et contact : rodhnin.com
• 💼 GitHub : @rodhnin
• 🔗 Projet : hephaestus-server-forger

Pour toute question, retour ou demande de collaboration, veuillez visiter rodhnin.com pour me contacter.

💬 Communauté

• Discussions : GitHub Discussions
• Issues : GitHub Issues
• Releases : GitHub Releases