GuardianUnivalle-Benito-Yucra 0.1.44__tar.gz → 0.1.46__tar.gz

{guardianunivalle_benito_yucra-0.1.44 → guardianunivalle_benito_yucra-0.1.46}/GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py

@@ -1,4 +1,4 @@
-
+# CSRF defense (parche recomendado)
 from __future__ import annotations
 import secrets
 import logging
@@ -9,9 +9,6 @@ from urllib.parse import urlparse
 from django.conf import settings
 from django.utils.deprecation import MiddlewareMixin
 
-# ======================================================
-# === CONFIGURACIÓN DE LOGGER ===
-# ======================================================
 logger = logging.getLogger("csrfdefense")
 logger.setLevel(logging.INFO)
 if not logger.handlers:
@@ -19,52 +16,34 @@ if not logger.handlers:
     handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
     logger.addHandler(handler)
 
-# ======================================================
-# === FUNCIONES AUXILIARES DE TOKEN CSRF ===
-# ======================================================
-def registrar_evento(tipo: str, mensaje: str):
-    """Registra eventos importantes en los logs."""
-    logger.warning(f"[{tipo}] {mensaje}")
-
-def generar_token_csrf() -> str:
-    """Genera un token CSRF seguro."""
-    token = secrets.token_hex(32)
-    registrar_evento("CSRF", "Token CSRF generado")
-    return token
-
-def validar_token_csrf(token: str, token_sesion: str) -> bool:
-    """Valida que el token recibido coincida con el token en sesión."""
-    valido = token == token_sesion
-    if not valido:
-        registrar_evento("CSRF", "Intento de CSRF detectado (token no coincide)")
-    return valido
-
-# ======================================================
-# === CONSTANTES Y CONFIGURACIONES ===
-# ======================================================
 STATE_CHANGING_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
 CSRF_HEADER_NAMES = ("HTTP_X_CSRFTOKEN", "HTTP_X_CSRF_TOKEN")
 CSRF_COOKIE_NAME = getattr(settings, "CSRF_COOKIE_NAME", "csrftoken")
 POST_FIELD_NAME = "csrfmiddlewaretoken"
 
-# Content-Type realmente sospechosos
+# Nota: NO consideramos 'application/json' sospechoso aquí por defecto,
+# porque muchas APIs legítimas usan JSON.
 SUSPICIOUS_CT_PATTERNS = [
     re.compile(r"text/plain", re.I),
-    re.compile(r"application/json", re.I),
+    re.compile(r"application/x-www-form-urlencoded", re.I),
+    re.compile(r"multipart/form-data", re.I),
 ]
 
-# ======================================================
-# === FUNCIONES DE APOYO ===
-# ======================================================
+# Umbral minimo de "señales" para marcar como ataque (configurable)
+CSRF_DEFENSE_MIN_SIGNALS = getattr(settings, "CSRF_DEFENSE_MIN_SIGNALS", 1)
+# Opción para excluir rutas de API que manejan JSON (cambia según tu proyecto)
+CSRF_DEFENSE_EXCLUDED_API_PREFIXES = getattr(settings, "CSRF_DEFENSE_EXCLUDED_API_PREFIXES", ["/api/"])
+
 def get_client_ip(request):
-    """Obtiene la IP real del cliente."""
     x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
     if x_forwarded_for:
-        return x_forwarded_for.split(",")[0].strip()
+        # toma la primera IP real
+        ips = [ip.strip() for ip in x_forwarded_for.split(",") if ip.strip()]
+        if ips:
+            return ips[0]
     return request.META.get("REMOTE_ADDR", "")
 
 def host_from_header(header_value: str) -> str | None:
-    """Extrae el host limpio desde una cabecera."""
     if not header_value:
         return None
     try:
@@ -76,53 +55,43 @@ def host_from_header(header_value: str) -> str | None:
         return None
 
 def origin_matches_host(request) -> bool:
-    """Verifica si Origin/Referer coinciden con Host."""
     host_header = request.META.get("HTTP_HOST") or request.META.get("SERVER_NAME")
     if not host_header:
         return True
-
     host = host_header.split(":")[0]
     origin = request.META.get("HTTP_ORIGIN", "")
     referer = request.META.get("HTTP_REFERER", "")
-
     origin_host = host_from_header(origin)
     referer_host = host_from_header(referer)
-
-    # Detectar valores con scripts o URLs maliciosas
-    if any(re.search(r"(javascript:|<script|data:text/html)", h or "", re.I)
-           for h in [origin, referer]):
+    # bloquear obvious javascript: referers
+    if any(re.search(r"(javascript:|<script|data:text/html)", h or "", re.I) for h in [origin, referer]):
         return False
-
     if origin_host and origin_host == host:
         return True
     if referer_host and referer_host == host:
         return True
