Comités de Seguridad

 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

class SecuritySteeringCommittee:
    def __init__(self):
        self.committee_info = {
            'name': 'Security Steering Committee',
            'purpose': 'Dirección estratégica de la seguridad de la información',
            'frequency': 'Monthly',
            'chair': 'CEO',
            'members': {
                'CEO': {
                    'role': 'Chair',
                    'responsibilities': [
                        'Presidir reuniones',
                        'Tomar decisiones finales',
                        'Aprobar presupuesto',
                        'Comunicar al board'
                    ]
                },
                'CISO': {
                    'role': 'Secretary',
                    'responsibilities': [
                        'Preparar agenda',
                        'Presentar reportes',
                        'Implementar decisiones',
                        'Coordinar acciones'
                    ]
                },
                'CTO': {
                    'role': 'Member',
                    'responsibilities': [
                        'Perspectiva técnica',
                        'Recursos IT',
                        'Arquitectura de seguridad',
                        'Innovación tecnológica'
                    ]
                },
                'CFO': {
                    'role': 'Member',
                    'responsibilities': [
                        'Presupuesto de seguridad',
                        'ROI de inversiones',
                        'Análisis de costos',
                        'Financiamiento de proyectos'
                    ]
                },
                'Legal_Counsel': {
                    'role': 'Member',
                    'responsibilities': [
                        'Aspectos legales',
                        'Cumplimiento normativo',
                        'Contratos de seguridad',
                        'Riesgo legal'
                    ]
                }
            }
        }
    
    def get_member_responsibilities(self, member):
        """Obtener responsabilidades de un miembro"""
        return self.committee_info['members'].get(member, {}).get('responsibilities', [])
    
    def get_all_members(self):
        """Obtener todos los miembros"""
        return list(self.committee_info['members'].keys())

# Ejemplo de uso
steering_committee = SecuritySteeringCommittee()
ciso_responsibilities = steering_committee.get_member_responsibilities('CISO')
print(f"Responsabilidades CISO: {ciso_responsibilities}")

all_members = steering_committee.get_all_members()
print(f"Miembros del comité: {all_members}")

 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

class SecurityOperationsCommittee:
    def __init__(self):
        self.committee_info = {
            'name': 'Security Operations Committee',
            'purpose': 'Coordinación de operaciones diarias de seguridad',
            'frequency': 'Weekly',
            'chair': 'CISO',
            'members': {
                'CISO': {
                    'role': 'Chair',
                    'responsibilities': [
                        'Dirigir operaciones',
                        'Coordinar respuestas',
                        'Tomar decisiones tácticas',
                        'Reportar al steering committee'
                    ]
                },
                'Security_Manager': {
                    'role': 'Vice-Chair',
                    'responsibilities': [
                        'Supervisar operaciones',
                        'Gestionar equipo',
                        'Implementar controles',
                        'Monitorear métricas'
                    ]
                },
                'IT_Manager': {
                    'role': 'Member',
                    'responsibilities': [
                        'Infraestructura de seguridad',
                        'Implementación técnica',
                        'Soporte operativo',
                        'Mantenimiento de sistemas'
                    ]
                },
                'Compliance_Manager': {
                    'role': 'Member',
                    'responsibilities': [
                        'Cumplimiento operativo',
                        'Auditorías internas',
                        'Documentación',
                        'Reportes regulatorios'
                    ]
                },
                'Incident_Response_Lead': {
                    'role': 'Member',
                    'responsibilities': [
                        'Respuesta a incidentes',
                        'Coordinación de crisis',
                        'Comunicaciones',
                        'Recuperación'
                    ]
                }
            }
        }
    
    def get_operational_metrics(self):
        """Obtener métricas operativas"""
        return {
            'incidents_resolved': 0,
            'vulnerabilities_patched': 0,
            'security_training_completed': 0,
            'compliance_score': 0,
            'system_uptime': 0
        }
    
    def get_weekly_agenda(self):
        """Obtener agenda semanal"""
        return [
            'Revisión de incidentes de la semana',
            'Estado de vulnerabilidades críticas',
            'Progreso de proyectos de seguridad',
            'Métricas de cumplimiento',
            'Próximas acciones'
        ]

