GuardianUnivalle-Benito-Yucra 0.1.43__py3-none-any.whl → 0.1.44__py3-none-any.whl

GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py

@@ -1,15 +1,3 @@
-"""
-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
@@ -31,7 +19,6 @@ if not logger.handlers:
     handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
     logger.addHandler(handler)
 
-
 # ======================================================
 # === FUNCIONES AUXILIARES DE TOKEN CSRF ===
 # ======================================================
@@ -39,14 +26,12 @@ def registrar_evento(tipo: str, mensaje: str):
     """Registra eventos importantes en los logs."""
     logger.warning(f"[{tipo}] {mensaje}")
 
-
 def generar_token_csrf() -> str:
     """Genera un token CSRF seguro."""
     token = secrets.token_hex(32)
     registrar_evento("CSRF", "Token CSRF generado")
     return token
 
-
 def validar_token_csrf(token: str, token_sesion: str) -> bool:
     """Valida que el token recibido coincida con el token en sesión."""
     valido = token == token_sesion
@@ -54,35 +39,32 @@ def validar_token_csrf(token: str, token_sesion: str) -> bool:
         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_HEADER_NAMES = ("HTTP_X_CSRFTOKEN", "HTTP_X_CSRF_TOKEN")
 CSRF_COOKIE_NAME = getattr(settings, "CSRF_COOKIE_NAME", "csrftoken")
 POST_FIELD_NAME = "csrfmiddlewaretoken"
 
+# Content-Type realmente sospechosos
 SUSPICIOUS_CT_PATTERNS = [
-    re.compile(r"application/x-www-form-urlencoded", re.I),
-    re.compile(r"multipart/form-data", re.I),
+    re.compile(r"text/plain", re.I),
+    re.compile(r"application/json", re.I),
 ]
 
-
 # ======================================================
 # === FUNCIONES DE APOYO ===
 # ======================================================
 def get_client_ip(request):
+    """Obtiene la IP real del cliente."""
     x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
     if x_forwarded_for:
         return x_forwarded_for.split(",")[0].strip()
     return request.META.get("REMOTE_ADDR", "")
 
-
 def host_from_header(header_value: str) -> str | None:
+    """Extrae el host limpio desde una cabecera."""
     if not header_value:
         return None
     try:
@@ -93,7 +75,6 @@ def host_from_header(header_value: str) -> str | None:
     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")
@@ -107,6 +88,11 @@ def origin_matches_host(request) -> bool:
     origin_host = host_from_header(origin)
     referer_host = host_from_header(referer)
 
+    # Detectar valores con scripts o URLs maliciosas
+    if any(re.search(r"(javascript:|<script|data:text/html)", h or "", re.I)
+           for h in [origin, referer]):
+        return False
+
     if origin_host and origin_host == host:
         return True
     if referer_host and referer_host == host:
@@ -116,9 +102,8 @@ def origin_matches_host(request) -> bool:
 
     return False
 
-
 def has_csrf_token(request) -> bool:
-    """Comprueba si hay signos de token CSRF presente."""
+    """Comprueba si hay un token CSRF presente."""
     for h in CSRF_HEADER_NAMES:
         if request.META.get(h):
             return True
@@ -136,9 +121,8 @@ def has_csrf_token(request) -> bool:
 
     return False
 
-
 def extract_payload_text(request) -> str:
-    """Extrae contenido útil de la solicitud para análisis."""
+    """Extrae el cuerpo útil de la solicitud."""
     parts: List[str] = []
     try:
         body = request.body.decode("utf-8", errors="ignore")
@@ -153,15 +137,14 @@ def extract_payload_text(request) -> str:
     parts.append(request.META.get("HTTP_REFERER", ""))
     return " ".join([p for p in parts if p])
 
-
 # ======================================================
 # === MIDDLEWARE DE DEFENSA CSRF ===
 # ======================================================
 class CSRFDefenseMiddleware(MiddlewareMixin):
     """
     Middleware para DETECTAR intentos de CSRF:
