Due Diligence (también “diligencia debida” o “evaluación exhaustiva de terceros”) es el proceso de evaluación exhaustiva de la postura de seguridad de proveedores, socios comerciales y terceros para identificar y mitigar riesgos de seguridad en la cadena de suministro. Este proceso incluye la revisión de políticas de seguridad, certificaciones, historial de incidentes, controles técnicos y cumplimiento normativo de los proveedores, siendo esencial para tomar decisiones informadas sobre relaciones comerciales.

¿Qué es Due Diligence en Seguridad?

Due Diligence en seguridad es una investigación y evaluación sistemática de la capacidad de seguridad de terceros antes de establecer relaciones comerciales, asegurando que cumplan con los estándares de seguridad requeridos y no introduzcan riesgos significativos.

Componentes del Proceso

Evaluación Inicial

  • Análisis de Riesgo: Evaluación del nivel de riesgo del tercero
  • Revisión de Capacidades: Análisis de capacidades de seguridad
  • Verificación de Certificaciones: Validación de certificaciones de seguridad
  • Evaluación de Reputación: Análisis de la reputación de seguridad

Evaluación Técnica

  • Auditoría de Seguridad: Evaluación técnica de controles
  • Pruebas de Penetración: Pruebas de seguridad externas
  • Revisión de Arquitectura: Análisis de arquitectura de seguridad
  • Evaluación de Incidentes: Revisión de historial de incidentes

Evaluación Continua

  • Monitoreo Continuo: Monitoreo de la postura de seguridad
  • Revisión Periódica: Evaluaciones regulares
  • Actualización de Evaluaciones: Actualización según cambios
  • Gestión de Incidencias: Respuesta a incidentes de terceros

Sistema de Due Diligence

Gestión de Evaluaciones

  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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import requests
import json

