GuardianUnivalle-Benito-Yucra 0.1.29__tar.gz → 0.1.31__tar.gz

guardianunivalle_benito_yucra-0.1.31/GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py

@@ -0,0 +1,239 @@
+"""
+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
+import logging
+import re
+import json
+from typing import List
+from urllib.parse import urlparse
+from django.conf import settings
+from django.utils.deprecation import MiddlewareMixin
+
+# ======================================================
+# === CONFIGURACIÓN DE LOGGER ===
+# ======================================================
+logger = logging.getLogger("csrfdefense")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+
+
+# ======================================================
+# === FUNCIONES AUXILIARES DE TOKEN CSRF ===
+# ======================================================
+def registrar_evento(tipo: str, mensaje: str):
+    """Registra eventos importantes en los logs."""
+    logger.warning(f"[{tipo}] {mensaje}")
+
+
+def generar_token_csrf() -> str:
+    """Genera un token CSRF seguro."""
+    token = secrets.token_hex(32)
+    registrar_evento("CSRF", "Token CSRF generado")
+    return token
+
+
+def validar_token_csrf(token: str, token_sesion: str) -> bool:
+    """Valida que el token recibido coincida con el token en sesión."""
+    valido = token == token_sesion
+    if not valido:
+        registrar_evento("CSRF", "Intento de CSRF detectado (token no coincide)")
+    return valido
+
+
+# ======================================================
+# === CONSTANTES Y CONFIGURACIONES ===
+# ======================================================
+STATE_CHANGING_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
+CSRF_HEADER_NAMES = (
+    "HTTP_X_CSRFTOKEN",
+    "HTTP_X_CSRF_TOKEN",
+)
+CSRF_COOKIE_NAME = getattr(settings, "CSRF_COOKIE_NAME", "csrftoken")
+POST_FIELD_NAME = "csrfmiddlewaretoken"
+
+SUSPICIOUS_CT_PATTERNS = [
+    re.compile(r"application/x-www-form-urlencoded", re.I),
+    re.compile(r"multipart/form-data", re.I),
+]
+
+
+# ======================================================
+# === FUNCIONES DE APOYO ===
+# ======================================================
+def get_client_ip(request):
+    x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
+    if x_forwarded_for:
+        return x_forwarded_for.split(",")[0].strip()
+    return request.META.get("REMOTE_ADDR", "")
+
+
+def host_from_header(header_value: str) -> str | None:
+    if not header_value:
+        return None
+    try:
+        parsed = urlparse(header_value)
+        if parsed.netloc:
+            return parsed.netloc.split(":")[0]
+        return header_value.split(":")[0]
+    except Exception:
+        return None
+
+
+def origin_matches_host(request) -> bool:
+    """Verifica si Origin/Referer coinciden con Host."""
+    host_header = request.META.get("HTTP_HOST") or request.META.get("SERVER_NAME")
+    if not host_header:
+        return True
+
+    host = host_header.split(":")[0]
+    origin = request.META.get("HTTP_ORIGIN", "")
+    referer = request.META.get("HTTP_REFERER", "")
+
+    origin_host = host_from_header(origin)
+    referer_host = host_from_header(referer)
+
+    if origin_host and origin_host == host:
+        return True
+    if referer_host and referer_host == host:
+        return True
+    if not origin and not referer:
+        return True
+
+    return False
+
+
+def has_csrf_token(request) -> bool:
+    """Comprueba si hay signos de token CSRF presente."""
+    for h in CSRF_HEADER_NAMES:
+        if request.META.get(h):
+            return True
+
+    cookie_val = request.COOKIES.get(CSRF_COOKIE_NAME)
+    if cookie_val:
+        return True
+
+    try:
+        if request.method == "POST" and hasattr(request, "POST"):
+            if request.POST.get(POST_FIELD_NAME):
+                return True
+    except Exception:
+        pass
+
+    return False
+
+
+def extract_payload_text(request) -> str:
+    """Extrae contenido útil de la solicitud para análisis."""
+    parts: List[str] = []
+    try:
+        body = request.body.decode("utf-8", errors="ignore")
+        if body:
+            parts.append(body)
+    except Exception:
+        pass
+    qs = request.META.get("QUERY_STRING", "")
+    if qs:
+        parts.append(qs)
+    parts.append(request.META.get("HTTP_USER_AGENT", ""))
+    parts.append(request.META.get("HTTP_REFERER", ""))
+    return " ".join([p for p in parts if p])
+
+
+# ======================================================
+# === MIDDLEWARE DE DEFENSA CSRF ===
+# ======================================================
+class CSRFDefenseMiddleware(MiddlewareMixin):
+    """
+    Middleware para DETECTAR intentos de CSRF:
+    - Marca request.sql_attack_info con 'tipos': ['CSRF'] y 'descripcion' con razones.
+    - No bloquea la petición directamente, permite que AuditoriaMiddleware lo maneje.
+    """
+
+    def process_request(self, request):
+        client_ip = get_client_ip(request)
+        trusted_ips = getattr(settings, "CSRF_DEFENSE_TRUSTED_IPS", [])
+        if client_ip in trusted_ips:
+            return None
+
+        excluded_paths = getattr(settings, "CSRF_DEFENSE_EXCLUDED_PATHS", [])
+        if any(request.path.startswith(p) for p in excluded_paths):
+            return None
+
+        method = (request.method or "").upper()
+        if method not in STATE_CHANGING_METHODS:
+            return None
+
+        descripcion: List[str] = []
+        payload = extract_payload_text(request)
+
+        # 1) Falta token CSRF
+        if not has_csrf_token(request):
+            descripcion.append("Falta token CSRF en cookie/header/form")
+
+        # 2) Origin/Referer no coinciden
+        if not origin_matches_host(request):
+            descripcion.append(
+                "Origin/Referer no coinciden con Host (posible cross-site)"
+            )
+
+        # 3) Content-Type sospechoso
+        content_type = request.META.get("CONTENT_TYPE", "") or ""
+        for patt in SUSPICIOUS_CT_PATTERNS:
+            if patt.search(content_type):
+                descripcion.append(f"Content-Type sospechoso: {content_type}")
+                break
+
+        # 4) Referer ausente
+        referer = request.META.get("HTTP_REFERER", "")
+        if not referer and not any(request.META.get(h) for h in CSRF_HEADER_NAMES):
+            descripcion.append("Referer ausente y sin X-CSRFToken")
+
+        # Si hay señales, calculamos puntaje y registramos
+        if descripcion:
+            w_csrf = getattr(settings, "CSRF_DEFENSE_WEIGHT", 0.2)
+            intentos_csrf = len(descripcion)
+            s_csrf = w_csrf * intentos_csrf
+
+            request.csrf_attack_info = {
+                "ip": client_ip,
+                "tipos": ["CSRF"],
+                "descripcion": descripcion,
+                "payload": payload,
+                "score": s_csrf,
+            }
+
+            logger.warning(
+                "CSRF detectado desde IP %s: %s ; payload: %.200s ; score: %.2f",
+                client_ip,
+                descripcion,
+                payload,
+                s_csrf,
+            )
+
+        return None
+
+
+""" 
+Algoritmos relacionados:
+    *Uso de secreto aleatorio criptográfico.
+    *Opcionalmente derivación con PBKDF2 / Argon2 para reforzar token.
+Contribución a fórmula de amenaza S:
+S_csrf = w_csrf * intentos_csrf
+S_csrf = 0.2 * 1
+donde w_csrf es peso asignado a CSRF y intentos_csrf es la cantidad de intentos detectados.
+"""

guardianunivalle_benito_yucra-0.1.31/GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

@@ -0,0 +1,166 @@
+"""
+Detector de ataques de tipo DoS (Denial of Service)
+====================================================
+
+Este módulo forma parte del sistema de detección de amenazas.
+Detecta tasas de petición anómalas en base a límites configurables,
+captura datos del atacante (IP, agente, cabeceras)
+y registra los incidentes para su auditoría.
+
+Componentes:
+- DOSDefenseMiddleware: Middleware principal de detección.
+- detectar_dos(): Evalúa si la tasa supera el umbral permitido.
+- calcular_nivel_amenaza_dos(): Calcula la severidad proporcional.
+- registrar_evento(): Registra los incidentes en auditoría.
+
+Algoritmos relacionados:
+    * Rate Limiting basado en ventana deslizante.
+    * Cálculo de score: S_dos = w_dos * (tasa_peticion / limite)
+"""
+
+from __future__ import annotations
+import time
+import logging
+import json
+from typing import Dict, List
+from django.conf import settings
+from django.utils.deprecation import MiddlewareMixin
+from ..mitigacion.limitador_peticion import limitar_peticion
+from ..auditoria.registro_auditoria import registrar_evento
+
+# =====================================================
+# ===            CONFIGURACIÓN DEL LOGGER            ===
+# =====================================================
+logger = logging.getLogger("dosdefense")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+
+
+# =====================================================
+# ===       PARÁMETROS DE CONFIGURACIÓN BASE         ===
+# =====================================================
+LIMITE_PETICIONES = getattr(settings, "DOS_LIMITE_PETICIONES", 100)  # por minuto
+VENTANA_SEGUNDOS = getattr(settings, "DOS_VENTANA_SEGUNDOS", 60)
+PESO_DOS = getattr(settings, "DOS_PESO", 0.6)
+
+
+# =====================================================
+# ===  REGISTRO TEMPORAL DE SOLICITUDES POR IP      ===
+# =====================================================
+# En producción se recomienda usar Redis o Memcached
+# para este tipo de conteo, aquí usamos una memoria temporal.
+REGISTRO_SOLICITUDES: Dict[str, List[float]] = {}
+
+
+# =====================================================
+# ===  FUNCIONES AUXILIARES                         ===
+# =====================================================
+def get_client_ip(request) -> str:
+    """Obtiene la IP real del cliente (considera proxies)."""
+    x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
+    if x_forwarded_for:
+        return x_forwarded_for.split(",")[0].strip()
+    return request.META.get("REMOTE_ADDR", "")
+
+
+def limpiar_registro(ip: str):
+    """Limpia peticiones antiguas fuera de la ventana de tiempo."""
+    ahora = time.time()
+    REGISTRO_SOLICITUDES[ip] = [
+        t for t in REGISTRO_SOLICITUDES.get(ip, []) if ahora - t < VENTANA_SEGUNDOS
+    ]
+
+
+def calcular_nivel_amenaza_dos(
+    tasa_peticion: int, limite: int = LIMITE_PETICIONES
+) -> float:
+    """
+    Calcula la puntuación de amenaza DoS basada en el peso configurado.
+    Fórmula: S_dos = w_dos * (tasa_peticion / limite)
+    """
+    proporcion = tasa_peticion / limite
+    s_dos = PESO_DOS * proporcion
+    return round(min(s_dos, 1.0), 3)
+
+
+def detectar_dos(ip: str, tasa_peticion: int, limite: int = LIMITE_PETICIONES) -> bool:
+    """Evalúa si la tasa de peticiones excede el umbral permitido."""
+    if tasa_peticion > limite:
+        registrar_evento(
+            tipo="DoS",
+            descripcion=f"Alta tasa de peticiones desde {ip}: {tasa_peticion} req/min (límite {limite})",
+            severidad="ALTA",
+        )
+        limitar_peticion()  # Acción de mitigación
+        return True
+    return False
+
+
+# =====================================================
+# ===      MIDDLEWARE DE DETECCIÓN DE DoS           ===
+# =====================================================
+class DOSDefenseMiddleware(MiddlewareMixin):
+    """
+    Middleware para detección y registro de ataques DoS.
+    - Captura IP, agente y cabeceras sospechosas.
+    - Evalúa la frecuencia de peticiones por IP.
+    - Marca request.sql_attack_info con información del intento.
+    """
+
+    def process_request(self, request):
+        client_ip = get_client_ip(request)
+        user_agent = request.META.get("HTTP_USER_AGENT", "Desconocido")
+        referer = request.META.get("HTTP_REFERER", "")
+        path = request.path
+
+        # Limpieza de registro anterior
+        limpiar_registro(client_ip)
+
+        # Registrar nueva petición
+        REGISTRO_SOLICITUDES.setdefault(client_ip, []).append(time.time())
+        tasa = len(REGISTRO_SOLICITUDES[client_ip])
+        nivel = calcular_nivel_amenaza_dos(tasa)
+        es_dos = detectar_dos(client_ip, tasa)
+
+        if es_dos:
+            descripcion = [
+                f"Tasa de {tasa} req/min excede límite {LIMITE_PETICIONES}",
+                f"User-Agent: {user_agent}",
+                f"Referer: {referer or 'N/A'}",
+                f"Ruta: {path}",
+            ]
+
+            # Log profesional
+            logger.warning(
+                "DoS detectado desde IP %s: %s ; nivel: %.2f",
+                client_ip,
+                descripcion,
+                nivel,
+            )
+
+            # Enviar a sistema de auditoría
+            request.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
+
+
+""" 
+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.
+"""

guardianunivalle_benito_yucra-0.1.31/GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py

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