# Ejemplo de uso
ops_committee = SecurityOperationsCommittee()
metrics = ops_committee.get_operational_metrics()
print(f"Métricas operativas: {metrics}")

agenda = ops_committee.get_weekly_agenda()
print(f"Agenda semanal: {agenda}")

 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

class CommitteeDecisionProcess:
    def __init__(self):
        self.decision_types = {
            'Strategic': {
                'approval_required': 'Unanimous',
                'timeframe': '2_weeks',
                'documentation': 'Formal',
                'communication': 'Board_level'
            },
            'Operational': {
                'approval_required': 'Majority',
                'timeframe': '1_week',
                'documentation': 'Standard',
                'communication': 'Management_level'
            },
            'Tactical': {
                'approval_required': 'Chair_decision',
                'timeframe': '3_days',
                'documentation': 'Brief',
                'communication': 'Team_level'
            },
            'Emergency': {
                'approval_required': 'Chair_decision',
                'timeframe': 'Immediate',
                'documentation': 'Post_incident',
                'communication': 'Immediate'
            }
        }
    
    def get_decision_process(self, decision_type):
        """Obtener proceso de decisión"""
        return self.decision_types.get(decision_type, {})
    
    def can_make_decision(self, decision_type, members_present, total_members):
        """Verificar si se puede tomar decisión"""
        process = self.get_decision_process(decision_type)
        approval_required = process.get('approval_required', 'Majority')
        
        if approval_required == 'Unanimous':
            return members_present == total_members
        elif approval_required == 'Majority':
            return members_present > total_members // 2
        elif approval_required == 'Chair_decision':
            return members_present >= 1
        else:
            return False

# Ejemplo de uso
decision_process = CommitteeDecisionProcess()
strategic_process = decision_process.get_decision_process('Strategic')
print(f"Proceso estratégico: {strategic_process}")

can_decide = decision_process.can_make_decision('Operational', 4, 5)
print(f"¿Puede decidir?: {can_decide}")

 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

class CommitteeVotingSystem:
    def __init__(self):
        self.voting_rules = {
            'quorum': 0.6,  # 60% de miembros presentes
            'majority_threshold': 0.5,  # 50% + 1 para mayoría
            'unanimous_threshold': 1.0,  # 100% para unanimidad
            'chair_veto': True  # Presidente puede vetar
        }
        
        self.votes = {}
        self.meetings = {}
    
    def start_voting(self, meeting_id, proposal, voting_type='Majority'):
        """Iniciar votación"""
        self.votes[meeting_id] = {
            'proposal': proposal,
            'voting_type': voting_type,
            'votes': {},
            'status': 'Open',
            'start_time': '2025-10-26T10:00:00Z'
        }
    
    def cast_vote(self, meeting_id, member, vote):
        """Emitir voto"""
        if meeting_id in self.votes and self.votes[meeting_id]['status'] == 'Open':
            self.votes[meeting_id]['votes'][member] = vote
    
    def close_voting(self, meeting_id, total_members):
        """Cerrar votación y calcular resultado"""
        if meeting_id not in self.votes:
            return None
        
        vote_data = self.votes[meeting_id]
        votes_cast = len(vote_data['votes'])
        
        # Verificar quórum
        if votes_cast < total_members * self.voting_rules['quorum']:
            vote_data['status'] = 'Failed - No Quorum'
            return vote_data
        
        # Contar votos
        yes_votes = sum(1 for vote in vote_data['votes'].values() if vote == 'Yes')
        no_votes = sum(1 for vote in vote_data['votes'].values() if vote == 'No')
        abstentions = sum(1 for vote in vote_data['votes'].values() if vote == 'Abstain')
        
        # Determinar resultado
        if vote_data['voting_type'] == 'Unanimous':
            if yes_votes == votes_cast:
                vote_data['status'] = 'Passed - Unanimous'
            else:
                vote_data['status'] = 'Failed - Not Unanimous'
        elif vote_data['voting_type'] == 'Majority':
            if yes_votes > no_votes:
                vote_data['status'] = 'Passed - Majority'
            else:
                vote_data['status'] = 'Failed - No Majority'
        
        vote_data['results'] = {
            'yes': yes_votes,
            'no': no_votes,
            'abstain': abstentions,
            'total_cast': votes_cast
        }
        
        return vote_data

