GuardianUnivalle-Benito-Yucra 0.1.50__tar.gz → 0.1.52__tar.gz

guardianunivalle_benito_yucra-0.1.52/GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

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

{guardianunivalle_benito_yucra-0.1.50 → guardianunivalle_benito_yucra-0.1.52}/GuardianUnivalle_Benito_Yucra.egg-info/PKG-INFO

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

@@ -9,20 +9,12 @@ GuardianUnivalle_Benito_Yucra.egg-info/SOURCES.txt
 GuardianUnivalle_Benito_Yucra.egg-info/dependency_links.txt
 GuardianUnivalle_Benito_Yucra.egg-info/requires.txt
 GuardianUnivalle_Benito_Yucra.egg-info/top_level.txt
-GuardianUnivalle_Benito_Yucra/auditoria/auditoria_servidor.py
 GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py
-GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py
-GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py
-GuardianUnivalle_Benito_Yucra/criptografia/kdf.py
 GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py
 GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py
 GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py
 GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py
 GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py
-GuardianUnivalle_Benito_Yucra/middleware_web/middleware_web.py
-GuardianUnivalle_Benito_Yucra/mitigacion/limitador_peticion.py
-GuardianUnivalle_Benito_Yucra/mitigacion/lista_bloqueo.py
-GuardianUnivalle_Benito_Yucra/puntuacion/puntuacion_amenaza.py
 guardianunivalle_benito_yucra.egg-info/PKG-INFO
 guardianunivalle_benito_yucra.egg-info/SOURCES.txt
 guardianunivalle_benito_yucra.egg-info/dependency_links.txt

{guardianunivalle_benito_yucra-0.1.50 → guardianunivalle_benito_yucra-0.1.52}/PKG-INFO

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

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/auditoria/auditoria_servidor.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/criptografia/kdf.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

