GuardianUnivalle-Benito-Yucra 0.1.69__py3-none-any.whl → 0.1.71__py3-none-any.whl

GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py

@@ -1,10 +1,12 @@
-# CSRF defense (versión reforzada)
+# csrf_defense.py
+# GuardianUnivalle_Benito_Yucra/detectores/csrf_defense.py
+
 from __future__ import annotations
 import secrets
 import logging
 import re
 import json
-from typing import List
+from typing import List, Dict, Any
 from urllib.parse import urlparse
 from django.conf import settings
 from django.utils.deprecation import MiddlewareMixin
@@ -21,21 +23,42 @@ CSRF_HEADER_NAMES = ("HTTP_X_CSRFTOKEN", "HTTP_X_CSRF_TOKEN")
 CSRF_COOKIE_NAME = getattr(settings, "CSRF_COOKIE_NAME", "csrftoken")
 POST_FIELD_NAME = "csrfmiddlewaretoken"
 
-# Patrón de Content-Type sospechoso
+# Patrón de Content-Type sospechoso - EXPANDIDO
 SUSPICIOUS_CT_PATTERNS = [
     re.compile(r"text/plain", re.I),
     re.compile(r"application/x-www-form-urlencoded", re.I),
     re.compile(r"multipart/form-data", re.I),
+    re.compile(r"application/json", re.I),
+    re.compile(r"text/html", re.I),  # Agregado para HTML CSRF
 ]
 
-# Parámetros sensibles típicos de CSRF
+# Parámetros sensibles típicos de CSRF - EXPANDIDO
 SENSITIVE_PARAMS = [
-    "password", "csrfmiddlewaretoken", "token", "amount", "transfer", "delete", "update"
+    "password", "csrfmiddlewaretoken", "token", "amount", "transfer", "delete", "update", "action", "email", "username"
 ]
 
+# Campos sensibles: ANALIZAMOS COMPLETAMENTE SIN DESCUENTO PARA ROBUSTEZ MÁXIMA
+SENSITIVE_FIELDS = ["password", "csrfmiddlewaretoken", "token", "auth", "email", "username"]
+
 CSRF_DEFENSE_MIN_SIGNALS = getattr(settings, "CSRF_DEFENSE_MIN_SIGNALS", 1)
 CSRF_DEFENSE_EXCLUDED_API_PREFIXES = getattr(settings, "CSRF_DEFENSE_EXCLUDED_API_PREFIXES", ["/api/"])
 
+# PATRONES EXPANDIDOS PARA ANÁLISIS DE PAYLOAD EN TODOS LOS CAMPOS (SIN DESCUENTO)
+CSRF_PAYLOAD_PATTERNS = [
+    (re.compile(r"<script[^>]*>.*?</script>", re.I | re.S), "Script tag en payload", 0.9),
+    (re.compile(r"javascript\s*:", re.I), "URI javascript: en payload", 0.8),
+    (re.compile(r"http[s]?://[^\s]+", re.I), "URL externa en payload", 0.7),
+    (re.compile(r"eval\s*\(", re.I), "eval() en payload", 1.0),
+    (re.compile(r"document\.cookie", re.I), "Acceso a cookie en payload", 0.9),
+    (re.compile(r"innerHTML\s*=", re.I), "Manipulación DOM innerHTML", 0.8),
+    (re.compile(r"XMLHttpRequest", re.I), "XHR en payload", 0.7),
+    (re.compile(r"fetch\s*\(", re.I), "fetch() en payload", 0.7),
+    (re.compile(r"&#x[0-9a-fA-F]+;", re.I), "Entidades HTML en payload", 0.6),
+    (re.compile(r"%3Cscript", re.I), "Script URL-encoded en payload", 0.8),
+    (re.compile(r"on\w+\s*=", re.I), "Eventos on* en payload", 0.7),
+    (re.compile(r"alert\s*\(", re.I), "alert() en payload (prueba)", 0.5),
+]
+
 def get_client_ip(request):
     x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
     if x_forwarded_for:
@@ -62,15 +85,15 @@ def origin_matches_host(request) -> bool:
     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)
     # Bloquear obvious javascript: referers
     if any(re.search(r"(javascript:|<script|data:text/html)", h or "", re.I) for h in [origin, referer]):
         return False
-    if origin_host and origin_host == host:
-        return True
-    if referer_host and referer_host == host:
-        return True
+    if origin_host := host_from_header(origin):
+        if origin_host == host:
+            return True
+    if referer_host := host_from_header(referer):
+        if referer_host == host:
+            return True
     if not origin and not referer:
         return True
     return False
@@ -118,6 +141,34 @@ def extract_parameters(request) -> List[str]:
         pass
     return params
 
+# FUNCIÓN ROBUSTA: Analizar payload en TODOS los campos (incluyendo sensibles sin descuento)
+def analyze_payload(value: str) -> float:
+    score = 0.0
+    for patt, desc, weight in CSRF_PAYLOAD_PATTERNS:
+        if patt.search(value):
+            score += weight  # Score full, sin descuento
+    return round(score, 3)
+
+# NUEVA FUNCIÓN: Extraer y analizar query string
+def analyze_query_string(request) -> float:
+    qs = request.META.get("QUERY_STRING", "")
+    if qs:
+        return analyze_payload(qs)
+    return 0.0
+
+# NUEVA FUNCIÓN: Analizar headers adicionales
+def analyze_headers(request) -> List[str]:
+    issues = []
+    ua = request.META.get("HTTP_USER_AGENT", "")
+    if re.search(r"(script|<|eval|bot|crawler)", ua, re.I):
+        issues.append("User-Agent sospechoso (posible automatización/bot)")
+    
+    accept_lang = request.META.get("HTTP_ACCEPT_LANGUAGE", "")
+    if not accept_lang or len(accept_lang) < 2:
+        issues.append("Accept-Language ausente o muy corto (posible bot)")
+    
+    return issues
+
 class CSRFDefenseMiddleware(MiddlewareMixin):
     def process_request(self, request):
         # Excluir APIs JSON si se configuró así
@@ -136,7 +187,7 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
             return None
 
         method = (request.method or "").upper()
-        if method not in STATE_CHANGING_METHODS:
+        if method not in STATE_CHANGING_METHODS:  # CORREGIDO: Agregado "in"
             return None
 
         descripcion: List[str] = []
