Evidencia de Pruebas y Documentación de Cumplimiento: Construcción de Sistemas QA Preparados para Auditorías

## Lista de Verificación de Evidencia de Pruebas SOX

### Pruebas de Controles de Acceso
- [ ] Caso de prueba: Prevención de acceso no autorizado
- [ ] Datos de prueba: Matriz de roles y permisos de usuario
- [ ] Resultado esperado: Acceso denegado para usuarios no autorizados
- [ ] Resultado real: Captura de pantalla de denegación de acceso
- [ ] Probador: John Smith (QA Independiente)
- [ ] Fecha: 2025-10-08
- [ ] Revisor: Jane Doe (Líder QA)
- [ ] Aprobación: Firma del Oficial de Cumplimiento

### Verificación de Pista de Auditoría
- [ ] Caso de prueba: Todas las transacciones financieras registradas
- [ ] Datos de prueba: Transacciones de muestra (sanitizadas)
- [ ] Resultado esperado: Pista de auditoría completa con marcas de tiempo
- [ ] Resultado real: Resultados de consulta de base de datos
- [ ] Evidencia: audit_trail_verification.pdf

test_case_id: HIPAA-ENC-001
requirement_id: SEC-002
regulation: HIPAA Security Rule § 164.312(a)(2)(iv)
title: Encriptación de PHI en Reposo

preconditions:
  - Base de datos de prueba contiene PHI de muestra (datos sintéticos)
  - Claves de encriptación configuradas correctamente
  - Registro de acceso a base de datos habilitado

test_steps:
  - step: 1
    action: Acceder a base de datos directamente (evitando aplicación)
    expected: Campos PHI encriptados en base de datos
    evidence_type: Captura de pantalla de base de datos

  - step: 2
    action: Recuperar registro de paciente vía aplicación
    expected: PHI mostrado en texto plano (desencriptado)
    evidence_type: Captura de pantalla de aplicación

  - step: 3
    action: Revisar registros de encriptación de base de datos
    expected: No hay PHI sin encriptar en registros
    evidence_type: Extracto de archivo de registro

test_data:
  patient_id: TEST-12345
  phi_fields: [ssn, diagnosis, medications]

evidence_files:
  - encrypted_database_view.png
  - application_display.png
  - encryption_logs_20251008.txt

pass_criteria:
  - Todos los campos PHI encriptados con AES-256
  - Desencriptación solo vía acceso autenticado de aplicación
  - No hay PHI visible en registros del sistema

tester: Sarah Johnson, CISA
test_date: 2025-10-08
reviewer: Michael Chen, CISSP
approval_date: 2025-10-09

## Protocolo de Validación del Sistema

**Sistema:** Sistema de Gestión de Información de Laboratorio (LIMS)
**Tipo de Validación:** IQ/OQ/PQ (Calificación de Instalación/Operacional/Rendimiento)
**Regulación:** 21 CFR Parte 11

### Calificación de Instalación (IQ)
| Componente | Versión Esperada | Versión Real | Estado | Evidencia |
|-----------|-----------------|--------------|--------|-----------|
| Servidor de Aplicación | v3.2.1 | v3.2.1 | ✓ Pasó | IQ-001.pdf |
| Base de Datos | PostgreSQL 14 | PostgreSQL 14 | ✓ Pasó | IQ-002.pdf |
| Sistema de Respaldo | Configurado | Verificado | ✓ Pasó | IQ-003.pdf |

### Calificación Operacional (OQ)
- Caso de Prueba OQ-001: Unicidad de firma electrónica
- Caso de Prueba OQ-002: Inmutabilidad de pista de auditoría
- Caso de Prueba OQ-003: Controles de acceso al sistema
- Caso de Prueba OQ-004: Respaldo y recuperación de datos

### Calificación de Rendimiento (PQ)
- PQ-001: Sistema funciona bajo carga normal
- PQ-002: Integridad de datos durante operaciones concurrentes
- PQ-003: Cálculos precisos para resultados de pruebas

Requirement ID,Requirement Description,Regulation,Design Spec,Test Case IDs,Test Status,Defects,Risk Level
REQ-001,"Autenticación de usuario con MFA",HIPAA §164.312(a)(2)(i),DS-AUTH-01,"TC-001,TC-002,TC-003",Pasado,Ninguno,Alto
REQ-002,"Tiempo de espera de sesión después de 15 min de inactividad",SOX IT Controls,DS-SESS-01,"TC-004,TC-005",Pasado,Ninguno,Medio
REQ-003,"Registro de auditoría de todo acceso a PHI",HIPAA §164.312(b),DS-AUDIT-01,"TC-006,TC-007,TC-008",Fallado,DEF-045,Crítico
REQ-004,"Encriptación de datos en reposo",ISO 27001 A.10.1.1,DS-ENC-01,"TC-009,TC-010",Pasado,Ninguno,Alto
REQ-005,"Control de acceso basado en roles",GDPR Art 32,DS-RBAC-01,"TC-011,TC-012,TC-013",En Progreso,Ninguno,Alto

// Caso de Prueba Xray con Enlaces de Requisitos
{
  "key": "TEST-123",
  "summary": "Verificar encriptación de campos de datos sensibles",
  "requirementKeys": ["REQ-004", "REQ-008"],
  "regulatoryReferences": [
    "HIPAA Security Rule § 164.312(a)(2)(iv)",
    "ISO 27001 Control A.10.1.1"
  ],
  "testType": "Manual",
  "steps": [...],
  "evidenceRequired": true
}

