GuardianUnivalle-Benito-Yucra 0.1.45__tar.gz → 0.1.47__tar.gz

guardianunivalle_benito_yucra-0.1.47/GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py

@@ -0,0 +1,118 @@
+import os
+import datetime
+import json
+import platform
+from django.utils import timezone
+
+LOG_FILE = "auditoria_guardian.log"
+
+# =====================================================
+# === FUNCIONES DE CAPTURA Y ANÁLISIS DE CLIENTE ===
+# =====================================================
+def capturar_datos_cliente(request) -> dict:
+    """Extrae información útil del cliente que accede al sistema."""
+    ip = request.META.get("HTTP_X_FORWARDED_FOR")
+    if ip:
+        ip = ip.split(",")[0].strip()
+    else:
+        ip = request.META.get("REMOTE_ADDR", "Desconocida")
+
+    user_agent = request.META.get("HTTP_USER_AGENT", "Desconocido")
+    metodo = request.method
+    ruta = request.path
+    parametros = request.GET.dict() if metodo == "GET" else request.POST.dict()
+    so_servidor = platform.system()
+
+    return {
+        "ip_cliente": ip,
+        "navegador": user_agent,
+        "metodo": metodo,
+        "ruta": ruta,
+        "parametros": parametros,
+        "servidor_os": so_servidor,
+        "hora_servidor": timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
+    }
+
+
+def analizar_comportamiento_cliente(datos_cliente: dict) -> tuple[str, str]:
+    """
+    Aplica reglas básicas de detección:
+      - IP sospechosa o repetitiva
+      - Agente extraño o vacío
+      - Peticiones sospechosas (ej: /admin, /etc/passwd)
+    Devuelve: (nivel_riesgo, descripcion)
+    """
+    descripcion = []
+    riesgo = "BAJO"
+
+    ip = datos_cliente.get("ip_cliente", "")
+    user_agent = datos_cliente.get("navegador", "").lower()
+    ruta = datos_cliente.get("ruta", "")
+
+    # === Reglas simples ===
+    if not user_agent or "curl" in user_agent or "python" in user_agent:
+        descripcion.append("Agente de usuario anómalo (posible bot o script).")
+        riesgo = "MEDIO"
+
+    if "admin" in ruta or "etc/passwd" in ruta or "../" in ruta:
+        descripcion.append("Ruta sospechosa accedida.")
+        riesgo = "ALTO"
+
+    if "Desconocida" in ip or ip.startswith("192.168.") is False:
+        descripcion.append(f"IP externa detectada: {ip}")
+        riesgo = "MEDIO"
+
+    # Comportamiento sin parámetros ni cabeceras
+    if not datos_cliente.get("parametros"):
+        descripcion.append("Petición sin parámetros ni cabeceras útiles.")
+        riesgo = "BAJO"
+
+    if not descripcion:
+        descripcion.append("Acceso normal detectado.")
+
+    return riesgo, " | ".join(descripcion)
+
+
+# =====================================================
+# === FUNCIÓN PRINCIPAL DE REGISTRO ===
+# =====================================================
+def registrar_evento(request, tipo: str = "ACCESO", extra: dict | None = None):
+    """Registra un evento de auditoría detallado del cliente."""
+    try:
+        datos_cliente = capturar_datos_cliente(request)
+        severidad, descripcion = analizar_comportamiento_cliente(datos_cliente)
+
+        evento = {
+            "fecha": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "tipo": tipo,
+            "descripcion": descripcion,
+            "severidad": severidad,
+            "cliente": datos_cliente,
+            "extra": extra or {},
+        }
+
+        # Crear carpeta solo si hay directorio en la ruta
+        log_dir = os.path.dirname(LOG_FILE)
+        if log_dir:
+            os.makedirs(log_dir, exist_ok=True)
+
+        # Registrar en archivo
+        with open(LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(json.dumps(evento, ensure_ascii=False) + "\n")
+
+        # (Opcional) Log en consola
+        print(f"[AUDITORÍA] Evento registrado: {evento['descripcion']} (nivel {severidad})")
+
+    except Exception as e:
+        print(f"[Auditoría] Error al registrar evento: {e}")
+
+
+# =====================================================
+# === CONSULTA DE REGISTROS ===
+# =====================================================
+def generar_reporte() -> str:
+    """Devuelve todo el contenido del archivo de auditoría."""
+    if not os.path.exists(LOG_FILE):
+        return "No hay registros aún."
+    with open(LOG_FILE, "r", encoding="utf-8") as f:
+        return f.read()

guardianunivalle_benito_yucra-0.1.47/GuardianUnivalle_Benito_Yucra/auditoria/utils_auditoria.py

@@ -0,0 +1,57 @@
+import requests
+from django.utils.timezone import now
+from user_agents import parse
+
+def obtener_datos_maquina(request):
+    """Obtiene información detallada del cliente desde la petición"""
+    try:
+        # --- IP real ---
+        ip = (
+            request.META.get("HTTP_X_FORWARDED_FOR")
+            or request.META.get("REMOTE_ADDR")
+            or "0.0.0.0"
+        )
+        ip = ip.split(",")[0].strip()
+
+        # --- User Agent ---
+        user_agent_str = request.META.get("HTTP_USER_AGENT", "Desconocido")
+        user_agent = parse(user_agent_str)
+        navegador = f"{user_agent.browser.family} {user_agent.browser.version_string}"
+        sistema = f"{user_agent.os.family} {user_agent.os.version_string}"
+
+        # --- Geolocalización (usando ipinfo.io gratuita) ---
+        geo_data = {}
+        try:
+            r = requests.get(f"https://ipinfo.io/{ip}/json", timeout=2)
+            if r.status_code == 200:
+                geo_data = r.json()
+        except Exception:
+            pass
+
+        pais = geo_data.get("country", "Desconocido")
+        ciudad = geo_data.get("city", "Desconocida")
+        isp = geo_data.get("org", "Desconocido")
+
+        # --- Usuario autenticado ---
+        usuario = "Anónimo"
+        if request.user and request.user.is_authenticated:
+            usuario = request.user.username
+
+        # --- Construir estructura ---
+        datos = {
+            "fecha": now().strftime("%Y-%m-%d %H:%M:%S"),
+            "ip": ip,
+            "pais": pais,
+            "ciudad": ciudad,
+            "isp": isp,
+            "usuario": usuario,
+            "user_agent": user_agent_str,
+            "navegador": navegador,
+            "sistema_operativo": sistema,
+            "url": request.path,
+            "metodo": request.method,
+        }
+
+        return datos
+    except Exception as e:
+        return {"error": str(e)}

{guardianunivalle_benito_yucra-0.1.45 → guardianunivalle_benito_yucra-0.1.47}/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.45 → guardianunivalle_benito_yucra-0.1.47}/GuardianUnivalle_Benito_Yucra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.45
+Version: 0.1.47
 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.45 → guardianunivalle_benito_yucra-0.1.47}/GuardianUnivalle_Benito_Yucra.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ GuardianUnivalle_Benito_Yucra.egg-info/dependency_links.txt
 GuardianUnivalle_Benito_Yucra.egg-info/requires.txt
 GuardianUnivalle_Benito_Yucra.egg-info/top_level.txt
 GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py
