feat(seguridad): rate limiting en /api + cabeceras de hardening (Fase 10)

.env.example

@@ -70,6 +70,12 @@ HF_TOKEN=
 # -----------------------------------------------------------------------------------
 EVENTS_PERSIST=false                      # true para volcar la telemetría a la tabla events
 
+# -----------------------------------------------------------------------------------
+# 7) Seguridad / hardening
+#    Rate limiting en memoria sobre /api (anti-abuso/DDoS). 0 = desactivado.
+# -----------------------------------------------------------------------------------
+RATE_LIMIT_PER_MIN=120                     # peticiones/min por IP a /api (0 desactiva)
+
 # -----------------------------------------------------------------------------------
 # 6) Supabase (BD PostGIS + Storage + Queues) — PLATAFORMA COMPLETA
 #    Project Settings -> API / Database. SERVICE_ROLE es SECRETO (solo backend, nunca UI).

backend/config.py

@@ -73,6 +73,7 @@ class Settings:
     allowed_origins: tuple[str, ...]
     counting_enabled: bool
     events_persist: bool
+    rate_limit_per_min: int
     max_upload_mb: int
     confidence_threshold: float
 
@@ -96,6 +97,7 @@ def get_settings() -> Settings:
         allowed_origins=origins,
         counting_enabled=_parse_bool(os.getenv("COUNTING_ENABLED"), default=False),
         events_persist=_parse_bool(os.getenv("EVENTS_PERSIST"), default=False),
