Políticas y Procedimientos

 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

class SecurityPolicy:
    def __init__(self):
        self.policy_structure = {
            'header': {
                'title': 'Política de Seguridad de la Información',
                'version': '2.0',
                'effective_date': '2025-01-01',
                'review_date': '2026-01-01',
                'approval': 'CISO',
                'classification': 'Internal'
            },
            'sections': {
                '1.0': {
                    'title': 'Propósito y Alcance',
                    'content': [
                        'Establecer el marco de seguridad de la información',
                        'Proteger los activos de información',
                        'Cumplir con regulaciones aplicables',
                        'Aplicar a todos los empleados y sistemas'
                    ]
                },
                '2.0': {
                    'title': 'Definiciones',
                    'content': [
                        'Información confidencial',
                        'Activos de información',
                        'Incidentes de seguridad',
                        'Controles de seguridad'
                    ]
                },
                '3.0': {
                    'title': 'Responsabilidades',
                    'content': [
                        'CISO: Estrategia y supervisión',
                        'Gerentes: Implementación local',
                        'Empleados: Cumplimiento',
                        'IT: Implementación técnica'
                    ]
                },
                '4.0': {
                    'title': 'Principios de Seguridad',
                    'content': [
                        'Confidencialidad',
                        'Integridad',
                        'Disponibilidad',
                        'Cumplimiento'
                    ]
                },
                '5.0': {
                    'title': 'Controles Requeridos',
                    'content': [
                        'Control de accesos',
                        'Cifrado de datos',
                        'Monitoreo de seguridad',
                        'Respuesta a incidentes'
                    ]
                }
            }
        }
    
    def get_policy_section(self, section_number):
        """Obtener sección de política"""
        return self.policy_structure['sections'].get(section_number, {})
    
    def get_all_sections(self):
        """Obtener todas las secciones"""
        return list(self.policy_structure['sections'].keys())

# Ejemplo de uso
policy = SecurityPolicy()
purpose_section = policy.get_policy_section('1.0')
print(f"Sección de propósito: {purpose_section}")

 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

class SpecificPolicies:
    def __init__(self):
        self.policies = {
            'Access_Control_Policy': {
                'title': 'Política de Control de Accesos',
                'scope': 'Sistemas de información',
                'requirements': [
                    'Autenticación multifactor',
                    'Principio de menor privilegio',
                    'Revisión regular de accesos',
                    'Segregación de funciones'
                ],
                'compliance': ['ISO 27001', 'NIST', 'GDPR']
            },
            'Data_Classification_Policy': {
                'title': 'Política de Clasificación de Datos',
                'scope': 'Toda la información',
                'requirements': [
                    'Clasificación por sensibilidad',
                    'Etiquetado de información',
                    'Manejo según clasificación',
                    'Destrucción segura'
                ],
                'compliance': ['ISO 27001', 'GDPR', 'SOX']
            },
            'Incident_Response_Policy': {
                'title': 'Política de Respuesta a Incidentes',
                'scope': 'Incidentes de seguridad',
                'requirements': [
                    'Procedimiento de reporte',
                    'Escalación de incidentes',
                    'Contención y erradicación',
                    'Lecciones aprendidas'
                ],
                'compliance': ['ISO 27001', 'NIST', 'PCI DSS']
            },
            'Remote_Work_Policy': {
                'title': 'Política de Trabajo Remoto',
                'scope': 'Empleados remotos',
                'requirements': [
                    'VPN obligatorio',
                    'Dispositivos corporativos',
                    'Entrenamiento de seguridad',
                    'Monitoreo de actividad'
                ],
                'compliance': ['ISO 27001', 'GDPR']
            }
        }
    
    def get_policy_by_name(self, policy_name):
        """Obtener política por nombre"""
        return self.policies.get(policy_name, {})
    
    def get_policies_by_compliance(self, standard):
        """Obtener políticas por estándar de cumplimiento"""
        matching_policies = []
        for name, policy in self.policies.items():
            if standard in policy.get('compliance', []):
                matching_policies.append(name)
        return matching_policies

# Ejemplo de uso
specific_policies = SpecificPolicies()
access_policy = specific_policies.get_policy_by_name('Access_Control_Policy')
print(f"Política de control de accesos: {access_policy['title']}")

iso_policies = specific_policies.get_policies_by_compliance('ISO 27001')
print(f"Políticas ISO 27001: {iso_policies}")

 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