class DueDiligenceManagement:
    def __init__(self):
        self.third_parties = {}
        self.evaluations = {}
        self.risk_categories = {
            'critical': {'score': 4, 'description': 'Acceso a sistemas críticos'},
            'high': {'score': 3, 'description': 'Acceso a datos sensibles'},
            'medium': {'score': 2, 'description': 'Acceso limitado a sistemas'},
            'low': {'score': 1, 'description': 'Acceso mínimo o sin acceso'}
        }
        
        self.evaluation_criteria = {
            'security_policies': {'weight': 0.2, 'max_score': 100},
            'technical_controls': {'weight': 0.3, 'max_score': 100},
            'incident_response': {'weight': 0.15, 'max_score': 100},
            'compliance': {'weight': 0.2, 'max_score': 100},
            'business_continuity': {'weight': 0.15, 'max_score': 100}
        }
    
    def register_third_party(self, party_id, party_data):
        """Registrar tercero"""
        self.third_parties[party_id] = {
            'party_id': party_id,
            'name': party_data['name'],
            'type': party_data['type'],
            'industry': party_data.get('industry', 'unknown'),
            'risk_level': party_data.get('risk_level', 'medium'),
            'services': party_data.get('services', []),
            'data_access': party_data.get('data_access', 'none'),
            'system_access': party_data.get('system_access', 'none'),
            'contact_info': party_data.get('contact_info', {}),
            'registration_date': datetime.now(),
            'status': 'pending_evaluation'
        }
    
    def create_evaluation(self, evaluation_id, party_id, evaluation_config):
        """Crear evaluación de due diligence"""
        if party_id not in self.third_parties:
            return False
        
        evaluation = {
            'evaluation_id': evaluation_id,
            'party_id': party_id,
            'evaluation_type': evaluation_config['type'],
            'scope': evaluation_config['scope'],
            'evaluator': evaluation_config['evaluator'],
            'start_date': evaluation_config.get('start_date', datetime.now()),
            'due_date': evaluation_config.get('due_date'),
            'status': 'in_progress',
            'scores': {},
            'findings': [],
            'recommendations': [],
            'overall_score': 0,
            'risk_assessment': {}
        }
        
        self.evaluations[evaluation_id] = evaluation
        return True
    
    def conduct_security_assessment(self, evaluation_id, assessment_data):
        """Realizar evaluación de seguridad"""
        if evaluation_id not in self.evaluations:
            return False
        
        evaluation = self.evaluations[evaluation_id]
        party = self.third_parties[evaluation['party_id']]
        
        # Evaluar cada criterio
        scores = {}
        findings = []
        
        for criterion, config in self.evaluation_criteria.items():
            score = self.evaluate_criterion(criterion, assessment_data, party)
            scores[criterion] = score
            
            # Generar hallazgos
            if score < 70:
                findings.append({
                    'criterion': criterion,
                    'score': score,
                    'severity': 'high' if score < 50 else 'medium',
                    'description': f"Puntuación baja en {criterion}: {score}/100"
                })
        
        # Calcular puntuación general
        overall_score = sum(scores[criterion] * config['weight'] 
                          for criterion, config in self.evaluation_criteria.items())
        
        # Evaluar riesgo
        risk_assessment = self.assess_risk(party, scores, findings)
        
        # Actualizar evaluación
        evaluation['scores'] = scores
        evaluation['findings'] = findings
        evaluation['overall_score'] = overall_score
        evaluation['risk_assessment'] = risk_assessment
        evaluation['status'] = 'completed'
        evaluation['completion_date'] = datetime.now()
        
        return True
    
    def evaluate_criterion(self, criterion, assessment_data, party):
        """Evaluar criterio específico"""
        if criterion == 'security_policies':
            return self.evaluate_security_policies(assessment_data)
        elif criterion == 'technical_controls':
            return self.evaluate_technical_controls(assessment_data)
        elif criterion == 'incident_response':
            return self.evaluate_incident_response(assessment_data)
        elif criterion == 'compliance':
            return self.evaluate_compliance(assessment_data)
        elif criterion == 'business_continuity':
            return self.evaluate_business_continuity(assessment_data)
        else:
            return 0
    
    def evaluate_security_policies(self, assessment_data):
        """Evaluar políticas de seguridad"""
        score = 0
        
        # Verificar existencia de políticas
        if assessment_data.get('has_security_policy'):
            score += 20
        
        if assessment_data.get('has_incident_response_policy'):
            score += 20
        
        if assessment_data.get('has_data_protection_policy'):
            score += 20
        
        if assessment_data.get('has_access_control_policy'):
            score += 20
        
        if assessment_data.get('has_business_continuity_plan'):
            score += 20
        
        return min(score, 100)
    
    def evaluate_technical_controls(self, assessment_data):
        """Evaluar controles técnicos"""
        score = 0
        
        # Verificar controles de red
        if assessment_data.get('has_firewall'):
            score += 15
        
        if assessment_data.get('has_intrusion_detection'):
            score += 15
        
        if assessment_data.get('has_antivirus'):
            score += 10
        
        # Verificar controles de acceso
        if assessment_data.get('has_mfa'):
            score += 15
        
        if assessment_data.get('has_privileged_access_management'):
            score += 15
        
        # Verificar monitoreo
        if assessment_data.get('has_siem'):
            score += 15
        
        if assessment_data.get('has_logging'):
            score += 15
        
        return min(score, 100)
    
    def evaluate_incident_response(self, assessment_data):
        """Evaluar respuesta a incidentes"""
        score = 0
        
        if assessment_data.get('has_incident_response_team'):
            score += 25
        
        if assessment_data.get('has_incident_response_procedures'):
            score += 25
        
        if assessment_data.get('has_communication_plan'):
            score += 25
        
        if assessment_data.get('has_forensic_capabilities'):
            score += 25
        
        return min(score, 100)
    
    def evaluate_compliance(self, assessment_data):
        """Evaluar cumplimiento"""
        score = 0
        
        # Verificar certificaciones
        certifications = assessment_data.get('certifications', [])
        if 'ISO_27001' in certifications:
            score += 30
        
        if 'SOC_2' in certifications:
            score += 25
        
        if 'PCI_DSS' in certifications:
            score += 20
        
        if 'GDPR' in certifications:
            score += 25
        
        return min(score, 100)
    
    def evaluate_business_continuity(self, assessment_data):
        """Evaluar continuidad del negocio"""
        score = 0
        
        if assessment_data.get('has_business_continuity_plan'):
            score += 25
        
        if assessment_data.get('has_disaster_recovery_plan'):
            score += 25
        
        if assessment_data.get('has_backup_systems'):
            score += 25
        
        if assessment_data.get('has_alternate_sites'):
            score += 25
        
        return min(score, 100)
    
    def assess_risk(self, party, scores, findings):
        """Evaluar riesgo del tercero"""
        # Calcular riesgo basado en puntuaciones
        overall_score = sum(scores.values()) / len(scores)
        
        # Ajustar por nivel de acceso
        access_risk = self.risk_categories.get(party['risk_level'], {}).get('score', 2)
        
        # Ajustar por hallazgos críticos
        critical_findings = len([f for f in findings if f['severity'] == 'high'])
        
        # Calcular riesgo final
        risk_score = (100 - overall_score) * access_risk + (critical_findings * 10)
        
        if risk_score >= 80:
            risk_level = 'critical'
        elif risk_score >= 60:
            risk_level = 'high'
        elif risk_score >= 40:
            risk_level = 'medium'
        else:
            risk_level = 'low'
        
        return {
            'risk_score': risk_score,
            'risk_level': risk_level,
            'access_risk': access_risk,
            'critical_findings': critical_findings,
            'mitigation_required': risk_level in ['critical', 'high']
        }
    
    def generate_evaluation_report(self, evaluation_id):
        """Generar reporte de evaluación"""
        if evaluation_id not in self.evaluations:
            return None
        
        evaluation = self.evaluations[evaluation_id]
        party = self.third_parties[evaluation['party_id']]
        
        report = {
            'evaluation_id': evaluation_id,
            'party_name': party['name'],
            'evaluation_date': evaluation['completion_date'],
            'overall_score': evaluation['overall_score'],
            'risk_assessment': evaluation['risk_assessment'],
            'scores_by_criterion': evaluation['scores'],
            'findings': evaluation['findings'],
            'recommendations': self.generate_recommendations(evaluation),
            'approval_status': self.determine_approval_status(evaluation)
        }
        
        return report
    
    def generate_recommendations(self, evaluation):
        """Generar recomendaciones basadas en evaluación"""
        recommendations = []
        
        # Recomendaciones basadas en puntuaciones bajas
        for criterion, score in evaluation['scores'].items():
            if score < 70:
                recommendations.append({
                    'type': 'improvement',
                    'criterion': criterion,
                    'description': f"Mejorar {criterion} - puntuación actual: {score}/100",
                    'priority': 'high' if score < 50 else 'medium'
                })
        
        # Recomendaciones basadas en riesgo
        risk_level = evaluation['risk_assessment']['risk_level']
        if risk_level in ['critical', 'high']:
            recommendations.append({
                'type': 'risk_mitigation',
                'description': f"Implementar controles adicionales - riesgo {risk_level}",
                'priority': 'critical'
            })
        
        # Recomendaciones basadas en hallazgos
        critical_findings = [f for f in evaluation['findings'] if f['severity'] == 'high']
        if critical_findings:
            recommendations.append({
                'type': 'immediate_action',
                'description': f"Abordar {len(critical_findings)} hallazgos críticos inmediatamente",
                'priority': 'critical'
            })
        
        return recommendations
    
    def determine_approval_status(self, evaluation):
        """Determinar estado de aprobación"""
        overall_score = evaluation['overall_score']
        risk_level = evaluation['risk_assessment']['risk_level']
        critical_findings = len([f for f in evaluation['findings'] if f['severity'] == 'high'])
        
        if overall_score >= 80 and risk_level in ['low', 'medium'] and critical_findings == 0:
            return 'approved'
        elif overall_score >= 70 and risk_level in ['low', 'medium', 'high'] and critical_findings <= 2:
            return 'approved_with_conditions'
        elif overall_score >= 60 and risk_level in ['low', 'medium'] and critical_findings <= 5:
            return 'pending_review'
        else:
            return 'rejected'