-    - Marca request.sql_attack_info con 'tipos': ['CSRF'] y 'descripcion' con razones.
-    - No bloquea la petición directamente, permite que AuditoriaMiddleware lo maneje.
+    - Registra request.csrf_attack_info con 'tipos': ['CSRF'] y 'descripcion' con las razones.
+    - No bloquea directamente: deja que AuditoriaMiddleware lo maneje.
     """
 
     def process_request(self, request):
@@ -187,9 +170,7 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
 
         # 2) Origin/Referer no coinciden
         if not origin_matches_host(request):
-            descripcion.append(
-                "Origin/Referer no coinciden con Host (posible cross-site)"
-            )
+            descripcion.append("Origin/Referer no coinciden con Host (posible cross-site)")
 
         # 3) Content-Type sospechoso
         content_type = request.META.get("CONTENT_TYPE", "") or ""
@@ -198,12 +179,12 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
                 descripcion.append(f"Content-Type sospechoso: {content_type}")
                 break
 
-        # 4) Referer ausente
+        # 4) Referer ausente y sin token
         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
+        # === Registro del ataque detectado ===
         if descripcion:
             w_csrf = getattr(settings, "CSRF_DEFENSE_WEIGHT", 0.2)
             intentos_csrf = len(descripcion)
@@ -219,14 +200,26 @@ class CSRFDefenseMiddleware(MiddlewareMixin):
 
             logger.warning(
                 "CSRF detectado desde IP %s: %s ; payload: %.200s ; score: %.2f",
-                client_ip,
-                descripcion,
-                payload,
-                s_csrf,
+                client_ip, descripcion, payload, s_csrf,
             )
 
         return None
 
+"""
+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).
+    * Integración con detección XSS/SQL Injection mediante registro unificado.
+    
+Fórmula de amenaza:
+    S_csrf = w_csrf * intentos_csrf
+    S_csrf = 0.2 * 1
+"""
+
 
 """ 
 Algoritmos relacionados:

GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py

@@ -1,15 +1,16 @@
 # xss_defense.py
+# GuardianUnivalle_Benito_Yucra/detectores/xss_defense.py
 from __future__ import annotations
 import json
 import logging
 import re
-from typing import List, Tuple
+from typing import List, Tuple, Any, Dict
 from django.conf import settings
 from django.utils.deprecation import MiddlewareMixin
 
-# =====================================================
-# ===               CONFIGURACIÓN LOGGER             ===
-# =====================================================
+# -------------------------------------------------
+# Logger
+# -------------------------------------------------
 logger = logging.getLogger("xssdefense")
 logger.setLevel(logging.INFO)
 if not logger.handlers:
@@ -17,172 +18,263 @@ if not logger.handlers:
     handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
     logger.addHandler(handler)
 
-# =====================================================
-# ===              INTENTAR CARGAR BLEACH            ===
-# =====================================================
+# -------------------------------------------------
+# Intentar usar bleach (si está instalado). Si no,
+# seguimos con heurísticos de patrones.
+# -------------------------------------------------
 try:
     import bleach
-
     _BLEACH_AVAILABLE = True
 except Exception:
     _BLEACH_AVAILABLE = False
 
-# =====================================================
-# ===           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 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"),
+# -------------------------------------------------
+# Patrones XSS con peso (descripcion, peso)
+# - pesos mayores = más severo (por ejemplo <script> o javascript:)
+# - esto permite un scoring acumulativo y menos falsos positivos
+# -------------------------------------------------
+XSS_PATTERNS: List[Tuple[re.Pattern, str, float]] = [
+    (re.compile(r"<\s*script\b", re.I), "Etiqueta <script>", 0.8),
+    (re.compile(r"javascript\s*:", re.I), "URI javascript:", 0.7),
+    (re.compile(r"<\s*iframe\b", re.I), "Etiqueta <iframe>", 0.7),
+    (re.compile(r"<\s*embed\b", re.I), "Etiqueta <embed>", 0.7),
+    (re.compile(r"<\s*object\b", re.I), "Etiqueta <object>", 0.7),
+    (re.compile(r"on\w+\s*=", re.I), "Atributo de evento (on*)", 0.5),
+    (re.compile(r"document\.cookie", re.I), "Acceso a document.cookie", 0.6),
+    (re.compile(r"alert\s*\(", re.I), "Uso de alert() potencial", 0.4),
+    # patrón para imágenes con onerror u onload (caso común)
+    (re.compile(r"<\s*img\b[^>]*on\w+\s*=", re.I), "Imagen con evento on*", 0.6),
 ]
 
+# -------------------------------------------------
+# Campos que NO queremos analizar (contraseñas, tokens, etc.)
+# -------------------------------------------------
+IGNORED_FIELDS = getattr(settings, "XSS_DEFENSE_IGNORED_FIELDS", ["password", "csrfmiddlewaretoken", "token", "auth"])
 
-# =====================================================
-# ===         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
+# 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)
 
