Evaluación de Riesgos (también “análisis de riesgos” o “risk assessment”) es el proceso sistemático de identificar, analizar y evaluar riesgos de seguridad para determinar su probabilidad, impacto y prioridad, facilitando la toma de decisiones informadas sobre el tratamiento de riesgos. Este proceso es fundamental en la gestión de riesgos de seguridad de la información e incluye la identificación de activos, amenazas y vulnerabilidades, y la priorización de riesgos basada en criterios como criticidad de activos y efectividad de controles existentes.

¿Qué es la Evaluación de Riesgos?

La evaluación de riesgos es un proceso fundamental en la gestión de la seguridad que permite a las organizaciones entender sus vulnerabilidades, amenazas y el impacto potencial, estableciendo la base para decisiones estratégicas de inversión en seguridad.

Componentes del Proceso

Identificación de Riesgos

  • Activos: Identificación de activos de información
  • Amenazas: Identificación de amenazas potenciales
  • Vulnerabilidades: Identificación de vulnerabilidades
  • Controles: Evaluación de controles existentes

Análisis de Riesgos

  • Probabilidad: Evaluación de la probabilidad de ocurrencia
  • Impacto: Evaluación del impacto potencial
  • Escenarios: Desarrollo de escenarios de riesgo
  • Cuantificación: Cuantificación de riesgos

Evaluación de Riesgos

  • Priorización: Priorización de riesgos
  • Comparación: Comparación con criterios de riesgo
  • Decisión: Decisión sobre tratamiento
  • Documentación: Documentación de resultados

Metodologías de Evaluación

Metodología Cuantitativa

 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

import numpy as np
import pandas as pd
from scipy import stats

class QuantitativeRiskAssessment:
    def __init__(self):
        self.risk_factors = {
            'probability': {
                'Very_Low': 0.1,
                'Low': 0.3,
                'Medium': 0.5,
                'High': 0.7,
                'Very_High': 0.9
            },
            'impact': {
                'Very_Low': 1000,
                'Low': 10000,
                'Medium': 100000,
                'High': 1000000,
                'Very_High': 10000000
            }
        }
    
    def calculate_risk_value(self, probability, impact):
        """Calcular valor del riesgo"""
        return probability * impact
    
    def calculate_annual_loss_expectancy(self, single_loss_expectancy, annual_rate_of_occurrence):
        """Calcular ALE (Annual Loss Expectancy)"""
        return single_loss_expectancy * annual_rate_of_occurrence
    
    def monte_carlo_simulation(self, risk_scenarios, iterations=10000):
        """Simulación de Monte Carlo para análisis de riesgo"""
        results = []
        
        for _ in range(iterations):
            total_risk = 0
            for scenario in risk_scenarios:
                # Generar valores aleatorios basados en distribuciones
                prob = np.random.beta(scenario['prob_alpha'], scenario['prob_beta'])
                impact = np.random.lognormal(scenario['impact_mean'], scenario['impact_std'])
                total_risk += prob * impact
            results.append(total_risk)
        
        return {
            'mean': np.mean(results),
            'std': np.std(results),
            'percentile_95': np.percentile(results, 95),
            'percentile_99': np.percentile(results, 99),
            'distribution': results
        }
    
    def risk_matrix(self, risks_data):
        """Crear matriz de riesgo"""
        matrix = np.zeros((5, 5))  # 5x5 matrix for probability vs impact
        
        for risk in risks_data:
            prob_idx = list(self.risk_factors['probability'].keys()).index(risk['probability'])
            impact_idx = list(self.risk_factors['impact'].keys()).index(risk['impact'])
            matrix[prob_idx][impact_idx] += 1
        
        return matrix

# Ejemplo de uso
quantitative_assessment = QuantitativeRiskAssessment()

# Calcular valor de riesgo
risk_value = quantitative_assessment.calculate_risk_value(0.7, 1000000)
print(f"Valor del riesgo: ${risk_value:,.2f}")

# Calcular ALE
ale = quantitative_assessment.calculate_annual_loss_expectancy(100000, 0.3)
print(f"ALE: ${ale:,.2f}")

# Simulación de Monte Carlo
scenarios = [
    {'prob_alpha': 2, 'prob_beta': 8, 'impact_mean': 10, 'impact_std': 1},
    {'prob_alpha': 5, 'prob_beta': 5, 'impact_mean': 12, 'impact_std': 1.5}
]
simulation_results = quantitative_assessment.monte_carlo_simulation(scenarios)
print(f"Simulación Monte Carlo - Media: ${simulation_results['mean']:,.2f}")

