Phase 2.1.1 : durcissement avant exposition publique

Fail-fast sur la configuration. Une limite de debit illisible (10/hours,
10/banana, -1/hour) arrete desormais le demarrage avec un message nommant la
variable, au lieu de desactiver silencieusement la protection : seules les
valeurs 0, off, none, disabled et vide desactivent volontairement. Meme
traitement pour MAX_SHARED_MAPS, MAX_SHARE_SIZE_MB, DEFAULT_SHARE_EXPIRY_DAYS
et chaque entree de TRUSTED_PROXY_CIDRS.

X-Forwarded-For n'est plus cru sur la seule foi de TRUST_PROXY_HEADERS : la
connexion doit aussi provenir d'un reseau declare dans TRUSTED_PROXY_CIDRS
(ipaddress, IPv4/IPv6/CIDR). Activer la confiance sans declarer de reseau est
refuse au demarrage, faute de quoi la configuration semblerait active sans
l'etre. L'adresse retenue est normalisee : les differentes ecritures d'une meme
IPv6 ne donnent plus des compteurs distincts.

MAX_SHARED_MAPS : comptage et insertion serialises par un verrou de processus,
pour que deux creations simultanees ne franchissent pas ensemble la derniere
place. Documente comme valable pour un service applicatif unique.

Ajoute APP_BIND pour ne pas publier 8080 sur toutes les interfaces en
production, une option backup --keep pour la retention, et documente Nginx,
Traefik en override, cron et systemd.

Corrige un bug de rendu du build local : mon edition avait reecrit
docker-entrypoint.sh en CRLF, rendant le shebang introuvable dans le conteneur.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/services/client_ip.py

@@ -4,16 +4,22 @@ Le point sensible : `X-Forwarded-For` est un en-tete que n'importe quel client
 peut ecrire. Le croire sans condition permettrait a un client direct de changer
 d'identite a chaque requete et de contourner toute limite.
 
-La confiance est donc explicite et desactivee par defaut
-(`TRUST_PROXY_HEADERS`). Quand elle est activee, on lit la DERNIERE valeur de
-`X-Forwarded-For` : un reverse proxy correctement configure ajoute l'adresse
-qu'il a reellement vue a la fin de la liste, tandis que les valeurs precedentes
-peuvent avoir ete forgees par le client. Cette lecture suppose un seul proxy
-directement devant OpenMind, ce qui correspond au deploiement documente.
+La confiance est donc doublement conditionnee :
+
+1. `TRUST_PROXY_HEADERS` doit etre actif ;
+2. la connexion doit provenir d'un reseau declare dans `TRUSTED_PROXY_CIDRS`.
+
+Sans ces deux conditions, l'en-tete est ignore et seule l'adresse reelle de la
+socket compte. OpenMind suppose **un reverse proxy frontal de confiance** : on
+lit la derniere valeur de la chaine, celle que ce proxy a ajoutee, les
+precedentes pouvant avoir ete forgees par le client.
 """
 
 from __future__ import annotations
 
+import ipaddress
+from collections.abc import Sequence
+
 from starlette.requests import Request
 
 FORWARDED_FOR = "x-forwarded-for"
@@ -21,19 +27,60 @@ REAL_IP = "x-real-ip"
 
 UNKNOWN_CLIENT = "unknown"
 
+IpNetwork = ipaddress.IPv4Network | ipaddress.IPv6Network
 
-def resolve_client_ip(request: Request, *, trust_proxy_headers: bool) -> str:
-    if trust_proxy_headers:
+
+def normalize_ip(value: str) -> str:
+    """Forme canonique d'une adresse, pour que la cle de limitation soit unique.
+
+    Sans cela, `2001:db8::1` et `2001:0db8:0000:0000:0000:0000:0000:0001`
+    designeraient deux clients differents, et il suffirait de reecrire son
+    adresse autrement pour repartir avec un compteur neuf.
+    """
+    text = value.strip()
+    if not text:
+        return UNKNOWN_CLIENT
+
+    # Un port peut trainer dans un en-tete mal configure : [::1]:443, 1.2.3.4:80.
+    if text.startswith("[") and "]" in text:
+        text = text[1 : text.index("]")]
+    elif text.count(":") == 1 and "." in text:
+        text = text.split(":", 1)[0]
+
+    try:
+        return str(ipaddress.ip_address(text))
+    except ValueError:
+        # Adresse illisible : on la garde telle quelle, bornee, plutot que de
+        # regrouper tous les clients douteux sous une meme cle.
+        return text[:64]
+
+
+def is_trusted_peer(host: str, networks: Sequence[IpNetwork]) -> bool:
+    if not networks:
+        return False
+    try:
+        address = ipaddress.ip_address(host)
+    except ValueError:
+        return False
+    return any(address in network for network in networks)
+
+
+def resolve_client_ip(
+    request: Request,
+    *,
+    trust_proxy_headers: bool,
+    trusted_networks: Sequence[IpNetwork] = (),
+) -> str:
+    peer = request.client.host if request.client and request.client.host else ""
+
+    if trust_proxy_headers and is_trusted_peer(peer, trusted_networks):
         forwarded = request.headers.get(FORWARDED_FOR)
         if forwarded:
             parts = [part.strip() for part in forwarded.split(",") if part.strip()]
             if parts:
-                return parts[-1]
+                return normalize_ip(parts[-1])
         real_ip = request.headers.get(REAL_IP)
         if real_ip and real_ip.strip():
-            return real_ip.strip()
+            return normalize_ip(real_ip)
 
-    client = request.client
-    if client and client.host:
-        return client.host
-    return UNKNOWN_CLIENT
+    return normalize_ip(peer) if peer else UNKNOWN_CLIENT

backend/app/services/rate_limit.py

@@ -33,6 +33,14 @@ _WINDOW_SECONDS = {
 # Garde-fou memoire : au-dela, les entrees les plus anciennes sont oubliees.
 MAX_TRACKED_CLIENTS = 20000
 
+# Seules ces valeurs desactivent volontairement une limite. Toute autre valeur
+# non analysable est une faute de frappe, pas une intention.
+DISABLED_VALUES = frozenset({"", "0", "off", "none", "disabled"})
+
+
+class RateLimitSyntaxError(ValueError):
+    """Regle de debit illisible. Remonte comme erreur de configuration."""
+
 
 @dataclass(frozen=True)
 class RateRule:
@@ -48,24 +56,39 @@ class RateRule:
 def parse_rate(spec: str) -> RateRule | None:
     """Lit une regle "10/hour". Retourne None si la limite est desactivee.
 