class AccessManagementProcedure:
    def __init__(self):
        self.procedure_steps = {
            '1': {
                'step': 'Solicitud de Acceso',
                'description': 'Empleado solicita acceso a sistema',
                'responsible': 'Solicitante',
                'duration': 'Immediate',
                'requirements': [
                    'Formulario de solicitud',
                    'Justificación del acceso',
                    'Aprobación del supervisor',
                    'Clasificación de datos'
                ]
            },
            '2': {
                'step': 'Evaluación de Riesgo',
                'description': 'Evaluar riesgo del acceso solicitado',
                'responsible': 'Security_Team',
                'duration': '2 business days',
                'requirements': [
                    'Análisis de impacto',
                    'Evaluación de controles',
                    'Revisión de privilegios',
                    'Documentación de decisión'
                ]
            },
            '3': {
                'step': 'Aprobación',
                'description': 'Aprobar o rechazar solicitud',
                'responsible': 'Data_Owner',
                'duration': '1 business day',
                'requirements': [
                    'Revisión de justificación',
                    'Verificación de necesidad',
                    'Aprobación formal',
                    'Notificación al solicitante'
                ]
            },
            '4': {
                'step': 'Implementación',
                'description': 'Crear cuenta y asignar permisos',
                'responsible': 'IT_Admin',
                'duration': '4 hours',
                'requirements': [
                    'Creación de cuenta',
                    'Asignación de permisos',
                    'Configuración de MFA',
                    'Notificación de activación'
                ]
            },
            '5': {
                'step': 'Monitoreo',
                'description': 'Monitorear uso del acceso',
                'responsible': 'Security_Team',
                'duration': 'Ongoing',
                'requirements': [
                    'Monitoreo de actividad',
                    'Revisión de accesos',
                    'Auditoría regular',
                    'Reporte de anomalías'
                ]
            }
        }
    
    def get_procedure_step(self, step_number):
        """Obtener paso del procedimiento"""
        return self.procedure_steps.get(step_number, {})
    
    def get_total_duration(self):
        """Obtener duración total del procedimiento"""
        total_days = 0
        for step in self.procedure_steps.values():
            if 'business days' in step['duration']:
                days = int(step['duration'].split()[0])
                total_days += days
        return total_days

# Ejemplo de uso
access_procedure = AccessManagementProcedure()
step_1 = access_procedure.get_procedure_step('1')
print(f"Paso 1: {step_1['step']}")

total_duration = access_procedure.get_total_duration()
print(f"Duración total: {total_duration} días hábiles")

 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

class IncidentResponseProcedure:
    def __init__(self):
        self.response_phases = {
            'Preparation': {
                'description': 'Preparación para respuesta a incidentes',
                'activities': [
                    'Capacitación del equipo',
                    'Herramientas de respuesta',
                    'Procedimientos documentados',
                    'Comunicaciones preparadas'
                ],
                'duration': 'Ongoing'
            },
            'Identification': {
                'description': 'Identificación del incidente',
                'activities': [
                    'Detección de anomalías',
                    'Clasificación inicial',
                    'Notificación inmediata',
                    'Activación del equipo'
                ],
                'duration': '0-1 hour'
            },
            'Containment': {
                'description': 'Contención del incidente',
                'activities': [
                    'Aislamiento de sistemas',
                    'Preservación de evidencia',
                    'Contención de daños',
                    'Comunicación interna'
                ],
                'duration': '1-4 hours'
            },
            'Eradication': {
                'description': 'Erradicación de la amenaza',
                'activities': [
                    'Eliminación de malware',
                    'Cierre de vulnerabilidades',
                    'Limpieza de sistemas',
                    'Verificación de limpieza'
                ],
                'duration': '4-24 hours'
            },
            'Recovery': {
                'description': 'Recuperación de servicios',
                'activities': [
                    'Restauración de sistemas',
                    'Verificación de funcionalidad',
                    'Monitoreo intensivo',
                    'Comunicación a usuarios'
                ],
                'duration': '1-3 days'
            },
            'Lessons_Learned': {
                'description': 'Lecciones aprendidas',
                'activities': [
                    'Análisis post-incidente',
                    'Identificación de mejoras',
                    'Actualización de procedimientos',
                    'Capacitación adicional'
                ],
                'duration': '1-2 weeks'
            }
        }
    
    def get_phase_activities(self, phase):
        """Obtener actividades de una fase"""
        return self.response_phases.get(phase, {}).get('activities', [])
    
    def get_critical_phases(self):
        """Obtener fases críticas"""
        critical_phases = []
        for phase, info in self.response_phases.items():
            if info['duration'] in ['0-1 hour', '1-4 hours']:
                critical_phases.append(phase)
        return critical_phases

# Ejemplo de uso
incident_procedure = IncidentResponseProcedure()
containment_activities = incident_procedure.get_phase_activities('Containment')
print(f"Actividades de contención: {containment_activities}")

