GuardianUnivalle-Benito-Yucra 0.1.50__py3-none-any.whl → 0.1.51__py3-none-any.whl

GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

@@ -3,14 +3,16 @@ import time
 import logging
 import json
 from collections import deque
-from typing import Dict, List
+from typing import Dict, List, Set
 from django.conf import settings
 from django.utils.deprecation import MiddlewareMixin
-from ..mitigacion.limitador_peticion import limitar_peticion
-from ..auditoria.registro_auditoria import registrar_evento
+from django.http import HttpResponseForbidden 
+import requests # ⬅️ Necesario para la función de scraping
+import re      # ⬅️ Necesario para el parseo de IPs/CIDR
+from ipaddress import ip_address, IPv4Address, IPv4Network # Necesario para el Escaneo Avanzado (CIDR)
 
 # =====================================================
-# === CONFIGURACIÓN DEL LOGGER ===
+# === CONFIGURACIÓN GLOBAL Y LOGGER ===
 # =====================================================
 logger = logging.getLogger("dosdefense")
 logger.setLevel(logging.INFO)
@@ -20,21 +22,112 @@ if not logger.handlers:
     logger.addHandler(handler)
 
 # =====================================================
-# === PARÁMETROS DE CONFIGURACIÓN BASE ===
+# === CONFIGURACIÓN DE INTELIGENCIA DE AMENAZAS (THREAT INTEL) ===
 # =====================================================
-LIMITE_PETICIONES = getattr(settings, "DOS_LIMITE_PETICIONES", 100)  # por minuto
+# URLs CONCEPTUALES de donde EXTRAERÍAS IPs/CIDR
+IP_BLACKLIST_SOURCES = [
+    "http://api.sitio_de_inteligencia.com/blacklist/ip_list", 
+    "http://otro_sitio.com/export_ips.txt",                 
+    "https://iplists.firehol.org/files/firehol_level1.netset", 
+]
+
+# Cabeceras para simular un navegador
+SCRAPING_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+}
+
+# =====================================================
+# === FUNCIONES DE INTELIGENCIA DE AMENAZAS ===
+# =====================================================
+
+def fetch_and_parse_blacklists() -> Set[str]:
+    """
+    Intenta obtener y parsear IPs/CIDR de varias fuentes externas.
+    """
+    global_blacklist: Set[str] = set()
+    # Patrón Regex para IPs (admite también rangos CIDR)
+    ip_pattern = re.compile(r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(/\d{1,2})?\b')
+
+    for url in IP_BLACKLIST_SOURCES:
+        try:
+            response = requests.get(url, headers=SCRAPING_HEADERS, timeout=15)
+            response.raise_for_status()
+            
+            found_ips = set(ip_pattern.findall(response.text))
+            
+            # Limpieza
+            cleaned_ips = {ip[0] for ip in found_ips if ip[0] not in ('0.0.0.0', '255.255.255.255')}
+            
+            global_blacklist.update(cleaned_ips)
+            logger.info(f"[Threat Intel] Éxito al obtener {len(cleaned_ips)} IPs/CIDR de {url}")
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"[Threat Intel] Error de conexión con {url}: {e}")
+        except Exception as e:
+            logger.error(f"[Threat Intel] Error inesperado al parsear {url}: {e}")
+
+    if '127.0.0.1' in global_blacklist:
+        global_blacklist.remove('127.0.0.1')
+        
+    return global_blacklist
+
+def check_ip_in_advanced_blacklist(client_ip: str, global_blacklist_cidrs: Set[str]) -> bool:
+    """
+    Escaneo avanzado: Chequea si una IP está en la lista negra, incluyendo rangos CIDR.
+    """
+    if not global_blacklist_cidrs:
+        return False
+        
+    try:
+        ip_a_chequear = IPv4Address(client_ip)
+        
+        # 1. Chequeo rápido de IPs individuales
+        if client_ip in global_blacklist_cidrs:
+             return True
+             
+        # 2. Chequeo de rangos CIDR (más lento)
+        for cidr_entry in global_blacklist_cidrs:
+            if '/' in cidr_entry:
+                try:
+                    if ip_a_chequear in IPv4Network(cidr_entry, strict=False):
+                        return True
+                except ValueError:
+                    continue # No es una red CIDR válida, continuar
+        return False
+        
+    except ValueError:
+        logger.error(f"IP del cliente inválida o no IPv4: {client_ip}")
+        return False
+
+# =====================================================
+# === PARÁMETROS DE CONFIGURACIÓN BASE Y SCORE ===
+# =====================================================
+LIMITE_PETICIONES = getattr(settings, "DOS_LIMITE_PETICIONES", 100)
 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", [])