+        rate_limit_per_min=int(os.getenv("RATE_LIMIT_PER_MIN", "120")),
         max_upload_mb=int(os.getenv("MAX_UPLOAD_MB", str(DEFAULT_MAX_UPLOAD_MB))),
         confidence_threshold=float(
             os.getenv("CONFIDENCE_THRESHOLD", str(DEFAULT_CONFIDENCE_THRESHOLD))

backend/core/ratelimit.py

@@ -0,0 +1,74 @@
+"""
+Archivo: ratelimit.py
+Fecha de modificación: 04/06/2026
+Autor: Equipo AgroVisión
+
+Descripción:
+Limitador de tasa **en memoria** (ventana deslizante) usado por el gateway como
+mitigación de abuso y picos de tráfico (defensa en profundidad junto al borde de
+Hugging Face Spaces). Es por proceso: suficiente para una sola instancia (HF free).
+NO sustituye una protección DDoS de red (eso lo aporta el edge del host).
+
+Estructura Interna:
+    - `SlidingWindowRateLimiter`: cuenta peticiones por clave (IP) en una ventana móvil.
+
+Entradas / Dependencias:
+    - Biblioteca estándar (`collections.deque`, `time`).
+
+Ejemplo de Integración:
+    from backend.core.ratelimit import SlidingWindowRateLimiter
+    rl = SlidingWindowRateLimiter(max_requests=120, window_seconds=60)
+    if not rl.allow(client_ip): ...  # responder 429
+"""
+
+from __future__ import annotations
+
+import time
+from collections import deque
+from collections.abc import Callable
+
+
+class SlidingWindowRateLimiter:
+    """
+    Limita peticiones por clave en una ventana de tiempo deslizante.
+
+    Args:
+        max_requests (int): Máximo de peticiones por ventana. `<= 0` desactiva el límite.
+        window_seconds (float): Tamaño de la ventana en segundos.
+        clock (Callable[[], float]): Fuente de tiempo monótono (inyectable en tests).
+    """
+
+    def __init__(
+        self,
+        max_requests: int,
+        window_seconds: float = 60.0,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self.max_requests = max_requests
+        self.window = window_seconds
+        self._clock = clock
+        self._hits: dict[str, deque[float]] = {}
+
+    @property
+    def enabled(self) -> bool:
+        """True si el limitador está activo (`max_requests > 0`)."""
+        return self.max_requests > 0
+
+    def allow(self, key: str) -> bool:
+        """
+        Registra una petición de `key` y devuelve si está permitida.
+
+        Returns:
+            bool: True si está dentro del cupo; False si excede el límite.
+        """
+        if not self.enabled:
+            return True
+        now = self._clock()
+        cutoff = now - self.window
+        bucket = self._hits.setdefault(key, deque())
+        while bucket and bucket[0] <= cutoff:
+            bucket.popleft()
+        if len(bucket) >= self.max_requests:
+            return False
+        bucket.append(now)
+        return True

backend/main.py

@@ -37,8 +37,9 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
 
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 
 from backend.api.chat import router as chat_router
@@ -50,9 +51,26 @@ from backend.api.ndvi import router as ndvi_router
 from backend.api.weather import router as weather_router
 from backend.config import get_settings
 from backend.core.inference import ModelNotAvailableError, create_adapter
+from backend.core.ratelimit import SlidingWindowRateLimiter
 
 _logger = logging.getLogger("agrovision.backend")
 
+# Cabeceras de seguridad aplicadas a todas las respuestas (hardening básico).
+_SECURITY_HEADERS = {
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "SAMEORIGIN",
+    "Referrer-Policy": "strict-origin-when-cross-origin",
+    "X-XSS-Protection": "0",  # CSP/headers modernos lo sustituyen; evita modos heredados
+}
+
+
+def _client_key(request: Request) -> str:
+    """IP del cliente para el rate limiting (respeta el proxy del host: X-Forwarded-For)."""
+    fwd = request.headers.get("x-forwarded-for")
+    if fwd:
+        return fwd.split(",")[0].strip()
+    return request.client.host if request.client else "unknown"
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
@@ -105,6 +123,25 @@ def create_app() -> FastAPI:
         allow_methods=["*"],
         allow_headers=["*"],  # necesario para las cabeceras BYOK X-User-*
     )
+
+    # Rate limiting (anti-abuso/DDoS) sobre /api + cabeceras de seguridad en todo.
+    # Por proceso/en memoria: defensa en profundidad junto al borde del host (HF Spaces).
+    limiter = SlidingWindowRateLimiter(settings.rate_limit_per_min, window_seconds=60.0)
+
+    @app.middleware("http")
+    async def _security_and_ratelimit(request: Request, call_next):  # type: ignore[no-untyped-def]
+        if limiter.enabled and request.url.path.startswith("/api"):
+            if not limiter.allow(_client_key(request)):
+                return JSONResponse(
+                    status_code=429,
+                    content={"detail": "Demasiadas peticiones. Inténtalo de nuevo en un momento."},
+                    headers={"Retry-After": "60", **_SECURITY_HEADERS},
+                )
+        response = await call_next(request)
+        for key, value in _SECURITY_HEADERS.items():
+            response.headers.setdefault(key, value)
+        return response
+
     app.include_router(fields_router)  # Creación de Parcelas
     app.include_router(ndvi_router)  # Teledetección NDVI
     app.include_router(weather_router)  # Clima

tests/integration/test_security.py

@@ -0,0 +1,61 @@
+"""
+Archivo: test_security.py
+Fecha de modificación: 04/06/2026
+Autor: Equipo AgroVisión
+
+Descripción:
+Pruebas del *hardening* del gateway: cabeceras de seguridad en las respuestas y el
+rate limiting de `/api` (429 al exceder el cupo). Recrea la app con un límite bajo.
+
+Ejecución:
+    uv run python -m pytest tests/integration/test_security.py
+"""
+
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from backend.config import get_settings
+
+
+@pytest.fixture(autouse=True)
+def _reset(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("COUNTING_ENABLED", raising=False)
+    get_settings.cache_clear()
+    yield
+    get_settings.cache_clear()
+
+
+def test_cabeceras_de_seguridad_presentes() -> None:
+    """Toda respuesta incluye las cabeceras de hardening."""
+    from backend.main import create_app
+
+    with TestClient(create_app()) as client:
+        r = client.get("/api/status")
+    assert r.headers.get("X-Content-Type-Options") == "nosniff"
+    assert r.headers.get("X-Frame-Options") == "SAMEORIGIN"
+    assert "Referrer-Policy" in r.headers
+
+
+def test_rate_limit_devuelve_429(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Al exceder el cupo de /api, el gateway responde 429 con Retry-After."""
+    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "3")
+    get_settings.cache_clear()
+    from backend.main import create_app
+
+    with TestClient(create_app()) as client:
+        codes = [client.get("/api/status").status_code for _ in range(4)]
+    assert codes[:3] == [200, 200, 200]
+    assert codes[3] == 429
+
+
+def test_rate_limit_desactivado_no_bloquea(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Con RATE_LIMIT_PER_MIN=0 no se aplica límite."""
+    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "0")
+    get_settings.cache_clear()
+    from backend.main import create_app
+
+    with TestClient(create_app()) as client:
+        codes = [client.get("/api/status").status_code for _ in range(10)]
+    assert all(c == 200 for c in codes)

tests/unit/test_ratelimit.py

@@ -0,0 +1,63 @@
+"""
+Archivo: test_ratelimit.py
+Fecha de modificación: 04/06/2026
+Autor: Equipo AgroVisión
+
+Descripción:
+Pruebas unitarias del limitador de tasa (ventana deslizante en memoria) usado como
+mitigación de abuso/DDoS de la API. Se inyecta un reloj falso para determinismo.
+
+Ejecución:
+    uv run python -m pytest tests/unit/test_ratelimit.py
+"""
+
+from __future__ import annotations
+
+from backend.core.ratelimit import SlidingWindowRateLimiter
+
+
+class _FakeClock:
+    """Reloj controlable para las pruebas (segundos)."""
+
+    def __init__(self) -> None:
+        self.t = 1000.0
+
+    def __call__(self) -> float:
+        return self.t
+
+
+def test_permite_hasta_el_maximo_y_luego_bloquea() -> None:
+    """Admite `max` peticiones en la ventana y rechaza la siguiente."""
+    clock = _FakeClock()
+    rl = SlidingWindowRateLimiter(max_requests=3, window_seconds=60, clock=clock)
+    assert rl.allow("ip-1") is True
+    assert rl.allow("ip-1") is True
+    assert rl.allow("ip-1") is True
+    assert rl.allow("ip-1") is False  # 4ª en la misma ventana → bloqueada
+
+
+def test_la_ventana_se_desliza() -> None:
+    """Al avanzar el tiempo más allá de la ventana, vuelve a permitir."""
+    clock = _FakeClock()
+    rl = SlidingWindowRateLimiter(max_requests=2, window_seconds=60, clock=clock)
+    assert rl.allow("ip-1") is True
+    assert rl.allow("ip-1") is True
+    assert rl.allow("ip-1") is False
+    clock.t += 61  # pasa la ventana
+    assert rl.allow("ip-1") is True
+
+
+def test_claves_independientes() -> None:
+    """Cada clave (IP) tiene su propio cupo."""
+    clock = _FakeClock()
+    rl = SlidingWindowRateLimiter(max_requests=1, window_seconds=60, clock=clock)
+    assert rl.allow("ip-1") is True
+    assert rl.allow("ip-2") is True  # otra IP no se ve afectada
+    assert rl.allow("ip-1") is False
+
+
+def test_max_cero_desactiva_el_limite() -> None:
+    """`max_requests<=0` desactiva el limitador (siempre permite)."""
+    rl = SlidingWindowRateLimiter(max_requests=0, window_seconds=60, clock=_FakeClock())
+    for _ in range(1000):
+        assert rl.allow("ip-1") is True