# Ejemplo de uso
voting_system = CommitteeVotingSystem()
voting_system.start_voting('MEET-001', 'Aprobar presupuesto de seguridad 2025', 'Majority')
voting_system.cast_vote('MEET-001', 'CEO', 'Yes')
voting_system.cast_vote('MEET-001', 'CISO', 'Yes')
voting_system.cast_vote('MEET-001', 'CTO', 'No')
voting_system.cast_vote('MEET-001', 'CFO', 'Yes')

result = voting_system.close_voting('MEET-001', 5)
print(f"Resultado de votación: {result['status']}")
print(f"Votos: {result['results']}")

 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 MeetingAgendaSystem:
    def __init__(self):
        self.agendas = {}
        self.meeting_templates = {
            'Steering_Committee': {
                'standard_items': [
                    'Aprobación de agenda',
                    'Revisión de minutos anteriores',
                    'Reporte de CISO',
                    'Revisión de métricas',
                    'Decisiones pendientes',
                    'Nuevos asuntos',
                    'Próxima reunión'
                ],
                'duration': '90 minutes'
            },
            'Operations_Committee': {
                'standard_items': [
                    'Revisión de incidentes',
                    'Estado de vulnerabilidades',
                    'Progreso de proyectos',
                    'Métricas operativas',
                    'Recursos y presupuesto',
                    'Próximas acciones'
                ],
                'duration': '60 minutes'
            }
        }
    
    def create_agenda(self, meeting_id, committee_type, custom_items=None):
        """Crear agenda de reunión"""
        template = self.meeting_templates.get(committee_type, {})
        standard_items = template.get('standard_items', [])
        
        agenda = {
            'meeting_id': meeting_id,
            'committee_type': committee_type,
            'items': standard_items.copy(),
            'duration': template.get('duration', '60 minutes'),
            'created_date': '2025-10-26',
            'status': 'Draft'
        }
        
        if custom_items:
            agenda['items'].extend(custom_items)
        
        self.agendas[meeting_id] = agenda
        return agenda
    
    def add_agenda_item(self, meeting_id, item, priority='Normal'):
        """Añadir item a agenda"""
        if meeting_id in self.agendas:
            self.agendas[meeting_id]['items'].append({
                'item': item,
                'priority': priority,
                'status': 'Pending'
            })
    
    def get_agenda(self, meeting_id):
        """Obtener agenda de reunión"""
        return self.agendas.get(meeting_id, {})

# Ejemplo de uso
agenda_system = MeetingAgendaSystem()
agenda = agenda_system.create_agenda('MEET-001', 'Steering_Committee', [
    'Aprobar nueva política de BYOD',
    'Revisar incidente de seguridad del mes'
])

agenda_system.add_agenda_item('MEET-001', 'Discutir presupuesto Q1 2025', 'High')
meeting_agenda = agenda_system.get_agenda('MEET-001')
print(f"Agenda de reunión: {meeting_agenda['items']}")

 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