+TIEMPO_BLOQUEO_SEGUNDOS = getattr(settings, "DOS_TIEMPO_BLOQUEO", 300) 
+
+# Parámetros del Score Avanzado
+PESO_BLACKLIST = getattr(settings, "DOS_PESO_BLACKLIST", 0.3)
+PESO_HEURISTICA = getattr(settings, "DOS_PESO_HEURISTICA", 0.1)
+UMBRAL_BLOQUEO = getattr(settings, "DOS_UMBRAL_BLOQUEO", 0.8)
+
+# === CARGA INICIAL DE LA LISTA NEGRA ===
+try:
+    IP_BLACKLIST: Set[str] = fetch_and_parse_blacklists() 
+    logger.info(f"Lista Negra Externa cargada con {len(IP_BLACKLIST)} IPs/CIDR.")
+except Exception as e:
+    logger.error(f"Error al cargar la IP Blacklist: {e}. Usando lista vacía.")
+    IP_BLACKLIST = set()
 
 # =====================================================
 # === REGISTRO TEMPORAL EN MEMORIA ===
 # =====================================================
-# Estructura: { ip: deque([timestamps]), ... }
-# deque es eficiente para ventanas deslizantes
 REGISTRO_SOLICITUDES: Dict[str, deque] = {}
 REGISTRO_ENDPOINTS: Dict[str, set] = {}
+BLOQUEOS_TEMPORALES: Dict[str, float] = {} 
 
 # =====================================================
 # === FUNCIONES AUXILIARES ===