-    Une valeur vide, "0", ou une syntaxe non reconnue desactive la limite :
-    une configuration erronee ne doit jamais rendre l'instance inutilisable.
+    Desactiver une limite se fait explicitement : valeur vide, `0`, `off`,
+    `none` ou `disabled`. Toute autre valeur illisible leve une erreur plutot
+    que d'etre silencieusement traitee comme une desactivation : une faute de
+    frappe comme `10/hours` laisserait sinon l'instance sans protection, sans
+    que personne ne s'en apercoive.
     """
     text = (spec or "").strip().lower()
-    if not text or text in {"0", "none", "off", "disabled"}:
+    if text in DISABLED_VALUES:
         return None
 
-    number, _, unit = text.partition("/")
+    number, separator, unit = text.partition("/")
     try:
         limit = int(number.strip())
     except ValueError:
-        return None
+        raise RateLimitSyntaxError(
+            f"'{spec}' n'est pas une limite de debit valide : le nombre est illisible. "
+            "Attendu : <nombre>/<fenetre>, par exemple 10/hour."
+        ) from None
     if limit <= 0:
-        return None
+        raise RateLimitSyntaxError(
+            f"'{spec}' n'est pas une limite de debit valide : le nombre doit etre positif. "
+            "Pour desactiver la limite, utilisez 0, off, ou une valeur vide."
+        )
 
-    window = _WINDOW_SECONDS.get(unit.strip() or "minute")
+    # "10" vaut 10/minute ; "10/" est une fenetre oubliee, pas un raccourci.
+    unit_name = unit.strip() if separator else "minute"
+    window = _WINDOW_SECONDS.get(unit_name)
     if window is None:
-        return None
+        allowed = ", ".join(sorted({"second", "minute", "hour", "day"}))
+        raise RateLimitSyntaxError(
+            f"'{spec}' n'est pas une limite de debit valide : fenetre '{unit_name}' inconnue. "
+            f"Fenetres acceptees : {allowed}."
+        )
     return RateRule(limit=limit, window_seconds=window)
 
 

backend/app/services/shares.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import json
 import logging
+import threading
 from datetime import timedelta
 
 from sqlalchemy import func, select
@@ -33,6 +34,13 @@ logger = logging.getLogger(__name__)
 # Duree maximale acceptee pour une expiration explicite (10 ans).
 MAX_EXPIRY_DAYS = 3650
 
+# Serialise "compter puis inserer" pour que deux creations simultanees ne
+# franchissent pas ensemble la derniere place. Suffisant pour l'architecture
+# d'OpenMind : un seul processus applicatif devant un SQLite local. Avec
+# plusieurs workers, la limite redeviendrait un garde-fou approximatif (voir
+# README, limitations connues).
+_capacity_lock = threading.Lock()
+
 
 def share_ref(share_token: str) -> str:
     """Reference courte et non reversible d'un partage, pour les journaux.
@@ -131,7 +139,6 @@ def create_share(
     """
     payload = serialize_map(document)
     _guard_payload_size(payload)
-    _guard_capacity(session)
 
     management_token = generate_management_token()
     share = SharedMap(
@@ -142,8 +149,11 @@ def create_share(
         map_data=payload,
         expires_at=resolve_expiry(expires_in_days, explicit=expiry_explicit),
     )
-    session.add(share)
-    session.commit()
+
+    with _capacity_lock:
+        _guard_capacity(session)
+        session.add(share)
+        session.commit()
     session.refresh(share)
 
     logger.info(