# Ejemplo de uso
dd_mgmt = DueDiligenceManagement()

# Registrar tercero
dd_mgmt.register_third_party('TP-001', {
    'name': 'Cloud Services Provider',
    'type': 'cloud_provider',
    'industry': 'technology',
    'risk_level': 'high',
    'services': ['cloud_infrastructure', 'data_storage'],
    'data_access': 'sensitive',
    'system_access': 'limited'
})

# Crear evaluación
dd_mgmt.create_evaluation('EVAL-001', 'TP-001', {
    'type': 'comprehensive',
    'scope': 'full_security_assessment',
    'evaluator': 'Security Team',
    'due_date': datetime.now() + timedelta(days=30)
})

# Realizar evaluación
assessment_data = {
    'has_security_policy': True,
    'has_incident_response_policy': True,
    'has_data_protection_policy': True,
    'has_access_control_policy': True,
    'has_business_continuity_plan': False,
    'has_firewall': True,
    'has_intrusion_detection': True,
    'has_antivirus': True,
    'has_mfa': True,
    'has_privileged_access_management': False,
    'has_siem': True,
    'has_logging': True,
    'has_incident_response_team': True,
    'has_incident_response_procedures': True,
    'has_communication_plan': True,
    'has_forensic_capabilities': False,
    'certifications': ['ISO_27001', 'SOC_2'],
    'has_business_continuity_plan': False,
    'has_disaster_recovery_plan': True,
    'has_backup_systems': True,
    'has_alternate_sites': False
}

