GuardianUnivalle-Benito-Yucra 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py

@@ -1,15 +1,233 @@
+"""
+CSRF Defense Middleware
+========================
+Detecta y registra posibles ataques CSRF (Cross-Site Request Forgery).
+
+Algoritmos relacionados:
+    * Uso de secreto aleatorio criptográfico (generar_token_csrf).
+    * Validación simple por comparación (validar_token_csrf).
+    * Contribución a fórmula de amenaza S:
+        S_csrf = w_csrf * intentos_csrf
+        S_csrf = 0.2 * 1
+"""
+
+from __future__ import annotations
 import secrets
-from ..auditoria.registro_auditoria import registrar_evento
+import logging
+import re
+import json
+from typing import List
+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:
+    handler = logging.StreamHandler()
+    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:
-    return secrets.token_hex(32)
+    """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")
+        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"
+
+SUSPICIOUS_CT_PATTERNS = [
+    re.compile(r"application/x-www-form-urlencoded", re.I),
+    re.compile(r"multipart/form-data", re.I),
+]
+
+
+# ======================================================
+# === FUNCIONES DE APOYO ===
+# ======================================================
+def get_client_ip(request):
+    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", "")
+
+
+def host_from_header(header_value: str) -> str | None:
+    if not header_value:
+        return None
+    try:
+        parsed = urlparse(header_value)
+        if parsed.netloc:
+            return parsed.netloc.split(":")[0]
+        return header_value.split(":")[0]
+    except Exception:
+        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)
+
+    if origin_host and origin_host == host:
+        return True
+    if referer_host and referer_host == host:
+        return True
+    if not origin and not referer:
+        return True
+
+    return False
+
+
+def has_csrf_token(request) -> bool:
+    """Comprueba si hay signos de token CSRF presente."""
+    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 contenido útil de la solicitud para análisis."""
+    parts: List[str] = []
+    try:
+        body = request.body.decode("utf-8", errors="ignore")
+        if body:
+            parts.append(body)
+    except Exception:
+        pass
+    qs = request.META.get("QUERY_STRING", "")
+    if qs:
+        parts.append(qs)
+    parts.append(request.META.get("HTTP_USER_AGENT", ""))
+    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:
+    - Marca request.sql_attack_info con 'tipos': ['CSRF'] y 'descripcion' con razones.
+    - No bloquea la petición directamente, permite que AuditoriaMiddleware lo maneje.
+    """
+
+    def process_request(self, request):
+        client_ip = get_client_ip(request)
+        trusted_ips = getattr(settings, "CSRF_DEFENSE_TRUSTED_IPS", [])
+        if client_ip in trusted_ips:
+            return None
+
+        excluded_paths = getattr(settings, "CSRF_DEFENSE_EXCLUDED_PATHS", [])
+        if any(request.path.startswith(p) for p in excluded_paths):
+            return None
+
+        method = (request.method or "").upper()
+        if method not in STATE_CHANGING_METHODS:
+            return None
+
+        descripcion: List[str] = []
+        payload = extract_payload_text(request)
+
+        # 1) Falta token CSRF
+        if not has_csrf_token(request):
+            descripcion.append("Falta token CSRF en cookie/header/form")
+
+        # 2) Origin/Referer no coinciden
+        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 ""
+        for patt in SUSPICIOUS_CT_PATTERNS:
+            if patt.search(content_type):
+                descripcion.append(f"Content-Type sospechoso: {content_type}")
+                break
+
+        # 4) Referer ausente
+        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")
+
+        # Si hay señales, calculamos puntaje y registramos
+        if descripcion:
+            w_csrf = getattr(settings, "CSRF_DEFENSE_WEIGHT", 0.2)
+            intentos_csrf = len(descripcion)
+            s_csrf = w_csrf * intentos_csrf
+
+            request.sql_attack_info = {
+                "ip": client_ip,
+                "tipos": ["CSRF"],
+                "descripcion": descripcion,
+                "payload": payload,
+                "score": s_csrf,
+            }
+
+            logger.warning(
+                "CSRF detectado desde IP %s: %s ; payload: %.200s ; score: %.2f",
+                client_ip,
+                descripcion,
+                payload,
+                s_csrf,
+            )
+
+        return None
+
+
 """ 
 Algoritmos relacionados:
     *Uso de secreto aleatorio criptográfico.