Metodología Cualitativa

 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

class QualitativeRiskAssessment:
    def __init__(self):
        self.risk_levels = {
            'Very_Low': 1,
            'Low': 2,
            'Medium': 3,
            'High': 4,
            'Very_High': 5
        }
        
        self.risk_categories = {
            'Confidentiality': 'Pérdida de confidencialidad de datos',
            'Integrity': 'Corrupción o modificación no autorizada',
            'Availability': 'Interrupción de servicios o datos',
            'Compliance': 'Incumplimiento de regulaciones',
            'Reputation': 'Daño a la reputación organizacional'
        }
    
    def assess_risk_level(self, probability, impact):
        """Evaluar nivel de riesgo"""
        prob_score = self.risk_levels.get(probability, 0)
        impact_score = self.risk_levels.get(impact, 0)
        
        risk_score = prob_score * impact_score
        
        if risk_score <= 2:
            return 'Very_Low'
        elif risk_score <= 4:
            return 'Low'
        elif risk_score <= 9:
            return 'Medium'
        elif risk_score <= 16:
            return 'High'
        else:
            return 'Very_High'
    
    def risk_heatmap(self, risks_data):
        """Crear mapa de calor de riesgos"""
        heatmap_data = {}
        
        for risk in risks_data:
            category = risk['category']
            level = self.assess_risk_level(risk['probability'], risk['impact'])
            
            if category not in heatmap_data:
                heatmap_data[category] = {}
            
            if level not in heatmap_data[category]:
                heatmap_data[category][level] = 0
            
            heatmap_data[category][level] += 1
        
        return heatmap_data
    
    def prioritize_risks(self, risks_data):
        """Priorizar riesgos"""
        prioritized_risks = []
        
        for risk in risks_data:
            risk_level = self.assess_risk_level(risk['probability'], risk['impact'])
            risk_score = self.risk_levels[risk_level]
            
            prioritized_risks.append({
                **risk,
                'risk_level': risk_level,
                'risk_score': risk_score
            })
        
        # Ordenar por score de riesgo (descendente)
        prioritized_risks.sort(key=lambda x: x['risk_score'], reverse=True)
        
        return prioritized_risks

# Ejemplo de uso
qualitative_assessment = QualitativeRiskAssessment()

# Evaluar nivel de riesgo
risk_level = qualitative_assessment.assess_risk_level('High', 'High')
print(f"Nivel de riesgo: {risk_level}")

# Datos de ejemplo
risks_data = [
    {'category': 'Confidentiality', 'probability': 'High', 'impact': 'High', 'description': 'Data breach'},
    {'category': 'Availability', 'probability': 'Medium', 'impact': 'High', 'description': 'DDoS attack'},
    {'category': 'Integrity', 'probability': 'Low', 'impact': 'Medium', 'description': 'Data corruption'}
]

prioritized = qualitative_assessment.prioritize_risks(risks_data)
print(f"Riesgos priorizados: {[(r['description'], r['risk_level']) for r in prioritized]}")

Herramientas de Evaluación

Sistema de Gestión de Riesgos

  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
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

