Modelo Predictivo en IA Para Detección Ransomware (I)

9 de abril de 2025 5 minutos de lectura 783 visualizacionesSin categoría

En el artículo de hoy os traigo un ejemplo de código en Python diseñado para construir un modelo predictivo de IA que detecte ataques de ransomware. Este modelo analizará características como patrones de acceso a archivos, actividad de red y comportamiento del sistema para identificar actividades sospechosas asociadas con ransomware.

Código: Modelo predictivo para detectar ransomware

# Importar librerías necesarias
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix, roc_auc_score, roc_curve
from imblearn.over_sampling import SMOTE  # Para balancear datos
import matplotlib.pyplot as plt
import seaborn as sns
import joblib  # Para guardar y cargar el modelo

# 1. Cargar el conjunto de datos
# Supongamos que tienes un archivo CSV con datos de actividad del sistema
# Las columnas podrían ser: file_access_rate, network_activity, cpu_usage, encryption_activity, label
# label es la etiqueta: 0 (normal), 1 (ransomware)
url = "https://example.com/ransomware_dataset.csv"  # Reemplaza con la URL o ruta de tu dataset
data = pd.read_csv(url)

# 2. Preprocesamiento de datos
# Verificar valores nulos
if data.isnull().sum().any():
    data = data.dropna()  # Eliminar filas con valores nulos

# Separar características (X) y etiquetas (y)
X = data.drop("label", axis=1)  # Características
y = data["label"]  # Etiquetas (0: normal, 1: ransomware)

# Balancear los datos (si están desbalanceados)
smote = SMOTE(random_state=42)
X, y = smote.fit_resample(X, y)

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Escalar las características para normalizar los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 3. Entrenar el modelo con optimización de hiperparámetros
# Definir el modelo
model = RandomForestClassifier(random_state=42)

# Definir la cuadrícula de hiperparámetros para GridSearchCV
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5, 10]
}

# Usar GridSearchCV para encontrar los mejores hiperparámetros
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid_search.fit(X_train, y_train)

# Mejor modelo encontrado
best_model = grid_search.best_estimator_
print("Mejores hiperparámetros:", grid_search.best_params_)

# 4. Evaluar el modelo
# Validación cruzada
cv_scores = cross_val_score(best_model, X_train, y_train, cv=5, scoring='accuracy')
print("Precisión en validación cruzada:", np.mean(cv_scores))

# Predicciones en el conjunto de prueba
y_pred = best_model.predict(X_test)
y_pred_proba = best_model.predict_proba(X_test)[:, 1]  # Probabilidades para la curva ROC

# Métricas de evaluación
print("\nPrecisión del modelo:", accuracy_score(y_test, y_pred))
print("\nReporte de clasificación:\n", classification_report(y_test, y_pred))
print("\nMatriz de confusión:\n", confusion_matrix(y_test, y_pred))
print("\nAUC-ROC:", roc_auc_score(y_test, y_pred_proba))

# 5. Visualización de métricas
# Matriz de confusión
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues')
plt.title("Matriz de Confusión")
plt.xlabel("Predicho")
plt.ylabel("Real")
plt.show()

# Curva ROC
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
plt.plot(fpr, tpr, label="Curva ROC (AUC = {:.2f})".format(roc_auc_score(y_test, y_pred_proba)))
plt.plot([0, 1], [0, 1], linestyle='--', color='gray')
plt.xlabel("Tasa de Falsos Positivos")
plt.ylabel("Tasa de Verdaderos Positivos")
plt.title("Curva ROC")
plt.legend()
plt.show()

# 6. Guardar el modelo entrenado
joblib.dump(best_model, "ransomware_detection_model.pkl")
joblib.dump(scaler, "ransomware_scaler.pkl")

# 7. Cargar el modelo y hacer predicciones en tiempo real (simulación)
# Cargar el modelo y el escalador
loaded_model = joblib.load("ransomware_detection_model.pkl")
loaded_scaler = joblib.load("ransomware_scaler.pkl")

# Simular un nuevo registro de actividad del sistema
new_activity = [[10, 150, 80, 5]]  # Ejemplo de características: file_access_rate, network_activity, cpu_usage, encryption_activity
new_activity_scaled = loaded_scaler.transform(new_activity)  # Escalar el nuevo dato
prediction = loaded_model.predict(new_activity_scaled)

if prediction[0] == 1:
    print("¡Alerta! Posible ataque de ransomware detectado.")
else:
    print("Actividad normal.")

Explicación del código

  1. Carga de datos:
    • Se carga un conjunto de datos que contiene registros de actividad del sistema, como tasas de acceso a archivos, actividad de red, uso de CPU y actividad de cifrado.
    • La columna label indica si la actividad es normal (0) o un ataque de ransomware (1).
  2. Preprocesamiento:
    • Se eliminan filas con valores nulos.
    • Se balancean los datos usando SMOTE para manejar posibles desequilibrios entre clases.
    • Se escalan las características para normalizar los datos.
  3. Entrenamiento del modelo:
    • Se utiliza Random Forest como clasificador.
    • Se optimizan los hiperparámetros usando GridSearchCV.
  4. Evaluación del modelo:
    • Se evalúa el modelo con validación cruzada y métricas como precisión, recall, F1-score y AUC-ROC.
    • Se visualiza la matriz de confusión y la curva ROC.
  5. Guardar y cargar el modelo:
    • Se guarda el modelo entrenado y el escalador para su uso futuro.
  6. Predicción en tiempo real:
    • Se simula la detección de un nuevo registro de actividad del sistema y se predice si es un ataque de ransomware.

Características clave para detectar ransomware

  • Tasa de acceso a archivos: Un aumento repentino en la lectura/escritura de archivos puede indicar cifrado.
  • Actividad de red: Comunicación con servidores maliciosos.
  • Uso de CPU: Picos inusuales en el uso de CPU debido al cifrado.
  • Actividad de cifrado: Detección de operaciones de cifrado en tiempo real.

Resultados esperados

  • El modelo debería predecir con alta precisión si la actividad del sistema es normal o un ataque de ransomware.
  • Las visualizaciones te ayudarán a interpretar mejor los resultados.

Cosas con las que podríais experimentar/trastear

  • Integración en tiempo real: Conectar el modelo a un sistema de monitoreo de seguridad para detectar ransomware en tiempo real.
  • Pruebas con más datos: Probar el modelo con conjuntos de datos más grandes y diversos.
  • Explorar otros algoritmos: Probar modelos como XGBoost, LightGBM o redes neuronales para comparar su rendimiento.
Veces visto: 783
0
Modelo Predictivo en IA Para Detección Ransomware (II) Modelo Predictivo en IA Para Detección DDoS (II)

Entradas relacionadas

No hay comentarios

Aún no hay comentarios

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *