Si os gustó el artículo anterior, no os perdáis la lectura de éste, en el que os propongo una modificiación para mejorar el código expuesto anterioriormente. ¿Y en qué va a consistir el código que os desarrollo hoy? Pues justamente, para predecir y bloquear procesos de ataque de ransomware. Para ello necesitaremos integrar el modelo predictivo con un sistema de monitoreo en tiempo real que pueda identificar y detener procesos maliciosos. A continuación, os presento una versión mejorada del código (Python) que incluye:

1. Monitoreo en tiempo real: Simulación de un sistema que monitorea procesos en busca de actividad sospechosa.
2. Bloqueo de procesos: Uso de comandos del sistema operativo para detener procesos identificados como ransomware.
3. Integración con el modelo predictivo: Uso del modelo entrenado para clasificar procesos en tiempo real.

Código mejorado: Detección y bloqueo de ransomware

import pandas as pd
import numpy as np
import time
import os
import psutil  # Para interactuar con procesos del sistema
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
import joblib

# 1. Cargar el modelo y el escalador preentrenados
model = joblib.load("ransomware_detection_model.pkl")
scaler = joblib.load("ransomware_scaler.pkl")

# 2. Función para monitorear procesos en tiempo real
def monitor_processes():
    print("Iniciando monitoreo de procesos...")
    while True:
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_info', 'io_counters']):
            try:
                # Obtener información del proceso
                pid = proc.info['pid']
                name = proc.info['name']
                cpu_usage = proc.info['cpu_percent']
                memory_usage = proc.info['memory_info'].rss  # Uso de memoria en bytes
                io_read = proc.info['io_counters'].read_count  # Operaciones de lectura
                io_write = proc.info['io_counters'].write_count  # Operaciones de escritura

                # Crear un vector de características para el proceso
                process_features = np.array([[cpu_usage, memory_usage, io_read, io_write]])

                # Escalar las características
                process_features_scaled = scaler.transform(process_features)

                # Predecir si el proceso es ransomware
                prediction = model.predict(process_features_scaled)
                prediction_proba = model.predict_proba(process_features_scaled)[:, 1]

                # Si se detecta ransomware, bloquear el proceso
                if prediction[0] == 1:
                    print(f"¡Alerta! Ransomware detectado en el proceso {name} (PID: {pid}). Probabilidad: {prediction_proba[0]:.2f}")
                    block_process(pid)
            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                continue

        # Esperar un tiempo antes de la siguiente iteración
        time.sleep(5)

# 3. Función para bloquear un proceso
def block_process(pid):
    try:
        process = psutil.Process(pid)
        process.terminate()  # Terminar el proceso
        print(f"Proceso {pid} terminado.")
    except psutil.NoSuchProcess:
        print(f"El proceso {pid} ya no existe.")
    except psutil.AccessDenied:
        print(f"No se pudo terminar el proceso {pid}. Permisos insuficientes.")

# 4. Iniciar el monitoreo
if __name__ == "__main__":
    monitor_processes()

Explicación del código mejorado

1. Carga del modelo y escalador:
   • Se cargan el modelo de detección de ransomware y el escalador preentrenados usando joblib.
2. Monitoreo en tiempo real:
   • La función monitor_processes utiliza la librería psutil para iterar sobre todos los procesos en ejecución.
   • Para cada proceso, se extraen características como:
     • Uso de CPU (cpu_percent).
     • Uso de memoria (memory_info.rss).
     • Operaciones de lectura/escritura (io_counters).
3. Predicción y bloqueo:
   • Las características del proceso se escalan y se pasan al modelo para predecir si es ransomware.
   • Si el modelo clasifica el proceso como ransomware (predicción = 1), se llama a la función block_process para terminar el proceso.
4. Bloqueo de procesos:
   • La función block_process utiliza psutil.Process(pid).terminate() para detener el proceso malicioso.
5. Ejecución continua:
   • El monitoreo se ejecuta en un bucle infinito, con una pausa de 5 segundos entre iteraciones para evitar sobrecargar el sistema.

Requisitos del sistema

1. Instalación de dependencias:
   • Asegúrate de tener instaladas las librerías necesarias:
     bash

     Copy

     pip install pandas numpy psutil scikit-learn imbalanced-learn joblib

2. Permisos de administrador:
   • Para terminar procesos, el script debe ejecutarse con permisos de administrador (en sistemas Unix, usa sudo).
3. Modelo preentrenado:
   • Asegúrate de tener el modelo (ransomware_detection_model.pkl) y el escalador (ransomware_scaler.pkl) preentrenados y disponibles en la misma carpeta que el script.

Ejemplo de uso

1. Entrenar el modelo:
   • Usa el código anterior para entrenar un modelo con datos de actividad de procesos etiquetados como «normal» o «ransomware».
2. Ejecutar el monitor:
   • Ejecuta el script mejorado para monitorear y bloquear procesos en tiempo real:
     bash

     Copy

     sudo python monitor_ransomware.py

3. Simular un ataque:
   • Para probar el sistema, puedes ejecutar un proceso que simule actividad de ransomware (por ejemplo, un script que cifre archivos). El monitor debería detectarlo y bloquearlo.

Mejoras adicionales

1. Registro de eventos:
   • Guardar un log de los procesos bloqueados para análisis posteriores.
   • Ejemplo:
     python

     Copy

     import logging
     logging.basicConfig(filename='ransomware_monitor.log', level=logging.INFO)
     logging.info(f"Proceso {pid} bloqueado: {name}")

2. Notificaciones:
   • Enviar alertas por correo electrónico o mensajes cuando se detecte ransomware.
   • Usar librerías como smtplib para enviar correos.
3. Integración con SIEM:
   • Conectar el monitor a un sistema de gestión de eventos de seguridad (SIEM) para centralizar las alertas.
4. Análisis de comportamiento:
   • Implementar técnicas avanzadas como análisis de comportamiento de procesos (UEBA) para mejorar la detección.

Mediante la implementación de este código mejorado podréis disponer de una solución completa capaz de detectar y bloquear ransomware en tiempo real, integrando un modelo predictivo de IA con herramientas de monitoreo del sistema. Por supuesto, es mejorable.

¡Espero que os sea útil!