@@ -174,33 +225,73 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
             if origin and host_from_header(origin) != (request.META.get("HTTP_HOST") or "").split(":")[0]:
                 descripcion.append("JSON POST desde origen externo (posible CSRF)")
 
+        # 7) Análisis ROBUSTO de payload en TODOS los campos (sin descuento)
+        payload_score = 0.0
+        payload_summary: List[Dict[str, Any]] = []
+        try:
+            # Analizar POST
+            if hasattr(request, "POST"):
+                for key, value in request.POST.items():
+                    if isinstance(value, str):
+                        score = analyze_payload(value)
+                        payload_score += score
+                        if score > 0:
+                            payload_summary.append({"field": key, "snippet": value[:300], "score": score})
+            # Analizar JSON
+            if "application/json" in content_type:
+                data = json.loads(request.body.decode("utf-8") or "{}")
+                for key, value in data.items():
+                    if isinstance(value, str):
+                        score = analyze_payload(value)
+                        payload_score += score
+                        if score > 0:
+                            payload_summary.append({"field": key, "snippet": value[:300], "score": score})
+        except Exception as e:
+            logger.debug(f"Error analizando payload: {e}")
+
+        if payload_score > 0:
+            descripcion.append(f"Payload sospechoso detectado (score total: {payload_score})")
+
+        # 8) Análisis de query string
+        qs_score = analyze_query_string(request)
+        if qs_score > 0:
+            descripcion.append(f"Query string sospechosa (score: {qs_score})")
+            payload_score += qs_score
+
+        # 9) Análisis de headers adicionales
+        header_issues = analyze_headers(request)
+        descripcion.extend(header_issues)
+
         # Señales >= umbral => marcar
-        if descripcion and len(descripcion) >= CSRF_DEFENSE_MIN_SIGNALS:
+        total_signals = len(descripcion)
+        if descripcion and total_signals >= CSRF_DEFENSE_MIN_SIGNALS:
             w_csrf = getattr(settings, "CSRF_DEFENSE_WEIGHT", 0.2)
-            s_csrf = w_csrf * len(descripcion)
+            s_csrf = w_csrf * total_signals + payload_score  # Score full sin descuento
             request.csrf_attack_info = {
                 "ip": client_ip,
                 "tipos": ["CSRF"],
                 "descripcion": descripcion,
-                "payload": payload,
+                "payload": json.dumps(payload_summary, ensure_ascii=False)[:1000],
                 "score": s_csrf,
             }
             logger.warning(
-                "CSRF detectado desde IP %s: %s ; path=%s ; Content-Type=%s ; score=%.2f",
+                "CSRF detectado desde IP %s: %s ; path=%s ; Content-Type=%s ; score=%.2f (Ultra-Robust: nada ignorado)",
                 client_ip, descripcion, request.path, content_type, s_csrf
             )
         else:
             if descripcion:
-                logger.debug(f"[CSRFDefense] low-signals ({len(descripcion)}) not marking: {descripcion}")
+                logger.debug(f"[CSRFDefense] low-signals ({total_signals}) not marking: {descripcion}")
 
         return None
 
 """
-CSRF Defense Middleware - Reforzado
-===================================
+CSRF Defense Middleware - Ultra-Robusto (Nada Ignorado)
+=======================================================
 - Detecta múltiples categorías de CSRF: clásico, login, logout, password change, file/action, JSON API.
-- Escanea payloads POST, GET y JSON.
+- Escanea payloads POST, GET, JSON, query string y headers, incluyendo TODOS los campos (sensibles y no) con score full (sin descuento).
 - Detecta parámetros sensibles enviados en GET o JSON desde origen externo.
+- Análisis adicional de User-Agent, Accept-Language, y payloads con patrones expandidos.
 - Scoring configurable y logging detallado.
 - Fácil integración con auditoría XSS/SQLi.
+- Máxima robustez: no ignora nada para detección óptima.
 """

GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py

@@ -8,7 +8,7 @@ from django.utils.deprecation import MiddlewareMixin
 from django.conf import settings
 import urllib.parse
 import html
-from typing import List, Tuple, Dict
+from typing import List, Tuple, Dict, Any
 
 # ----------------------------
 # Configuración del logger
@@ -108,9 +108,23 @@ SQL_PATTERNS: List[Tuple[re.Pattern, str, float]] = [
     # ------------------ Catch‑all aggressive patterns (usar con cuidado) ------------------
     (re.compile(r"(['\"]).*?;\s*(drop|truncate|delete|update|insert)\b", re.I | re.S), "Cadena con terminador y DDL/DML (potencial ataque)", 0.9),
     (re.compile(r"\b(or)\b\s+1\s*=\s*1\b", re.I), "OR 1=1 tautology", 0.85),
+
+    # ---------- NUEVOS PATRONES PARA ROBUSTEZ ----------
+    (re.compile(r"\b(select\s+.*\s+from\s+.*\s+where\s+.*\s+in\s*\()", re.I | re.S), "Subquery anidada (IN subquery)", 0.75),
+    (re.compile(r"\bcase\s+when\s+.*\s+then\s+.*\s+else\b", re.I), "CASE WHEN (blind boolean)", 0.78),
+    (re.compile(r"/\*\!.+\*\//", re.I), "Comentarios condicionales MySQL (/*!...*/)", 0.7),
+    (re.compile(r"\bif\s*\(\s*.*\s*,\s*.*\s*,\s*.*\s*\)", re.I), "IF() MySQL (conditional)", 0.72),
+    (re.compile(r"\bgroup_concat\s*\(", re.I), "GROUP_CONCAT() (exfiltración en error)", 0.8),
 ]
 
-IGNORED_FIELDS = ["password", "csrfmiddlewaretoken", "token", "auth"]
+# Campos sensibles: ANALIZAMOS COMPLETAMENTE SIN DESCUENTO PARA ROBUSTEZ MÁXIMA
+SENSITIVE_FIELDS = ["password", "csrfmiddlewaretoken", "token", "auth", "email", "username"]
+
+DEFAULT_THRESHOLDS = {
+    "HIGH": 1.8,
+    "MEDIUM": 1.0,
+    "LOW": 0.5,
+}
 
 # ----------------------------
 # Obtener IP real del cliente
