Probabilidad y Estadística son herramientas matemáticas fundamentales en ciberseguridad para el análisis de riesgos, evaluación de amenazas y toma de decisiones basada en datos.

¿Qué son Probabilidad y Estadística?

La probabilidad estudia la incertidumbre y los eventos aleatorios, mientras que la estadística analiza datos para extraer conclusiones y patrones, siendo ambas esenciales para la gestión de riesgos en ciberseguridad.

Conceptos Fundamentales

Probabilidad

  • Definición: Medida de la posibilidad de que ocurra un evento
  • Rango: 0 ≤ P(A) ≤ 1
  • Eventos: Mutuamente excluyentes, independientes
  • Aplicación: Análisis de riesgos

Estadística Descriptiva

  • Medidas de Tendencia Central: Media, mediana, moda
  • Medidas de Dispersión: Varianza, desviación estándar
  • Distribuciones: Normal, binomial, Poisson
  • Aplicación: Análisis de datos de seguridad

Estadística Inferencial

  • Hipótesis: Pruebas de hipótesis
  • Intervalos de Confianza: Estimación de parámetros
  • Regresión: Análisis de relaciones
  • Aplicación: Predicción de amenazas

Distribuciones de Probabilidad

Distribución Normal

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

def normal_distribution_example():
    """Ejemplo de distribución normal"""
    # Parámetros
    mu = 0  # Media
    sigma = 1  # Desviación estándar
    
    # Generar datos
    x = np.linspace(-4, 4, 100)
    y = stats.norm.pdf(x, mu, sigma)
    
    # Calcular probabilidades
    prob_less_than_1 = stats.norm.cdf(1, mu, sigma)
    prob_between = stats.norm.cdf(1, mu, sigma) - stats.norm.cdf(-1, mu, sigma)
    
    print(f"P(X < 1) = {prob_less_than_1:.4f}")
    print(f"P(-1 < X < 1) = {prob_between:.4f}")
    
    return x, y

# Ejemplo de uso
x, y = normal_distribution_example()

Distribución Binomial

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

def binomial_distribution_example():
    """Ejemplo de distribución binomial"""
    # Parámetros
    n = 100  # Número de ensayos
    p = 0.1  # Probabilidad de éxito
    
    # Calcular probabilidades
    prob_exactly_10 = stats.binom.pmf(10, n, p)
    prob_at_most_10 = stats.binom.cdf(10, n, p)
    prob_at_least_10 = 1 - stats.binom.cdf(9, n, p)
    
    print(f"P(X = 10) = {prob_exactly_10:.4f}")
    print(f"P(X ≤ 10) = {prob_at_most_10:.4f}")
    print(f"P(X ≥ 10) = {prob_at_least_10:.4f}")
    
    return n, p

# Ejemplo de uso
n, p = binomial_distribution_example()

Distribución de Poisson

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

def poisson_distribution_example():
    """Ejemplo de distribución de Poisson"""
    # Parámetros
    lambda_param = 5  # Tasa de ocurrencia
    
    # Calcular probabilidades
    prob_exactly_5 = stats.poisson.pmf(5, lambda_param)
    prob_at_most_5 = stats.poisson.cdf(5, lambda_param)
    prob_more_than_5 = 1 - stats.poisson.cdf(5, lambda_param)
    
    print(f"P(X = 5) = {prob_exactly_5:.4f}")
    print(f"P(X ≤ 5) = {prob_at_most_5:.4f}")
    print(f"P(X > 5) = {prob_more_than_5:.4f}")
    
    return lambda_param

# Ejemplo de uso
lambda_param = poisson_distribution_example()

Análisis de Riesgos

Evaluación de Riesgos

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

def risk_assessment(probability, impact):
    """Evaluación de riesgos"""
    risk_score = probability * impact
    
    if risk_score >= 0.8:
        risk_level = "Alto"
    elif risk_score >= 0.5:
        risk_level = "Medio"
    else:
        risk_level = "Bajo"
    
    return risk_score, risk_level