@@ -1,226 +0,0 @@
-from __future__ import annotations
-import time
-import logging
-import json
-from collections import deque
-from typing import Dict, List
-from django.conf import settings
-from django.utils.deprecation import MiddlewareMixin
-from ..mitigacion.limitador_peticion import limitar_peticion
-from ..auditoria.registro_auditoria import registrar_evento
-
-# =====================================================
-# === 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)
-LIMITE_ENDPOINTS_DISTINTOS = getattr(settings, "DOS_LIMITE_ENDPOINTS", 50)
-TRUSTED_IPS = getattr(settings, "DOS_TRUSTED_IPS", [])
-
-# =====================================================
-# === REGISTRO TEMPORAL EN MEMORIA ===
-# =====================================================
-# Estructura: { ip: deque([timestamps]), ... }
-# deque es eficiente para ventanas deslizantes
-REGISTRO_SOLICITUDES: Dict[str, deque] = {}
-REGISTRO_ENDPOINTS: Dict[str, set] = {}
-
-# =====================================================
-# === 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", "") or "0.0.0.0"
-
-
-def limpiar_registro_global():
-    """Elimina IPs sin actividad reciente para evitar uso excesivo de memoria."""
-    ahora = time.time()
-    expiracion = VENTANA_SEGUNDOS * 2  # doble ventana
-    inactivas = [
-        ip for ip, tiempos in REGISTRO_SOLICITUDES.items()
-        if tiempos and ahora - tiempos[-1] > expiracion
-    ]
-    for ip in inactivas:
-        REGISTRO_SOLICITUDES.pop(ip, None)
-        REGISTRO_ENDPOINTS.pop(ip, None)
-
-
-def limpiar_registro(ip: str):
-    """Limpia peticiones antiguas fuera de la ventana de tiempo."""
-    ahora = time.time()
-    if ip not in REGISTRO_SOLICITUDES:
-        REGISTRO_SOLICITUDES[ip] = deque()
-    tiempos = REGISTRO_SOLICITUDES[ip]
-    while tiempos and ahora - tiempos[0] > VENTANA_SEGUNDOS:
-        tiempos.popleft()
-
-
-def calcular_nivel_amenaza_dos(tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> float:
-    """
-    Calcula la puntuación de amenaza DoS.
-    Fórmula: S_dos = w_dos * (tasa_peticion / limite)
-    """
-    proporcion = tasa_peticion / max(limite, 1)
-    s_dos = PESO_DOS * min(proporcion, 2.0)
-    return round(min(s_dos, 1.0), 3)
-
-
-def detectar_dos(ip: str, tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> bool:
-    """Evalúa si la tasa de peticiones excede el umbral permitido."""
-    if tasa_peticion > limite:
-        registrar_evento(
-            tipo="DoS",
-            descripcion=f"Alta tasa de peticiones desde {ip}: {tasa_peticion} req/min (límite {limite})",
-            severidad="ALTA",
-        )
-        limitar_peticion(usuario_id="anonimo")
-        return True
-    elif tasa_peticion > limite * 0.75:
-        # Umbral de advertencia
-        registrar_evento(
-            tipo="DoS",
-            descripcion=f"Posible saturación desde {ip}: {tasa_peticion} req/min",
-            severidad="MEDIA",
-        )
-    return False
-
-
-def analizar_headers(user_agent: str, referer: str) -> List[str]:
-    """Detecta patrones de agentes o cabeceras sospechosas."""
-    sospechas = []
-    if not user_agent or len(user_agent) < 10:
-        sospechas.append("User-Agent vacío o anómalo")
-    if "curl" in user_agent.lower() or "python" in user_agent.lower():
-        sospechas.append("User-Agent indica script o bot")
-    if referer and any(palabra in referer.lower() for palabra in ["attack", "scan", "bot"]):
-        sospechas.append("Referer sospechoso")
-    return sospechas
-
-
-# =====================================================
-# === MIDDLEWARE PRINCIPAL DE DEFENSA DoS ===
-# =====================================================
-class DOSDefenseMiddleware(MiddlewareMixin):
-    """
-    Middleware de detección y registro de ataques DoS.
-    """
-
-    def process_request(self, request):
-        limpiar_registro_global()
-
-        client_ip = get_client_ip(request)
-        if client_ip in TRUSTED_IPS:
-            return None
-
-        user_agent = request.META.get("HTTP_USER_AGENT", "Desconocido")
-        referer = request.META.get("HTTP_REFERER", "")
-        path = request.path
-
-        # Registrar endpoint accedido
-        REGISTRO_ENDPOINTS.setdefault(client_ip, set()).add(path)
-
-        # Mantener ventana deslizante
-        limpiar_registro(client_ip)
-        REGISTRO_SOLICITUDES[client_ip].append(time.time())
-
-        tasa = len(REGISTRO_SOLICITUDES[client_ip])
-        nivel = calcular_nivel_amenaza_dos(tasa)
-        es_dos = detectar_dos(client_ip, tasa)
-
-        descripcion = []
-        sospechas_headers = analizar_headers(user_agent, referer)
-        if sospechas_headers:
-            descripcion.extend(sospechas_headers)
-
-        # Verificar exceso de endpoints distintos (indicativo de escaneo)
-        if len(REGISTRO_ENDPOINTS[client_ip]) > LIMITE_ENDPOINTS_DISTINTOS:
-            descripcion.append("Número anormal de endpoints distintos accedidos")
-
-        if es_dos or descripcion:
-            descripcion.insert(0, f"Tasa actual: {tasa} req/min (nivel {nivel:.2f})")
-            descripcion.append(f"Ruta: {path}")
-
-            logger.warning(
-                "DoS detectado o sospechoso desde IP %s: %s ; nivel: %.2f",
-                client_ip,
-                descripcion,
-                nivel,
-            )
-
-            request.dos_attack_info = {
-                "ip": client_ip,
-                "tipos": ["DoS"],
-                "descripcion": descripcion,
-                "payload": json.dumps(
-                    {"user_agent": user_agent, "referer": referer, "path": path}
-                ),
-                "score": nivel,
-            }
-
-        return None
-
-
-"""
-Detector de ataques de tipo DoS (Denial of Service)
-====================================================
-
-Este módulo forma parte del sistema de detección de amenazas.
-Detecta tasas de petición anómalas en base a límites configurables,
-captura datos del atacante (IP, agente, cabeceras)
-y registra los incidentes para su auditoría.
-
-Componentes:
-- DOSDefenseMiddleware: Middleware principal de detección.
-- detectar_dos(): Evalúa si la tasa supera el umbral permitido.
-- calcular_nivel_amenaza_dos(): Calcula la severidad proporcional.
-- registrar_evento(): Registra los incidentes en auditoría.
-
-Algoritmos relacionados:
-    * Rate Limiting basado en ventana deslizante.
-    * Cálculo de score: S_dos = w_dos * (tasa_peticion / limite)
-"""
-
-
-""" 
-Algoritmos relacionados:
-    *Rate Limiting, listas de bloqueo.
-    *Opcional: cifrado de logs con ChaCha20-Poly1305.
-Contribución a fórmula de amenaza S:
-S_dos = w_dos * (tasa_peticion / limite)
-S_dos = 0.6 * (150 / 100)
-donde w_dos es peso asignado a DoS y tasa_peticion / limite es la proporción de la tasa actual sobre el límite.
-"""
-"""
-Detector de ataques de tipo DoS (Denial of Service)
-====================================================
-
-Este módulo forma parte del sistema de detección de amenazas.
-Detecta tasas de petición anómalas en base a límites configurables,
-captura datos del atacante (IP, agente, cabeceras)
-y registra los incidentes para su auditoría.
-
-Componentes:
-- DOSDefenseMiddleware: Middleware principal de detección.
-- detectar_dos(): Evalúa si la tasa supera el umbral permitido.
-- calcular_nivel_amenaza_dos(): Calcula la severidad proporcional.
-- registrar_evento(): Registra los incidentes en auditoría.
-
-Algoritmos relacionados:
-    * Rate Limiting basado en ventana deslizante.
-    * Cálculo de score: S_dos = w_dos * (tasa_peticion / limite)
-"""

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/middleware_web/middleware_web.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/mitigacion/limitador_peticion.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/mitigacion/lista_bloqueo.py

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

guardianunivalle_benito_yucra-0.1.50/GuardianUnivalle_Benito_Yucra/puntuacion/puntuacion_amenaza.py

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