critical_phases = incident_procedure.get_critical_phases()
print(f"Fases críticas: {critical_phases}")

 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

class PolicyManagementSystem:
    def __init__(self):
        self.policies = {}
        self.procedures = {}
        self.compliance_status = {}
        self.review_schedule = {}
    
    def add_policy(self, policy_id, policy_data):
        """Añadir política"""
        self.policies[policy_id] = {
            **policy_data,
            'status': 'Draft',
            'created_date': '2025-10-26',
            'last_review': None,
            'next_review': '2026-01-26'
        }
    
    def approve_policy(self, policy_id, approver):
        """Aprobar política"""
        if policy_id in self.policies:
            self.policies[policy_id]['status'] = 'Approved'
            self.policies[policy_id]['approver'] = approver
            self.policies[policy_id]['approval_date'] = '2025-10-26'
    
    def publish_policy(self, policy_id):
        """Publicar política"""
        if policy_id in self.policies:
            self.policies[policy_id]['status'] = 'Published'
            self.policies[policy_id]['publish_date'] = '2025-10-26'
    
    def get_policies_by_status(self, status):
        """Obtener políticas por estado"""
        return [pid for pid, policy in self.policies.items() 
                if policy['status'] == status]
    
    def get_policies_due_for_review(self):
        """Obtener políticas pendientes de revisión"""
        due_policies = []
        for pid, policy in self.policies.items():
            if policy['next_review'] and policy['next_review'] <= '2025-10-26':
                due_policies.append(pid)
        return due_policies

# Ejemplo de uso
policy_system = PolicyManagementSystem()
policy_system.add_policy('POL-001', {
    'title': 'Política de Seguridad de la Información',
    'version': '2.0',
    'owner': 'CISO'
})

policy_system.approve_policy('POL-001', 'CEO')
policy_system.publish_policy('POL-001')

published_policies = policy_system.get_policies_by_status('Published')
print(f"Políticas publicadas: {published_policies}")

 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

class ComplianceSystem:
    def __init__(self):
        self.compliance_frameworks = {
            'ISO_27001': {
                'name': 'ISO/IEC 27001:2022',
                'requirements': [
                    'A.5.1.1 - Policies for Information Security',
                    'A.5.1.2 - Review of Information Security Policies',
                    'A.6.1.1 - Information Security Roles and Responsibilities',
                    'A.8.1.1 - Inventory of Assets',
                    'A.9.1.1 - Access Control Policy'
                ],
                'compliance_level': 'High'
            },
            'GDPR': {
                'name': 'General Data Protection Regulation',
                'requirements': [
                    'Article 32 - Security of Processing',
                    'Article 33 - Notification of Breach',
                    'Article 35 - Data Protection Impact Assessment',
                    'Article 25 - Data Protection by Design',
                    'Article 30 - Records of Processing Activities'
                ],
                'compliance_level': 'High'
            },
            'PCI_DSS': {
                'name': 'Payment Card Industry Data Security Standard',
                'requirements': [
                    'Requirement 1 - Firewall Configuration',
                    'Requirement 2 - Default Passwords',
                    'Requirement 3 - Stored Cardholder Data',
                    'Requirement 4 - Transmission of Cardholder Data',
                    'Requirement 5 - Anti-virus Software'
                ],
                'compliance_level': 'Medium'
            }
        }
        
        self.policy_mapping = {
            'POL-001': ['ISO_27001', 'GDPR'],
            'POL-002': ['ISO_27001', 'PCI_DSS'],
            'POL-003': ['GDPR']
        }
    
    def get_compliance_status(self, policy_id):
        """Obtener estado de cumplimiento de una política"""
        if policy_id not in self.policy_mapping:
            return 'No mapping found'
        
        frameworks = self.policy_mapping[policy_id]
        compliance_status = {}
        
        for framework in frameworks:
            compliance_status[framework] = {
                'name': self.compliance_frameworks[framework]['name'],
                'level': self.compliance_frameworks[framework]['compliance_level'],
                'status': 'Compliant'
            }
        
        return compliance_status
    
    def get_framework_requirements(self, framework):
        """Obtener requisitos de un marco"""
        return self.compliance_frameworks.get(framework, {}).get('requirements', [])

# Ejemplo de uso
compliance_system = ComplianceSystem()
policy_status = compliance_system.get_compliance_status('POL-001')
print(f"Estado de cumplimiento: {policy_status}")

iso_requirements = compliance_system.get_framework_requirements('ISO_27001')
print(f"Requisitos ISO 27001: {len(iso_requirements)}")