@@ -0,0 +1,32 @@
+# syntax=docker/dockerfile:1
+# Honeypot HTTP (EPIC-2) — émulation WordPress, image minimale, exécutée en non-root.
+FROM python:3.12-slim-bookworm
+
+# Empêche Python de bufferiser stdout : les événements JSONL sortent en temps
+# réel dans les logs Docker / vers Filebeat.
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /app
+
+# Dépendances d'abord (cache de build).
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Code applicatif.
+COPY app ./app
+COPY alerts ./alerts
+
+# Utilisateur non privilégié + répertoire de logs inscriptible (aligné SSH).
+RUN useradd --system --no-create-home --uid 10001 honey \
+    && mkdir -p /var/log/honeypot \
+    && chown honey:honey /var/log/honeypot
+USER honey
+
+EXPOSE 8080
+
+# Vérifie que le port HTTP accepte les connexions TCP.
+HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
+    CMD python -c "import socket,os,sys; s=socket.socket(); s.settimeout(3); sys.exit(s.connect_ex(('127.0.0.1', int(os.getenv('HTTP_PORT','8080')))))"
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
@@ -0,0 +1,49 @@
+"""Client Redis pour pousser les alertes critiques (US-11).
+
+L'envoi est best-effort : si Redis est indisponible (dev local), l'alerte est
+seulement journalisée sur stderr, sans bloquer la réponse du honeypot.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from app.config import ALERT_CHANNEL, REDIS_URL
+
+try:
+    import redis
+except ImportError:  # redis optionnel en dev
+    redis = None
+
+_client = None
+
+
+def _get_client():
+    global _client
+    if redis is None:
+        return None
+    if _client is None:
+        _client = redis.Redis.from_url(REDIS_URL, socket_connect_timeout=1, socket_timeout=1)
+    return _client
+
+
+def _log_stderr(event: dict[str, Any]) -> None:
+    print(f"[ALERT] {json.dumps(event, ensure_ascii=False)}", file=sys.stderr, flush=True)
+
+
+def push_alert(event: dict[str, Any]) -> bool:
+    """Publie l'alerte sur le canal Redis + l'empile. Retourne False si indisponible."""
+    client = _get_client()
+    if client is None:
+        _log_stderr(event)
+        return False
+    try:
+        message = json.dumps(event, ensure_ascii=False)
+        client.publish(ALERT_CHANNEL, message)
+        client.lpush(ALERT_CHANNEL, message)
+        return True
+    except Exception:  # Redis indisponible ne doit jamais casser le honeypot
+        _log_stderr(event)
+        return False
@@ -0,0 +1,30 @@
+"""Configuration du honeypot HTTP : headers cohérents et constantes d'émulation.
+
+Chaque réponse imite un serveur Apache/PHP réel pour rester crédible face aux
+scanners (cohérence imposée par US-08 et US-28).
+"""
+
+import os
+
+# Headers renvoyés sur CHAQUE réponse (US-08 / US-28).
+SERVER_HEADER = "Apache/2.4.57 (Debian)"
+X_POWERED_BY = "PHP/7.4.33"
+
+COHERENT_HEADERS = {
+    "Server": SERVER_HEADER,
+    "X-Powered-By": X_POWERED_BY,
+}
+
+# Port d'écoute interne du conteneur (l'hôte de bind est fourni par uvicorn/Docker).
+LISTEN_PORT = 8080
+
+# Journalisation des événements (JSON Lines) — voir app/events/builder.py.
+# Même dossier/convention que le honeypot SSH (/var/log/honeypot/<service>.jsonl).
+LOG_FILE = os.getenv("HTTP_LOG_FILE", "/var/log/honeypot/http.jsonl")
+# Hostname simulé : identique au SSH pour que le SIEM corrèle une seule machine.
+HONEYPOT_HOST = os.getenv("HONEYPOT_HOST", "prod-srv-01")
+SCHEMA_VERSION = "1.0.0"
+
+# Alertes canary (US-11) poussées vers Redis.
+REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0")
+ALERT_CHANNEL = os.getenv("ALERT_CHANNEL", "honeypot:alerts")
@@ -0,0 +1,17 @@
+APP_NAME=AcmePortal
+APP_ENV=production
+APP_KEY=base64:Zk9Jx2cQ7v3mN1pR8sT4uW6yA0bC5dE7gH9iK2lM4n=
+APP_DEBUG=false
+APP_URL=https://portal.acme-corp.internal
+
+DB_CONNECTION=mysql
+DB_HOST=10.0.4.12
+DB_PORT=3306
+DB_DATABASE=acme_prod
+DB_USERNAME=acme_admin
+DB_PASSWORD=Wint3r-2024-ProdDB-Decoy
+
+REDIS_HOST=10.0.4.20
+MAIL_HOST=smtp.acme-corp.internal
+AWS_ACCESS_KEY_ID=AKIA5EXAMPLEDECOYKEY00
+AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMIK7MDENGbPxRfiCYDECOYEXAMPLEKEY
@@ -0,0 +1,14 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[remote "origin"]
+	url = https://github.com/acme-corp/internal-portal.git
+	fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "main"]
+	remote = origin
+	merge = refs/heads/main
+[user]
+	name = deploy-bot
+	email = deploy@acme-corp.internal
@@ -0,0 +1,113 @@
+"""Construction et écriture des événements honeypot (Epic 2).
+
+Chaque événement est conforme à docs/event.schema.json (HoneypotEvent v1).
+Sortie : une ligne JSON par événement (JSON Lines) sur stdout (logs Docker) et,
+optionnellement, dans un fichier tail par Filebeat/Fluent Bit puis expédié au
+SIEM. Conventions alignées sur le honeypot SSH (honeypots/ssh/events.py).
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, TextIO
+
+from app.config import HONEYPOT_HOST, LOG_FILE, SCHEMA_VERSION
+
+SERVICE = "http"
+
+
+def _now_iso() -> str:
+    """Timestamp ISO 8601 UTC avec millisecondes, ex: 2024-06-03T08:45:12.123Z."""
+    now = datetime.now(UTC)
+    return now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z"
+
+
+def normalize_ipv4(addr: str) -> str:
+    """Ramène une adresse à la forme IPv4 attendue par le schéma (cf. SSH).
+
+    Déplie les IPv4 mappées IPv6 (``::ffff:127.0.0.1``) et rabat le loopback
+    IPv6 sur ``127.0.0.1`` pour respecter ``format: ipv4``.
+    """
+    if addr.startswith("::ffff:") and "." in addr:
+        return addr.rsplit(":", 1)[-1]
+    if addr in ("::1", "::"):
+        return "127.0.0.1"
+    return addr
+
+
+def build_event(
+    *,
+    event_type: str,
+    src_ip: str,
+    payload: dict[str, Any],
+    src_port: int | None = None,
+    session_id: str | None = None,
+    classification: dict[str, Any] | None = None,
+    honeypot_host: str = HONEYPOT_HOST,
+) -> dict[str, Any]:
+    """Assemble un événement conforme au schéma HoneypotEvent."""
+    event: dict[str, Any] = {
+        "id": str(uuid.uuid4()),
+        "timestamp": _now_iso(),
+        "service": SERVICE,
+        "event_type": event_type,
+        "src_ip": normalize_ipv4(src_ip),
+        "payload": payload,
+        "meta": {"honeypot_host": honeypot_host, "schema_version": SCHEMA_VERSION},
+    }
+    if src_port is not None:
+        event["src_port"] = src_port
+    if session_id is not None:
+        event["session_id"] = session_id
+    if classification:
+        event["classification"] = classification
+    return event
+
+
+class EventSink:
+    """Écrit les événements en JSON Lines sur stdout et (optionnellement) un fichier.
+
+    Le fichier est ouvert en append et flush à chaque ligne pour que Filebeat
+    voie les événements en quasi temps réel. Une panne d'écriture fichier ne
+    doit jamais interrompre le honeypot : on retombe sur stdout seul.
+    """
+
+    def __init__(self, log_file: str | None = None, *, stream: TextIO | None = None) -> None:
+        self._stream = stream if stream is not None else sys.stdout
+        self._file: TextIO | None = None
+        if log_file:
+            try:
+                path = Path(log_file)
+                path.parent.mkdir(parents=True, exist_ok=True)
+                self._file = path.open("a", encoding="utf-8")
+            except OSError as exc:  # pragma: no cover - dépend du FS
+                print(f"[events] fichier de log indisponible ({exc}), stdout seul", file=sys.stderr)
+
+    def emit(self, event: dict[str, Any]) -> None:
+        """Sérialise et écrit un événement sur toutes les sorties disponibles."""
+        line = json.dumps(event, ensure_ascii=False, separators=(",", ":"))
+        print(line, file=self._stream, flush=True)
+        if self._file is not None:
+            try:
+                self._file.write(line + "\n")
+                self._file.flush()
+            except OSError as exc:  # pragma: no cover - dépend du FS
+                print(f"[events] écriture fichier échouée: {exc}", file=sys.stderr)
+
+    def close(self) -> None:
+        if self._file is not None:
+            self._file.close()
+            self._file = None
+
+
+# Sink partagé par les middlewares et les routes (le fichier reste ouvert).
+sink = EventSink(LOG_FILE)
+
+
+def emit(event: dict[str, Any]) -> None:
+    """Émet via le sink partagé (API conservée pour les routes/middlewares)."""
+    sink.emit(event)
@@ -0,0 +1,49 @@
+"""Honeypot HTTP — application FastAPI émulant un WordPress (Epic 2).
+
+Pipeline de traitement :
+  1. middleware log_requests : journalise chaque requête, détecte scanners (US-12)
+     et exploits (US-10), émet un event `request`.
+  2. middleware add_coherent_headers : injecte les headers Apache/PHP cohérents.
+  3. routeurs : wordpress (US-08), extra (US-28), credentials (US-09), canary (US-11).
+
+Les endpoints docs/openapi de FastAPI sont désactivés : un vrai WordPress ne les
+exposerait pas (tell de honeypot évité).
+"""
+
+import os
+
+import uvicorn
+from fastapi import FastAPI, Request, Response
+
+from app.config import COHERENT_HEADERS, LISTEN_PORT
+from app.middleware.logging import log_requests
+from app.routes import canary, credentials, extra, wordpress
+
+app = FastAPI(title="wordpress", docs_url=None, redoc_url=None, openapi_url=None)
+
+app.include_router(wordpress.router)
+app.include_router(extra.router)
+app.include_router(credentials.router)
+app.include_router(canary.router)
+
+
+@app.middleware("http")
+async def add_coherent_headers(request: Request, call_next) -> Response:
+    """Injecte Server / X-Powered-By cohérents sur chaque réponse."""
+    response = await call_next(request)
+    for name, value in COHERENT_HEADERS.items():
+        response.headers[name] = value
+    return response
+
+
+# Enregistré après le middleware de headers => s'exécute en premier (lit la requête brute).
+app.middleware("http")(log_requests)
+
+
+def main() -> None:
+    host = os.getenv("HTTP_HOST", "127.0.0.1")
+    uvicorn.run(app, host=host, port=LISTEN_PORT)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,67 @@
+"""Détection d'exploits HTTP (US-10) : LFI, SQLi, RCE, XSS, Log4Shell, etc.
+
+Analyse l'URL, la query string, le body et les headers. Renvoie une
+classification (catégorie EXPLOIT_ATTEMPT + sévérité + tags) ou None.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_SEVERITY_RANK = {"critical": 4, "high": 3, "medium": 2, "low": 1, "info": 0}
+
+# (tag, sévérité, motif). Couvre les 7 patterns demandés par US-10.
+_PATTERNS: list[tuple[str, str, re.Pattern[str]]] = [
+    ("log4shell", "critical", re.compile(r"\$\{jndi:(ldap|ldaps|rmi|dns|iiop)://", re.IGNORECASE)),
+    (
+        "reverse_shell",
+        "critical",
+        re.compile(r"bash\s+-i|/dev/tcp/|nc\s+-e|mkfifo|socket\.socket|sh\s+-i", re.IGNORECASE),
+    ),
+    (
+        "rce",
+        "critical",
+        re.compile(
+            r";\s*(cat|wget|curl|chmod|nc|bash|sh|id|uname|whoami)\b|"
+            r"\|\s*(bash|sh)\b|`[^`]+`|\$\([^)]+\)",
+            re.IGNORECASE,
+        ),
+    ),
+    (
+        "sqli",
+        "high",
+        re.compile(
+            r"union\s+select|'\s*or\s*'?1'?\s*=\s*'?1|sleep\(\d+\)|benchmark\(|information_schema",
+            re.IGNORECASE,
+        ),
+    ),
+    (
+        "path_traversal",
+        "high",
+        re.compile(r"(\.\./|\.\.\\|%2e%2e%2f|%2e%2e/){2,}|/etc/passwd|/etc/shadow", re.IGNORECASE),
+    ),
+    (
+        "lfi",
+        "high",
+        re.compile(r"php://(filter|input)|file://|/proc/self/environ|data://", re.IGNORECASE),
+    ),
+    ("xss", "medium", re.compile(r"<script\b|onerror\s*=|javascript:|<img[^>]+onerror", re.IGNORECASE)),
+]
+
+
+def detect(*parts: str) -> dict[str, Any] | None:
+    """Cherche des patterns d'exploit dans les fragments fournis (url, query, body, headers)."""
+    haystack = "\n".join(p for p in parts if p)
+    if not haystack:
+        return None
+    tags: list[str] = []
+    severity = "info"
+    for tag, sev, pattern in _PATTERNS:
+        if pattern.search(haystack):
+            tags.append(tag)
+            if _SEVERITY_RANK[sev] > _SEVERITY_RANK[severity]:
+                severity = sev
+    if not tags:
+        return None
+    return {"category": "EXPLOIT_ATTEMPT", "severity": severity, "tags": tags}