+    # si no hay origin ni referer, lo consideramos neutral (no marcar)
     if not origin and not referer:
         return True
-
     return False
 
 def has_csrf_token(request) -> bool:
-    """Comprueba si hay un token CSRF presente."""
+    # busca header, cookie o campo form
     for h in CSRF_HEADER_NAMES:
         if request.META.get(h):
             return True
-
     cookie_val = request.COOKIES.get(CSRF_COOKIE_NAME)
     if cookie_val:
         return True
-
     try:
         if request.method == "POST" and hasattr(request, "POST"):
             if request.POST.get(POST_FIELD_NAME):
                 return True
     except Exception:
         pass
-
     return False
 
 def extract_payload_text(request) -> str:
-    """Extrae el cuerpo útil de la solicitud."""
     parts: List[str] = []
     try:
         body = request.body.decode("utf-8", errors="ignore")
@@ -137,17 +106,15 @@ def extract_payload_text(request) -> str:
     parts.append(request.META.get("HTTP_REFERER", ""))
     return " ".join([p for p in parts if p])
 
-# ======================================================
-# === MIDDLEWARE DE DEFENSA CSRF ===
-# ======================================================
 class CSRFDefenseMiddleware(MiddlewareMixin):
-    """
-    Middleware para DETECTAR intentos de CSRF:
-    - Registra request.csrf_attack_info con 'tipos': ['CSRF'] y 'descripcion' con las razones.
-    - No bloquea directamente: deja que AuditoriaMiddleware lo maneje.
-    """
-
     def process_request(self, request):
+        # 1) Excluir APIs JSON si se configuró así
+        for prefix in CSRF_DEFENSE_EXCLUDED_API_PREFIXES:
+            if request.path.startswith(prefix):
+                # debug log opcional
+                logger.debug(f"[CSRFDefense] Skip analysis for API prefix {prefix} path {request.path}")
+                return None
+
         client_ip = get_client_ip(request)
         trusted_ips = getattr(settings, "CSRF_DEFENSE_TRUSTED_IPS", [])
         if client_ip in trusted_ips:
@@ -172,20 +139,20 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
         if not origin_matches_host(request):
             descripcion.append("Origin/Referer no coinciden con Host (posible cross-site)")
 
-        # 3) Content-Type sospechoso
-        content_type = request.META.get("CONTENT_TYPE", "") or ""
+        # 3) Content-Type sospechoso (solo marcaremos si coincide uno de los patterns)
+        content_type = (request.META.get("CONTENT_TYPE") or "")
         for patt in SUSPICIOUS_CT_PATTERNS:
             if patt.search(content_type):
                 descripcion.append(f"Content-Type sospechoso: {content_type}")
                 break
 
-        # 4) Referer ausente y sin token
+        # 4) Referer ausente y sin header CSRF
         referer = request.META.get("HTTP_REFERER", "")
         if not referer and not any(request.META.get(h) for h in CSRF_HEADER_NAMES):
             descripcion.append("Referer ausente y sin X-CSRFToken")
 
-        # === Registro del ataque detectado ===
-        if descripcion:
+        # Si señales >= umbral entonces marcamos para auditoría
+        if descripcion and len(descripcion) >= CSRF_DEFENSE_MIN_SIGNALS:
             w_csrf = getattr(settings, "CSRF_DEFENSE_WEIGHT", 0.2)
             intentos_csrf = len(descripcion)
             s_csrf = w_csrf * intentos_csrf
@@ -199,9 +166,13 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
             }
 
             logger.warning(
-                "CSRF detectado desde IP %s: %s ; payload: %.200s ; score: %.2f",
-                client_ip, descripcion, payload, s_csrf,
+                "CSRF detectado desde IP %s: %s ; path=%s ; Content-Type=%s ; score=%.2f",
+                client_ip, descripcion, request.path, content_type, s_csrf
             )
+        else:
+            # debug útil: saber por qué NO se marcó
+            if descripcion:
+                logger.debug(f"[CSRFDefense] low-signals ({len(descripcion)}) not marking: {descripcion}")
 
         return None
 

{guardianunivalle_benito_yucra-0.1.44 → guardianunivalle_benito_yucra-0.1.46}/GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import time
 import logging
 import json
+from collections import deque
 from typing import Dict, List
 from django.conf import settings
 from django.utils.deprecation import MiddlewareMixin
@@ -9,7 +10,7 @@ from ..mitigacion.limitador_peticion import limitar_peticion
 from ..auditoria.registro_auditoria import registrar_evento
 
 # =====================================================
-# ===            CONFIGURACIÓN DEL LOGGER            ===
+# === CONFIGURACIÓN DEL LOGGER ===
 # =====================================================
 logger = logging.getLogger("dosdefense")
 logger.setLevel(logging.INFO)