class RiskManagementSystem:
    def __init__(self):
        self.risks = {}
        self.assets = {}
        self.threats = {}
        self.vulnerabilities = {}
        self.controls = {}
        self.assessments = {}
    
    def add_asset(self, asset_id, asset_data):
        """Añadir activo"""
        self.assets[asset_id] = {
            **asset_data,
            'created_date': '2025-10-26',
            'last_updated': '2025-10-26',
            'status': 'Active'
        }
    
    def add_threat(self, threat_id, threat_data):
        """Añadir amenaza"""
        self.threats[threat_id] = {
            **threat_data,
            'created_date': '2025-10-26',
            'last_updated': '2025-10-26',
            'status': 'Active'
        }
    
    def add_vulnerability(self, vuln_id, vuln_data):
        """Añadir vulnerabilidad"""
        self.vulnerabilities[vuln_id] = {
            **vuln_data,
            'created_date': '2025-10-26',
            'last_updated': '2025-10-26',
            'status': 'Open'
        }
    
    def create_risk_assessment(self, assessment_id, assets, threats, vulnerabilities):
        """Crear evaluación de riesgo"""
        assessment = {
            'assessment_id': assessment_id,
            'assets': assets,
            'threats': threats,
            'vulnerabilities': vulnerabilities,
            'risks': [],
            'created_date': '2025-10-26',
            'status': 'Draft'
        }
        
        # Generar riesgos basados en activos, amenazas y vulnerabilidades
        for asset_id in assets:
            for threat_id in threats:
                for vuln_id in vulnerabilities:
                    risk_id = f"{asset_id}_{threat_id}_{vuln_id}"
                    risk = self.calculate_risk(asset_id, threat_id, vuln_id)
                    assessment['risks'].append(risk)
        
        self.assessments[assessment_id] = assessment
        return assessment
    
    def calculate_risk(self, asset_id, threat_id, vuln_id):
        """Calcular riesgo específico"""
        asset = self.assets.get(asset_id, {})
        threat = self.threats.get(threat_id, {})
        vulnerability = self.vulnerabilities.get(vuln_id, {})
        
        # Cálculo simplificado de riesgo
        probability = threat.get('probability', 0.5)
        impact = asset.get('value', 100000) * vulnerability.get('severity', 0.5)
        risk_value = probability * impact
        
        return {
            'risk_id': f"{asset_id}_{threat_id}_{vuln_id}",
            'asset_id': asset_id,
            'threat_id': threat_id,
            'vulnerability_id': vuln_id,
            'probability': probability,
            'impact': impact,
            'risk_value': risk_value,
            'status': 'Open'
        }
    
    def get_risk_summary(self, assessment_id):
        """Obtener resumen de riesgos"""
        if assessment_id not in self.assessments:
            return None
        
        assessment = self.assessments[assessment_id]
        risks = assessment['risks']
        
        if not risks:
            return {'total_risks': 0}
        
        total_risks = len(risks)
        high_risks = len([r for r in risks if r['risk_value'] > 500000])
        medium_risks = len([r for r in risks if 100000 < r['risk_value'] <= 500000])
        low_risks = len([r for r in risks if r['risk_value'] <= 100000])
        
        total_value = sum(r['risk_value'] for r in risks)
        avg_risk = total_value / total_risks if total_risks > 0 else 0
        
        return {
            'total_risks': total_risks,
            'high_risks': high_risks,
            'medium_risks': medium_risks,
            'low_risks': low_risks,
            'total_value': total_value,
            'average_risk': avg_risk
        }

# Ejemplo de uso
risk_system = RiskManagementSystem()

# Añadir activos
risk_system.add_asset('ASSET-001', {
    'name': 'Database Server',
    'type': 'Infrastructure',
    'value': 1000000,
    'owner': 'IT Department'
})

# Añadir amenazas
risk_system.add_threat('THREAT-001', {
    'name': 'SQL Injection',
    'type': 'Cyber Attack',
    'probability': 0.3,
    'source': 'External'
})

# Añadir vulnerabilidades
risk_system.add_vulnerability('VULN-001', {
    'name': 'Unpatched Database',
    'type': 'Software',
    'severity': 0.8,
    'cvss_score': 7.5
})

# Crear evaluación
assessment = risk_system.create_risk_assessment(
    'ASSESS-001',
    ['ASSET-001'],
    ['THREAT-001'],
    ['VULN-001']
)

summary = risk_system.get_risk_summary('ASSESS-001')
print(f"Resumen de evaluación: {summary}")

Análisis de Escenarios

  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
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