# Ejemplo de uso
prob = 0.7  # Probabilidad de ocurrencia
impact = 0.9  # Impacto (0-1)
risk_score, risk_level = risk_assessment(prob, impact)
print(f"Riesgo: {risk_level} (Score: {risk_score:.2f})")

Análisis de Vulnerabilidades

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

def vulnerability_analysis(vulnerabilities):
    """Análisis estadístico de vulnerabilidades"""
    # Estadísticas descriptivas
    mean_cvss = np.mean([v['cvss'] for v in vulnerabilities])
    std_cvss = np.std([v['cvss'] for v in vulnerabilities])
    median_cvss = np.median([v['cvss'] for v in vulnerabilities])
    
    # Clasificación por severidad
    critical = len([v for v in vulnerabilities if v['cvss'] >= 9.0])
    high = len([v for v in vulnerabilities if 7.0 <= v['cvss'] < 9.0])
    medium = len([v for v in vulnerabilities if 4.0 <= v['cvss'] < 7.0])
    low = len([v for v in vulnerabilities if v['cvss'] < 4.0])
    
    return {
        'mean_cvss': mean_cvss,
        'std_cvss': std_cvss,
        'median_cvss': median_cvss,
        'critical': critical,
        'high': high,
        'medium': medium,
        'low': low
    }

# Ejemplo de uso
vulnerabilities = [
    {'name': 'CVE-2023-001', 'cvss': 9.8},
    {'name': 'CVE-2023-002', 'cvss': 7.5},
    {'name': 'CVE-2023-003', 'cvss': 5.2},
    {'name': 'CVE-2023-004', 'cvss': 3.1}
]
analysis = vulnerability_analysis(vulnerabilities)
print(f"Análisis: {analysis}")

Análisis de Datos de Seguridad

Detección de Anomalías

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

def anomaly_detection(data, threshold=2):
    """Detección de anomalías usando Z-score"""
    mean = np.mean(data)
    std = np.std(data)
    
    z_scores = np.abs((data - mean) / std)
    anomalies = z_scores > threshold
    
    return anomalies, z_scores

# Ejemplo de uso
data = np.random.normal(100, 15, 1000)  # Datos normales
data[50] = 200  # Anomalía
anomalies, z_scores = anomaly_detection(data)
print(f"Anomalías detectadas: {np.sum(anomalies)}")

Análisis de Tendencias

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def trend_analysis(time_series):
    """Análisis de tendencias en series temporales"""
    from scipy import stats
    
    # Regresión lineal
    x = np.arange(len(time_series))
    slope, intercept, r_value, p_value, std_err = stats.linregress(x, time_series)
    
    # Predicción
    future_x = np.arange(len(time_series), len(time_series) + 10)
    future_y = slope * future_x + intercept
    
    return {
        'slope': slope,
        'r_squared': r_value**2,
        'p_value': p_value,
        'future_predictions': future_y
    }

# Ejemplo de uso
time_series = np.random.normal(100, 10, 100) + np.linspace(0, 20, 100)
trend = trend_analysis(time_series)
print(f"Tendencia: {trend['slope']:.4f}")
print(f"R²: {trend['r_squared']:.4f}")

Pruebas de Hipótesis

Prueba t de Student

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def t_test(sample1, sample2, alpha=0.05):
    """Prueba t de Student para dos muestras"""
    from scipy import stats
    
    # Prueba t
    t_stat, p_value = stats.ttest_ind(sample1, sample2)
    
    # Decisión
    if p_value < alpha:
        decision = "Rechazar H0"
    else:
        decision = "No rechazar H0"
    
    return {
        't_statistic': t_stat,
        'p_value': p_value,
        'decision': decision
    }

# Ejemplo de uso
sample1 = np.random.normal(100, 15, 50)
sample2 = np.random.normal(105, 15, 50)
result = t_test(sample1, sample2)
print(f"Resultado: {result}")

Prueba de Chi-cuadrado

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