@@ -18,4 +236,4 @@ Contribución a fórmula de amenaza S:
 S_csrf = w_csrf * intentos_csrf
 S_csrf = 0.2 * 1
 donde w_csrf es peso asignado a CSRF y intentos_csrf es la cantidad de intentos detectados.
-"""
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

@@ -1,11 +1,160 @@
+"""
+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)
+"""
+
+from __future__ import annotations
+import time
+import logging
+import json
+from typing import Dict, List
+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
 
-def detectar_dos(tasa_peticion: int, limite: int = 100) -> bool:
+# =====================================================
+# ===            CONFIGURACIÓN DEL LOGGER            ===
+# =====================================================
+logger = logging.getLogger("dosdefense")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+
+
+# =====================================================
+# ===       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)
+
+
+# =====================================================
+# ===  REGISTRO TEMPORAL DE SOLICITUDES POR IP      ===
+# =====================================================
+# En producción se recomienda usar Redis o Memcached
+# para este tipo de conteo, aquí usamos una memoria temporal.
+REGISTRO_SOLICITUDES: Dict[str, List[float]] = {}
+
+
+# =====================================================
+# ===  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", "")
+
+
+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
+    ]
+
+
+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.
+    Fórmula: S_dos = w_dos * (tasa_peticion / limite)
+    """
+    proporcion = tasa_peticion / limite
+    s_dos = PESO_DOS * proporcion
+    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("DoS", f"Tasa de petición elevada: {tasa_peticion}")
+        registrar_evento(
+            tipo="DoS",
+            descripcion=f"Alta tasa de peticiones desde {ip}: {tasa_peticion} req/min (límite {limite})",
+            severidad="ALTA",
+        )
+        limitar_peticion()  # Acción de mitigación
         return True
     return False
+
+
+# =====================================================
+# ===      MIDDLEWARE DE DETECCIÓN DE 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.sql_attack_info con información del intento.
+    """
+
+    def process_request(self, request):
+        client_ip = get_client_ip(request)
+        user_agent = request.META.get("HTTP_USER_AGENT", "Desconocido")
+        referer = request.META.get("HTTP_REFERER", "")
+        path = request.path
+
+        # Limpieza de registro anterior
+        limpiar_registro(client_ip)
+
+        # 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}",
+            ]
+
+            # Log profesional
+            logger.warning(
+                "DoS detectado desde IP %s: %s ; nivel: %.2f",
+                client_ip,
+                descripcion,
+                nivel,
+            )
+
+            # Enviar a sistema de auditoría
+            request.sql_attack_info = {
+                "ip": client_ip,
+                "tipos": ["DoS"],
+                "descripcion": descripcion,
+                "payload": json.dumps(
+                    {"user_agent": user_agent, "referer": referer, "path": path}
+                ),
+                "score": nivel,
+            }
+
+        return None
+
+
 """ 
 Algoritmos relacionados:
     *Rate Limiting, listas de bloqueo.