dd_mgmt.conduct_security_assessment('EVAL-001', assessment_data)

# Generar reporte
report = dd_mgmt.generate_evaluation_report('EVAL-001')
print(f"Reporte de evaluación: {report['overall_score']}/100")
print(f"Estado de aprobación: {report['approval_status']}")

Monitoreo Continuo

  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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240

class ContinuousMonitoring:
    def __init__(self):
        self.monitoring_rules = {}
        self.alerts = {}
        self.third_party_status = {}
        self.risk_updates = {}
    
    def setup_monitoring(self, party_id, monitoring_config):
        """Configurar monitoreo para tercero"""
        self.monitoring_rules[party_id] = {
            'party_id': party_id,
            'monitoring_type': monitoring_config['type'],
            'frequency': monitoring_config['frequency'],
            'criteria': monitoring_config['criteria'],
            'alert_thresholds': monitoring_config['alert_thresholds'],
            'enabled': True,
            'last_check': None
        }
    
    def check_third_party_status(self, party_id):
        """Verificar estado del tercero"""
        if party_id not in self.monitoring_rules:
            return None
        
        rule = self.monitoring_rules[party_id]
        
        # Simular verificación de estado
        status_check = {
            'party_id': party_id,
            'check_date': datetime.now(),
            'security_score': np.random.randint(60, 100),
            'incident_count': np.random.randint(0, 5),
            'compliance_status': np.random.choice(['compliant', 'non_compliant', 'pending']),
            'certification_status': np.random.choice(['valid', 'expired', 'pending_renewal']),
            'overall_status': 'good'
        }
        
        # Determinar estado general
        if (status_check['security_score'] < 70 or 
            status_check['incident_count'] > 3 or 
            status_check['compliance_status'] == 'non_compliant'):
            status_check['overall_status'] = 'warning'
        
        if (status_check['security_score'] < 50 or 
            status_check['incident_count'] > 5 or 
            status_check['certification_status'] == 'expired'):
            status_check['overall_status'] = 'critical'
        
        # Verificar alertas
        self.check_alerts(party_id, status_check)
        
        # Actualizar estado
        self.third_party_status[party_id] = status_check
        rule['last_check'] = datetime.now()
        
        return status_check
    
    def check_alerts(self, party_id, status_check):
        """Verificar alertas para tercero"""
        rule = self.monitoring_rules[party_id]
        thresholds = rule['alert_thresholds']
        
        alerts = []
        
        # Verificar umbrales
        if status_check['security_score'] < thresholds.get('security_score_min', 70):
            alerts.append({
                'type': 'security_score_low',
                'severity': 'high',
                'message': f"Puntuación de seguridad baja: {status_check['security_score']}"
            })
        
        if status_check['incident_count'] > thresholds.get('incident_count_max', 3):
            alerts.append({
                'type': 'high_incident_count',
                'severity': 'medium',
                'message': f"Alto número de incidentes: {status_check['incident_count']}"
            })
        
        if status_check['compliance_status'] == 'non_compliant':
            alerts.append({
                'type': 'compliance_issue',
                'severity': 'high',
                'message': "Estado de cumplimiento: no conforme"
            })
        
        if status_check['certification_status'] == 'expired':
            alerts.append({
                'type': 'certification_expired',
                'severity': 'critical',
                'message': "Certificación expirada"
            })
        
        # Registrar alertas
        for alert in alerts:
            alert_id = f"ALERT-{len(self.alerts) + 1}"
            self.alerts[alert_id] = {
                'alert_id': alert_id,
                'party_id': party_id,
                'timestamp': datetime.now(),
                'status': 'active',
                **alert
            }
    
    def get_active_alerts(self, party_id=None):
        """Obtener alertas activas"""
        if party_id:
            return [alert for alert in self.alerts.values() 
                   if alert['party_id'] == party_id and alert['status'] == 'active']
        else:
            return [alert for alert in self.alerts.values() if alert['status'] == 'active']
    
    def update_risk_assessment(self, party_id, risk_factors):
        """Actualizar evaluación de riesgo"""
        self.risk_updates[party_id] = {
            'party_id': party_id,
            'update_date': datetime.now(),
            'risk_factors': risk_factors,
            'risk_level': self.calculate_updated_risk(risk_factors)
        }
    
    def calculate_updated_risk(self, risk_factors):
        """Calcular riesgo actualizado"""
        risk_score = 0
        
        # Factores de riesgo
        if risk_factors.get('security_incidents', 0) > 3:
            risk_score += 30
        
        if risk_factors.get('compliance_violations', 0) > 0:
            risk_score += 40
        
        if risk_factors.get('certification_issues', False):
            risk_score += 20
        
        if risk_factors.get('financial_instability', False):
            risk_score += 25
        
        if risk_factors.get('management_changes', False):
            risk_score += 15
        
        # Determinar nivel de riesgo
        if risk_score >= 80:
            return 'critical'
        elif risk_score >= 60:
            return 'high'
        elif risk_score >= 40:
            return 'medium'
        else:
            return 'low'
    
    def generate_monitoring_report(self, party_id=None):
        """Generar reporte de monitoreo"""
        if party_id:
            parties = [party_id]
        else:
            parties = list(self.monitoring_rules.keys())
        
        report = {
            'report_date': datetime.now(),
            'monitored_parties': len(parties),
            'party_status': {},
            'active_alerts': [],
            'risk_updates': {},
            'recommendations': []
        }
        
        # Estado de cada tercero
        for party in parties:
            if party in self.third_party_status:
                report['party_status'][party] = self.third_party_status[party]
        
        # Alertas activas
        report['active_alerts'] = self.get_active_alerts(party_id)
        
        # Actualizaciones de riesgo
        for party in parties:
            if party in self.risk_updates:
                report['risk_updates'][party] = self.risk_updates[party]
        
        # Generar recomendaciones
        report['recommendations'] = self.generate_monitoring_recommendations(parties)
        
        return report
    
    def generate_monitoring_recommendations(self, parties):
        """Generar recomendaciones de monitoreo"""
        recommendations = []
        
        # Analizar alertas activas
        active_alerts = self.get_active_alerts()
        if len(active_alerts) > 5:
            recommendations.append({
                'type': 'alert_management',
                'priority': 'high',
                'description': f"Gestionar {len(active_alerts)} alertas activas"
            })
        
        # Analizar terceros con problemas
        problematic_parties = []
        for party in parties:
            if party in self.third_party_status:
                status = self.third_party_status[party]
                if status['overall_status'] in ['warning', 'critical']:
                    problematic_parties.append(party)
        
        if problematic_parties:
            recommendations.append({
                'type': 'party_review',
                'priority': 'medium',
                'description': f"Revisar {len(problematic_parties)} terceros con problemas"
            })
        
        return recommendations