def chi_square_test(observed, expected):
    """Prueba de Chi-cuadrado"""
    from scipy import stats
    
    chi2_stat, p_value = stats.chisquare(observed, expected)
    
    return {
        'chi2_statistic': chi2_stat,
        'p_value': p_value
    }

# Ejemplo de uso
observed = [10, 15, 20, 25]
expected = [12, 18, 18, 22]
result = chi_square_test(observed, expected)
print(f"Chi-cuadrado: {result}")

Machine Learning para Seguridad

Clasificación de Amenazas

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

def threat_classification(features, labels):
    """Clasificación de amenazas usando Random Forest"""
    # Dividir datos
    X_train, X_test, y_train, y_test = train_test_split(
        features, labels, test_size=0.2, random_state=42
    )
    
    # Entrenar modelo
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    
    # Predecir
    y_pred = model.predict(X_test)
    
    # Evaluar
    report = classification_report(y_test, y_pred)
    
    return model, report

# Ejemplo de uso
# features = np.random.randn(1000, 10)  # Características
# labels = np.random.randint(0, 3, 1000)  # Etiquetas (0: benigno, 1: malware, 2: phishing)
# model, report = threat_classification(features, labels)
# print(report)

Detección de Intrusiones

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

def intrusion_detection(data, threshold=0.5):
    """Detección de intrusiones usando análisis estadístico"""
    # Calcular métricas
    mean = np.mean(data)
    std = np.std(data)
    
    # Detectar anomalías
    z_scores = np.abs((data - mean) / std)
    intrusions = z_scores > threshold
    
    # Calcular métricas de rendimiento
    true_positives = np.sum(intrusions)
    false_positives = np.sum(intrusions) - np.sum(intrusions)  # Simplificado
    
    return {
        'intrusions_detected': intrusions,
        'true_positives': true_positives,
        'false_positives': false_positives
    }

# Ejemplo de uso
data = np.random.normal(100, 15, 1000)
data[50:60] = np.random.normal(200, 20, 10)  # Intrusiones
result = intrusion_detection(data)
print(f"Intrusiones detectadas: {np.sum(result['intrusions_detected'])}")

Análisis de Rendimiento

Métricas de Rendimiento

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def performance_metrics(y_true, y_pred):
    """Calcular métricas de rendimiento"""
    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
    
    accuracy = accuracy_score(y_true, y_pred)
    precision = precision_score(y_true, y_pred, average='weighted')
    recall = recall_score(y_true, y_pred, average='weighted')
    f1 = f1_score(y_true, y_pred, average='weighted')
    
    return {
        'accuracy': accuracy,
        'precision': precision,
        'recall': recall,
        'f1_score': f1
    }

# Ejemplo de uso
y_true = [0, 1, 1, 0, 1, 0, 1, 1, 0, 1]
y_pred = [0, 1, 0, 0, 1, 0, 1, 0, 0, 1]
metrics = performance_metrics(y_true, y_pred)
print(f"Métricas: {metrics}")

Conceptos Relacionados

  • Teoría de Números - Fundamentos matemáticos complementarios
  • Álgebra Abstracta - Estructuras matemáticas complementarias
  • Criptoanálisis - Análisis que usa probabilidad y estadística
  • Machine Learning - Técnicas que usan probabilidad y estadística
  • CISO - Rol que supervisa probabilidad y estadística
  • Ciberseguridad General - Disciplina que incluye probabilidad y estadística
  • Brechas de seguridad - Incidentes analizados con probabilidad y estadística
  • Vectores de ataque - Ataques analizados con probabilidad y estadística
  • Incident Response - Proceso que incluye probabilidad y estadística
  • SIEM - Sistema que usa probabilidad y estadística
  • SOAR - Automatización que usa probabilidad y estadística
  • EDR - Herramienta que usa probabilidad y estadística
  • Firewall - Dispositivo que usa probabilidad y estadística
  • VPN - Conexión que usa probabilidad y estadística
  • Dashboards - Visualización de métricas probabilidad y estadística
  • Registros - Logs analizados con probabilidad y estadística

Referencias