+GuardianUnivalle_Benito_Yucra/auditoria/utils_auditoria.py
 GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py
 GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py
 GuardianUnivalle_Benito_Yucra/criptografia/kdf.py

{guardianunivalle_benito_yucra-0.1.45 → guardianunivalle_benito_yucra-0.1.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.45
+Version: 0.1.47
 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.45 → guardianunivalle_benito_yucra-0.1.47}/pyproject.toml

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

guardianunivalle_benito_yucra-0.1.45/GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py

@@ -1,40 +0,0 @@
-import os
-import datetime
-import json
-
-LOG_FILE = "auditoria_guardian.log"
-
-
-def registrar_evento(
-    tipo: str,
-    descripcion: str = "",
-    severidad: str = "MEDIA",
-    extra: dict | None = None,
-):
-    try:
-        evento = {
-            "fecha": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "tipo": tipo,
-            "descripcion": descripcion,
-            "severidad": severidad,
-            "extra": extra or {},
-        }
-
-        # ✅ Crear carpeta solo si hay directorio en la ruta
-        log_dir = os.path.dirname(LOG_FILE)
-        if log_dir:
-            os.makedirs(log_dir, exist_ok=True)
-
-        with open(LOG_FILE, "a", encoding="utf-8") as f:
-            f.write(json.dumps(evento, ensure_ascii=False) + "\n")
-
-    except Exception as e:
-        print(f"[Auditoría] Error al registrar evento: {e}")
-
-
-def generar_reporte() -> str:
-    """Devuelve todo el contenido del archivo de auditoría."""
-    if not os.path.exists(LOG_FILE):
-        return "No hay registros aún."
-    with open(LOG_FILE, "r", encoding="utf-8") as f:
-        return f.read()