@@ -46,22 +139,29 @@ def get_client_ip(request) -> str:
         return x_forwarded_for.split(",")[0].strip()
     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."""
+    """Elimina IPs sin actividad reciente y desbloquea IPs temporales."""
+    # ... (La implementación de limpiar_registro_global permanece igual)
     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
-    ]
+    expiracion = VENTANA_SEGUNDOS * 2
+    inactivas = []
+    
+    for ip, tiempos in REGISTRO_SOLICITUDES.items():
+        if tiempos and ahora - tiempos[-1] > expiracion:
+            inactivas.append(ip)
+
     for ip in inactivas:
         REGISTRO_SOLICITUDES.pop(ip, None)
         REGISTRO_ENDPOINTS.pop(ip, None)
-
+    
+    ips_a_desbloquear = [ip for ip, tiempo_desbloqueo in BLOQUEOS_TEMPORALES.items() if ahora > tiempo_desbloqueo]
+    for ip in ips_a_desbloquear:
+        BLOQUEOS_TEMPORALES.pop(ip, None)
+        logger.info(f"[Desbloqueo] IP {ip} desbloqueada automáticamente.")
 
 def limpiar_registro(ip: str):
     """Limpia peticiones antiguas fuera de la ventana de tiempo."""
+    # ... (La implementación de limpiar_registro permanece igual)
     ahora = time.time()
     if ip not in REGISTRO_SOLICITUDES:
         REGISTRO_SOLICITUDES[ip] = deque()
@@ -69,29 +169,48 @@ def limpiar_registro(ip: str):
     while tiempos and ahora - tiempos[0] > VENTANA_SEGUNDOS:
         tiempos.popleft()
 
-
 def calcular_nivel_amenaza_dos(tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> float:
-    """
-    Calcula la puntuación de amenaza DoS.
-    Fórmula: S_dos = w_dos * (tasa_peticion / limite)
-    """
+    """Calcula la puntuación de amenaza DoS (Rate Limiting)."""
+    # ... (La implementación de calcular_nivel_amenaza_dos permanece igual)
     proporcion = tasa_peticion / max(limite, 1)
     s_dos = PESO_DOS * min(proporcion, 2.0)
     return round(min(s_dos, 1.0), 3)
 
 
+# =====================================================
+# === FUNCIONES INTERNAS DE SEGURIDAD Y AUDITORÍA ===
+# =====================================================
+def limitar_peticion(usuario_id: str):
+    """Implementa la mitigación: Bloquea temporalmente la IP."""
+    ahora = time.time()
+    tiempo_desbloqueo = ahora + TIEMPO_BLOQUEO_SEGUNDOS
+    BLOQUEOS_TEMPORALES[usuario_id] = tiempo_desbloqueo
+    logger.warning(
+        f"[Bloqueo Activo] IP {usuario_id} bloqueada temporalmente hasta {time.ctime(tiempo_desbloqueo)}"
+    )
+
+def registrar_evento(tipo: str, descripcion: str, severidad: str = "MEDIA"):
+    """Simula el registro de auditoría de un evento de seguridad."""
+    evento = {
+        "tipo": tipo,
+        "descripcion": descripcion,
+        "severidad": severidad,
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    logger.info(f"[AUDITORÍA] {json.dumps(evento, ensure_ascii=False)}")
+
 def detectar_dos(ip: str, tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> bool:
-    """Evalúa si la tasa de peticiones excede el umbral permitido."""
+    """Evalúa si la tasa de peticiones excede el umbral permitido y aplica mitigación."""
+    # ... (La implementación de detectar_dos permanece igual)
     if tasa_peticion > limite:
         registrar_evento(
             tipo="DoS",
             descripcion=f"Alta tasa de peticiones desde {ip}: {tasa_peticion} req/min (límite {limite})",
             severidad="ALTA",
         )
-        limitar_peticion(usuario_id="anonimo")
+        limitar_peticion(usuario_id=ip) 
         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",
@@ -99,16 +218,21 @@ def detectar_dos(ip: str, tasa_peticion: int, limite: int = LIMITE_PETICIONES) -
         )
     return False
 
-
-def analizar_headers(user_agent: str, referer: str) -> List[str]:
-    """Detecta patrones de agentes o cabeceras sospechosas."""
+def analizar_headers_avanzado(user_agent: str, referer: str) -> List[str]:
+    """Detecta patrones sospechosos, penalizando User-Agents automatizados."""
+    # ... (La implementación de analizar_headers_avanzado permanece igual)
     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")
+    
+    if not user_agent or len(user_agent) < 10 or user_agent.lower() == "python-requests/2.25.1": 
+        sospechas.append("User-Agent vacío/Defecto")
+        
+    automation_keywords = ["curl", "python", "wget", "bot", "spider", "scraper", "headless", "phantom"]
+    if any(patron in user_agent.lower() for patron in automation_keywords):
+        sospechas.append("Herramienta de automatización detectada")
+        
+    if referer and any(palabra in referer.lower() for palabra in ["attack", "scan"]):
+        sospechas.append("Referer indicando abuso")
+        
     return sospechas
 
 
@@ -117,110 +241,95 @@ def analizar_headers(user_agent: str, referer: str) -> List[str]:
 # =====================================================
 class DOSDefenseMiddleware(MiddlewareMixin):
     """