-    for patt, message in XSS_PATTERNS:
-        if patt.search(text):
-            matches.append(message)
 
-    return len(matches) > 0, matches
+# -------------------------------------------------
+# 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:
+        import ipaddress
+        ipaddress.ip_address(ip)
+        return True
+    except Exception:
+        return False
 
 
-def sanitize_input_basic(text: str) -> str:
+def get_client_ip(request) -> str:
     """
-    Sanitiza una cadena eliminando etiquetas o caracteres peligrosos.
-    Usa bleach si está disponible, de lo contrario hace escape manual.
+    Obtiene la mejor estimación de la IP del cliente:
+    - Revisa X-Forwarded-For (primera IP no vacía).
+    - Luego X-Real-IP, CF-Connecting-IP.
+    - Finalmente REMOTE_ADDR como fallback.
     """
-    if text is None:
-        return text
-
-    if _BLEACH_AVAILABLE:
-        return bleach.clean(text, tags=[], attributes={}, protocols=[], strip=True)
-
-    replacements = [
-        ("&", "&amp;"),
-        ("<", "&lt;"),
-        (">", "&gt;"),
-        ('"', "&quot;"),
-        ("'", "&#x27;"),
-        ("/", "&#x2F;"),
-    ]
-    result = text
-    for old, new in replacements:
-        result = result.replace(old, new)
-    return result
-
-
-def extract_payload_text(request) -> str:
+    # Preferir X-Forwarded-For
+    xff = request.META.get("HTTP_X_FORWARDED_FOR")
+    if xff:
+        # "client, proxy1, proxy2" => tomar la primera no vacía
+        parts = [p.strip() for p in xff.split(",") if p.strip()]
+        if parts:
+            return parts[0]
+
+    # Otros encabezados comunes
+    for h in ("HTTP_X_REAL_IP", "HTTP_CF_CONNECTING_IP", "HTTP_CLIENT_IP"):
+        v = request.META.get(h)
+        if v and _is_valid_ip(v):
+            return v
+
+    # Fallback
+    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
+# - NO añade User-Agent o Referer al texto a analizar
+# -------------------------------------------------
+def extract_body_as_map(request) -> Dict[str, Any]:
     """
-    Extrae un texto combinado con información del cuerpo, querystring,
-    agente de usuario y referer para análisis XSS.
+    Extrae un diccionario con los datos a analizar:
+    - Si JSON: devuelve el dict JSON.
+    - Si form-data: devuelve request.POST.dict()
+    - Si otro: devuelve {'raw': <texto>}
     """
-    parts: List[str] = []
-
     try:
-        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))
+        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:
+                    # si el JSON no es un objeto (ej: lista), lo devolvemos como raw
+                    return {"raw": raw}
+            except Exception:
+                return {"raw": raw}
         else:
-            body_text = request.body.decode("utf-8", errors="ignore")
-            if body_text:
-                parts.append(body_text)
+            # FORM data (request.POST) u otros
+            try:
+                post = request.POST.dict()
+                if post:
+                    return post
+            except Exception:
+                pass
+            # fallback: cuerpo crudo
+            raw = request.body.decode("utf-8", errors="ignore")
+            if raw:
+                return {"raw": raw}
     except Exception:
         pass
+    return {}
 
-    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", ""))
+# -------------------------------------------------
+# 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]]:
+    """
+    Analiza una cadena y devuelve:
+      - score acumulado (sum pesos)
+      - lista de descripciones activadas
+      - lista de patrones (regex.pattern) que matchearon
+    """
+    if not value:
+        return 0.0, [], []
 
-    return " ".join([p for p in parts if p])
+    score_total = 0.0
+    descripcion = []
+    matches = []
 
+    # Si bleach está disponible, podemos "limpiar" y comparar; pero aquí solo detectamos
+    for patt, msg, weight in XSS_PATTERNS:
+        if patt.search(value):
+            score_total += weight
+            descripcion.append(msg)
+            matches.append(patt.pattern)
 