@@ -19,108 +20,148 @@ if not logger.handlers:
     logger.addHandler(handler)
 
 # =====================================================
-# ===       PARÁMETROS DE CONFIGURACIÓN BASE         ===
+# === PARÁMETROS DE CONFIGURACIÓN BASE ===
 # =====================================================
 LIMITE_PETICIONES = getattr(settings, "DOS_LIMITE_PETICIONES", 100)  # por minuto
 VENTANA_SEGUNDOS = getattr(settings, "DOS_VENTANA_SEGUNDOS", 60)
 PESO_DOS = getattr(settings, "DOS_PESO", 0.6)
+LIMITE_ENDPOINTS_DISTINTOS = getattr(settings, "DOS_LIMITE_ENDPOINTS", 50)
+TRUSTED_IPS = getattr(settings, "DOS_TRUSTED_IPS", [])
 
 # =====================================================
-# ===  REGISTRO TEMPORAL DE SOLICITUDES POR IP      ===
+# === REGISTRO TEMPORAL EN MEMORIA ===
 # =====================================================
-# En producción se recomienda Redis o Memcached
-REGISTRO_SOLICITUDES: Dict[str, List[float]] = {}
-
+# Estructura: { ip: deque([timestamps]), ... }
+# deque es eficiente para ventanas deslizantes
+REGISTRO_SOLICITUDES: Dict[str, deque] = {}
+REGISTRO_ENDPOINTS: Dict[str, set] = {}
 
 # =====================================================
-# ===  FUNCIONES AUXILIARES                         ===
+# === FUNCIONES AUXILIARES ===
 # =====================================================
 def get_client_ip(request) -> str:
     """Obtiene la IP real del cliente (considera proxies)."""
     x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
     if x_forwarded_for:
         return x_forwarded_for.split(",")[0].strip()
-    return request.META.get("REMOTE_ADDR", "")
+    return request.META.get("REMOTE_ADDR", "") or "0.0.0.0"
+
+
+def limpiar_registro_global():
+    """Elimina IPs sin actividad reciente para evitar uso excesivo de memoria."""
+    ahora = time.time()
+    expiracion = VENTANA_SEGUNDOS * 2  # doble ventana
+    inactivas = [
+        ip for ip, tiempos in REGISTRO_SOLICITUDES.items()
+        if tiempos and ahora - tiempos[-1] > expiracion
+    ]
+    for ip in inactivas:
+        REGISTRO_SOLICITUDES.pop(ip, None)
+        REGISTRO_ENDPOINTS.pop(ip, None)
 
 
 def limpiar_registro(ip: str):
     """Limpia peticiones antiguas fuera de la ventana de tiempo."""
     ahora = time.time()