@@ -124,26 +138,34 @@ def get_client_ip(request):
     return request.META.get("REMOTE_ADDR", "")
 
 # ----------------------------
-# Extraer payload de la solicitud
+# Extraer payload de la solicitud - MEJORADO PARA ANÁLISIS POR CAMPO
 # ----------------------------
-def extract_payload(request):
-    parts = []
+def extract_payload_as_map(request) -> Dict[str, Any]:
     try:
-        if "application/json" in request.META.get("CONTENT_TYPE", ""):
-            data = json.loads(request.body.decode("utf-8") or "{}")
-            parts.append(json.dumps(data))
+        ct = request.META.get("CONTENT_TYPE", "")
+        if "application/json" in ct:
+            raw = request.body.decode("utf-8") or "{}"
+            try:
+                data = json.loads(raw)
+                if isinstance(data, dict):
+                    return data
+                else:
+                    return {"raw": raw}
+            except Exception:
+                return {"raw": raw}
         else:
-            body = request.body.decode("utf-8", errors="ignore")
-            if body:
-                parts.append(body)
+            try:
+                post = request.POST.dict()
+                if post:
+                    return post
+            except Exception:
+                pass
+            raw = request.body.decode("utf-8", errors="ignore")
+            if raw:
+                return {"raw": raw}
     except Exception:
         pass
-
-    qs = request.META.get("QUERY_STRING", "")
-    if qs:
-        parts.append(qs)
-
-    return " ".join(parts)
+    return {}
 
 # ----------------------------
 # Normalización / preprocesamiento
@@ -159,13 +181,12 @@ def normalize_input(s: str) -> str:
         s_dec = html.unescape(s_dec)
     except Exception:
         pass
-    # Reemplazo seguro de secuencias \xNN
     s_dec = re.sub(r"\\x([0-9a-fA-F]{2})", r"\\x\g<1>", s_dec)
     s_dec = re.sub(r"\s+", " ", s_dec)
     return s_dec.strip()
 
 # ----------------------------
-# Detector SQLi
+# Detector SQLi - ROBUSTO SIN DESCUENTO
 # ----------------------------
 def detect_sql_injection(text: str) -> Dict:
     norm = normalize_input(text or "")
@@ -174,7 +195,7 @@ def detect_sql_injection(text: str) -> Dict:
     descriptions = []
     for pattern, desc, weight in SQL_PATTERNS:
         if pattern.search(norm):
-            score += weight
+            score += weight  # Score full, sin descuento
             matches.append((desc, pattern.pattern, weight))
             descriptions.append(desc)
 
@@ -185,14 +206,8 @@ def detect_sql_injection(text: str) -> Dict:
         "sample": norm[:1200],
     }
 
-DEFAULT_THRESHOLDS = {
-    "HIGH": 1.8,
-    "MEDIUM": 1.0,
-    "LOW": 0.5,
-}
-
 # ----------------------------
-# Middleware SQLi
+# Middleware SQLi - ULTRA-ROBUSTO
 # ----------------------------
 class SQLIDefenseMiddleware(MiddlewareMixin):
     def process_request(self, request):
@@ -202,33 +217,65 @@ class SQLIDefenseMiddleware(MiddlewareMixin):
 
         if client_ip in trusted_ips:
             return None
-
         referer = request.META.get("HTTP_REFERER", "")
         host = request.get_host()
         if any(url in referer for url in trusted_urls) or any(url in host for url in trusted_urls):
             return None
-
-        payload = extract_payload(request)
-        result = detect_sql_injection(payload)
-        score = result["score"]
-        descripciones = result["descriptions"]
-
-        if score == 0:
+        # Extraer datos como mapa para análisis por campo
+        data = extract_payload_as_map(request)
+        qs = request.META.get("QUERY_STRING", "")
+        if qs:
+            data["_query_string"] = qs
+        if not data:
+            return None
+        total_score = 0.0
+        all_descriptions = []
+        all_matches = []
+        payload_summary = []
+        # Analizar campo por campo - AHORA SIN DESCUENTO PARA ROBUSTEZ
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if isinstance(value, (dict, list)):
+                    try:
+                        vtext = json.dumps(value, ensure_ascii=False)
+                    except Exception:
+                        vtext = str(value)
+                else:
+                    vtext = str(value or "")
+
+                result = detect_sql_injection(vtext)
+                total_score += result["score"]
+                all_descriptions.extend(result["descriptions"])
+                all_matches.extend(result["matches"])
+
+                if result["score"] > 0:
+                    is_sensitive = isinstance(key, str) and key.lower() in SENSITIVE_FIELDS
+                    payload_summary.append({"field": key, "snippet": vtext[:300], "sensitive": is_sensitive})
+        else:
+            raw = str(data)
+            result = detect_sql_injection(raw)
+            total_score += result["score"]
+            all_descriptions.extend(result["descriptions"])
+            all_matches.extend(result["matches"])
+            if result["score"] > 0:
+                payload_summary.append({"field": "raw", "snippet": raw[:500], "sensitive": False})
+
+        if total_score == 0:
             return None
 
         # Registrar ataque
         logger.warning(
             f"[SQLiDetect] IP={client_ip} Host={host} Referer={referer} "
-            f"Score={score:.2f} Desc={descripciones} Payload={payload[:500]}"
+            f"Score={total_score:.2f} Desc={all_descriptions} Payload={json.dumps(payload_summary, ensure_ascii=False)[:500]}"
         )
 
         # Guardar info en request
         request.sql_attack_info = {
             "ip": client_ip,
             "tipos": ["SQLi"],
-            "descripcion": descripciones,
-            "payload": payload[:1000],
-            "score": round(score, 2),
+            "descripcion": all_descriptions,
+            "payload": json.dumps(payload_summary, ensure_ascii=False)[:1000],
+            "score": round(total_score, 2),
             "url": request.build_absolute_uri(),
         }
 

GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py

@@ -29,11 +29,10 @@ except Exception:
     _BLEACH_AVAILABLE = False
 
 # -------------------------------------------------
-# Patrones XSS con peso (descripcion, peso)
+# Patrones XSS con peso (descripcion, peso) - EXPANDIDOS PARA ROBUSTEZ
 # - pesos mayores = más severo (por ejemplo <script> o javascript:)