# Ejemplo de uso
monitoring = ContinuousMonitoring()

# Configurar monitoreo
monitoring.setup_monitoring('TP-001', {
    'type': 'comprehensive',
    'frequency': 'weekly',
    'criteria': ['security_score', 'incident_count', 'compliance_status'],
    'alert_thresholds': {
        'security_score_min': 70,
        'incident_count_max': 3
    }
})

# Verificar estado
status = monitoring.check_third_party_status('TP-001')
print(f"Estado del tercero: {status['overall_status']}")

# Obtener alertas activas
alerts = monitoring.get_active_alerts('TP-001')
print(f"Alertas activas: {len(alerts)}")

# Generar reporte
report = monitoring.generate_monitoring_report('TP-001')
print(f"Reporte de monitoreo: {report['monitored_parties']} terceros monitoreados")

Mejores Prácticas

Evaluación Inicial

  • Criterios Claros: Criterios de evaluación claros y objetivos
  • Documentación: Documentación completa de hallazgos
  • Verificación: Verificación independiente de información
  • Transparencia: Transparencia en el proceso

Evaluación Continua

  • Monitoreo Regular: Monitoreo regular del estado
  • Actualización: Actualización de evaluaciones
  • Respuesta Rápida: Respuesta rápida a cambios
  • Comunicación: Comunicación efectiva con terceros

Gestión de Riesgos

  • Mitigación: Implementación de controles de mitigación
  • Contingencia: Planes de contingencia
  • Escalación: Procesos de escalación
  • Revisión: Revisión regular de riesgos

Conceptos Relacionados

Referencias