-    REGISTRO_SOLICITUDES[ip] = [
-        t for t in REGISTRO_SOLICITUDES.get(ip, []) if ahora - t < VENTANA_SEGUNDOS
-    ]
+    if ip not in REGISTRO_SOLICITUDES:
+        REGISTRO_SOLICITUDES[ip] = deque()
+    tiempos = REGISTRO_SOLICITUDES[ip]
+    while tiempos and ahora - tiempos[0] > VENTANA_SEGUNDOS:
+        tiempos.popleft()
 
 
-def calcular_nivel_amenaza_dos(
-    tasa_peticion: int, limite: int = LIMITE_PETICIONES
-) -> float:
+def calcular_nivel_amenaza_dos(tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> float:
     """
-    Calcula la puntuación de amenaza DoS basada en el peso configurado.
+    Calcula la puntuación de amenaza DoS.
     Fórmula: S_dos = w_dos * (tasa_peticion / limite)
     """
-    proporcion = tasa_peticion / limite
-    s_dos = PESO_DOS * proporcion
+    proporcion = tasa_peticion / max(limite, 1)
+    s_dos = PESO_DOS * min(proporcion, 2.0)
     return round(min(s_dos, 1.0), 3)
 
 
 def detectar_dos(ip: str, tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> bool:
     """Evalúa si la tasa de peticiones excede el umbral permitido."""
     if tasa_peticion > limite:
-        # Registrar evento en auditoría
         registrar_evento(
             tipo="DoS",
             descripcion=f"Alta tasa de peticiones desde {ip}: {tasa_peticion} req/min (límite {limite})",
             severidad="ALTA",
         )
-        # Mitigación: pasar un usuario genérico
         limitar_peticion(usuario_id="anonimo")
         return True
+    elif tasa_peticion > limite * 0.75:
+        # Umbral de advertencia
+        registrar_evento(
+            tipo="DoS",
+            descripcion=f"Posible saturación desde {ip}: {tasa_peticion} req/min",
+            severidad="MEDIA",
+        )
     return False
 
 
+def analizar_headers(user_agent: str, referer: str) -> List[str]:
+    """Detecta patrones de agentes o cabeceras sospechosas."""
+    sospechas = []
+    if not user_agent or len(user_agent) < 10:
+        sospechas.append("User-Agent vacío o anómalo")
+    if "curl" in user_agent.lower() or "python" in user_agent.lower():
+        sospechas.append("User-Agent indica script o bot")
+    if referer and any(palabra in referer.lower() for palabra in ["attack", "scan", "bot"]):
+        sospechas.append("Referer sospechoso")
+    return sospechas
+
+
 # =====================================================
-# ===      MIDDLEWARE DE DETECCIÓN DE DoS           ===
+# === MIDDLEWARE PRINCIPAL DE DEFENSA DoS ===
 # =====================================================
 class DOSDefenseMiddleware(MiddlewareMixin):
     """
-    Middleware para detección y registro de ataques DoS.
-    - Captura IP, agente y cabeceras sospechosas.
-    - Evalúa la frecuencia de peticiones por IP.
-    - Marca request.dos_attack_info con información del intento.
+    Middleware de detección y registro de ataques DoS.
     """
 
     def process_request(self, request):
+        limpiar_registro_global()
+
         client_ip = get_client_ip(request)
+        if client_ip in TRUSTED_IPS:
+            return None
+
         user_agent = request.META.get("HTTP_USER_AGENT", "Desconocido")
         referer = request.META.get("HTTP_REFERER", "")
         path = request.path
 
-        # Limpieza de registro anterior
+        # Registrar endpoint accedido
+        REGISTRO_ENDPOINTS.setdefault(client_ip, set()).add(path)
+
+        # Mantener ventana deslizante
         limpiar_registro(client_ip)
+        REGISTRO_SOLICITUDES[client_ip].append(time.time())
 
-        # Registrar nueva petición
-        REGISTRO_SOLICITUDES.setdefault(client_ip, []).append(time.time())
         tasa = len(REGISTRO_SOLICITUDES[client_ip])
         nivel = calcular_nivel_amenaza_dos(tasa)
         es_dos = detectar_dos(client_ip, tasa)
 
-        if es_dos:
-            descripcion = [
-                f"Tasa de {tasa} req/min excede límite {LIMITE_PETICIONES}",
-                f"User-Agent: {user_agent}",
-                f"Referer: {referer or 'N/A'}",
-                f"Ruta: {path}",
-            ]
+        descripcion = []
+        sospechas_headers = analizar_headers(user_agent, referer)
+        if sospechas_headers:
+            descripcion.extend(sospechas_headers)
+
+        # Verificar exceso de endpoints distintos (indicativo de escaneo)
+        if len(REGISTRO_ENDPOINTS[client_ip]) > LIMITE_ENDPOINTS_DISTINTOS:
+            descripcion.append("Número anormal de endpoints distintos accedidos")
+
+        if es_dos or descripcion:
+            descripcion.insert(0, f"Tasa actual: {tasa} req/min (nivel {nivel:.2f})")
+            descripcion.append(f"Ruta: {path}")
 
-            # Log profesional
             logger.warning(
-                "DoS detectado desde IP %s: %s ; nivel: %.2f",
+                "DoS detectado o sospechoso desde IP %s: %s ; nivel: %.2f",
                 client_ip,
                 descripcion,
                 nivel,
             )
 
-            # Enviar a sistema de auditoría
             request.dos_attack_info = {
                 "ip": client_ip,
                 "tipos": ["DoS"],

{guardianunivalle_benito_yucra-0.1.44 → guardianunivalle_benito_yucra-0.1.46}/GuardianUnivalle_Benito_Yucra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.44
+Version: 0.1.46
 Summary: Middleware y detectores de seguridad (SQLi, XSS, CSRF, DoS, Keylogger) para Django/Flask
 Author-email: Andres Benito Calle Yucra <benitoandrescalle035@gmail.com>
 License: MIT

{guardianunivalle_benito_yucra-0.1.44 → guardianunivalle_benito_yucra-0.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.44
+Version: 0.1.46
 Summary: Middleware y detectores de seguridad (SQLi, XSS, CSRF, DoS, Keylogger) para Django/Flask
 Author-email: Andres Benito Calle Yucra <benitoandrescalle035@gmail.com>
 License: MIT

{guardianunivalle_benito_yucra-0.1.44 → guardianunivalle_benito_yucra-0.1.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GuardianUnivalle-Benito-Yucra"  # usar mayúsculas consistente
-version = "0.1.44"
+version = "0.1.46"
 description = "Middleware y detectores de seguridad (SQLi, XSS, CSRF, DoS, Keylogger) para Django/Flask"
 authors = [
     { name = "Andres Benito Calle Yucra", email = "benitoandrescalle035@gmail.com" }