class MeetingMinutesSystem:
    def __init__(self):
        self.minutes = {}
        self.action_items = {}
    
    def create_minutes(self, meeting_id, attendees, agenda_items):
        """Crear minutos de reunión"""
        self.minutes[meeting_id] = {
            'meeting_id': meeting_id,
            'date': '2025-10-26',
            'attendees': attendees,
            'agenda_items': agenda_items,
            'decisions': [],
            'action_items': [],
            'next_meeting': None,
            'status': 'Draft'
        }
    
    def add_decision(self, meeting_id, decision, responsible, deadline=None):
        """Añadir decisión"""
        if meeting_id in self.minutes:
            decision_item = {
                'decision': decision,
                'responsible': responsible,
                'deadline': deadline,
                'status': 'Pending'
            }
            self.minutes[meeting_id]['decisions'].append(decision_item)
    
    def add_action_item(self, meeting_id, action, owner, deadline, priority='Normal'):
        """Añadir item de acción"""
        if meeting_id in self.minutes:
            action_item = {
                'action': action,
                'owner': owner,
                'deadline': deadline,
                'priority': priority,
                'status': 'Open'
            }
            self.minutes[meeting_id]['action_items'].append(action_item)
            self.action_items[f"{meeting_id}_{len(self.minutes[meeting_id]['action_items'])}"] = action_item
    
    def get_pending_actions(self, owner=None):
        """Obtener acciones pendientes"""
        pending = []
        for action_id, action in self.action_items.items():
            if action['status'] == 'Open':
                if owner is None or action['owner'] == owner:
                    pending.append(action)
        return pending

# Ejemplo de uso
minutes_system = MeetingMinutesSystem()
minutes_system.create_minutes('MEET-001', ['CEO', 'CISO', 'CTO', 'CFO'], [
    'Aprobar presupuesto de seguridad',
    'Revisar política de BYOD'
])

minutes_system.add_decision('MEET-001', 'Aprobar presupuesto de $2M para 2025', 'CFO', '2025-11-01')
minutes_system.add_action_item('MEET-001', 'Actualizar política de BYOD', 'CISO', '2025-11-15', 'High')

pending_actions = minutes_system.get_pending_actions('CISO')
print(f"Acciones pendientes CISO: {len(pending_actions)}")

 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 CommitteeMetrics:
    def __init__(self):
        self.metrics = {
            'meeting_attendance': {
                'description': 'Asistencia a reuniones',
                'target': '>90%',
                'measurement': 'Monthly'
            },
            'decision_implementation': {
                'description': 'Implementación de decisiones',
                'target': '>95%',
                'measurement': 'Monthly'
            },
            'action_item_completion': {
                'description': 'Completitud de acciones',
                'target': '>90%',
                'measurement': 'Monthly'
            },
            'meeting_efficiency': {
                'description': 'Eficiencia de reuniones',
                'target': '>80%',
                'measurement': 'Quarterly'
            }
        }
    
    def calculate_attendance_rate(self, meetings_data):
        """Calcular tasa de asistencia"""
        total_possible = 0
        total_attended = 0
        
        for meeting in meetings_data:
            expected_attendees = meeting['expected_attendees']
            actual_attendees = meeting['actual_attendees']
            
            total_possible += expected_attendees
            total_attended += actual_attendees
        
        return (total_attended / total_possible * 100) if total_possible > 0 else 0
    
    def calculate_decision_implementation_rate(self, decisions_data):
        """Calcular tasa de implementación de decisiones"""
        total_decisions = len(decisions_data)
        implemented_decisions = len([d for d in decisions_data if d['status'] == 'Implemented'])
        
        return (implemented_decisions / total_decisions * 100) if total_decisions > 0 else 0

# Ejemplo de uso
committee_metrics = CommitteeMetrics()
meetings_data = [
    {'expected_attendees': 5, 'actual_attendees': 5},
    {'expected_attendees': 5, 'actual_attendees': 4},
    {'expected_attendees': 5, 'actual_attendees': 5}
]

attendance_rate = committee_metrics.calculate_attendance_rate(meetings_data)
print(f"Tasa de asistencia: {attendance_rate:.1f}%")