@@ -14,4 +163,4 @@ 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.
-"""
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py

@@ -1,13 +1,172 @@
+"""
+Detector extendido de Keyloggers
+================================
+
+Módulo avanzado de detección de keyloggers y software espía en el sistema.
+Incluye revisión de procesos activos, archivos ejecutables sospechosos y
+aplicaciones instaladas en el sistema operativo Windows.
+
+Componentes:
+- Escaneo de procesos activos.
+- Detección de archivos con extensiones críticas (.exe, .dll, .scr, .bat, .cmd, .msi).
+- Revisión de aplicaciones instaladas (si se ejecuta en Windows).
+- Cálculo de nivel de amenaza y registro de auditoría.
+
+Algoritmos:
+    * Revisión de procesos (psutil)
+    * Análisis de archivos con extensiones críticas
+    * Detección de software instalado
+    * Registro cifrado con AES-256 + SHA-512
+    * Fórmula: S_keylogger = w_keylogger * (procesos + archivos + instalaciones)
+"""
+
+from __future__ import annotations
 import psutil
+import os
+import logging
+import platform
+import subprocess
+from typing import List, Dict
+from django.conf import settings
 from ..auditoria.registro_auditoria import registrar_evento
 
-def detectar_keylogger():
-    sospechosos = []
-    for proc in psutil.process_iter(['pid', 'name']):
-        if "keylogger" in proc.info['name'].lower():
-            sospechosos.append(proc.info)
-            registrar_evento("Keylogger", f"Proceso sospechoso: {proc.info}")
-    return sospechosos
+# =====================================================
+# === CONFIGURACIÓN DEL LOGGER ===
+# =====================================================
+logger = logging.getLogger("keyloggerdefense")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+
+# =====================================================
+# === CONFIGURACIÓN DE PARÁMETROS ===
+# =====================================================
+PESO_KEYLOGGER = getattr(settings, "KEYLOGGER_PESO", 0.4)
+EXTENSIONES_SOSPECHOSAS = [".exe", ".dll", ".scr", ".bat", ".cmd", ".msi"]
+CARPETAS_CRITICAS = [
+    "C:\\Users\\Public",
+    "C:\\Users\\%USERNAME%\\AppData\\Roaming",
+    "C:\\Users\\%USERNAME%\\AppData\\Local\\Temp",
+    "C:\\ProgramData",
+    "C:\\Windows\\Temp",
+]
+PATRONES_NOMBRES = ["keylogger", "spy", "hook", "keyboard", "capture", "stealer"]
+
+
+# =====================================================
+# === FUNCIONES AUXILIARES ===
+# =====================================================
+def calcular_score_keylogger(total_items: int) -> float:
+    """Calcula el nivel de amenaza normalizado."""
+    return round(min(PESO_KEYLOGGER * total_items, 1.0), 3)
+
+
+def detectar_procesos_sospechosos() -> List[Dict]:
+    """Escanea procesos activos y detecta posibles keyloggers."""
+    hallazgos = []
+    for proc in psutil.process_iter(["pid", "name", "exe"]):
+        try:
+            nombre = proc.info.get("name", "").lower()
+            if any(pat in nombre for pat in PATRONES_NOMBRES):
+                hallazgos.append(proc.info)
+                registrar_evento("Keylogger", f"Proceso sospechoso: {proc.info}")
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return hallazgos
+
+
+def detectar_archivos_sospechosos() -> List[str]:
+    """
+    Busca archivos con extensiones peligrosas y nombres relacionados
+    a keyloggers en carpetas críticas del sistema.
+    """
+    hallazgos = []
+    for base in CARPETAS_CRITICAS:
+        base = os.path.expandvars(base)  # reemplaza %USERNAME%
+        if not os.path.exists(base):
+            continue
+        for root, _, files in os.walk(base):
+            for file in files:
+                if any(file.lower().endswith(ext) for ext in EXTENSIONES_SOSPECHOSAS):
+                    if any(pat in file.lower() for pat in PATRONES_NOMBRES):
+                        ruta = os.path.join(root, file)
+                        hallazgos.append(ruta)
+                        registrar_evento("Keylogger", f"Archivo sospechoso: {ruta}")
+    return hallazgos
+
+
+def detectar_programas_instalados() -> List[str]:
+    """
+    Analiza programas instalados en el sistema (solo Windows)
+    para encontrar software potencialmente malicioso.
+    """
+    hallazgos = []
+    if platform.system() != "Windows":
+        return hallazgos
+
+    try:
+        salida = subprocess.check_output(
+            ["wmic", "product", "get", "name"], stderr=subprocess.DEVNULL
+        ).decode("utf-8", errors="ignore")
+
+        for linea in salida.splitlines():
+            nombre = linea.strip().lower()
+            if any(pat in nombre for pat in PATRONES_NOMBRES):
+                hallazgos.append(nombre)
+                registrar_evento("Keylogger", f"Software sospechoso: {nombre}")
+    except Exception as e:
+        logger.error("Error al listar programas instalados: %s", e)
+
+    return hallazgos
+
+
+# =====================================================
+# === CLASE PRINCIPAL DE DETECCIÓN ===
+# =====================================================
+class KEYLOGGERDefense:
+    """
+    Escanea procesos, archivos y programas para detectar keyloggers
+    o software espía potencialmente malicioso.
+    """
+
+    def ejecutar_escaneo(self):
+        procesos = detectar_procesos_sospechosos()
+        archivos = detectar_archivos_sospechosos()
+        programas = detectar_programas_instalados()
+
+        total_hallazgos = len(procesos) + len(archivos) + len(programas)
+        score = calcular_score_keylogger(total_hallazgos)
+
+        if total_hallazgos > 0:
+            descripcion = [
+                f"Procesos sospechosos: {len(procesos)}",
+                f"Archivos sospechosos: {len(archivos)}",
+                f"Programas sospechosos: {len(programas)}",
+            ]
+
+            logger.warning("Keylogger detectado: %s ; nivel: %.2f", descripcion, score)
+
+            evento = {
+                "tipo": "Keylogger",
+                "descripcion": descripcion,
+                "procesos": procesos,
+                "archivos": archivos,
+                "programas": programas,
+                "score": score,
+            }
+
+            registrar_evento(
+                tipo="Keylogger",
+                descripcion=f"Detectados {total_hallazgos} elementos sospechosos.",
+                severidad="ALTA" if score >= 0.5 else "MEDIA",
+            )
+
+            return evento
+        else:
+            logger.info("Sin procesos, archivos o programas sospechosos detectados.")
+            return {"tipo": "Keylogger", "descripcion": "Sin hallazgos", "score": 0.0}
 
 
 """ 