class ScenarioAnalysis:
    def __init__(self):
        self.scenarios = {}
        self.scenario_templates = {
            'Data_Breach': {
                'description': 'Brecha de datos confidenciales',
                'probability_factors': ['Security_controls', 'Employee_training', 'System_patches'],
                'impact_factors': ['Data_volume', 'Data_sensitivity', 'Regulatory_requirements']
            },
            'Ransomware': {
                'description': 'Ataque de ransomware',
                'probability_factors': ['Email_security', 'Backup_systems', 'User_awareness'],
                'impact_factors': ['System_downtime', 'Data_recovery', 'Business_continuity']
            },
            'Insider_Threat': {
                'description': 'Amenaza interna',
                'probability_factors': ['Access_controls', 'Monitoring_systems', 'Employee_satisfaction'],
                'impact_factors': ['Data_access', 'System_damage', 'Reputation']
            }
        }
    
    def create_scenario(self, scenario_id, scenario_type, custom_factors=None):
        """Crear escenario de riesgo"""
        template = self.scenario_templates.get(scenario_type, {})
        
        scenario = {
            'scenario_id': scenario_id,
            'type': scenario_type,
            'description': template.get('description', ''),
            'probability_factors': template.get('probability_factors', []),
            'impact_factors': template.get('impact_factors', []),
            'probability_score': 0,
            'impact_score': 0,
            'risk_score': 0,
            'created_date': '2025-10-26'
        }
        
        if custom_factors:
            scenario.update(custom_factors)
        
        self.scenarios[scenario_id] = scenario
        return scenario
    
    def assess_scenario(self, scenario_id, factor_scores):
        """Evaluar escenario con scores de factores"""
        if scenario_id not in self.scenarios:
            return None
        
        scenario = self.scenarios[scenario_id]
        
        # Calcular probabilidad basada en factores
        prob_factors = scenario['probability_factors']
        prob_scores = [factor_scores.get(factor, 0) for factor in prob_factors]
        scenario['probability_score'] = sum(prob_scores) / len(prob_scores) if prob_scores else 0
        
        # Calcular impacto basado en factores
        impact_factors = scenario['impact_factors']
        impact_scores = [factor_scores.get(factor, 0) for factor in impact_factors]
        scenario['impact_score'] = sum(impact_scores) / len(impact_scores) if impact_scores else 0
        
        # Calcular score de riesgo
        scenario['risk_score'] = scenario['probability_score'] * scenario['impact_score']
        
        return scenario
    
    def compare_scenarios(self, scenario_ids):
        """Comparar escenarios"""
        comparison = []
        
        for scenario_id in scenario_ids:
            if scenario_id in self.scenarios:
                scenario = self.scenarios[scenario_id]
                comparison.append({
                    'scenario_id': scenario_id,
                    'type': scenario['type'],
                    'probability': scenario['probability_score'],
                    'impact': scenario['impact_score'],
                    'risk_score': scenario['risk_score']
                })
        
        # Ordenar por score de riesgo
        comparison.sort(key=lambda x: x['risk_score'], reverse=True)
        
        return comparison

# Ejemplo de uso
scenario_analysis = ScenarioAnalysis()

# Crear escenarios
scenario_analysis.create_scenario('SCEN-001', 'Data_Breach')
scenario_analysis.create_scenario('SCEN-002', 'Ransomware')
scenario_analysis.create_scenario('SCEN-003', 'Insider_Threat')

# Evaluar escenarios
factor_scores = {
    'Security_controls': 0.7,
    'Employee_training': 0.6,
    'System_patches': 0.8,
    'Data_volume': 0.9,
    'Data_sensitivity': 0.8,
    'Regulatory_requirements': 0.7,
    'Email_security': 0.5,
    'Backup_systems': 0.8,
    'User_awareness': 0.6,
    'System_downtime': 0.7,
    'Data_recovery': 0.6,
    'Business_continuity': 0.8,
    'Access_controls': 0.7,
    'Monitoring_systems': 0.6,
    'Employee_satisfaction': 0.8,
    'Data_access': 0.9,
    'System_damage': 0.5,
    'Reputation': 0.8
}

for scenario_id in ['SCEN-001', 'SCEN-002', 'SCEN-003']:
    scenario_analysis.assess_scenario(scenario_id, factor_scores)

comparison = scenario_analysis.compare_scenarios(['SCEN-001', 'SCEN-002', 'SCEN-003'])
print(f"Comparación de escenarios: {comparison}")

Mejores Prácticas

Proceso de Evaluación

  • Metodología Consistente: Usar metodología consistente
  • Participación: Incluir stakeholders relevantes
  • Documentación: Documentar completamente
  • Revisión: Revisión regular de evaluaciones

Análisis de Riesgos

  • Objetividad: Mantener objetividad en el análisis
  • Evidencia: Basar en evidencia sólida
  • Escenarios: Considerar múltiples escenarios
  • Incertidumbre: Reconocer incertidumbre

Comunicación

  • Claridad: Comunicar claramente los resultados
  • Contexto: Proporcionar contexto adecuado
  • Recomendaciones: Incluir recomendaciones claras
  • Seguimiento: Establecer seguimiento

Conceptos Relacionados

Referencias