-# =====================================================
-# ===            MIDDLEWARE DE DEFENSA XSS           ===
-# =====================================================
+    return round(score_total, 3), descripcion, matches
+
+
+# -------------------------------------------------
+# Middleware principal XSS
+# -------------------------------------------------
 class XSSDefenseMiddleware(MiddlewareMixin):
     """
-    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).
+    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. Filtrar IPs de confianza
-        # ---------------------------------------------
+        # 1) IP y exclusiones
+        client_ip = get_client_ip(request)
         trusted_ips: List[str] = getattr(settings, "XSS_DEFENSE_TRUSTED_IPS", [])
-        client_ip = request.META.get("REMOTE_ADDR", "")
-        if client_ip in trusted_ips:
+        if client_ip and client_ip in trusted_ips:
             return None
 
-        # ---------------------------------------------
-        # 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 y analizar payload
-        # ---------------------------------------------
-        payload = extract_payload_text(request)
-        if not payload:
+        # 2) Extraer datos para analizar (dict)
+        data = extract_body_as_map(request)
+
+        # Incluir querystring (como campo separado) para análisis si existe
+        qs = request.META.get("QUERY_STRING", "")
+        if qs:
+            data["_query_string"] = qs
+
+        if not data:
             return None
 
-        flagged, matches = detect_xss_text(payload)
-        if not flagged:
+        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
+        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
+
+                # convertir a string si es otro tipo (list, int...)
+                if isinstance(value, (dict, list)):
+                    try:
+                        vtext = json.dumps(value, ensure_ascii=False)
+                    except Exception:
+                        vtext = str(value)
+                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)
+                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] })
+
+        else:
+            # si no es dict, analizar el raw como texto
+            raw = str(data)
+            s, descs, matches = detect_xss_in_value(raw)
+            total_score += s
+            all_descriptions.extend(descs)
+            all_matches.extend(matches)
+            if s > 0:
+                payload_summary.append({"field":"raw","snippet": raw[:500]})
+
+        # 4) si no detectó nada, continuar
+        if total_score == 0:
             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) construir info para auditoría (truncada)
+        url = request.build_absolute_uri()
+        score_rounded = round(total_score, 3)
+        payload_for_request = json.dumps(payload_summary, ensure_ascii=False)[:2000]
 
-        # ---------------------------------------------
-        # 5. Loggear y marcar en el request
-        # ---------------------------------------------
         logger.warning(
-            "XSS detectado desde IP %s: %s ; payload: %.200s ; score: %.2f",
+            "XSS detectado desde IP %s URL=%s Score=%.3f Desc=%s",
             client_ip,
-            matches,
-            payload,
-            s_xss,
+            url,
+            score_rounded,
+            all_descriptions,
         )
 
+        # 6) marcar en el request (AuditoriaMiddleware lo consumirá)
         request.xss_attack_info = {
             "ip": client_ip,
             "tipos": ["XSS"],
-            "descripcion": matches,
-            "payload": payload,
-            "score": s_xss,
+            "descripcion": all_descriptions,
+            "payload": payload_for_request,
+            "score": score_rounded,
+            "url": url,
         }
 
+        # 7) NO bloquear aquí — lo hace AuditoriaMiddleware según su política
         return None
 
-
 # =====================================================
 # ===              INFORMACIÓN EXTRA                ===
 # =====================================================

{guardianunivalle_benito_yucra-0.1.43.dist-info → guardianunivalle_benito_yucra-0.1.44.dist-info}/METADATA

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

@@ -4,17 +4,17 @@ 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=wt9LRMG9XK4eSSmW91tlGmsJWfyk445b8-n2oxlXlwo,7893
+GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py,sha256=tEFJTydl9gKcYQPxeQNSQ1WwoY_4oHvtDrhJROeH4E0,8109
 GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=l_JYCmRYpsXt1ZauNPF_wy5uGJhmunRbtJ_WKpC3Otc,6953
 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=Ipw1XXBd1-SsOOhhl9joQGduTq0GhSa61TRTyASF3XE,6795
+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.43.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
-guardianunivalle_benito_yucra-0.1.43.dist-info/METADATA,sha256=liLKkhHpRW9wdYFAD8zmbj86Gn6YIE1mSXjpPkhws_E,1893
-guardianunivalle_benito_yucra-0.1.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guardianunivalle_benito_yucra-0.1.43.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
-guardianunivalle_benito_yucra-0.1.43.dist-info/RECORD,,
+guardianunivalle_benito_yucra-0.1.44.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
+guardianunivalle_benito_yucra-0.1.44.dist-info/METADATA,sha256=8h01QKIbaxCdYkJ9wPEkmiIsRRDlIptoO_O_aWJkoaQ,1893
+guardianunivalle_benito_yucra-0.1.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guardianunivalle_benito_yucra-0.1.44.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
+guardianunivalle_benito_yucra-0.1.44.dist-info/RECORD,,