## Convención de Nomenclatura de Capturas de Pantalla
Formato: [TestCaseID]_[Step]_[Result]_[Timestamp].png

Ejemplos:
- TC-001_Step3_Pass_20251008_143052.png
- TC-045_Step7_Fail_20251008_150321.png

## Elementos Requeridos en Capturas de Pantalla:
✓ Marca de tiempo o fecha visible
✓ Identificación de usuario (usuario conectado)
✓ Referencia de ID de caso de prueba
✓ Visualización clara de resultado esperado vs real
✓ No PHI o PII (usar solo datos de prueba)

## Directrices de Grabación de Pantalla:
- Duración máxima: 5 minutos por caso de prueba
- Resolución: 1920x1080 mínimo
- Formato: MP4 (códec H.264)
- Narración de audio: Opcional pero recomendada
- Incluir ID de caso de prueba en título de video

import os
from datetime import datetime
from selenium import webdriver
from selenium.webdriver.common.by import By

class ComplianceTestRecorder:
    def __init__(self, test_case_id, evidence_dir="./evidence"):
        self.test_case_id = test_case_id
        self.evidence_dir = evidence_dir
        self.driver = webdriver.Chrome()
        self.step_counter = 0

        # Crear directorio de evidencia
        os.makedirs(f"{evidence_dir}/{test_case_id}", exist_ok=True)

    def capture_evidence(self, step_description, result="PASS"):
        """Capturar captura de pantalla con metadatos"""
        self.step_counter += 1
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"{self.test_case_id}_Step{self.step_counter}_{result}_{timestamp}.png"
        filepath = f"{self.evidence_dir}/{self.test_case_id}/{filename}"

        # Capturar captura de pantalla
        self.driver.save_screenshot(filepath)

        # Registrar metadatos
        metadata = {
            "test_case": self.test_case_id,
            "step": self.step_counter,
            "description": step_description,
            "result": result,
            "timestamp": timestamp,
            "screenshot": filename,
            "url": self.driver.current_url,
            "browser": "Chrome",
            "tester": os.getenv("TESTER_NAME", "Automatizado")
        }

        # Agregar a registro de evidencia
        with open(f"{self.evidence_dir}/{self.test_case_id}/evidence_log.json", "a") as f:
            import json
            f.write(json.dumps(metadata) + "\n")

        return filepath

    def test_login_with_mfa(self):
        """Ejemplo: Prueba de inicio de sesión compatible con HIPAA con evidencia"""
        self.driver.get("https://app.example.com/login")

        # Paso 1: Ingresar credenciales
        self.driver.find_element(By.ID, "username").send_keys("test_user")
        self.driver.find_element(By.ID, "password").send_keys("SecureP@ss123")
        self.capture_evidence("Credenciales ingresadas", "PASS")

        # Paso 2: Enviar formulario de inicio de sesión
        self.driver.find_element(By.ID, "login-button").click()
        self.capture_evidence("Inicio de sesión enviado", "PASS")

        # Paso 3: Verificar que aparece solicitud de MFA
        mfa_prompt = self.driver.find_element(By.ID, "mfa-verification")
        assert mfa_prompt.is_displayed()
        self.capture_evidence("Solicitud de MFA mostrada", "PASS")

        # Paso 4: Ingresar código MFA
        self.driver.find_element(By.ID, "mfa-code").send_keys("123456")
        self.capture_evidence("Código MFA ingresado", "PASS")

import hashlib
import json
from datetime import datetime, timedelta

class ComplianceArchive:
    def __init__(self, storage_backend):
        self.storage = storage_backend

    def archive_test_evidence(self, test_case_id, evidence_files,
                              retention_years=7, regulation="SOX"):
        """Archivar evidencia de prueba con metadatos y verificación de integridad"""

        # Calcular expiración de retención
        retention_date = datetime.now() + timedelta(days=365 * retention_years)

        # Generar manifiesto
        manifest = {
            "archive_id": f"ARC-{test_case_id}-{datetime.now().strftime('%Y%m%d')}",
            "test_case_id": test_case_id,
            "archived_date": datetime.now().isoformat(),
            "retention_until": retention_date.isoformat(),
            "regulation": regulation,
            "files": []
        }

        # Procesar cada archivo de evidencia
        for filepath in evidence_files:
            with open(filepath, 'rb') as f:
                file_content = f.read()
                file_hash = hashlib.sha256(file_content).hexdigest()

            file_metadata = {
                "filename": os.path.basename(filepath),
                "size_bytes": len(file_content),
                "sha256": file_hash,
                "archived_at": datetime.now().isoformat()
            }
            manifest["files"].append(file_metadata)

            # Subir a almacenamiento de archivo (S3, Azure Blob, etc.)
            archive_path = f"{regulation}/{test_case_id}/{os.path.basename(filepath)}"
            self.storage.upload(filepath, archive_path, metadata={
                "retention_until": retention_date.isoformat(),
                "regulation": regulation,
                "sha256": file_hash
            })

        # Almacenar manifiesto
        manifest_path = f"{regulation}/{test_case_id}/manifest.json"
        self.storage.upload_text(json.dumps(manifest, indent=2), manifest_path)

        return manifest

    def verify_integrity(self, archive_id):
        """Verificar que la evidencia archivada no ha sido alterada"""
        # Implementación para verificaciones periódicas de integridad
        pass