-    Middleware de detección y registro de ataques DoS.
+    Middleware de detección, registro y mitigación de ataques DoS/Scraping avanzado.
     """
 
     def process_request(self, request):
         limpiar_registro_global()
 
         client_ip = get_client_ip(request)
+        
+        # 1. BLOQUEOS Y EXCEPCIONES PREVIAS
         if client_ip in TRUSTED_IPS:
             return None
+            
+        # BLOQUEO TEMPORAL: IPs previamente bloqueadas por alto Score o DoS
+        if client_ip in BLOQUEOS_TEMPORALES and time.time() < BLOQUEOS_TEMPORALES[client_ip]:
+            registrar_evento(
+                tipo="Temporary Block",
+                descripcion=f"Bloqueo temporal por abuso previo: IP {client_ip}.",
+                severidad="ALTA",
+            )
+            return HttpResponseForbidden("Acceso denegado temporalmente por comportamiento sospechoso.")
 
+        # 2. ANÁLISIS DE LA PETICIÓN Y CÁLCULO DE MÉTRICAS BASE
         user_agent = request.META.get("HTTP_USER_AGENT", "Desconocido")
         referer = request.META.get("HTTP_REFERER", "")
         path = request.path
 
-        # Registrar endpoint accedido
+        # Mantener ventana deslizante y tasa
         REGISTRO_ENDPOINTS.setdefault(client_ip, set()).add(path)
-
-        # Mantener ventana deslizante
         limpiar_registro(client_ip)
         REGISTRO_SOLICITUDES[client_ip].append(time.time())
 
         tasa = len(REGISTRO_SOLICITUDES[client_ip])
-        nivel = calcular_nivel_amenaza_dos(tasa)
-        es_dos = detectar_dos(client_ip, tasa)
-
-        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})")
+        
+        # 3. CÁLCULO DE LOS COMPONENTES DEL SCORE DE AMENAZA
+
+        # S_dos: Tasa de Petición (Rate Limiting)
+        nivel_dos = calcular_nivel_amenaza_dos(tasa) 
+        
+        # S_blacklist: Escaneo Avanzado (CIDR)
+        nivel_blacklist = PESO_BLACKLIST if check_ip_in_advanced_blacklist(client_ip, IP_BLACKLIST) else 0
+
+        # S_heuristica: Análisis de Comportamiento (Scraping/Escaneo)
+        sospechas_headers = analizar_headers_avanzado(user_agent, referer)
+        
+        score_headers = 0.5 if sospechas_headers else 0
+        score_endpoints = 0.5 if len(REGISTRO_ENDPOINTS[client_ip]) > LIMITE_ENDPOINTS_DISTINTOS else 0
+
+        nivel_heuristica = PESO_HEURISTICA * (score_headers + score_endpoints) 
+
+        # 4. CÁLCULO DEL SCORE TOTAL Y DECISIÓN DE MITIGACIÓN
+
+        S_total = nivel_dos + nivel_blacklist + nivel_heuristica
+
+        if S_total >= UMBRAL_BLOQUEO:
+            descripcion_log = [
+                f"Score Total: {S_total:.3f} > Umbral {UMBRAL_BLOQUEO}",
+                f"DoS: {nivel_dos:.3f}, Blacklist: {nivel_blacklist:.3f}, Heurística: {nivel_heuristica:.3f}"
+            ]
+            registrar_evento(
+                tipo="Bloqueo por Score Total",
+                descripcion=" ; ".join(descripcion_log),
+                severidad="CRÍTICA",
+            )
+            limitar_peticion(usuario_id=client_ip)
+            return HttpResponseForbidden("Acceso denegado por alto Score de Amenaza.")
+
+        # 5. REGISTRO DE ADVERTENCIA (Si no se bloquea, pero es sospechoso)
+        
+        if S_total > UMBRAL_BLOQUEO * 0.75 or (nivel_dos > 0) or len(sospechas_headers) > 0:
+            
+            descripcion = sospechas_headers
+            if score_endpoints > 0:
+                 descripcion.append("Número anormal de endpoints distintos accedidos (posible escaneo/scraping)")
+
+            descripcion.insert(0, f"Score Total: {S_total:.3f} (Tasa: {tasa} req/min)")
             descripcion.append(f"Ruta: {path}")
 
             logger.warning(
-                "DoS detectado o sospechoso desde IP %s: %s ; nivel: %.2f",
+                "Tráfico Sospechoso desde IP %s: %s",
                 client_ip,
-                descripcion,
-                nivel,
+                " ; ".join(descripcion),
             )
-
+            
             request.dos_attack_info = {
                 "ip": client_ip,
-                "tipos": ["DoS"],
+                "tipos": ["DoS", "Scraping/Escaneo"],
                 "descripcion": descripcion,
-                "payload": json.dumps(
-                    {"user_agent": user_agent, "referer": referer, "path": path}
-                ),
-                "score": nivel,
+                "payload": json.dumps({"user_agent": user_agent, "referer": referer, "path": path}),
+                "score": S_total,
             }
 
-        return None
-
-
-"""
-Detector de ataques de tipo DoS (Denial of Service)
-====================================================
-
-Este módulo forma parte del sistema de detección de amenazas.
-Detecta tasas de petición anómalas en base a límites configurables,
-captura datos del atacante (IP, agente, cabeceras)
-y registra los incidentes para su auditoría.
-
-Componentes:
-- DOSDefenseMiddleware: Middleware principal de detección.
-- detectar_dos(): Evalúa si la tasa supera el umbral permitido.
-- calcular_nivel_amenaza_dos(): Calcula la severidad proporcional.
-- registrar_evento(): Registra los incidentes en auditoría.
-
-Algoritmos relacionados:
-    * Rate Limiting basado en ventana deslizante.
-    * Cálculo de score: S_dos = w_dos * (tasa_peticion / limite)
-"""
-
-
-""" 
-Algoritmos relacionados:
-    *Rate Limiting, listas de bloqueo.
-    *Opcional: cifrado de logs con ChaCha20-Poly1305.
-Contribución a fórmula de amenaza S:
-S_dos = w_dos * (tasa_peticion / limite)
-S_dos = 0.6 * (150 / 100)
-donde w_dos es peso asignado a DoS y tasa_peticion / limite es la proporción de la tasa actual sobre el límite.
-"""
-"""
-Detector de ataques de tipo DoS (Denial of Service)
-====================================================
-
-Este módulo forma parte del sistema de detección de amenazas.
-Detecta tasas de petición anómalas en base a límites configurables,
-captura datos del atacante (IP, agente, cabeceras)
-y registra los incidentes para su auditoría.
-
-Componentes:
-- DOSDefenseMiddleware: Middleware principal de detección.
-- detectar_dos(): Evalúa si la tasa supera el umbral permitido.
-- calcular_nivel_amenaza_dos(): Calcula la severidad proporcional.
-- registrar_evento(): Registra los incidentes en auditoría.
-
-Algoritmos relacionados:
-    * Rate Limiting basado en ventana deslizante.
-    * Cálculo de score: S_dos = w_dos * (tasa_peticion / limite)
-"""
+        return None

{guardianunivalle_benito_yucra-0.1.50.dist-info → guardianunivalle_benito_yucra-0.1.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.50
+Version: 0.1.51
 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.51.dist-info/RECORD

@@ -0,0 +1,13 @@
+GuardianUnivalle_Benito_Yucra/__init__.py,sha256=lbIRb8fCFYfAdyJV6NsYVZJ5pKYSJZKhhK-En9g_1M8,762
+GuardianUnivalle_Benito_Yucra/utilidades.py,sha256=lFNVnlyTSYmQ1CqtmHx6aefK5uNw0wsMdHRQyxAIZy0,120
+GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py,sha256=NnKBOeRWkXVGaMBeQRYU528rWlaBDBPmTAzfji9n8fw,1135
+GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py,sha256=q7-UsVseTtIYZz4bbpx2X0kzpDmu2Cetm7eYPJtsruA,7608
+GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=m5ibalfC5ZVd-Ec8303lfVgxsnupA7FHQGssyhbGB7o,14193
+GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py,sha256=L5RQ0Sdgg7hTU1qkZYwt7AcDqtAzT6u-jwBGo7YWfsw,8078
+GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=EEbnn5J7sZxnsA2a0cT1VAB4ZS7BMhQiHSeqrR2SU3A,4820
+GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=EDxGDaOosFJCyWTS_HkB300qL30ArxAEi-i0cVrzXyU,11027
+guardianunivalle_benito_yucra-0.1.51.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
+guardianunivalle_benito_yucra-0.1.51.dist-info/METADATA,sha256=-cN5bh7xRQHQ9TqZ5r_-PbhYzF5seAt7-cVW0kPsW2A,1893
+guardianunivalle_benito_yucra-0.1.51.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guardianunivalle_benito_yucra-0.1.51.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
+guardianunivalle_benito_yucra-0.1.51.dist-info/RECORD,,

GuardianUnivalle_Benito_Yucra/auditoria/auditoria_servidor.py

@@ -1,119 +0,0 @@
-import logging
-import json
-import platform
-import socket
-import uuid
-from datetime import datetime
-from django.utils.deprecation import MiddlewareMixin
-
-logger = logging.getLogger("auditoria_servidor")
-logger.setLevel(logging.INFO)
-if not logger.handlers:
-    handler = logging.StreamHandler()
-    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
-    logger.addHandler(handler)
-
-
-def obtener_datos_maquina(request):
-    """
-    Retorna un diccionario con información del cliente y del servidor.
-    No accede a ningún modelo Django.
-    """
-    datos = {}
-    try:
-        # Datos del cliente
-        datos["ip"] = request.META.get("HTTP_X_FORWARDED_FOR", "").split(",")[0] or request.META.get("REMOTE_ADDR", "")
-        datos["user_agent"] = request.META.get("HTTP_USER_AGENT", "")
-        datos["navegador"] = datos["user_agent"].split("/")[0] if "/" in datos["user_agent"] else datos["user_agent"]
-        datos["sistema_operativo"] = platform.system()
-        datos["url"] = request.build_absolute_uri()
-        datos["fecha"] = datetime.now().isoformat()
-
-        # Datos del servidor
-        datos["servidor_nombre"] = socket.gethostname()
-        datos["servidor_ip"] = socket.gethostbyname(socket.gethostname())
-        datos["servidor_uuid"] = str(uuid.uuid4())
-    except Exception as e:
-        logger.error(f"Error obteniendo datos de máquina: {e}")
-    return datos
-
-
-def analizar_comportamiento_cliente(datos):
-    """
-    Analiza los datos del cliente y retorna una evaluación general:
-    (nivel_severidad, descripcion)
-    """
-    if not datos:
-        return "BAJA", "Sin datos del cliente"
-
-    ip = datos.get("ip", "")
-    navegador = datos.get("navegador", "")
-    descripcion = f"Actividad detectada desde IP {ip} con navegador {navegador}"
-
-    if "bot" in navegador.lower():
-        return "MEDIA", descripcion + " (posible bot)"
-    return "BAJA", descripcion
-
-
-def registrar_evento(tipo, descripcion, severidad="BAJA", usuario_id=None, extra=None):
-    """
-    Prepara un registro de auditoría (para luego guardarlo en BD desde Django).
-    """
-    try:
-        registro = {
-            "tipo": tipo,
-            "descripcion": descripcion,
-            "severidad": severidad,
-            "usuario_id": usuario_id,  # <-- guardamos ID en lugar de FK
-            "fecha": datetime.now().isoformat(),
-            "extra": extra or {},
-        }
-        logger.info("[AUDITORIA] %s", json.dumps(registro, ensure_ascii=False))
-        return registro
-    except Exception as e:
-        logger.error(f"Error registrando evento: {e}")
-        return None
-
-
-class AuditoriaServidorMiddleware(MiddlewareMixin):
-    """
-    Middleware que integra toda la información generada por los detectores (SQLi, XSS, etc.)
-    y la deja lista en request.guardian_auditoria para que el backend (Django)
-    la guarde en la base de datos.
-    """
-
-    def process_request(self, request):
-        try:
-            datos_cliente = obtener_datos_maquina(request)
-            severidad, descripcion = analizar_comportamiento_cliente(datos_cliente)
-
-            # Base del registro
-            registro_base = {
-                "datos_cliente": datos_cliente,
-                "descripcion": descripcion,
-                "severidad": severidad,
-                "eventos_detectados": [],
-                "usuario_id": getattr(request.user, "id", None)  # <-- si está autenticado
-            }
-
-            # Integrar información de ataques detectada por otros middlewares
-            for attr in ["sql_attack_info", "xss_attack_info", "csrf_attack_info", "dos_attack_info"]:
-                if hasattr(request, attr):
-                    registro_base["eventos_detectados"].append(getattr(request, attr))
-
-            # Si hubo algún evento sospechoso
-            if registro_base["eventos_detectados"]:
-                registrar_evento(
-                    tipo="ATAQUE_DETECTADO",
-                    descripcion="Se detectó comportamiento sospechoso en la solicitud",
-                    severidad="ALTA",
-                    usuario_id=registro_base["usuario_id"],
-                    extra=registro_base,
-                )
-
-            # Guardar la info para el backend (sin registrar aún en BD)
-            request.guardian_auditoria = registro_base
-
-        except Exception as e:
-            logger.error(f"Error en AuditoriaServidorMiddleware: {e}")
-        return None

GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py

@@ -1,25 +0,0 @@
-"""
-Cifrado simétrico autenticado: AES-GCM y ChaCha20-Poly1305
-"""
-from cryptography.hazmat.primitives.ciphers.aead import AESGCM, ChaCha20Poly1305
-import os
-
-def cifrar_aes_gcm(mensaje: bytes, clave: bytes) -> dict:
-    aes = AESGCM(clave)
-    nonce = os.urandom(12)
-    ciphertext = aes.encrypt(nonce, mensaje, None)
-    return {"nonce": nonce, "ciphertext": ciphertext}
-
-def descifrar_aes_gcm(cipher: dict, clave: bytes) -> bytes:
-    aes = AESGCM(clave)
-    return aes.decrypt(cipher["nonce"], cipher["ciphertext"], None)
-
-def cifrar_chacha20(mensaje: bytes, clave: bytes) -> dict:
-    cipher = ChaCha20Poly1305(clave)
-    nonce = os.urandom(12)
-    ciphertext = cipher.encrypt(nonce, mensaje, None)
-    return {"nonce": nonce, "ciphertext": ciphertext}
-
-def descifrar_chacha20(cipher: dict, clave: bytes) -> bytes:
-    cipher_obj = ChaCha20Poly1305(clave)
-    return cipher_obj.decrypt(cipher["nonce"], cipher["ciphertext"], None)

GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py

@@ -1,23 +0,0 @@
-"""
-Gestión de intercambio de claves con ECDH y derivación HKDF.
-"""
-from cryptography.hazmat.primitives.asymmetric import ec
-from cryptography.hazmat.primitives.kdf.hkdf import HKDF
-from cryptography.hazmat.primitives import hashes
-
-def generar_claves_ecdh():
-    """Genera clave privada y pública ECDH"""
-    clave_privada = ec.generate_private_key(ec.SECP384R1())
-    clave_publica = clave_privada.public_key()
-    return clave_privada, clave_publica
-
-def derivar_clave_secreta(clave_privada, clave_publica):
-    """Deriva una clave compartida usando HKDF"""
-    shared_key = clave_privada.exchange(ec.ECDH(), clave_publica)
-    derived_key = HKDF(
-        algorithm=hashes.SHA256(),
-        length=32,
-        salt=None,
-        info=b'guardianclave'
-    ).derive(shared_key)
-    return derived_key

GuardianUnivalle_Benito_Yucra/criptografia/kdf.py

@@ -1,23 +0,0 @@
-"""
-Wrappers para derivación de claves segura: PBKDF2 y Argon2
-"""
-from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-from argon2 import PasswordHasher
-from cryptography.hazmat.primitives import hashes
-import os
-
-def pbkdf2_derivar_clave(password: str, salt: bytes = None) -> bytes:
-    """Deriva clave usando PBKDF2"""
-    salt = salt or os.urandom(16)
-    kdf = PBKDF2HMAC(
-        algorithm=hashes.SHA256(),
-        length=32,
-        salt=salt,
-        iterations=100_000,
-    )
-    return kdf.derive(password.encode()), salt
-
-def argon2_derivar_clave(password: str) -> str:
-    """Deriva clave usando Argon2"""
-    ph = PasswordHasher()
-    return ph.hash(password)

GuardianUnivalle_Benito_Yucra/middleware_web/middleware_web.py

@@ -1,13 +0,0 @@
-"""
-Middleware base para frameworks web (Django/Flask/FastAPI)
-"""
-from ..detectores.detector_sql import detectar_inyeccion_sql
-from ..detectores.detector_xss import detectar_xss
-
-def middleware_proteccion(request):
-    # Simulación de protección de entrada
-    if detectar_inyeccion_sql(request.get("query", "")):
-        return {"error": "SQL Injection detectado"}
-    if detectar_xss(request.get("input", "")):
-        return {"error": "XSS detectado"}
-    return {"ok": True}

GuardianUnivalle_Benito_Yucra/mitigacion/limitador_peticion.py

@@ -1,7 +0,0 @@
-"""
-Limitador de peticiones para prevenir DoS
-"""
-def limitar_peticion(usuario_id: str, max_peticion: int = 100) -> bool:
-    # Simulación de limitador: True si excede
-    print(f"✅ Limitador activo para {usuario_id}")
-    return False

GuardianUnivalle_Benito_Yucra/mitigacion/lista_bloqueo.py

@@ -1,10 +0,0 @@
-"""
-Manejo de lista de bloqueo
-"""
-lista_bloqueo = set()
-
-def agregar_bloqueo(ip: str):
-    lista_bloqueo.add(ip)
-
-def esta_bloqueado(ip: str) -> bool:
-    return ip in lista_bloqueo

GuardianUnivalle_Benito_Yucra/puntuacion/puntuacion_amenaza.py

@@ -1,15 +0,0 @@
-"""
-Fórmula compuesta S para puntuar la amenaza global
-"""
-def calcular_puntuacion(detecciones_sql=0, detecciones_xss=0, intentos_csrf=0,
-                        procesos_keylogger=0, tasa_dos=0,
-                        w_sql=1.5, w_xss=1.2, w_csrf=1.0, w_keylogger=2.0, w_dos=2.5,
-                        limite_dos=100) -> float:
-    S = (
-        w_sql * detecciones_sql +
-        w_xss * detecciones_xss +
-        w_csrf * intentos_csrf +
-        w_keylogger * procesos_keylogger +
-        w_dos * (tasa_dos / limite_dos)
-    )
-    return S

guardianunivalle_benito_yucra-0.1.50.dist-info/RECORD

@@ -1,21 +0,0 @@
-GuardianUnivalle_Benito_Yucra/__init__.py,sha256=lbIRb8fCFYfAdyJV6NsYVZJ5pKYSJZKhhK-En9g_1M8,762
-GuardianUnivalle_Benito_Yucra/utilidades.py,sha256=lFNVnlyTSYmQ1CqtmHx6aefK5uNw0wsMdHRQyxAIZy0,120
-GuardianUnivalle_Benito_Yucra/auditoria/auditoria_servidor.py,sha256=ZXyzegZb_iQI4ICzPBw2uJeco4LMYZ1wv12DuTnKb7M,4543
-GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py,sha256=NnKBOeRWkXVGaMBeQRYU528rWlaBDBPmTAzfji9n8fw,1135
-GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py,sha256=wfoRpaKvOqPbollNQsDNUNWClYJlXYTKTYvv0qcR6aI,962
-GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py,sha256=9djnlzb022hUhrDbQyWz7lWLbkn_vQZ4K7qar1FXYmo,829
-GuardianUnivalle_Benito_Yucra/criptografia/kdf.py,sha256=_sbepEY1qHEKga0ExrX2WRg1HeCPY5MC5CfXZWYyl-A,709
-GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py,sha256=q7-UsVseTtIYZz4bbpx2X0kzpDmu2Cetm7eYPJtsruA,7608
-GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=167mD_OvicP5T-ptUoBBQlNqFbmL8N1o_4oSKbmcf2Q,8594
-GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py,sha256=L5RQ0Sdgg7hTU1qkZYwt7AcDqtAzT6u-jwBGo7YWfsw,8078
-GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=EEbnn5J7sZxnsA2a0cT1VAB4ZS7BMhQiHSeqrR2SU3A,4820
-GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=EDxGDaOosFJCyWTS_HkB300qL30ArxAEi-i0cVrzXyU,11027
-GuardianUnivalle_Benito_Yucra/middleware_web/middleware_web.py,sha256=23pLLYqliUoMrIC6ZEwz3hKXeDjWfHSm9vYPWGmDDik,495
-GuardianUnivalle_Benito_Yucra/mitigacion/limitador_peticion.py,sha256=ipMOebYhql-6mSyHs0ddYXOcXq9w8P_IXLlpiIqGncw,246
-GuardianUnivalle_Benito_Yucra/mitigacion/lista_bloqueo.py,sha256=6AYWII4mrmwCLHCvGTyoBxR4Oasr4raSHpFbVjqn7d8,193
-GuardianUnivalle_Benito_Yucra/puntuacion/puntuacion_amenaza.py,sha256=Wx5XfcII4oweLvZsTBEJ7kUc9pMpP5-36RfI5C5KJXo,561
-guardianunivalle_benito_yucra-0.1.50.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
-guardianunivalle_benito_yucra-0.1.50.dist-info/METADATA,sha256=S1Slmtk8V-fzvKQqKOc-GvCcQ46C3DrDCPTlNQkATLw,1893
-guardianunivalle_benito_yucra-0.1.50.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guardianunivalle_benito_yucra-0.1.50.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
-guardianunivalle_benito_yucra-0.1.50.dist-info/RECORD,,