@@ -18,4 +177,4 @@ S_keylogger = w_keylogger * numero_procesos_sospechosos
 S_keylogger = 0.4 * 2
 donde w_keylogger es peso asignado a keyloggers y numero_procesos_sospechosos es la cantidad de procesos detectados.
 
-"""
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py

@@ -1,7 +1,15 @@
-from django.utils.deprecation import MiddlewareMixin
+# sql_defense.py
+from __future__ import annotations
+import json
+import logging
+import re
+from typing import List, Tuple
 from django.conf import settings
-import logging, re, json
+from django.utils.deprecation import MiddlewareMixin
 
+# =====================================================
+# ===             CONFIGURACIÓN DEL LOGGER           ===
+# =====================================================
 logger = logging.getLogger("sqlidefense")
 logger.setLevel(logging.INFO)
 if not logger.handlers:
@@ -9,80 +17,171 @@ if not logger.handlers:
     handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
     logger.addHandler(handler)
 
-# 🔹 Patrones de ataque SQL
-PATTERNS = [
-    (re.compile(r"\bunion\b\s+(all\s+)?\bselect\b", re.I), "UNION SELECT"),
+
+# =====================================================
+# ===        PATRONES DE DETECCIÓN DE SQLi           ===
+# =====================================================
+SQLI_PATTERNS: List[Tuple[re.Pattern, str]] = [
+    # Inyección clásica con UNION SELECT
+    (re.compile(r"\bunion\b\s+(all\s+)?\bselect\b", re.I), "Uso de UNION SELECT"),
+    # Combinaciones OR/AND en consultas WHERE
     (
         re.compile(r"\bselect\b.*\bfrom\b.*\bwhere\b.*\b(or|and)\b.*=", re.I),
         "SELECT con OR/AND",
     ),
-    (re.compile(r"\b(or|and)\s+\d+\s*=\s*\d+", re.I), "OR/AND 1=1"),
+    # Comparaciones tautológicas (1=1)
+    (
+        re.compile(r"\b(or|and)\s+\d+\s*=\s*\d+", re.I),
+        "Expresión tautológica OR/AND 1=1",
+    ),
+    # Manipulación de tablas
     (
         re.compile(r"\b(drop|truncate|delete|insert|update)\b", re.I),
-        "Manipulación de tabla",
+        "Comando de manipulación de tabla",
     ),
+    # Comentarios sospechosos o terminadores
     (re.compile(r"(--|#|;)", re.I), "Comentario o terminador sospechoso"),
-    (re.compile(r"exec\s*\(", re.I), "Ejecución de procedimiento"),
+    # Ejecución directa de procedimientos
+    (re.compile(r"exec\s*\(", re.I), "Ejecución de procedimiento almacenado"),
+    # Subconsultas y SELECT anidados sospechosos
+    (re.compile(r"\(\s*select\b.*\)", re.I), "Subconsulta sospechosa"),
 ]
 
 
-def extract_payload_text(request):
-    parts = []
+# =====================================================
+# ===          FUNCIONES AUXILIARES SQLi             ===
+# =====================================================
+def extract_payload_text(request) -> str:
+    """
+    Extrae texto de interés desde el cuerpo, querystring,
+    encabezados y referencias para analizar posible SQLi.
+    """
+    parts: List[str] = []
+
     try:
-        if "application/json" in request.META.get("CONTENT_TYPE", ""):
-            body_json = json.loads(request.body.decode("utf-8") or "{}")
-            parts.append(json.dumps(body_json))
+        content_type = request.META.get("CONTENT_TYPE", "")
+        if "application/json" in content_type:
+            data = json.loads(request.body.decode("utf-8") or "{}")
+            parts.append(json.dumps(data))
         else:
-            parts.append(request.body.decode("utf-8", errors="ignore"))
-    except:
+            body = request.body.decode("utf-8", errors="ignore")
+            if body:
+                parts.append(body)
+    except Exception:
         pass
-    if request.META.get("QUERY_STRING"):
-        parts.append(request.META.get("QUERY_STRING"))
+
+    qs = request.META.get("QUERY_STRING", "")
+    if qs:
+        parts.append(qs)
+
     parts.append(request.META.get("HTTP_USER_AGENT", ""))
     parts.append(request.META.get("HTTP_REFERER", ""))
+
     return " ".join([p for p in parts if p])
 
 
-def detect_sql_attack(text):
-    descripcion = []
-    for patt, msg in PATTERNS:
+def detect_sql_attack(text: str) -> Tuple[bool, List[str]]:
+    """
+    Recorre el texto buscando patrones típicos de inyección SQL.
+    Retorna (True, lista_de_descripciones) si se detecta algún patrón.
+    """
+    descripcion: List[str] = []
+
+    for patt, msg in SQLI_PATTERNS:
         if patt.search(text):
             descripcion.append(msg)
+
     return (len(descripcion) > 0, descripcion)
 
 
-def get_client_ip(request):
+def get_client_ip(request) -> str:
+    """
+    Obtiene la IP real del cliente considerando X-Forwarded-For.
+    """
     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", "")
 
 
+# =====================================================
+# ===          MIDDLEWARE DE DEFENSA SQLi            ===
+# =====================================================
 class SQLIDefenseMiddleware(MiddlewareMixin):
+    """
+    Middleware profesional de detección de inyección SQL.
+    - Detecta patrones en parámetros, cuerpo y cabeceras.
+    - No bloquea directamente; marca el intento para auditoría.
+    """
+
     def process_request(self, request):
+        # ---------------------------------------------
+        # 1. Filtrar IPs confiables
+        # ---------------------------------------------
         client_ip = get_client_ip(request)
-        trusted_ips = getattr(settings, "SQLI_DEFENSE_TRUSTED_IPS", [])
-
+        trusted_ips: List[str] = getattr(settings, "SQLI_DEFENSE_TRUSTED_IPS", [])
         if client_ip in trusted_ips:
             return None
 
-        text = extract_payload_text(request)
-        if not text:
+        # ---------------------------------------------
+        # 2. Extraer payload de la solicitud
+        # ---------------------------------------------
+        payload = extract_payload_text(request)
+        if not payload:
             return None
 
-        flagged, descripcion = detect_sql_attack(text)
-        if flagged:
-            # Solo tipo SQL, descripción con los patrones detectados
-            request.sql_attack_info = {
-                "ip": client_ip,
-                "tipos": ["SQL"],
-                "descripcion": descripcion,
-                "payload": text,
-            }
-
-            logger.warning(
-                f"Ataque SQL detectado desde IP {client_ip}: {descripcion}, payload: {text}"
-            )
-
-            # No devolvemos JsonResponse, solo marcamos el ataque
+        # ---------------------------------------------
+        # 3. Analizar contenido en busca de patrones SQLi
+        # ---------------------------------------------
+        flagged, descripcion = detect_sql_attack(payload)
+        if not flagged:
             return None
+
+        # ---------------------------------------------
+        # 4. Calcular puntaje de amenaza S_sqli
+        # ---------------------------------------------
+        w_sqli = getattr(settings, "SQLI_DEFENSE_WEIGHT", 0.4)
+        detecciones_sqli = len(descripcion)
+        s_sqli = w_sqli * detecciones_sqli
+
+        # ---------------------------------------------
+        # 5. Registrar e informar el intento
+        # ---------------------------------------------
+        logger.warning(
+            "Inyección SQL detectada desde IP %s: %s ; payload: %.200s ; score: %.2f",
+            client_ip,
+            descripcion,
+            payload,
+            s_sqli,
+        )
+
+        # Marcar información del ataque para el sistema de auditoría
+        request.sql_attack_info = {
+            "ip": client_ip,
+            "tipos": ["SQLi"],
+            "descripcion": descripcion,
+            "payload": payload,
+            "score": s_sqli,
+        }
+
+        return None
+
+
+# =====================================================
+# ===              INFORMACIÓN EXTRA                ===
+# =====================================================
+"""
+Algoritmos relacionados:
+    - Se recomienda almacenar logs SQLi cifrados (AES-GCM) 
+      para proteger evidencia de intentos maliciosos.
+
+Cálculo de puntaje de amenaza:
+    S_sqli = w_sqli * detecciones_sqli
+    Ejemplo: S_sqli = 0.4 * 3 = 1.2
+
+Integración:
+    Este middleware puede combinarse con:
+        - CSRFDefenseMiddleware
+        - XSSDefenseMiddleware
+    para calcular un score total de amenaza y decidir bloqueo.
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py

@@ -1,18 +1,15 @@
-"""
-detector_xss.py (version separada con IPs confiables independientes)
-"""
-
+# xss_defense.py
 from __future__ import annotations
 import json
 import logging
 import re
 from typing import List, Tuple
-
 from django.conf import settings
-from django.http import JsonResponse
 from django.utils.deprecation import MiddlewareMixin
 
-# Logger
+# =====================================================
+# ===               CONFIGURACIÓN LOGGER             ===
+# =====================================================
 logger = logging.getLogger("xssdefense")
 logger.setLevel(logging.INFO)
 if not logger.handlers:
@@ -20,7 +17,9 @@ if not logger.handlers:
     handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
     logger.addHandler(handler)
 
-# Intentar usar bleach si está disponible
+# =====================================================
+# ===              INTENTAR CARGAR BLEACH            ===
+# =====================================================
 try:
     import bleach
 
@@ -28,32 +27,51 @@ try:
 except Exception:
     _BLEACH_AVAILABLE = False
 
-# Patrones de detección XSS
+# =====================================================
+# ===           PATRONES DE DETECCIÓN XSS            ===
+# =====================================================
 XSS_PATTERNS: List[Tuple[re.Pattern, str]] = [
     (re.compile(r"<\s*script\b", re.I), "Etiqueta <script>"),
-    (re.compile(r"on\w+\s*=", re.I), "Atributo evento (on*)"),
+    (re.compile(r"on\w+\s*=", re.I), "Atributo de evento (on*)"),
     (re.compile(r"javascript:\s*", re.I), "URI javascript:"),
     (re.compile(r"<\s*iframe\b", re.I), "Etiqueta <iframe>"),
     (re.compile(r"<\s*embed\b", re.I), "Etiqueta <embed>"),
+    (re.compile(r"<\s*object\b", re.I), "Etiqueta <object>"),
+    (re.compile(r"document\.cookie", re.I), "Acceso a document.cookie"),
+    (re.compile(r"alert\s*\(", re.I), "Uso de alert() potencial"),
 ]
 
 
