Muchos de los que leeis este blog, ya sabéis que la escalada de privilegios de usuario en Windows es una vulnerabilidad de ciberseguridad que puede producirse cuando un usuario o un programa consigue obtener permisos superiores a los que debería tener dentro de un sistema. En condiciones normales, Windows limita las acciones que puede realizar cada usuario para evitar que se modifiquen archivos, configuraciones o recursos importantes sin la autorización correspondiente. Sin embargo, cuando existe un fallo de seguridad que permite saltarse estas restricciones, un atacante puede aprovecharlo para aumentar sus privilegios y obtener un mayor control sobre el equipo.

Este tipo de vulnerabilidad supone un riesgo importante, especialmente cuando el atacante ya ha conseguido acceder de alguna forma al sistema. A partir de ahí, una escalada de privilegios puede permitirle realizar acciones que normalmente estarían restringidas, como modificar configuraciones, acceder a información protegida o ejecutar determinados procesos con permisos elevados. Por este motivo, comprender cómo se produce este tipo de fallo y cómo puede prevenirse es fundamental para mejorar la seguridad de los sistemas Windows.

En este artículo os muestro cómo con un modelo predictivo de IA, programado -como siempre- en Python es posible explotar esta vulnerabilidad.

Vamos al lío.

Código: Modelo predictivo para detección de elevación de privilegios en Windows

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix, roc_auc_score, roc_curve
from sklearn.preprocessing import StandardScaler
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 registros de eventos de seguridad de Windows
# Las columnas podrían ser: event_id, user, process_name, privilege_level, activity_type, label
# label es la etiqueta: 0 (normal), 1 (elevación de privilegios)
url = "https://example.com/windows_privilege_escalation_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

# Convertir variables categóricas a numéricas (si las hay)
data = pd.get_dummies(data, columns=["user", "process_name", "activity_type"], drop_first=True)

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

# 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
# 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 y el escalador
joblib.dump(best_model, "privilege_escalation_model.pkl")
joblib.dump(scaler, "privilege_escalation_scaler.pkl")

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

# Simular un nuevo registro de evento de seguridad
new_event = [[4624, 1, 0, 1, 0]]  # Ejemplo de características: event_id, user, process_name, privilege_level, activity_type
new_event_scaled = loaded_scaler.transform(new_event)  # Escalar el nuevo dato
prediction = loaded_model.predict(new_event_scaled)

if prediction[0] == 1:
    print("¡Alerta! Posible intento de elevación de privilegios detectado.")
else:
    print("Actividad normal.")

Explicación del código

1. Carga de datos:
   • Se carga un conjunto de datos que contiene registros de eventos de seguridad de Windows, como ID de evento, usuario, nombre del proceso, nivel de privilegio y tipo de actividad.
   • La columna label indica si la actividad es normal (0) o un intento de elevación de privilegios (1).
2. Preprocesamiento:
   • Se eliminan filas con valores nulos.
   • Se convierten variables categóricas (como user y process_name) en numéricas usando one-hot encoding.
   • 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 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 guardan 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 evento de seguridad y se predice si es un intento de elevación de privilegios.

Características clave para detectar elevación de privilegios

• ID de evento: Eventos específicos de Windows como 4624 (inicio de sesión exitoso) o 4672 (asignación de privilegios especiales).
• Usuario: Actividad de usuarios con altos privilegios o cuentas sospechosas.
• Nombre del proceso: Procesos comúnmente asociados con exploits (por ejemplo, cmd.exe, powershell.exe).
• Nivel de privilegio: Cambios inusuales en los niveles de privilegio.
• Tipo de actividad: Actividades sospechosas como ejecución de scripts o modificación de registros.

Resultados esperados

• El modelo debería predecir con alta precisión si una actividad es normal o un intento de elevación de privilegios.
• Las visualizaciones te ayudarán a interpretar mejor los resultados.

Próximos pasos

Como posibles líneas de trabajo para continuar desarrollando el proyecto, se plantean varias mejoras. En primer lugar, sería interesante integrar el modelo con un sistema SIEM, como Splunk o Elasticsearch, para poder recopilar y analizar los eventos de seguridad en tiempo real. Esto permitiría detectar comportamientos sospechosos de una forma más rápida y centralizada.

Por otro lado, también se podría mejorar el modelo probando otros algoritmos de aprendizaje automático, como XGBoost, LightGBM o incluso redes neuronales, y comparar sus resultados con el modelo utilizado actualmente.

Otra mejora importante sería implementar un sistema de registro de eventos que permita guardar las actividades consideradas sospechosas. De esta manera, estos datos podrían revisarse posteriormente para estudiar los incidentes y detectar posibles patrones.

Finalmente, se podría incorporar un sistema de notificaciones que avise a los administradores cuando se detecte un posible intento de elevación de privilegios. Esto permitiría reaccionar con mayor rapidez ante una amenaza y mejorar la capacidad de respuesta del sistema.