-# - esto permite un scoring acumulativo y menos falsos positivos
+# - Agregados patrones para DOM-based, polyglots y evasiones avanzadas
 # -------------------------------------------------
-
 XSS_PATTERNS: List[Tuple[re.Pattern, str, float]] = [
     # ---------- Máxima severidad / ejecución directa ----------
     (re.compile(r"<\s*script\b", re.I), "Etiqueta <script> (directa)", 0.95),
@@ -94,20 +93,30 @@ XSS_PATTERNS: List[Tuple[re.Pattern, str, float]] = [
     # ---------- Heurísticos de baja severidad (informativo) ----------
     (re.compile(r"<\s*form\b", re.I), "Form (posible vector de ataque relacionado)", 0.25),
     (re.compile(r"(onmouseover|onfocus|onmouseenter|onmouseleave)\b", re.I), "Eventos UI (mouseover/focus)", 0.45),
+
+    # ---------- NUEVOS PATRONES PARA ROBUSTEZ ----------
+    (re.compile(r"\binnerHTML\s*=\s*.*[<>\"']", re.I), "Asignación a innerHTML con tags", 0.85),  # DOM-based
+    (re.compile(r"\bdocument\.getElementById\s*\(\s*.*\)\.innerHTML", re.I), "Manipulación DOM innerHTML", 0.80),
+    (re.compile(r"<script[^>]*src\s*=\s*['\"][^'\"]*['\"][^>]*>", re.I), "Script externo (posible carga remota)", 0.75),
+    (re.compile(r"\bXMLHttpRequest\s*\(\s*\)\.open\s*\(\s*['\"](GET|POST)['\"]", re.I), "XHR manipulado (posible exfiltración)", 0.70),
+    (re.compile(r"<\s*link\b[^>]*\bhref\s*=\s*['\"][^'\"]*javascript\s*:", re.I), "Link con href javascript:", 0.78),
+    (re.compile(r"\bwindow\.open\s*\(\s*['\"]*javascript\s*:", re.I), "window.open con javascript:", 0.82),
 ]
 
 # -------------------------------------------------
-# Campos que NO queremos analizar (contraseñas, tokens, etc.)
+# Campos sensibles: NO LOS IGNORAMOS COMPLETAMENTE, PERO LES DAMOS DESCUENTO EN SCORE
+# Para robustez, los analizamos pero reducimos el peso para evitar falsos positivos.
 # -------------------------------------------------
-IGNORED_FIELDS = getattr(settings, "XSS_DEFENSE_IGNORED_FIELDS", ["password", "csrfmiddlewaretoken", "token", "auth"])
+SENSITIVE_FIELDS = ["password", "csrfmiddlewaretoken", "token", "auth"]
+SENSITIVE_DISCOUNT = 0.5  # Multiplicador para campos sensibles
 
 # Umbral por defecto para considerar "alto riesgo" (Auditoria puede bloquear según su lógica)
 XSS_DEFENSE_THRESHOLD = getattr(settings, "XSS_DEFENSE_THRESHOLD", 0.6)
 
-
 # -------------------------------------------------
 # Util: validación / extracción de IP (robusta)
 # -------------------------------------------------
+
 def _is_valid_ip(ip: str) -> bool:
     """Verifica que la cadena sea una IP válida (v4 o v6)."""
     try:
@@ -117,7 +126,6 @@ def _is_valid_ip(ip: str) -> bool:
     except Exception:
         return False
 
-
 def get_client_ip(request) -> str:
     """
     Obtiene la mejor estimación de la IP del cliente:
@@ -143,7 +151,6 @@ def get_client_ip(request) -> str:
     remote = request.META.get("REMOTE_ADDR")
     return remote or ""
 
-
 # -------------------------------------------------
 # Extraer payload pero evitando cabeceras (para reducir falsos positivos)
 # - Devuelve dict si es JSON, o dict con 'raw' para otros cuerpos
@@ -185,15 +192,14 @@ def extract_body_as_map(request) -> Dict[str, Any]:
         pass
     return {}
 
-
 # -------------------------------------------------
 # Analizar un solo valor (string) en busca de XSS usando patrones
 # Devuelve (score, descripciones, matches_patterns)
 # -------------------------------------------------
-def detect_xss_in_value(value: str) -> Tuple[float, List[str], List[str]]:
+def detect_xss_in_value(value: str, is_sensitive: bool = False) -> Tuple[float, List[str], List[str]]:
     """
     Analiza una cadena y devuelve:
-      - score acumulado (sum pesos)
+      - score acumulado (sum pesos, con descuento si es campo sensible)
       - lista de descripciones activadas
       - lista de patrones (regex.pattern) que matchearon
     """
@@ -204,28 +210,26 @@ def detect_xss_in_value(value: str) -> Tuple[float, List[str], List[str]]:
     descripcion = []
     matches = []
 
-    # Si bleach está disponible, podemos "limpiar" y comparar; pero aquí solo detectamos
+    # Si bleach está disponible, sanitizar y comparar para detección adicional
+    if _BLEACH_AVAILABLE:
+        cleaned = bleach.clean(value, strip=True)
+        if cleaned != value:
+            score_total += 0.5  # Penalización por cambios en sanitización
+            descripcion.append("Contenido alterado por sanitización (bleach)")
+
     for patt, msg, weight in XSS_PATTERNS:
         if patt.search(value):
-            score_total += weight
+            adjusted_weight = weight * SENSITIVE_DISCOUNT if is_sensitive else weight
+            score_total += adjusted_weight
             descripcion.append(msg)
             matches.append(patt.pattern)
 
     return round(score_total, 3), descripcion, matches
 
-
 # -------------------------------------------------
-# Middleware principal XSS
+# Middleware principal XSS - MEJORADO PARA ROBUSTEZ
 # -------------------------------------------------
 class XSSDefenseMiddleware(MiddlewareMixin):
-    """
-    Middleware para detección XSS.
-    - Analiza el body (campo por campo) y querystring si aplica.
-    - Ignora campos sensibles (password, token).
-    - No incluye User-Agent/Referer en el texto analizado (evita falsos positivos).
-    - Añade request.xss_attack_info con: ip, tipos, descripcion, payload, score, url.
-    """
-
     def process_request(self, request):
         # 1) IP y exclusiones
         client_ip = get_client_ip(request)
@@ -251,15 +255,12 @@ class XSSDefenseMiddleware(MiddlewareMixin):
         total_score = 0.0
         all_descriptions: List[str] = []
         all_matches: List[str] = []
-        # payload_for_storage: guardamos un resumen/truncado para auditoría
         payload_summary = []
 
-        # 3) Analizar campo por campo (si es dict) o el raw
+        # 3) Analizar campo por campo (si es dict) o el raw - AHORA ANALIZA TODO, CON DESCUENTO PARA SENSIBLES
         if isinstance(data, dict):
             for key, value in data.items():
-                # evitar analizar campos sensibles
-                if isinstance(key, str) and key.lower() in [f.lower() for f in IGNORED_FIELDS]:
-                    continue
+                is_sensitive = isinstance(key, str) and key.lower() in SENSITIVE_FIELDS
 
                 # convertir a string si es otro tipo (list, int...)
                 if isinstance(value, (dict, list)):
@@ -270,20 +271,13 @@ class XSSDefenseMiddleware(MiddlewareMixin):
                 else:
                     vtext = str(value or "")
 
-                # salto rápido: si el valor parece ser un email o password muy corto y sin signos,
-                # las probabilidades de XSS son muy bajas; continúa (reduce falsos positivos).
-                if key.lower() in ("email", "username") and len(vtext) < 256:
-                    # aún así pasar por patrones (no lo ignoramos completamente), pero podemos bajar sensibilidad
-                    pass
-
-                s, descs, matches = detect_xss_in_value(vtext)
+                s, descs, matches = detect_xss_in_value(vtext, is_sensitive)
                 total_score += s
                 all_descriptions.extend(descs)
                 all_matches.extend(matches)
 
                 if s > 0:
-                    # almacenar fragmento del campo para auditoría (truncado)
-                    payload_summary.append({ "field": key, "snippet": vtext[:300] })
+                    payload_summary.append({"field": key, "snippet": vtext[:300], "sensitive": is_sensitive})
 
         else:
             # si no es dict, analizar el raw como texto
@@ -293,7 +287,7 @@ class XSSDefenseMiddleware(MiddlewareMixin):
             all_descriptions.extend(descs)
             all_matches.extend(matches)
             if s > 0:
-                payload_summary.append({"field":"raw","snippet": raw[:500]})
+                payload_summary.append({"field": "raw", "snippet": raw[:500], "sensitive": False})
 
         # 4) si no detectó nada, continuar
         if total_score == 0:
@@ -305,7 +299,7 @@ class XSSDefenseMiddleware(MiddlewareMixin):
         payload_for_request = json.dumps(payload_summary, ensure_ascii=False)[:2000]
 
         logger.warning(
-            "XSS detectado desde IP %s URL=%s Score=%.3f Desc=%s",
+            "XSS detectado desde IP %s URL=%s Score=%.3f Desc=%s (Robust: incluye sensibles con descuento)",
             client_ip,
             url,
             score_rounded,
@@ -320,8 +314,7 @@ class XSSDefenseMiddleware(MiddlewareMixin):
             "payload": payload_for_request,
             "score": score_rounded,
             "url": url,
-        }
-
+        }    
         # 7) NO bloquear aquí — lo hace AuditoriaMiddleware según su política
         return None
 

guardianunivalle_benito_yucra-0.1.71.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: GuardianUnivalle-Benito-Yucra
+Version: 0.1.71
+Summary: Middleware y detectores de seguridad (SQLi, XSS, CSRF, DoS) para Django/Flask
+Author-email: Andres Benito Calle Yucra <benitoandrescalle035@gmail.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/guardianunivalle-benito-yucra/
+Project-URL: Bug_Tracker, https://github.com/Andyyupy/guardianunivalle-benito-yucra/issues
+Keywords: security,django,flask,sqli,xss,csrf,middleware
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Django
+Classifier: Framework :: Flask
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis>=4.0
+Requires-Dist: django>=3.2
+Dynamic: license-file
+
+<!-- Información de la librería -->
+<table align="center" style="width: 100%; text-align: center; border-collapse: collapse; background-color: #f4f4f9; border-radius: 15px; box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1); padding: 20px;">
+  <tr>
+    <td style="border: none; padding: 10px 20px;">
+      <img src="https://res.cloudinary.com/dsbgmboh1/image/upload/v1761866594/Andres_Benito_Calle_Yucra_nxyqee.png"
+           alt="Univalle Logo" width="300" 
+           style="transition: transform 0.3s ease-in-out;" 
+           onmouseover="this.style.transform='scale(1.1)'" 
+           onmouseout="this.style.transform='scale(1)'">
+    </td>
+    <td style="border: none; padding: 10px 20px; text-align: center;">
+      <h1 style="font-size: 50px; margin: 0; color: #c62828; font-family: 'Arial', sans-serif; text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);">
+        Guardian Univalle Benito Yucra
+      </h1>
+      <p style="margin: 5px 0 0 0; font-size: 18px; color: #444; font-family: 'Segoe UI', sans-serif;">
+        Framework de detección y defensa de amenazas web para Django.
+      </p>
+    </td>
+    <td style="border: none; padding: 10px 20px;">
+      <img src="https://res.cloudinary.com/dsbgmboh1/image/upload/v1761864884/GuardianUnivalle_imeegq.png" 
+           alt="Django Logo" width="300" 
+           style="transition: transform 0.3s ease-in-out;" 
+           onmouseover="this.style.transform='scale(1.1)'" 
+           onmouseout="this.style.transform='scale(1)'">
+    </td>
+  </tr>
+</table>
+
+
+`Guardian Univalle` es un sistema de seguridad modular desarrollado para fortalecer aplicaciones Django frente a ataques web comunes como **XSS**, **CSRF**, **inyección SQL**, **ataques DoS** y **scraping automatizado**.  
+Cada módulo opera mediante **middlewares independientes** que analizan el tráfico HTTP en tiempo real, aplican heurísticas inteligentes y registran eventos sospechosos para auditoría y bloqueo adaptativo.
+
+---
+## Arquitectura general
+
+Guardian Univalle está diseñado bajo una **arquitectura modular y extensible**, donde cada tipo de amenaza se gestiona mediante un middleware especializado.  
+Cada middleware:
+
+- Se ejecuta en la fase inicial del request (`process_request`).
+- Analiza cabeceras, cuerpo y metadatos de la petición.
+- Evalúa indicadores de ataque según patrones heurísticos y reglas configurables.
+- Calcula una puntuación de riesgo (score) para cada evento.
+- Anexa la información al objeto `request` (por ejemplo, `request.xss_attack_info`) para que otros módulos (como el de auditoría) la procesen.
+
+---
+
+##  Módulos de defensa incluidos
+
+### 1. CSRFDefenseMiddleware
+**Defensa contra Cross-Site Request Forgery (CSRF)**
+
+Este módulo detecta intentos de falsificación de peticiones mediante:
+
+- Verificación de cabeceras **Origin** y **Referer** contra el host real.  
+- Validación de **tokens CSRF** en cookies, cabeceras o formularios.  
+- Análisis del **tipo de contenido** (`Content-Type`) y parámetros sensibles.  
+- Detección de peticiones JSON o formularios enviados desde dominios externos.  
+- Asignación de un **score de riesgo** proporcional al número y severidad de señales encontradas.  
+
+**Algoritmos utilizados:** heurísticas basadas en cabeceras HTTP, validación semántica de origen y detección de anomalías en métodos `POST`, `PUT`, `DELETE` y `PATCH`.
+
+---
+
+### 2. XSSDefenseMiddleware
+**Defensa contra Cross-Site Scripting (XSS)**
+
+Analiza los datos enviados en el cuerpo y querystring, detectando vectores de inyección HTML/JS mediante:
+
+- Patrones de alto riesgo (`<script>`, `javascript:`, `onload=`, `eval()`).
+- Ofuscaciones con entidades (`&#x3C;`, `%3Cscript`).
+- Detección de atributos de eventos (`onmouseover`, `onfocus`, etc.).
+- Análisis de URIs maliciosas (`data:text/html`, `vbscript:`).
+- Scoring ponderado por severidad (de 0.3 a 0.95).
+
+**Algoritmos utilizados:** expresiones regulares avanzadas con pesos heurísticos y uso opcional de la librería **Bleach** para sanitización comparativa.
+
+**Salida:** agrega `request.xss_attack_info` con los detalles de detección, IP de origen, descripción, payload y score total.
+
+---
+
+### 3. SQLIDefenseMiddleware
+**Defensa contra Inyección SQL (SQLi)**
+
+Identifica intentos de inyección SQL en parámetros enviados a través de:
+
+- Palabras clave peligrosas (`UNION`, `SELECT`, `DROP`, `INSERT`, `UPDATE`).
+- Uso de comentarios (`--`, `#`, `/* ... */`).
+- Concatenaciones o subconsultas sospechosas.
+- Comportamientos anómalos en parámetros GET, POST o JSON.
+
+**Algoritmos utilizados:** heurísticas sintácticas + patrones combinados con contextos.  
+Evalúa combinaciones de operadores y palabras reservadas para minimizar falsos positivos.
+
+**Resultado:** registra el intento en `request.sql_injection_info` con score calculado y parámetros comprometidos.
+
+---
+
+### 4. DOSDefenseMiddleware
+**Detección de ataques de Denegación de Servicio (DoS)**
+
+Monitorea la frecuencia de peticiones por IP y calcula una métrica adaptativa:
+
+- Detecta exceso de solicitudes en intervalos cortos.
+- Analiza `User-Agent`, patrones repetitivos y tamaño de payloads.
+- Aplica límites configurables (`MAX_REQUESTS_PER_WINDOW`).
+- Marca IPs sospechosas para registro y bloqueo temporal.
+
+**Algoritmos utilizados:** Sliding Window con conteo adaptativo, controlado por señales de frecuencia e intensidad.
+
+---
+
+### 5. ScrapingDefenseMiddleware (opcional)
+**Detección de scraping y bots automatizados**
+
+Evalúa características típicas de scraping:
+
+- User-Agent anómalo o ausente.  
+- Patrón de navegación repetitivo o excesivamente rápido.  
+- Ausencia de cabeceras humanas como `Accept-Language` o `Referer`.  
+- Combinación con heurísticas de DoS para detectar scrapers agresivos.
+
+**Algoritmos utilizados:** análisis estadístico de cabeceras + patrones de comportamiento a corto plazo.
+
+---
+
+## Integración y uso
+
+### Instalación
+
+```bash
+pip install guardian-univalle
+```
+### Configuración en settings.py
+
+```bash
+MIDDLEWARE = [
+    # Middlewares personalizados  
+    "GuardianUnivalle_Benito_Yucra.detectores.detector_dos.DOSDefenseMiddleware", 
+    "GuardianUnivalle_Benito_Yucra.detectores.detector_sql.SQLIDefenseMiddleware",
+    "GuardianUnivalle_Benito_Yucra.detectores.detector_xss.XSSDefenseMiddleware",
+    "GuardianUnivalle_Benito_Yucra.detectores.detector_csrf.CSRFDefenseMiddleware",
+    "users.middleware.AuditoriaMiddleware",
+    "users.auditoria_servidor.AuditoriaServidorMiddleware",
+]
+
+```
+
+```bash
+ALLOWED_HOSTS = [
+    "192.168.0.3",
+    "127.0.0.1",
+    "localhost",
+]
+
+```
+### Parámetros de defensa avanzada
+
+```bash
+# --- DoS Defense ---
+DOS_LIMITE_PETICIONES = 120 
+DOS_VENTANA_SEGUNDOS = 60
+DOS_PESO = 0.6
+DOS_LIMITE_ENDPOINTS = 80 
+DOS_TIEMPO_BLOQUEO = 300 
+DOS_TRUSTED_IPS = ["127.0.0.1", "192.168.0.3"]
+
+# Score total de bloqueo
+DOS_PESO_BLACKLIST = 0.3
+DOS_PESO_HEURISTICA = 0.1
+DOS_UMBRAL_BLOQUEO = 0.8
+
+# Configuración general
+DOS_DEFENSE_MAX_REQUESTS = 100
+DOS_DEFENSE_BLOCK_TIME = 300
+DOS_DEFENSE_TRUSTED_IPS = ["127.0.0.1", "192.168.0.3"]
+
+```
+
+```bash
+# --- SQL Injection Defense ---
+SQLI_DEFENSE_TRUSTED_IPS = ["127.0.0.1", "192.168.0.3"]
+
+# --- XSS Defense ---
+XSS_DEFENSE_TRUSTED_IPS = ["127.0.0.1", "192.168.0.3"]
+XSS_DEFENSE_SANITIZE_INPUT = False
+XSS_DEFENSE_BLOCK = True
+XSS_DEFENSE_EXCLUDED_PATHS = ["/health", "/internal"]
+
+# --- CSRF Defense ---
+CSRF_DEFENSE_TRUSTED_IPS = ["127.0.0.1", "192.168.0.3"]
+CSRF_DEFENSE_BLOCK = True
+CSRF_DEFENSE_LOG = True
+
+```
+### Auditoría y correlación de eventos
+```bash
+request.xss_attack_info = {
+    "ip": "192.168.1.10",
+    "tipos": ["XSS"],
+    "descripcion": ["Etiqueta <script> detectada"],
+    "payload": {"field": "comentario", "snippet": "<script>alert(1)</script>"},
+    "score": 0.92,
+    "url": "/comentarios/enviar/",
+}
+
+```
+### Filosofía del proyecto
+Guardian Univalle – Benito & Junkrat busca proporcionar una capa de defensa proactiva para entornos Django universitarios y empresariales, combinando:
+
+#Detección heurística.
+
+#Análisis semántico de cabeceras y payloads.
+
+#Escalamiento de score basado en señales múltiples.
+
+Su diseño es didáctico y extensible, ideal tanto para proyectos reales como para enseñanza de ciberseguridad aplicada.
+---
+### Estructura del paquete
+```bash
+guardian_univalle/
+│
+├── detectores/
+│   ├── csrf_defense.py
+│   ├── xss_defense.py
+│   ├── sql_defense.py
+│   ├── dos_defense.py
+│   ├── scraping_defense.py
+│
+├── auditoria/
+│   └── auditoria_middleware.py
+│
+└── __init__.py
+
+```
+### Licencia 
+Este proyecto se distribuye bajo la licencia MIT, permitiendo libre uso y modificación con atribución.
+
+📘 Universidad Privada del Valle – Sede La Paz
+
+👨‍💻 Desarrollado por: Benito Yucra
+
+📅 Año: 2025

{guardianunivalle_benito_yucra-0.1.69.dist-info → guardianunivalle_benito_yucra-0.1.71.dist-info}/RECORD

@@ -4,16 +4,16 @@ GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py,sha256=NnKBOeRWkXV
 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=VASJJztJtKwYpjuEUXc-biHSVbIYXhwCzOPrLNXu3qY,7832
+GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py,sha256=cVc5-rIwgOuFkov1tHtUR2PnyFdF3Ns6RvJMq4hkuOU,12486
 GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=Jy4fhI-6n9wQR0quzpondcUyCA2447lDq4fmOFeM1jA,14989
-GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=toYXgxLo1Wy_QCnqcboD7_qYbgudPtP4kEzci7GoDkA,12089
-GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=Cirjf1fo0j-wOO2baG8GFehAvjPy5JUF9krUg5AtofU,14452
+GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=9UZFr68WqzZ7LxouY-4fPkzNWJGcrrB8HDEKUqwP_KQ,14765
+GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=azK7pTnO7fxcClEEDoLVBdvWF-hQAvM5KElg9O6Ohkc,14963
 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.69.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
-guardianunivalle_benito_yucra-0.1.69.dist-info/METADATA,sha256=EnImanXF-rGOrfmdT8Cl7APWzSVHbppYJMIXLJMAWiY,7534
-guardianunivalle_benito_yucra-0.1.69.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guardianunivalle_benito_yucra-0.1.69.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
-guardianunivalle_benito_yucra-0.1.69.dist-info/RECORD,,
+guardianunivalle_benito_yucra-0.1.71.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
+guardianunivalle_benito_yucra-0.1.71.dist-info/METADATA,sha256=62MKAtQZZ5gi7qyui4-rDZ5sLXyHaS12MvmLWnWBZlQ,9984
+guardianunivalle_benito_yucra-0.1.71.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guardianunivalle_benito_yucra-0.1.71.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
+guardianunivalle_benito_yucra-0.1.71.dist-info/RECORD,,

guardianunivalle_benito_yucra-0.1.69.dist-info/METADATA

@@ -1,192 +0,0 @@
-Metadata-Version: 2.4
-Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.69
-Summary: Middleware y detectores de seguridad (SQLi, XSS, CSRF, DoS) para Django/Flask
-Author-email: Andres Benito Calle Yucra <benitoandrescalle035@gmail.com>
-License: MIT
-Project-URL: Homepage, https://pypi.org/project/guardianunivalle-benito-yucra/
-Project-URL: Bug_Tracker, https://github.com/Andyyupy/guardianunivalle-benito-yucra/issues
-Keywords: security,django,flask,sqli,xss,csrf,middleware
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Security
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Framework :: Django
-Classifier: Framework :: Flask
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: redis>=4.0
-Requires-Dist: django>=3.2
-Dynamic: license-file
-
-<!-- Información de la librería -->
-
-# 🛡️ Guardian Univalle – Benito & Junkrat
-
-Framework de detección y defensa de amenazas web para Django y Flask
-
-Guardian Univalle es un sistema de seguridad modular desarrollado para fortalecer aplicaciones Django frente a ataques web comunes como XSS, CSRF, inyección SQL, ataques DoS y scraping automatizado.
-Cada módulo opera mediante middleware independientes que analizan el tráfico HTTP en tiempo real, aplican heurísticas inteligentes y registran eventos sospechosos para auditoría y bloqueo adaptativo.
-
-⚙️ Arquitectura general
-
-Guardian Univalle está diseñado bajo una arquitectura modular y extensible, donde cada tipo de amenaza se gestiona mediante un middleware especializado.
-Cada middleware:
-
-- Se ejecuta en la fase inicial del request (process_request).
-- Analiza cabeceras, cuerpo y metadatos de la petición.
-- Evalúa indicadores de ataque según patrones heurísticos y reglas configurables.
-- Calcula una puntuación de riesgo (score) para cada evento.
-- Anexa la información al objeto request (por ejemplo, request.xss_attack_info) para que otros módulos (como el de auditoría) la procesen.
-
-🧩 Módulos de defensa incluidos
-
-1. 🔐 CSRFDefenseMiddleware
-
-Defensa contra Cross-Site Request Forgery (CSRF).
-
-Este módulo detecta intentos de falsificación de peticiones mediante:
-
-- Verificación de cabeceras Origin y Referer contra el host real.
-- Validación de tokens CSRF en cookies, cabeceras o formularios.
-- Análisis del tipo de contenido (Content-Type) y parámetros sensibles.
-- Detección de peticiones JSON o formularios enviados desde dominios externos.
-- Asignación de un score de riesgo proporcional al número y severidad de señales encontradas.
-
-Algoritmos utilizados:
-Heurísticas basadas en cabeceras HTTP, validación semántica de origen, y detección de anomalías en métodos POST, PUT, DELETE y PATCH.
-
-2. 🧬 XSSDefenseMiddleware
-
-Defensa contra Cross-Site Scripting (XSS).
-
-Analiza en profundidad los datos enviados en el cuerpo y querystring, detectando vectores de inyección HTML/JS mediante:
-
-- Patrones de alto riesgo (<script>, javascript:, onload=, eval()).
-- Ofuscaciones con entidades (&#x3C;, %3Cscript).
-- Detección de atributos de eventos (onmouseover, onfocus, etc.).
-- Análisis de URIs maliciosas (data:text/html, vbscript:).
-- Scoring ponderado por severidad (de 0.3 a 0.95).
-
-Algoritmos utilizados:
-Detección basada en expresiones regulares avanzadas con pesos heurísticos y uso opcional de la librería Bleach para sanitización comparativa.
-
-Salida:
-Agrega request.xss_attack_info con los detalles de detección, la IP de origen, descripción, payload y score total.
-
-3. 💾 SQLIDefenseMiddleware
-
-Defensa contra Inyección SQL (SQLi).
-
-Identifica intentos de inyección SQL en los parámetros enviados a través de:
-
-- Palabras clave peligrosas (UNION, SELECT, DROP, INSERT, UPDATE).
-- Uso de comentarios (--, #, /_ ... _/).
-- Concatenaciones o subconsultas sospechosas.
-- Comportamientos anómalos en parámetros GET, POST o JSON.
-
-Algoritmos utilizados:
-Heurísticas sintácticas + patrones combinados con contextos.
-Evalúa combinaciones de operadores y palabras reservadas para minimizar falsos positivos.
-
-Resultado:
-Registra el intento en request.sql_injection_info con score calculado y parámetros comprometidos.
-
-4. 🌐 DOSDefenseMiddleware
-
-Detección de ataques de Denegación de Servicio (DoS).
-
-Monitorea la frecuencia de peticiones por IP y calcula una métrica adaptativa de comportamiento:
-
-- Detecta exceso de solicitudes en intervalos cortos.
-- Analiza User-Agent, patrones repetitivos y tamaño de payloads.
-- Aplica límites configurables (MAX_REQUESTS_PER_WINDOW).
-- Marca IPs sospechosas para registro y bloqueo temporal.
-
-Algoritmos utilizados:
-Sliding Window con conteo adaptativo en memoria, controlado por señales de frecuencia e intensidad.
-
-5. 🕷️ ScrapingDefenseMiddleware (opcional)
-
-Detección de scraping y bots automatizados.
-
-Evalúa características típicas de scraping:
-
-- User-Agent anómalo o ausente.
-- Patrón de navegación repetitivo o excesivamente rápido.
-- Ausencia de cabeceras humanas (como Accept-Language o Referer).
-- Combinación con heurísticas de DoS para detectar scrapers agresivos.
-
-Algoritmos utilizados:
-Análisis estadístico de cabeceras + patrones de comportamiento a corto plazo.
-
-🧠 Integración y uso
-
-Instalar la librería:
-
-pip install guardian-univalle
-
-En tu archivo settings.py de Django, añadir los middlewares:
-
-MIDDLEWARE = [
-"guardian_univalle.detectores.csrf_defense.CSRFDefenseMiddleware",
-"guardian_univalle.detectores.xss_defense.XSSDefenseMiddleware",
-"guardian_univalle.detectores.sql_defense.SQLIDefenseMiddleware",
-"guardian_univalle.detectores.dos_defense.DOSDefenseMiddleware",
-"guardian_univalle.detectores.scraping_defense.ScrapingDefenseMiddleware", # opcional
-]
-
-(Opcional) Configurar umbrales en settings.py:
-
-XSS_DEFENSE_THRESHOLD = 0.6
-CSRF_DEFENSE_MIN_SIGNALS = 1
-DOS_DEFENSE_MAX_REQUESTS = 100
-SQLI_DEFENSE_THRESHOLD = 0.5
-
-🧾 Auditoría y correlación de eventos
-
-Cada middleware genera un diccionario con detalles de detección:
-
-request.xss_attack_info = {
-"ip": "192.168.1.10",
-"tipos": ["XSS"],
-"descripcion": ["Etiqueta <script> detectada"],
-"payload": "{'field': 'comentario', 'snippet': '<script>alert(1)</script>'}",
-"score": 0.92,
-"url": "/comentarios/enviar/",
-}
-
-Estos datos pueden ser almacenados por un AuditoriaMiddleware o enviados a un sistema SIEM para correlación y respuesta automatizada.
-
-🧩 Filosofía del proyecto
-
-Guardian Univalle – Benito & Junkrat busca proporcionar una capa de defensa proactiva para entornos Django universitarios y empresariales, combinando:
-
-Detección heurística,
-
-Análisis semántico de cabeceras y payloads, y
-
-Escalamiento de score basado en señales múltiples.
-
-Su diseño es didáctico y extensible, ideal tanto para proyectos reales como para enseñanza de ciberseguridad aplicada.
-
-🧱 Estructura del paquete
-guardian_univalle/
-│
-├── detectores/
-│ ├── csrf_defense.py
-│ ├── xss_defense.py
-│ ├── sql_defense.py
-│ ├── dos_defense.py
-│ ├── scraping_defense.py
-│
-├── auditoria/
-│ └── auditoria_middleware.py
-│
-└── **init**.py
-
-🧾 Licencia
-
-Este proyecto se distribuye bajo la licencia MIT, permitiendo libre uso y modificación con atribución.