-# Funciones auxiliares
+# =====================================================
+# ===         FUNCIONES AUXILIARES XSS              ===
+# =====================================================
 def detect_xss_text(text: str) -> Tuple[bool, List[str]]:
+    """
+    Busca patrones de XSS conocidos dentro de un texto.
+    Devuelve (True, lista_de_coincidencias) si hay indicios.
+    """
     matches: List[str] = []
     if not text:
         return False, matches
+
     for patt, message in XSS_PATTERNS:
         if patt.search(text):
             matches.append(message)
+
     return len(matches) > 0, matches
 
 
 def sanitize_input_basic(text: str) -> str:
+    """
+    Sanitiza una cadena eliminando etiquetas o caracteres peligrosos.
+    Usa bleach si está disponible, de lo contrario hace escape manual.
+    """
     if text is None:
         return text
+
     if _BLEACH_AVAILABLE:
         return bleach.clean(text, tags=[], attributes={}, protocols=[], strip=True)
+
     replacements = [
         ("&", "&amp;"),
         ("<", "&lt;"),
@@ -69,101 +87,111 @@ def sanitize_input_basic(text: str) -> str:
 
 
 def extract_payload_text(request) -> str:
+    """
+    Extrae un texto combinado con información del cuerpo, querystring,
+    agente de usuario y referer para análisis XSS.
+    """
     parts: List[str] = []
+
     try:
-        ct = request.META.get("CONTENT_TYPE", "")
-        if "application/json" in ct:
-            parts.append(
-                json.dumps(
-                    json.loads(request.body.decode("utf-8") or "{}"), ensure_ascii=False
-                )
-            )
+        content_type = request.META.get("CONTENT_TYPE", "")
+
+        if "application/json" in content_type:
+            body_data = json.loads(request.body.decode("utf-8") or "{}")
+            parts.append(json.dumps(body_data, ensure_ascii=False))
         else:
-            parts.append(request.body.decode("utf-8", errors="ignore"))
+            body_text = request.body.decode("utf-8", errors="ignore")
+            if body_text:
+                parts.append(body_text)
     except Exception:
         pass
+
     qs = request.META.get("QUERY_STRING", "")
     if qs:
         parts.append(qs)
+
     parts.append(request.META.get("HTTP_USER_AGENT", ""))
     parts.append(request.META.get("HTTP_REFERER", ""))
+
     return " ".join([p for p in parts if p])
 
 
-# Middleware XSS
+# =====================================================
+# ===            MIDDLEWARE DE DEFENSA XSS           ===
+# =====================================================
 class XSSDefenseMiddleware(MiddlewareMixin):
     """
-    Middleware Django que detecta XSS en IPs no confiables.
+    Middleware profesional de detección XSS.
+    - Detecta patrones maliciosos en solicitudes sospechosas.
+    - No bloquea directamente, solo marca el ataque para auditoría.
+    - Se integra con AuditoriaMiddleware (request.sql_attack_info).
     """
 
     def process_request(self, request):
-        # 1) Obtener IP confiable específica para XSS
+        # ---------------------------------------------
+        # 1. Filtrar IPs de confianza
+        # ---------------------------------------------
         trusted_ips: List[str] = getattr(settings, "XSS_DEFENSE_TRUSTED_IPS", [])
-        ip = request.META.get("REMOTE_ADDR", "")
-        if ip in trusted_ips:
-            return None  # IP confiable → no analizar
+        client_ip = request.META.get("REMOTE_ADDR", "")
+        if client_ip in trusted_ips:
+            return None
 
-        # 2) Verificar rutas excluidas
+        # ---------------------------------------------
+        # 2. Excluir rutas seguras
+        # ---------------------------------------------
         excluded_paths: List[str] = getattr(settings, "XSS_DEFENSE_EXCLUDED_PATHS", [])
         if any(request.path.startswith(p) for p in excluded_paths):
             return None
 
-        # 3) Extraer payload
+        # ---------------------------------------------
+        # 3. Extraer y analizar payload
+        # ---------------------------------------------
         payload = extract_payload_text(request)
         if not payload:
             return None
 
-        # 4) Detectar XSS
         flagged, matches = detect_xss_text(payload)
         if not flagged:
             return None
 
+        # ---------------------------------------------
+        # 4. Calcular puntaje de amenaza S_xss
+        # ---------------------------------------------
+        w_xss = getattr(settings, "XSS_DEFENSE_WEIGHT", 0.3)
+        detecciones_xss = len(matches)
+        s_xss = w_xss * detecciones_xss
+
+        # ---------------------------------------------
+        # 5. Loggear y marcar en el request
+        # ---------------------------------------------
         logger.warning(
-            "XSS detectado desde IP %s: %s ; payload truncated: %.200s",
-            ip,
+            "XSS detectado desde IP %s: %s ; payload: %.200s ; score: %.2f",
+            client_ip,
             matches,
             payload,
+            s_xss,
         )
 
-        # 5) Sanitizar si está configurado
-        if getattr(settings, "XSS_DEFENSE_SANITIZE_INPUT", False):
-            try:
-                if hasattr(request, "POST"):
-                    mutable_post = request.POST.copy()
-                    for k in mutable_post.keys():
-                        mutable_post[k] = sanitize_input_basic(mutable_post.get(k))
-                    request.POST = mutable_post
-                if hasattr(request, "GET"):
-                    mutable_get = request.GET.copy()
-                    for k in mutable_get.keys():
-                        mutable_get[k] = sanitize_input_basic(mutable_get.get(k))
-                    request.GET = mutable_get
-            except Exception:
-                logger.debug("Error sanitizando inputs; continuar")
-
-        # 6) Registrar ataque en AuditoriaMiddleware
         request.sql_attack_info = {
-            "ip": ip,
+            "ip": client_ip,
             "tipos": ["XSS"],
             "descripcion": matches,
             "payload": payload,
+            "score": s_xss,
         }
 
-        # 7) Bloquear petición si está configurado
-        if getattr(settings, "XSS_DEFENSE_BLOCK", True):
-            return JsonResponse(
-                {"mensaje": "Ataque detectado (XSS)", "tipos": matches}, status=403
-            )
-
         return None
 
 
-""" 
+# =====================================================
+# ===              INFORMACIÓN EXTRA                ===
+# =====================================================
+"""
 Algoritmos relacionados:
-    *Guardar entradas sospechosas con AES-GCM para confidencialidad y autenticidad.
-Contribución a fórmula de amenaza S:
-S_xss = w_xss * detecciones_xss
-S_xss = 0.3 * 2
-donde w_xss es peso asignado a XSS y detecciones_xss es la cantidad de patrones detectados.
+    - Se recomienda almacenar los payloads XSS cifrados con AES-GCM
+      para confidencialidad e integridad.
 
+Contribución a fórmula de amenaza S:
+    S_xss = w_xss * detecciones_xss
+    Ejemplo: S_xss = 0.3 * 2 = 0.6
 """

{guardianunivalle_benito_yucra-0.1.28.dist-info → guardianunivalle_benito_yucra-0.1.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.28
+Version: 0.1.30
 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.28.dist-info → guardianunivalle_benito_yucra-0.1.30.dist-info}/RECORD

@@ -4,17 +4,17 @@ GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py,sha256=YxEtF6ZJj8M
 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=EAYfLkHuxGC5rXSu4mZJ4yZDCbwBpTX8xZWGKz7i5wA,692
-GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=lMWmCw6nccCEnek53nVjpoBCeiBqLdrSXxqRuI7VP2I,696
-GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py,sha256=rEDG-Q_R56OsG2ypfHVBK7erolYjdvATnAxB3yvPXts,729
-GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=b7pd4-CTH0FqW5-dwA6RA38Dls0bSBXKSLlmnKbLnbA,2982
-GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=S0E8myh4uKxYjXMDvG6i1nc66XgB0iKIRa-9gDJErdA,5411
+GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py,sha256=8gynkJlxF2XfHPLdWaMS048b5Tuhznsb4JI3bqggC0g,7892
+GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=ech5UmUwK84EPSVZvjI0Q4Pq7w8WGymuYc77LgAKiiA,6163
+GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py,sha256=T46HXHT3LZz3kke4GcxOM8urJSy-Vq2BEDfo9_F56Pw,6717
+GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=o2IXqF3Nbsh5roPihyLal42iCzgxfyX3D6Ef-cxOpVo,6644
+GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=kdXJsoDjvBVccrO2QiE65Q527sUjy1WmlzYg8rDjmqA,6795
 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.28.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
-guardianunivalle_benito_yucra-0.1.28.dist-info/METADATA,sha256=ljR3reAfOBK8g2jaAp6pbsG7BpTMcjNFoLK26q4v7PM,1893
-guardianunivalle_benito_yucra-0.1.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guardianunivalle_benito_yucra-0.1.28.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
-guardianunivalle_benito_yucra-0.1.28.dist-info/RECORD,,
+guardianunivalle_benito_yucra-0.1.30.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
+guardianunivalle_benito_yucra-0.1.30.dist-info/METADATA,sha256=yS2g75_JDicESJXiuBDwCJXOYiyCe0lrXzlSjEB8XNM,1893
+guardianunivalle_benito_yucra-0.1.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guardianunivalle_benito_yucra-0.1.30.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
+guardianunivalle_benito_yucra-0.1.30.dist-info/RECORD,,